Akshay Baviskar's Blog

Simplifying Data Access with Spring Boot Data Jpa

Akshay Baviskar's photo
Akshay Baviskar
·

3 min read

Spring Boot, a popular java-based framework simplifies a development of robust and efficient application. One of its key features is Spring Data Jpa , which provides a powerful way to interact with relational databases using Java Persistence Api (JPA). In this blog we will explore Spring Boot Data Jpa.

What is Spring Boot Data Jpa?

Spring Boot Data Jpa is a part of larger Spring Boot project that aims to simplify data access in spring applications. It provides a high level abstractions over Jpa, allowing developers to interact with databases using familiar java objects and methods. With Spring Boot Data Jpa you can eliminate boilerplate code and can focus on business logic.

Getting started with Spring Boot Data Jpa

To use Spring Boot Data Jpa you first need to include the necessary dependency in your pom.xml file. For Maven, add the following dependency. We are also adding h2 database dependency for storing data into database, h2 is a popular in memory relational database.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Before that we to get look on some important annotations which are often used in program:

  • @Entity : Marks a class as JPA entity which means it will be mapped to a table in the database.

  • @Table : Specifies the name of the database table to which the entity is mapped if not specified the table name will be same as entity name.

  • @Id : Specifies the primary key for the table.

  • @GeneratedValue : Configures the way primary keys are generated. Common strategies include GenerationType.AUTO , GenerationType.IDENTITY and GenerationType.SEQUENCE

  • @OneToOne, @OneToMany, @ManyToOne, @ManyToMany: Annotations used to define different types of relationships between entities.

Creating Entity

Next you need to define your Jpa entity. These are simple java classes that represents table in your databases for that mapping we have to annotate class by @Entity to map class with database table. @Id is used to specify a primary key.

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    // getters and setters
}

Creating Repository

Repository is an interface which extends an interface called JpaRepository<Product, Long> . These interface define common CRUD operation (create, update, read, delete) Spring Data Jpa automatically generate implementation for these method at runtime.

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    Product findByName(String name);
}

Using Repository in Service

In your service classes, you can inject repository instance and use them to interact with database. Spring Boot will automatically manage the transactional behaviour for you.

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;

    public Product findProductByName(String name) {
        return productRepository.findByName(name);
    }    
    // other business logic methods
}

Configuring The Data Source

Spring Boot simplifies database configuration through properties in the application.properties or application.yml file. For example, to configure an in-memory H2 Database you can add the following properties.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

Running the Application

With everything set up, you can now run your Spring Boot application. Spring Boot will automatically create the necessary database tables based on your entity classes and start the embedded web server. You can then access your application at http://localhost:8080.

Conclusion

Spring Boot Data JPA simplifies the development of data centric application in java by providing an powerful abstraction over JPA. It eliminates boilerplate code and allows you to focus on writing business logic. By following the steps outlined in this blog, you can quickly get started with Spring Boot Data JPA and build efficient and scalable applications.

Spring Data JpaSpringboot