# Spring Boot

## Introduction

### Problem

* Initially, we need to do the configuration one by one, such as spring container , hibernate, security, servlet, jackson
* We need to search for the dependency and enter into pom.xml one by one
* We need to install tomcat manually to host the application

### Solution

* The annotation of spring boot application is already included component scanning, configuration and property source ( default : reading application.properties)

```java
@SpringBootApplication
public class CruddemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(CruddemoApplication.class, args);
	}
}
```

* The dependency of spring boot starter web already include jackson ,spring-core, spring-mvc, hibernate-validator

```markup
<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
```

* The spring boot application contains embedded tomcat, so we can just run command mvnw package and mvnw spring-boot:run to start the application&#x20;

## Hibernate

### Configuration

* Initially, we need to do a long long configuration to create session factory and transaction manager

```java
package com.luv2code.springdemo.config;

import java.beans.PropertyVetoException;
import java.util.Properties;
import java.util.logging.Logger;

import javax.sql.DataSource;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.mchange.v2.c3p0.ComboPooledDataSource;

@Configuration
@EnableWebMvc
@EnableTransactionManagement
@ComponentScan("com.luv2code.springdemo")
@PropertySource({ "classpath:persistence-mysql.properties" })
public class DemoAppConfig implements WebMvcConfigurer {

	@Autowired
	private Environment env;
	
	private Logger logger = Logger.getLogger(getClass().getName());
	
	@Bean
	public DataSource myDataSource() {
		
		// create connection pool
		ComboPooledDataSource myDataSource = new ComboPooledDataSource();

		// set the jdbc driver
		try {
			myDataSource.setDriverClass("com.mysql.jdbc.Driver");		
		}
		catch (PropertyVetoException exc) {
			throw new RuntimeException(exc);
		}
		
		// for sanity's sake, let's log url and user ... just to make sure we are reading the data
		logger.info("jdbc.url=" + env.getProperty("jdbc.url"));
		logger.info("jdbc.user=" + env.getProperty("jdbc.user"));
		
		// set database connection props
		myDataSource.setJdbcUrl(env.getProperty("jdbc.url"));
		myDataSource.setUser(env.getProperty("jdbc.user"));
		myDataSource.setPassword(env.getProperty("jdbc.password"));
		
		// set connection pool props
		myDataSource.setInitialPoolSize(getIntProperty("connection.pool.initialPoolSize"));
		myDataSource.setMinPoolSize(getIntProperty("connection.pool.minPoolSize"));
		myDataSource.setMaxPoolSize(getIntProperty("connection.pool.maxPoolSize"));		
		myDataSource.setMaxIdleTime(getIntProperty("connection.pool.maxIdleTime"));

		return myDataSource;
	}
	
	private Properties getHibernateProperties() {

		// set hibernate properties
		Properties props = new Properties();

		props.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
		props.setProperty("hibernate.show_sql", env.getProperty("hibernate.show_sql"));
		
		return props;				
	}

	
	// need a helper method 
	// read environment property and convert to int
	
	private int getIntProperty(String propName) {
		
		String propVal = env.getProperty(propName);
		
		// now convert to int
		int intPropVal = Integer.parseInt(propVal);
		
		return intPropVal;
	}	
	
	@Bean
	public LocalSessionFactoryBean sessionFactory(){
		
		// create session factorys
		LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
		
		// set the properties
		sessionFactory.setDataSource(myDataSource());
		sessionFactory.setPackagesToScan(env.getProperty("hibernate.packagesToScan"));
		sessionFactory.setHibernateProperties(getHibernateProperties());
		
		return sessionFactory;
	}
	
	@Bean
	@Autowired
	public HibernateTransactionManager transactionManager(SessionFactory sessionFactory) {
		
		// setup transaction manager based on session factory
		HibernateTransactionManager txManager = new HibernateTransactionManager();
		txManager.setSessionFactory(sessionFactory);

		return txManager;
	}	
	
}

```

* After using spring boot, we can just easily enter the path of sql table , username  and password in application properties , the entity manager (which is similar with session factory ) will be generated automatically

```java
spring.datasource.url=jdbc:mysql://localhost:3306/employee_directory?useSSL=false&serverTimezone=UTC
spring.datasource.username=springstudent
spring.datasource.password=springstudent
```

### Operation (CRUD) (Without Spring Data)

#### Session Factory

* Read the hibernate config file&#x20;
* Generate the session object

#### Session

* Wrap in a JDBC Connection
* Used to perform CRUD Operation

#### Example

```java
public class Main {

    public static void main(String[] args) {
	// write your code here
//        String jdbcUrl = "jdbc:mysql://localhost:3306/test";
//        String user = "root";
//        String pass = "1234";
//
//        try{
//            Connection myConn = DriverManager.getConnection(jdbcUrl, user, pass);
//            System.out.println("Connected!!!!");
//        } catch (SQLException throwables) {
//            throwables.printStackTrace();
//        }

        SessionFactory factory = new Configuration().configure("hibernate.cfg.xml").addAnnotatedClass(Store.class).addAnnotatedClass(Product.class).buildSessionFactory();

        Session session =  factory.getCurrentSession();

        try{
            Transaction tx = session.beginTransaction();

//            Student newStudent = new Student("Peter","Cheng","test@gmail.com");
//            session.save(newStudent);


//            List<Student> studentList = session.createSQLQuery("SELECT * FROM student").addEntity(Student.class).list();
//            studentList.stream().forEach(student -> {
//                System.out.println(student);
//            });

//            SQLQuery sqlQuery = session.createSQLQuery("update student set email = :EMAIL" );
//            sqlQuery.setParameter("EMAIL","p@gmail.com");
//            sqlQuery.executeUpdate();


//            Instructor instructor = new Instructor("Peter","Cheng","gg@gmail.com");
//            InstructorDetail instructorDetail = new InstructorDetail("football");
//            instructorDetail.setInstructor(instructor);
//            instructor.setInstructorDetail(instructorDetail);
//            session.save(instructorDetail);

//            Instructor instructor= session.get(Instructor.class,5L);
//            session.delete(instructor);

//            Teacher teacher = new Teacher("Mary");
//            List<Course> courseList = new ArrayList<>();
//            courseList.add(new Course("football"));
//            courseList.add(new Course("basketball"));
//            teacher.setCourseList(courseList);
//            System.out.println(teacher.getCourseList());
//            session.save(teacher);

//           Teacher teacher = session.get(Teacher.class, 2L);
//           session.delete(teacher);



            List<Product> productList = new ArrayList<>();
            List<Store> storeList = new ArrayList<>();


            Store store1 = new Store("ABC", productList);
            Store store2 = new Store("BCD",productList);
            session.save(store1);
            session.save(store2);
            storeList.add(store1);
            storeList.add(store2);

            Product product1 = new Product("Heyman", storeList);
            Product product2 = new Product("shitman", storeList);
            session.save(product1);
            session.save(product2);


//            Store store = session.get(Store.class, 6L);
//            List<Product> products = store.getProductList();
//            Product newProduct = new Product("superman", storeList);
//            products.add(newProduct);
//            store.setProductList(products);
//            session.save(newProduct);
//            session.save(store);

            tx.commit();
        //    session.flush();
            session.close();

        }
        finally {

            factory.close();
        }

    }
```

### Operation (CRUD) (With Spring Data)

* Spring data contains interface that include default crud method
* we can just make good use of this without define the method manually

```java
public interface EmployeeRepository extends JpaRepository<Employee, Integer> {

	// that's it ... no need to write any code LOL!
	
}
```

