Spring Boot and Hibernate Tutorial

In this tutorial, we will explore the integration of Spring Boot and Hibernate in a web application using a CRUD (Create, Read, Update, Delete) example. This tutorial assumes that you have prior knowledge of both technologies.

### Setting up the Database

To begin with, let's create our database table using SQL script:

```sql

CREATE TABLE PERSON (

`id` int(11) unsigned NOT NULL AUTO_INCREMENT,

`name` varchar(50),

`country` varchar(20),

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

```

This table has three columns: `id`, `name`, and `country`. We will map this table to our entity bean in the next step.

### Entity Bean

Our entity bean maps to the `PERSON` table in the MySQL database. Note that we have not annotated the `name` and `country` fields with Hibernate annotations because they are of the same name. This is a common scenario where we need to provide mapping file details while configuring Hibernate SessionFactory in Spring bean configurations.

Here's our entity bean class:

```java

@Entity

@Table(name = 'PERSON')

public class Person {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private int id;

private String name;

private String country;

// Getters and setters

}

```

### Configuring Hibernate SessionFactory

To configure our Hibernate SessionFactory, we need to provide the mapping file details in our Spring bean configuration file. Here's an example of how you can do it:

```xml

xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'

xsi:schemaLocation='http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd'>

```

In this configuration, we are telling Spring to use the `LocalSessionFactoryBean` class and provide the Hibernate configuration file (`hibernate.cfg.xml`) and the package where our entity beans are located.

### Creating a Service Layer

Next, let's create a service layer that will interact with our database using Hibernate. Here's an example of how you can do it:

```java

public interface PersonService {

List getAllPersons();

Person getPersonById(int id);

void savePerson(Person person);

void deletePerson(int id);

}

```

Here, we are defining a service interface with methods to perform CRUD operations on our `Person` entity.

### Implementing the Service Layer

Next, let's implement our `PersonService` interface:

```java

@Service('personService')

public class PersonServiceImpl implements PersonService {

@Autowired

private SessionFactory sessionFactory;

public List getAllPersons() {

Session session = sessionFactory.getCurrentSession();

Query query = session.createQuery('from Person');

return query.list();

}

public Person getPersonById(int id) {

Session session = sessionFactory.getCurrentSession();

return (Person) session.get(Person.class, id);

}

public void savePerson(Person person) {

Session session = sessionFactory.getCurrentSession();

session.saveOrUpdate(person);

}

public void deletePerson(int id) {

Session session = sessionFactory.getCurrentSession();

Person person = (Person) session.get(Person.class, id);

if (person != null) {

session.delete(person);

}

```

Here, we are using Spring's `@Service` annotation to mark our service class as a bean and using Spring's `@Autowired` annotation to inject the `SessionFactory` bean.

###

In this tutorial, we have explored the integration of Spring Boot and Hibernate in a web application using a CRUD example. We have created a database table, mapped it to our entity bean, configured Hibernate SessionFactory, and implemented a service layer using Hibernate. This is just the beginning of our journey with Spring Boot and Hibernate, and we will explore more features and scenarios in future tutorials.

Spring boot and hibernate tutorial