The core of mastering Advanced Spring Data JPA is to select the appropriate data access method based on the scenario and ensure performance and maintainability. 1. In custom query, @Query supports JPQL and native SQL, which is suitable for complex association and aggregation operations. It is recommended to use DTO or interface projection to perform type-safe mapping to avoid maintenance problems caused by using Object[]. 2. The paging operation needs to be implemented in combination with Pageable, but beware of N 1 query problems. You can preload the associated data through JOIN FETCH or use projection to reduce entity loading, thereby improving performance. 3. For multi-condition dynamic queries, JpaSpecificationExecutor should be used to combine Specification to build reusable and composable query logic to improve code readability and flexibility. 4. The audit function automatically fills the time and operator through annotations such as @CreatedDate, @LastModifiedBy, etc., and needs to be enabled with @EntityListeners and @EnableJpaAuditing, and provides current user information through AuditorAware. 5. Custom Repository requires the implementation class of interface and Impl suffix. Spring Data will be automatically assembled, which is suitable for encapsulating complex logic such as stored procedure calls. 6. In transaction management, @Transactional can configure readOnly to improve query performance. During batch operations, flush and clear EntityManager should be manually flushed and clear EntityManager to control the cache size and avoid memory overflow. In summary, the truly production-level DAO layer needs to comprehensively use these technologies to balance efficiency, security and maintainability, and ultimately achieve efficient and stable database access.

If you have used Spring Data JPA to do some basic CRUD operations and now want to further improve the efficiency and maintainability of the data access layer, then "Advanced Spring Data JPA" is what you should master in depth. It is not just writing JpaRepository<t id></t> interface, but how to operate the database efficiently, flexibly and securely in complex business scenarios.

The following is a few key directions to take you into advanced usage.

1. Custom query: Not only @Query, but also need to understand native SQL and dynamic splicing

Spring Data JPA provides a variety of ways to execute queries. In addition to method name resolution (such as findByStatusAndCreateTimeAfter ), advanced developers should master it:

• Advanced usage of @Query annotations
  Supports JPQL and native SQL. Native SQL is more flexible when it is necessary to associate multiple tables, aggregate functions, or database-specific functions.

   @Query(value = """
      SELECT u.id, u.name, COUNT(o.id) as orderCount
      FROM users u
      LEFT JOIN orders o ON u.id = o.user_id
      WHERE u.status = :status
      GROUP BY u.id, u.name
      """, nativeQuery = true)
  List<Object[]> findUserWithOrderCount(@Param("status") String status);

  Note: When returning List<Object[]> , the field order needs to be mapped manually. It is recommended to encapsulate it into a DTO.

  

• Simplify result mapping using Projection
  Defines an interface or class to receive partial fields to avoid loading full entities.

   public interface UserSummary {
      Long getId();
      String getName();
      Integer getOrderCount();
  }

  Then use in @Query :

   @Query("SELECT u.id as id, u.name as name, COUNT(o) as orderCount "  
         "FROM User u LEFT JOIN u.orders o "  
         "WHERE u.status = :status "  
         "GROUP BY u.id")
  List<UserSummary> findUserSummariesByStatus(@Param("status") String status);

2. Pagination and performance optimization: Avoid N 1 query problems

Pagination may seem simple, but it can easily cause performance problems in reality, especially when associated queries.

• Use Pageable to correctly paginate
  With the method signature plus the Pageable parameter, Spring will automatically process the paging logic.

   Page<User> findByRole(String role, Pageable pageable);

  When called:

   Pageable page = PageRequest.of(0, 10, Sort.by("createTime").descending());
  Page<User> users = userRepository.findByRole("ADMIN", page);

• Beware of N 1 query
  When an entity contains a @OneToMany association, returning directly to Page<User> may cause each User to trigger an association query.

  Solution:

  • Preload associated data in the main query using JOIN FETCH :

     @Query("SELECT u FROM User u LEFT JOIN FETCH u.orders WHERE u.role = :role")
    Page<User> findUsersWithOrdersByRole(@Param("role") String role, Pageable pageable);

  • Or use DTO projection to avoid loading the entire entity.

3. Specification: an elegant solution for dynamic query

When query conditions are complex and optional (such as background management searches), hard-coded @Query can become difficult to maintain. JpaSpecificationExecutor Specification is a powerful tool for building dynamic queries.

 public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
}

Then build dynamic conditions:

 public static Specification<User> hasNameLike(String name) {
    return (root, query, cb) -> 
        name == null ? null : cb.like(root.get("name"), "%" name "%");
}

public static Specification<User> hasStatus(String status) {
    return (root, query, cb) -> 
        status == null ? null : cb.equal(root.get("status"), status);
}

Combination use:

 Specification<User> spec = Specification.where(hasNameLike(name))
                                       .and(hasStatus(status));
Page<User> result = userRepository.findAll(spec, pageable);

This method is readable and easy to reuse and test.

4. Audit and auto-filling: @CreatedDate, @LastModifiedBy, etc.

Spring Data JPA supports automatic recording of creation/modification time with users, reducing boilerplate code.

• Enable auditing on entity:

   @Entity
  @EntityListeners(AuditingEntityListener.class)
  public class User {
      @CreatedDate
      private LocalDateTime createTime;
  
      @LastModifiedBy
      private String lastModifiedBy;
  }

• The configuration class enables auditing:

   @Configuration
  @EnableJpaAuditing
  public class JpaConfig {
      @Bean
      public AuditorAware<String> auditorProvider() {
          return () -> Optional.of(SecurityContextHolder.getContext()
                                                       .getAuthentication()
                                                       .getName());
      }
  }

Suitable for recording operation traces, log audits and other scenarios.

5. Custom Repository implementation: Complement the interface capabilities

Spring Data JPA allows adding custom methods to a Repository.

Structural naming rules: CustomUserRepository interface → CustomUserRepositoryImpl implementation class.

 public interface CustomUserRepository {
    void refreshUsersFromLegacySystem();
}

public class CustomUserRepositoryImpl implements CustomUserRepository {
    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public void refreshUsersFromLegacySystem() {
        // Customize complex logic, such as calling stored procedures, batch updates, etc. StoredProcedureQuery query = entityManager
            .createStoredProcedureQuery("refresh_users_from_legacy");
        query.execute();
    }
}

Let the main Repository inherit it:

 public interface UserRepository extends JpaRepository<User, Long>, CustomUserRepository {
}

6. Transaction management and flush mode control

By default, Spring's @Transactional is REQUIRED , but some scenarios require more granular control.

• Manual flush control (for batch processing):

   @Transactional
  public void batchInsertUsers(List<User> users) {
      for (int i = 0; i < users.size(); i ) {
          userRepository.save(users.get(i));
          if (i % 50 == 0) {
              entityManager.flush();
              entityManager.clear(); // Avoid excessive level 1 cache}
      }
  }

• Setting read-only transactions to improve performance:

   @Transactional(readOnly = true)
  public Page<User> searchUsers(String keyword, Pageable pageable) {
      // Query operation, the database can optimize the execution plan}

Basically that's it. The core of Advanced Spring Data JPA is not "knowing to use interfaces", but:
Choose the right way in the correct scenario - is it using the method name? @Query? Specification? Or a custom implementation?
At the same time, focus on performance, maintainability and database interaction efficiency.

Only by mastering these can the DAO layer you write truly be "production-level".

The above is the detailed content of Advanced Spring Data JPA for Java Developers. For more information, please follow other related articles on the PHP Chinese website!