How to use JPA repository in spring boot project

In Spring Boot, the JPA (Java Persistence API) repository is a powerful feature that simplifies the process of working with databases. It provides an easy way to perform CRUD (Create, Read, Update, Delete) operations on your entities without having to write boilerplate SQL queries.

To use JPA repository in Spring Boot:

1. Define your entity class: An entity is a Java class representing a table in the database. Use the `@Entity` annotation to mark it as an entity and `@Id` to define the primary key.

2. Create a repository interface: Extend the `JpaRepository` interface from Spring Data JPA and pass your entity class and the type of the primary key as generic parameters.

Example:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MyEntityRepository extends JpaRepository {
    // You can define custom query methods here if needed
}

3. Enable JPA repositories: Ensure that you have enabled Spring Data JPA by using the `@EnableJpaRepositories` annotation on your main application class or a configuration class.

4. Start using the repository: Inject the repository into your service or controller using the `@Autowired` annotation, and you can use its methods to interact with the database.

Example:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Autowired   
    private final MyEntityRepository myEntityRepository;

    public MyService(MyEntityRepository myEntityRepository) {
        this.myEntityRepository = myEntityRepository;
    }

    // Now you can use myEntityRepository to perform CRUD operations

    public void saveEntity(MyEntity entity) {
        myEntityRepository.save(entity);
    }

    public MyEntity getEntityById(Long id) {
        return myEntityRepository.findById(id).orElse(null);
    }
    // ... other methods
}

Spring Boot will automatically generate the necessary SQL queries based on the method names defined in your repository interface, making it convenient to work with databases in your application.

How to write named and native query in JPA repository

To write named and native queries in JPA (Java Persistence API), you can use the `@NamedQuery` and `@NamedNativeQuery` annotations respectively. Here's a brief explanation of each:

1. Named Queries (`@NamedQuery`):

Named queries are used to define SQL-like queries in your Java code, and they are associated with a particular entity class. These queries are written using JPQL (Java Persistence Query Language). To create a named query, you can do the following:

@Entity
@NamedQuery(name = "findAllEmployees", query = "SELECT e FROM Employee e")
public class Employee {

    // Entity class code

}

In the above example, we created a named query with the name "findAllEmployees" that retrieves all records from the "Employee" entity.

2. Native Queries (`@NamedNativeQuery`):

Native queries allow you to write native SQL queries directly. These queries are suitable when you need to perform database-specific operations that might not be supported in JPQL. To create a native query, use the `@NamedNativeQuery` annotation:

@Entity
@NamedNativeQuery(name = "findAllEmployeesNative", query = "SELECT * FROM employees", resultClass = Employee.class)
public class Employee {

    // Entity class code

}

In this example, we created a native query with the name "findAllEmployeesNative" that retrieves all records from the "employees" table and maps the results to the `Employee` entity class.

To use the named queries in your code, you can use the `EntityManager` or `TypedQuery` to execute the named query.

For example:

EntityManager em = // Obtain the entity manager

TypedQuery namedQuery = em.createNamedQuery("findAllEmployees", Employee.class);

List<Employee> employees = namedQuery.getResultList();

Using Native Query:

EntityManager em = // Obtain the entity manager

TypedQuery nativeQuery = em.createNamedQuery("findAllEmployeesNative", Employee.class);

List<Employee> employees = nativeQuery.getResultList();

If you want to know more or have doubt in any topic regarding spring boot then feel free to contact us or leave a comment below the blog post. We are here to help you! :)