Spring JPA – Giới thiệu các tính năng và cách sử dụng

Spring Daa JPA là gì?

Spring Data JPA không phải là một JPA provider điều này khác với Hibernate. Hiberate là JPA provider hay nói cách khác Hibernate implement JPA.

Các tính năng cơ bản của Spring Data JPA.

• Hỗ trợ xây dựng respositories dựa trên Spring và JPA.
• Hỗ trợ phân trang, thực hiện query động..
• Hỗ trợ XML mapping
• Cấu hình JavaConfig bằng việc sử dụng @EnableJpaRepositories.

Spring Data Commons and Spring Data JPA Repositories/interfaces

Bên dưới là sơ đồ các interface từ Spring Data Commons và Spring Data JPA modules.

Spring Data Commonds là một phần của Spring data nó cung cấp nền tảng chia sẻ. Nó bao gồm các repository interfaces cũng như các metadata model cho persit java class. Nó có các giao diện sau.

1. Repository<T, ID extends Serializable> interface
2. CrudRepository<T, ID extends Serializable> interface
3. PagingAndSortingRepository<T, ID extends Serializable> interface
4. QueryDslPredicateExecutor interface

Chúng ta sẽ xem chi tiết về interface với source code và các hàm.

The Repository<T, ID extends Serializable> interface

package org.springframework.data.repository;

import org.springframework.stereotype.Indexed;

@Indexed
public interface Repository<T, ID> {

}

Đoạn code trên mô tả nó là 1 interface marker, để hiểu hơn về các bạn có thể xem tại đây

https://www.baeldung.com/java-marker-interfaces

The CrudRepository<T, ID extends Serializable> interface

The CrudRepository<T, ID extends Serializable> : Interface này cung cấp các hành động CRUD.

package org.springframework.data.repository;

import java.util.Optional;  @NoRepositoryBean
public interface CrudRepository < T, ID > extends Repository < T, ID > {

    <S extends T > S save(S entity);

    <S extends T > Iterable < S > saveAll(Iterable < S > entities);

    Optional < T > findById(ID id);

    boolean existsById(ID id);

    Iterable < T > findAll();

    Iterable < T > findAllById(Iterable < ID > ids);

    long count();

    void deleteById(ID id);

    void delete(T entity);

    void deleteAll();
}

Cách sử dụng:

1. long count() – Trả về số entity
2. void delete(T entity) – Xóa một entity
3. void deleteAll() – Xóa tất cả các entity
4. void deleteAll(Iterable<? extends T> entities) – Xóa tập hợp các entity
5. void deleteById(ID id) – Xóa entity theo ID
6. boolean existsById(ID id) – Returns whether an entity with the given id exists. Trả về có hay không một entity với ID
7. Iterable findAll() – Trả về tất cả instances của type.
8. Iterable findAllById(Iterable ids) -Trả về tất cả instance của type với ID.
9. Optional findById(ID id) – Tìm entity theo ID.
10. save(S entity) -Save một entity đã cho.
11. Iterable saveAll(Iterable entities) -Save tập hợp Entity.

The PagingAndSortingRepository<T, ID extends Serializable> interface

Interface PagingAndSortingRepository<T, ID extends Serializable> là kế thừa CrudRepository  để cung cấp các phương thức phục vụ cho việc phân trang và sắp xếp.

package org.springframework.data.repository;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

@NoRepositoryBean
public interface PagingAndSortingRepository < T, ID > extends CrudRepository < T, ID > {

    /**
     * Returns all entities sorted by the given options.
     * 
     * @param sort
     * @return all entities sorted by the given options
     */
    Iterable < T > findAll(Sort sort);

    /**
     * Returns a {@link Page} of entities meeting the paging restriction provided in the {@code Pageable} object.
     * 
     * @param pageable
     * @return a page of entities
     */
    Page < T > findAll(Pageable pageable);
}

The QueryDslPredicateExecutor interface

Khai báo các phương thức sử dụng để lấy dữ liệu từ database bằng việc sử dụng đối tượng QueryDls

package org.springframework.data.querydsl;

import java.util.Optional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

import com.querydsl.core.types.OrderSpecifier;
import com.querydsl.core.types.Predicate;

public interface QuerydslPredicateExecutor < T > {

    Optional < T > findOne(Predicate predicate);

    Iterable < T > findAll(Predicate predicate);

    Iterable < T > findAll(Predicate predicate, Sort sort);

    Iterable < T > findAll(Predicate predicate, OrderSpecifier << ? > ...orders);

    Iterable < T > findAll(OrderSpecifier << ? > ...orders);

    Page < T > findAll(Predicate predicate, Pageable pageable);

    long count(Predicate predicate);

    boolean exists(Predicate predicate);
}

Spring Data JPA Interfaces

Spring Data JPA project cung cấp 2 interface sau:

• JpaRepository<T, ID extends Serializable> interface
• JpaSpecificationExecutor interface

JpaRepository<T, ID extends Serializable> interface

package org.springframework.data.jpa.repository;

import java.util.List;

import javax.persistence.EntityManager;

import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

@NoRepositoryBean
public interface JpaRepository < T, ID > extends PagingAndSortingRepository < T, ID > , QueryByExampleExecutor < T > {

    List < T > findAll();

    List < T > findAll(Sort sort);

    List < T > findAllById(Iterable < ID > ids);

    <S extends T > List < S > saveAll(Iterable < S > entities);

    void flush();

    <S extends T > S saveAndFlush(S entity);

    void deleteInBatch(Iterable < T > entities);

    void deleteAllInBatch();

    T getOne(ID id);

    @Override <
    S extends T > List < S > findAll(Example < S > example);

    @Override <
    S extends T > List < S > findAll(Example < S > example, Sort sort);
}

JpaSpecificationExecutor interface

package org.springframework.data.jpa.repository;

import java.util.List;
import java.util.Optional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.lang.Nullable;

public interface JpaSpecificationExecutor<T> {

 Optional<T> findOne(@Nullable Specification<T> spec);

 List<T> findAll(@Nullable Specification<T> spec);

 Page<T> findAll(@Nullable Specification<T> spec, Pageable pageable);

 List<T> findAll(@Nullable Specification<T> spec, Sort sort);

 long count(@Nullable Specification<T> spec);
}

Sau khi đã tìm hiểu các tính năng của Spring Data JPA và các interface của nó.

Làm thế nào để sử dụng Spring Data JPA.

Dưới đây là 3 bước để sử dụng Spring Data JPA.

1. Tạo 1 interface thừa kế interface CrudRepository  được cung cấp từ Spring Data.

public interface CustomerRepository extends CrudRepository<Customer, Long> {

}

Thêm các hàm tiện ích nếu bạn muốn.

public interface CustomerRepository extends CrudRepository<Customer, Long> {

    long deleteByLastname(String lastname);

    List<User> removeByLastname(String lastname);

    long countByLastname(String lastname);
}

Để sử dụng cấu hình bằng java code, tạo 1 class như sau:

import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@EnableJpaRepositories
public class Config {}

Để sử dụng xml khai báo bean như sau:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/data/jpa
     http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

   <jpa:repositories base-package="com.acme.repositories"/>

</beans>

Inject các thành phần tới các lớp khác..

@Service
public class CustomerServiceImpl implements CustomerService {

    @Autowired
    private CustomerRepository customerRepository;

    @Override
    @Transactional
    public List < Customer > getCustomers() {
        return customerRepository.findAll();
    }

    @Override
    @Transactional
    public void saveCustomer(Customer theCustomer) {
        customerRepository.save(theCustomer);
    }

    @Override
    @Transactional
    public Customer getCustomer(int id) throws ResourceNotFoundException {
        return customerRepository.findById(id).orElseThrow(
            () - > new ResourceNotFoundException(id));
    }

    @Override
    @Transactional
    public void deleteCustomer(int theId) {
        customerRepository.deleteById(theId);
    }
}

Cảm ơn các bạn đã theo dõi.