Spring Data JPA 如何在使用 get("property") 链与 Join 时指定 Join 类型或 Fetch Mode

Question

I have two (Hibernate-based) Spring Data JPA domain classes, the "One" side Customer.class:

@Entity
@Table(name = "sys_customer")
@Data
public class Customer implements Serializable {
    @Id
    @Column(name = "cust_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "cust_name")
    private String customerName;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "customer")
    private Set<Order> orders;

}

and the "Many" side Order.class:

@Entity
@Table(name = "sys_order")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Order implements Serializable {

    @Id
    @Column(name = "order_id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "order_name")
    private String orderName;

    @ManyToOne
    @JoinColumn(name = "order_cust_id", referencedColumnName = "cust_id")
    private Customer customer;

    public Order( String orderName) {
        this.orderName = orderName;
    }

    public Order(String orderName, Customer customer) {
        this.orderName = orderName;
        this.customer = customer;
    }
}

I have OrderRepository interface which extends JpaRepository interface and JpaSpecificationExecutor interface:

public interface OrderRepository extends JpaRepository<Order, Long>, JpaSpecificationExecutor<Order> {
}

I have a OrderSpecification.class with the static method searchByCustomerName :

public class OrderSpecification {
    public static Specification<Order> searchByCustomerName(String customerName) {
        return new Specification<Order>() {
            @Override
            public Predicate toPredicate(Root<Order> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                Join<Order, Customer> join = root.join("customer");
                return criteriaBuilder.like(join.get("customerName"), "%" + customerName + "%");
                //return criteriaBuilder.like(root.get("customer").get("customerName"), "%" + customerName + "%");
            }
        };
    }
} 

To find the differences between get("property") chain and Join , I wrote a simple test method and comment out the above OrderSpecificatin.class code

    @Test
    @Transactional
    public void testFindOrderByCustomerName(){
        String name = "adam";
        List<Order> orders = orderRepository.findAll(OrderSpecification.searchByCustomerName(name));
        for(Order order: orders){
            Customer customer = order.getCustomer();
            log.info(new StringBuilder().append(customer.getId()).append(" ").append(customer.getCustomerName()).toString());

        }
    }

I found that: get("property") chain use a cross-join(which is very bad performancing) while Join use inner-join(since ManyToOne() by default is Fetch= FetchType.EAGER)

/* get("property") chain: Hibernate: select order0_.order_id as order_id1_1_, order0_.order_cust_id as order_cu3_1_, order0_.order_name as order_na2_1_ from sys_order order0_ cross join sys_customer customer1_ where order0_.order_cust_id=customer1_.cust_id and (customer1_.cust_name like ?) Hibernate: select customer0_.cust_id as cust_id1_0_0_, customer0_.cust_name as cust_nam2_0_0_ from sys_customer customer0_ where customer0_.cust_id=? */

/** * "Join": * Hibernate: select order0_.order_id as order_id1_1_, order0_.order_cust_id as order_cu3_1_, order0_.order_name as order_na2_1_ from sys_order order0_ inner join sys_customer customer1_ on order0_.order_cust_id=customer1_.cust_id where customer1_.cust_name like ? * Hibernate: select customer0_.cust_id as cust_id1_0_0_, customer0_.cust_name as cust_nam2_0_0_ from sys_customer customer0_ where customer0_.cust_id=? */

My questions are:

1. Can I specify the Join type(inner, all three outers) or Fetch Type(LAZY, EAGER) when using get("property") chain approach to avoid cross-join?
2. What scenario/best practice should I use get("chain") or always stay in Join?
3. Does the approach OrderSpecification.class with static method obey a good OOP design pattern?

Answer 1

You can't specify the join type for paths. It will use INNER join semantics by default and that is mandated by the JPA specification. If you want a different join type, you will have to create joins explicitly. The fact that using get renders as cross joins is a limitation of the old query model of Hibernate, but Hibernate 6.0 will fix this. The semantics are the same though and the query planner of your database should be able to treat both queries the same way. Maybe you just need to update your database version?

There is no "best practice" ie this really depends on your needs. Explicit joins are just that, explicit. So multiple calls to join will create multiple joins in SQL.

As for the OOP question, I think this is fine, yes.