In this lesson, we will create a simple Spring Boot based application which will leverage the power of Hibernate configuration along with Spring Data JPA. We will make use of H2 in-memory database. The choice for the database should not affect the Spring Data definitions we will construct as this is the main advantage Hibernate & Spring Data JPA offers. It enables us to completely separate the Database queries from the application logic.<\/p>\n
2. Making the Spring Boot Project<\/h2>\n
We will be using one of the most popular web tool to make a sample project in this lesson and won’t do it from the command line, we will make use of Spring Initializr<\/a>. Just open the link in your browser and explore around. To setup our project, we used the following configuration:<\/p>\n We added three dependencies in this tool:<\/p>\n Next, unzip the downloaded zip project and import it into your favourite IDE.<\/p>\n To start with, we need to see what Maven dependencies were added to our project by the tool and what others are needed. We will have the following dependency to our pom.xml<\/em> file:<\/p>\n pom.xml<\/em><\/span><\/p>\n Find the latest Spring related dependencies here<\/a>. We have added dependencies which are need to perform Hibernate search too.<\/p>\n Note that we have also added the H2 database dependency here as well with its scope as runtime as the H2 data is washed away as soon as the application has stopped. In this lesson, we will not focus on how H2 actually works but will restrict ourself to Hibernate configuration. You may also see how we can Configure Embedded H2 Console With a Spring Application<\/a>.<\/p>\n Finally, to understand all the JARs which are added to the project when we added this dependency, we can run a simple Maven command which allows us to see a complete Dependency Tree for a project when we add some dependencies to it. Here is a command which we can use:<\/p>\n Check Dependency Tree<\/em><\/span><\/p>\n When we run this command, it will show us the following Dependency Tree:<\/p>\n Dependency Tree<\/em><\/span><\/p>\n Noticed something? So many dependencies were added by just adding four dependencies to the project. Spring Boot collects all related dependencies itself and leaves nothing for us in that matter. The biggest advantage is that all these dependencies are guaranteed to be compatible with each other. Before we move on and start working on the code for the project, let\u2019s present here the project structure we will have once we\u2019re finished adding all code to the project:<\/p>\n We have divided the project into multiple packages so that the principle of separation of concern<\/a> is followed and code remains modular.<\/p>\n Note that the indexpath<\/em> directory was created by Hibernate for storing indexes (discussed later in the lesson) and it will not exist when you import the project in your IDE.<\/p>\n In the application.properties file, we define two properties which are used by Spring Data JPA which is present on the project classpath. Spring Boot uses Hibernate as the default JPA implementation.<\/p>\n application.properties<\/em><\/span><\/p>\n The We will start by adding a very simple model in our project, a Person.java<\/em><\/span><\/p>\n We omitted standard getters and setters for brevity but they are necessary to be made as Jackson uses them during Serialization and Deserialization<\/a> of an Object.<\/p>\n The Finally, we added a custom implementation for the In this section, we will define a service interface which will act as a contract for the implementation and represent all the actions our Service must support. These actions will be related to making a new user and getting information related to the objects in the database.<\/p>\n Here is the contract definition we will be using:<\/p>\n PersonService.java<\/em><\/span><\/p>\n Notice that the contract also includes two methods at the end to provide support for Hibernate search as well. We will use the above interface definition to provide its implementation so that we can perform CRUD operations related to the PersonServiceImpl.java<\/em><\/span><\/p>\n We just used the DAL bean to access the methods we defined above. We also made use of the\u00a0 As most of the operations are done by JPA Repository itself, let’s define it here:<\/p>\n PersonRepository.java<\/em><\/span><\/p>\n Although above interface definition is empty, we still have some points which we need to understand:<\/p>\n Although we have defined the JPA Repository which performs all the CRUD operations, we still will be making a DAL layer which defines the queries for Hibernate free-text search. Let us look at the contract we define:<\/p>\n PersonDAL.java<\/em><\/span><\/p>\n In the DAL Interface we defined, we will be implementing two different type of free-text search:<\/p>\n Let us implement both of these in our DAL layer.<\/p>\n![\"Spring](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/project-creation-1.png\")
<\/a>\n
3. Maven Dependencies<\/h2>\n
<dependencies>\n\n<dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-data-jpa<\/artifactId>\n<\/dependency>\n\n<dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-web<\/artifactId>\n<\/dependency>\n\n<dependency>\n <groupId>org.hibernate<\/groupId>\n <artifactId>hibernate-search-orm<\/artifactId>\n <version>5.6.1.Final<\/version>\n<\/dependency>\n\n<dependency>\n <groupId>org.hibernate<\/groupId>\n <artifactId>hibernate-entitymanager<\/artifactId>\n<\/dependency>\n\n<dependency>\n <groupId>com.h2database<\/groupId>\n <artifactId>h2<\/artifactId>\n <scope>runtime<\/scope>\n<\/dependency>\n\n<dependency>\n <groupId>org.springframework.boot<\/groupId>\n <artifactId>spring-boot-starter-test<\/artifactId>\n <scope>test<\/scope>\n<\/dependency>\n\n<\/dependencies>\n<\/pre>\n
mvn dependency:tree\n<\/pre>\n
[INFO] --------< com.javacodegeeks.example:JCG-BootHibernate-Example >---------\n[INFO] Building JCG-BootHibernate-Example 1.0-SNAPSHOT\n[INFO] --------------------------------[ jar ]---------------------------------\n[INFO]\n[INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ JCG-BootHibernate-Example ---\n[INFO] com.javacodegeeks.example:JCG-BootHibernate-Example:jar:1.0-SNAPSHOT\n[INFO] +- org.springframework.boot:spring-boot-starter-data-jpa:jar:1.5.6.RELEASE:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot-autoconfigure:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.springframework.boot:spring-boot-starter-logging:jar:1.5.6.RELEASE:compile\n[INFO] | | | +- ch.qos.logback:logback-classic:jar:1.1.11:compile\n[INFO] | | | | \\- ch.qos.logback:logback-core:jar:1.1.11:compile\n[INFO] | | | +- org.slf4j:jul-to-slf4j:jar:1.7.25:compile\n[INFO] | | | \\- org.slf4j:log4j-over-slf4j:jar:1.7.25:compile\n[INFO] | | \\- org.yaml:snakeyaml:jar:1.17:runtime\n[INFO] | +- org.springframework.boot:spring-boot-starter-aop:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.springframework:spring-aop:jar:4.3.10.RELEASE:compile\n[INFO] | | \\- org.aspectj:aspectjweaver:jar:1.8.10:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter-jdbc:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.apache.tomcat:tomcat-jdbc:jar:8.5.16:compile\n[INFO] | | | \\- org.apache.tomcat:tomcat-juli:jar:8.5.16:compile\n[INFO] | | \\- org.springframework:spring-jdbc:jar:4.3.10.RELEASE:compile\n[INFO] | +- org.hibernate:hibernate-core:jar:5.0.12.Final:compile\n[INFO] | | +- antlr:antlr:jar:2.7.7:compile\n[INFO] | | \\- org.jboss:jandex:jar:2.0.0.Final:compile\n[INFO] | +- javax.transaction:javax.transaction-api:jar:1.2:compile\n[INFO] | +- org.springframework.data:spring-data-jpa:jar:1.11.6.RELEASE:compile\n[INFO] | | +- org.springframework.data:spring-data-commons:jar:1.13.6.RELEASE:compile\n[INFO] | | +- org.springframework:spring-orm:jar:4.3.10.RELEASE:compile\n[INFO] | | +- org.springframework:spring-context:jar:4.3.10.RELEASE:compile\n[INFO] | | +- org.springframework:spring-tx:jar:4.3.10.RELEASE:compile\n[INFO] | | +- org.springframework:spring-beans:jar:4.3.10.RELEASE:compile\n[INFO] | | +- org.slf4j:slf4j-api:jar:1.7.25:compile\n[INFO] | | \\- org.slf4j:jcl-over-slf4j:jar:1.7.25:compile\n[INFO] | \\- org.springframework:spring-aspects:jar:4.3.10.RELEASE:compile\n[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:1.5.6.RELEASE:compile\n[INFO] | +- org.springframework.boot:spring-boot-starter-tomcat:jar:1.5.6.RELEASE:compile\n[INFO] | | +- org.apache.tomcat.embed:tomcat-embed-core:jar:8.5.16:compile\n[INFO] | | +- org.apache.tomcat.embed:tomcat-embed-el:jar:8.5.16:compile\n[INFO] | | \\- org.apache.tomcat.embed:tomcat-embed-websocket:jar:8.5.16:compile\n[INFO] | +- org.hibernate:hibernate-validator:jar:5.3.5.Final:compile\n[INFO] | | +- javax.validation:validation-api:jar:1.1.0.Final:compile\n[INFO] | | \\- com.fasterxml:classmate:jar:1.3.3:compile\n[INFO] | +- com.fasterxml.jackson.core:jackson-databind:jar:2.8.9:compile\n[INFO] | | +- com.fasterxml.jackson.core:jackson-annotations:jar:2.8.0:compile\n[INFO] | | \\- com.fasterxml.jackson.core:jackson-core:jar:2.8.9:compile\n[INFO] | +- org.springframework:spring-web:jar:4.3.10.RELEASE:compile\n[INFO] | \\- org.springframework:spring-webmvc:jar:4.3.10.RELEASE:compile\n[INFO] | \\- org.springframework:spring-expression:jar:4.3.10.RELEASE:compile\n[INFO] +- org.hibernate:hibernate-search-orm:jar:5.6.1.Final:compile\n[INFO] | \\- org.hibernate:hibernate-search-engine:jar:5.6.1.Final:compile\n[INFO] | +- org.apache.lucene:lucene-core:jar:5.5.4:compile\n[INFO] | +- org.apache.lucene:lucene-misc:jar:5.5.4:compile\n[INFO] | +- org.apache.lucene:lucene-analyzers-common:jar:5.5.4:compile\n[INFO] | \\- org.apache.lucene:lucene-facet:jar:5.5.4:compile\n[INFO] | \\- org.apache.lucene:lucene-queries:jar:5.5.4:compile\n[INFO] +- org.hibernate:hibernate-entitymanager:jar:5.0.12.Final:compile\n[INFO] | +- org.jboss.logging:jboss-logging:jar:3.3.1.Final:compile\n[INFO] | +- dom4j:dom4j:jar:1.6.1:compile\n[INFO] | +- org.hibernate.common:hibernate-commons-annotations:jar:5.0.1.Final:compile\n[INFO] | +- org.hibernate.javax.persistence:hibernate-jpa-2.1-api:jar:1.0.0.Final:compile\n[INFO] | +- org.javassist:javassist:jar:3.21.0-GA:compile\n[INFO] | \\- org.apache.geronimo.specs:geronimo-jta_1.1_spec:jar:1.1.1:compile\n[INFO] +- com.h2database:h2:jar:1.4.196:runtime\n[INFO] \\- org.springframework.boot:spring-boot-starter-test:jar:1.5.6.RELEASE:test\n[INFO] +- org.springframework.boot:spring-boot-test:jar:1.5.6.RELEASE:test\n[INFO] +- org.springframework.boot:spring-boot-test-autoconfigure:jar:1.5.6.RELEASE:test\n[INFO] +- com.jayway.jsonpath:json-path:jar:2.2.0:test\n[INFO] | \\- net.minidev:json-smart:jar:2.2.1:test\n[INFO] | \\- net.minidev:accessors-smart:jar:1.1:test\n[INFO] | \\- org.ow2.asm:asm:jar:5.0.3:test\n[INFO] +- junit:junit:jar:4.12:test\n[INFO] +- org.assertj:assertj-core:jar:2.6.0:test\n[INFO] +- org.mockito:mockito-core:jar:1.10.19:test\n[INFO] | \\- org.objenesis:objenesis:jar:2.1:test\n[INFO] +- org.hamcrest:hamcrest-core:jar:1.3:test\n[INFO] +- org.hamcrest:hamcrest-library:jar:1.3:test\n[INFO] +- org.skyscreamer:jsonassert:jar:1.4.0:test\n[INFO] | \\- com.vaadin.external.google:android-json:jar:0.0.20131108.vaadin1:test\n[INFO] +- org.springframework:spring-core:jar:4.3.10.RELEASE:compile\n[INFO] \\- org.springframework:spring-test:jar:4.3.10.RELEASE:test\n[INFO] ------------------------------------------------------------------------\n[INFO] BUILD SUCCESS\n[INFO] ------------------------------------------------------------------------\n<\/pre>\n
4. Project Structure<\/h2>\n
![\"Hibernate](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/project-structure-1.png\")
<\/a>5. Defining Hibernate Dialects<\/h2>\n
## Hibernate Properties\n# The SQL dialect makes Hibernate generate better SQL for the chosen database\nspring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect\n\n# Hibernate DDL auto (create, create-drop, validate, update)\nspring.jpa.hibernate.ddl-auto = update\n<\/pre>\n
spring.jpa.hibernate.ddl-auto<\/code> property is important here. Due to this, Spring Data will automatically make Database tables on the basis of entities we define in our project and columns will be made from the entity’s fields. As we have set the property to update<\/code>, whenever we update a field in our Entity class, it will automatically be updated in the DB as soon as we relaunch the project.<\/p>\n6. Defining an Entity<\/h2>\n
Person<\/code>. Its definition will be very standard, like:<\/p>\n@Entity\n@Indexed\npublic class Person {\n\n @Id\n @GeneratedValue\n private Long id;\n\n @Field(termVector = TermVector.YES)\n private String name;\n\n @Field\n private int age;\n\n \/\/ standard getters and setters\n\n @Override\n public String toString() {\n return String.format(\"Person{id=%d, name='%s', age=%d}\", id, name, age);\n }\n}\n<\/pre>\n@Entity<\/code> annotation marks this POJO as an object which will be managed by the Spring Data APIs and its fields will be treated as table columns (unless marked transient) and @Field<\/code> annotation marks that this field should be indexed by Hibernate so that we can run the full-text search<\/strong> query on these fields as well.<\/p>\ntoString()<\/code> method so that we can print related data when we test our application.<\/p>\n7. Making a Service Interface<\/h2>\n
public interface PersonService {\n Person createPerson(Person person);\n Person getPerson(Long id);\n Person editPerson(Person person);\n void deletePerson(Person person);\n void deletePerson(Long id);\n List<Person> getAllPersons(int pageNumber, int pageSize);\n List<Person> getAllPersons();\n long countPersons();\n List<Person> fuzzySearchPerson(String term);\n List<Person> wildCardSearchPerson(String term);\n}\n<\/pre>\n
\n[ulp id=’oiCtu6x3AwpaVNPI’]
\n <\/p>\n8. Implementing the Service<\/h2>\n
Person<\/code> Entity we defined earlier. We will do it here:<\/p>\n@Service\npublic class PersonServiceImpl implements PersonService {\n\n private final PersonRepository personRepository;\n private final PersonDAL personDAL;\n\n @Autowired\n public PersonServiceImpl(PersonRepository personRepository, PersonDAL personDAL) {\n this.personRepository = personRepository;\n this.personDAL = personDAL;\n }\n\n @Override\n public Person createPerson(Person person) {\n return personRepository.save(person);\n }\n\n @Override\n public Person getPerson(Long id) {\n return personRepository.findOne(id);\n }\n\n @Override\n public Person editPerson(Person person) {\n return personRepository.save(person);\n }\n\n @Override\n public void deletePerson(Person person) {\n personRepository.delete(person);\n }\n\n @Override\n public void deletePerson(Long id) {\n personRepository.delete(id);\n }\n\n @Override\n public List<Person> getAllPersons(int pageNumber, int pageSize) {\n return personRepository.findAll(new PageRequest(pageNumber, pageSize)).getContent();\n }\n\n @Override\n public List<Person> getAllPersons() {\n return personRepository.findAll();\n }\n\n @Override\n public long countPersons() {\n return personRepository.count();\n }\n\n @Override\n @Transactional(readOnly = true)\n public List<Person> fuzzySearchPerson(String term) {\n return personDAL.fuzzySearchPerson(term);\n }\n\n @Override\n @Transactional(readOnly = true)\n public List<Person> wildCardSearchPerson(String term) {\n return personDAL.wildCardSearchPerson(term);\n }\n}\n<\/pre>\n@Transactional(readOnly = true)<\/code> annotation so that we don’t have to open a Hibernate session which is needed when you do some write operations, but as we only need to perform the search, we can safely mention readOnly<\/code> property to true<\/code>.<\/p>\n9. Defining JPA Repository<\/h2>\n
@Repository\npublic interface PersonRepository extends JpaRepository<Person, Long> {\n}\n<\/pre>\n\n
@Repository<\/code> annotation marks this interface as a Spring Bean which is initialised on application startup. With this annotation, Spring takes care of managing exception database interaction throws gracefully<\/li>\nPerson<\/code> as a parameter to signify that this JPA interface will manage the Person Entity<\/li>\nLong<\/code> as a parameter. This signifies that the Person<\/code> Entity contains a unique identifier which is of the type Long<\/li>\n<\/ul>\n10. Defining Data Access Layer (DAL) Interface<\/h2>\n
public interface PersonDAL {\n List<Person> fuzzySearchPerson(String term);\n List<Person> wildCardSearchPerson(String term);\n}\n<\/pre>\n11. Implementing DAL Interface<\/h2>\n
\n
Hibernate<\/code> and Hibernat<\/code> has a gap of 1 due to missing e<\/code> in later word, the terms Hibernate<\/code> and Hibernawe<\/code> also has a gap of 1 as a single character in later String i.e. w<\/code> can be replaced to form the former String.<\/li>\nHibernate<\/code> can be Hiber<\/code>, bernate<\/code> etc.<\/li>\n<\/ul>\n11.1 Defining Fuzzy Query<\/h3>\n
![\"Run](\"http:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2018\/04\/run-hibernate-project.png\")
<\/a>