Welcome to the first lesson of the course, "Persisting Data with Spring Data JPA." Throughout this course, you'll learn how to leverage Spring Data JPA to connect your application to relational databases, create simple and complex relations, implement pagination and sorting, and more. In this introductory lesson, we’ll explore the low-level way of working with relational databases using JDBC and contrast it with the high-level, more efficient way using JPA. We'll also introduce Spring Data JPA, a Spring module that simplifies database operations by building on top of JPA. Let's get started!

Java Database Connectivity (JDBC) is a Java Standard Edition (SE) API that allows Java applications to interact with relational databases. It involves writing explicit SQL queries, managing database connections, and handling result sets manually. Here is an example of how to retrieve data using JDBC:

As you can see, this approach is cumbersome with a lot of boilerplate code. This method has nothing to do with Spring Boot and reflects the complexities involved in manual database operations.

If you want to dive deeper into JDBC, refer to the official specification.

The Java Persistence API (JPA) is a Java Enterprise Edition (EE) specification for Object Relational Mapping (ORM), which simplifies database interactions by mapping Java objects to database tables. ORM allows you to manipulate database records through Java objects, making your code cleaner and more maintainable. Here’s an example of a JPA entity class:

In this example:

• @Entity: Marks this class as a JPA entity. This annotation will map the class to a database table named person (default naming convention).
• @Id: Specifies the primary key of the entity. This annotation maps the id field to the primary key column of the person table.
• @GeneratedValue(strategy = GenerationType.IDENTITY): Defines how the primary key is generated. Using IDENTITY strategy, the id field will be auto-incremented by the database.

So, this class will be mapped to a table named person, which will have columns id, name, and age, with id being the primary key.

For more information on JPA, consult the official specification.

Spring Data JPA is a Spring module that builds on top of JPA and provides an abstraction layer to further reduce the boilerplate code required for database operations. It integrates closely with the Spring framework, offering additional features such as derived queries, pagination, and auditing. This module simplifies data access in Spring applications and makes writing repository interfaces straightforward and less time-consuming.

Here are the essential Gradle dependencies you need to add to your project:

Explanation:

• spring-boot-starter-data-jpa: This dependency includes Spring Data JPA and Hibernate as the default JPA provider.
• com.h2database:h2: This is the JDBC driver for the H2 database. Note that the database driver is not included in spring-boot-starter-data-jpa, so you need to specify the appropriate driver for your database.

The H2 database is an open-source in-memory database which is particularly useful during development for its speed and simplicity. For more information, visit their official website.

Hibernate is the most commonly used JPA provider, but there are alternatives such as EclipseLink and OpenJPA. If you prefer to use a different JPA provider, you can exclude Hibernate and include your preferred provider in the dependencies:

To explore more about Spring Data JPA, check out the official documentation.

Here is how you can define an entity class using Spring Data JPA:

As Spring Data JPA is an extension of JPA, the entity class will look exactly the same as if we were using basic JPA. In this class:

• @Entity marks it as a JPA entity.
• @Id specifies the primary key.
• @GeneratedValue(strategy = GenerationType.IDENTITY) defines how the primary key is generated.

To interact with the TodoItem entity, you can define a repository interface:

This interface extends JpaRepository<TodoItem, Long> (where Long is the type of the primary key of TodoItem), which provides CRUD operations and other methods out of the box. Spring Data JPA generates the actual implementation at runtime. When your Spring Boot application starts, it will create an instance of this interface, which you can then inject into your controllers or other beans using @Autowired or constructor injection.

Let's implement a simple CRUD controller to manage TodoItem entities:

In this controller:

• TodoRepository#findAll(): Retrieves all TodoItem entities.
• TodoRepository#save(TodoItem todoItem): Saves a new or updated TodoItem entity.
• TodoRepository#findById(Long id): Finds a TodoItem entity by its ID and returns an Optional<TodoItem>.
• TodoRepository#deleteById(Long id): Deletes a TodoItem entity by its ID.

Hibernate, the most commonly used JPA provider, allows you to enable SQL logging to see the actual SQL queries it generates. You can enable this feature in your application.properties file:

This setting helps you understand and debug the SQL operations that JPA performs behind the scenes.

In this lesson, we introduced you to JDBC, JPA, and Spring Data JPA, explaining their purposes and differences. We demonstrated how to create a JPA entity class and a Spring Data JPA repository interface, and how to implement a CRUD controller to manage the entity. Lastly, we showed how to enable SQL logging to see the actual SQL queries. In the next practice, you'll get hands-on experience with these concepts.