FetchMode ทำงานอย่างไรใน Spring Data JPA

Question 1

ฉันมีความสัมพันธ์ระหว่างโมเดลอ็อบเจ็กต์สามตัวในโปรเจ็กต์ของฉัน (โมเดลและส่วนย่อยที่เก็บในตอนท้ายของโพสต์

เมื่อฉันเรียกPlaceRepository.findByIdมันจะทำให้เกิดการค้นหาสามรายการ:

("sql")

SELECT * FROM place p where id = arg
SELECT * FROM user u where u.id = place.user.id
SELECT * FROM city c LEFT OUTER JOIN state s on c.woj_id = s.id where c.id = place.city.id

นั่นเป็นพฤติกรรมที่ค่อนข้างผิดปกติ (สำหรับฉัน) เท่าที่ฉันสามารถบอกได้หลังจากอ่านเอกสาร Hibernate แล้วก็ควรใช้แบบสอบถาม JOIN เสมอ ไม่มีความแตกต่างในแบบสอบถามเมื่อFetchType.LAZYเปลี่ยนเป็น FetchType.EAGERในPlaceคลาส (แบบสอบถามที่มี SELECT เพิ่มเติม) เช่นเดียวกับCityคลาสเมื่อFetchType.LAZYเปลี่ยนเป็น FetchType.EAGER(แบบสอบถามที่มี JOIN)

เมื่อฉันใช้ CityRepository.findByIdการระงับการยิงสองตัวเลือก:

SELECT * FROM city c where id = arg
SELECT * FROM state s where id = city.state.id

เป้าหมายของฉันคือการมีพฤติกรรมที่เหมือนกันในทุกสถานการณ์ (ไม่ว่าจะ JOIN หรือ SELECT เสมอก็ตามควรเข้าร่วม)

คำจำกัดความของโมเดล:

สถานที่:

@Entity
@Table(name = "place")
public class Place extends Identified {

    @Fetch(FetchMode.JOIN)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "id_user_author")
    private User author;

    @Fetch(FetchMode.JOIN)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "area_city_id")
    private City city;
    //getters and setters
}

เมือง:

@Entity
@Table(name = "area_city")
public class City extends Identified {

    @Fetch(FetchMode.JOIN)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "area_woj_id")
    private State state;
    //getters and setters
}

ที่เก็บ:

PlaceRepository

public interface PlaceRepository extends JpaRepository<Place, Long>, PlaceRepositoryCustom {
    Place findById(int id);
}

UserRepository:

public interface UserRepository extends JpaRepository<User, Long> {
        List<User> findAll();
    User findById(int id);
}

CityRepository:

public interface CityRepository extends JpaRepository<City, Long>, CityRepositoryCustom {    
    City findById(int id);
}

Question 2

ฉันคิดว่า Spring Data ไม่สนใจ FetchMode ฉันมักจะใช้คำอธิบายประกอบ@NamedEntityGraphและ@EntityGraphคำอธิบายประกอบเมื่อทำงานกับ Spring Data

@Entity
@NamedEntityGraph(name = "GroupInfo.detail",
  attributeNodes = @NamedAttributeNode("members"))
public class GroupInfo {

  // default fetch mode is lazy.
  @ManyToMany
  List<GroupMember> members = new ArrayList<GroupMember>();

  …
}

@Repository
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(value = "GroupInfo.detail", type = EntityGraphType.LOAD)
  GroupInfo getByGroupName(String name);

}

ตรวจสอบเอกสารที่นี่

Question 3

ก่อนอื่น@Fetch(FetchMode.JOIN)และ@ManyToOne(fetch = FetchType.LAZY)เป็นปฏิปักษ์กันคนหนึ่งสั่งให้ EAGER ดึงข้อมูลในขณะที่อีกคนหนึ่งแนะนำให้ดึง LAZY

การดึงข้อมูลอย่างกระตือรือร้นไม่ค่อยเป็นทางเลือกที่ดีและสำหรับพฤติกรรมที่คาดเดาได้คุณควรใช้JOIN FETCHคำสั่งเวลาสืบค้น:

public interface PlaceRepository extends JpaRepository<Place, Long>, PlaceRepositoryCustom {

    @Query(value = "SELECT p FROM Place p LEFT JOIN FETCH p.author LEFT JOIN FETCH p.city c LEFT JOIN FETCH c.state where p.id = :id")
    Place findById(@Param("id") int id);
}

public interface CityRepository extends JpaRepository<City, Long>, CityRepositoryCustom { 
    @Query(value = "SELECT c FROM City c LEFT JOIN FETCH c.state where c.id = :id")   
    City findById(@Param("id") int id);
}

Question 4

Spring-jpa สร้างคิวรีโดยใช้ตัวจัดการเอนทิตีและไฮเบอร์เนตจะละเว้นโหมดการดึงข้อมูลหากคิวรีสร้างโดยตัวจัดการเอนทิตี

ต่อไปนี้เป็นวิธีแก้ปัญหาที่ฉันใช้:

ใช้ที่เก็บแบบกำหนดเองซึ่งสืบทอดมาจาก SimpleJpaRepository
แทนที่วิธีการgetQuery(Specification<T> spec, Sort sort):
```
@Override
protected TypedQuery<T> getQuery(Specification<T> spec, Sort sort) { 
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<T> query = builder.createQuery(getDomainClass());

    Root<T> root = applySpecificationToCriteria(spec, query);
    query.select(root);

    applyFetchMode(root);

    if (sort != null) {
        query.orderBy(toOrders(sort, root, builder));
    }

    return applyRepositoryMethodMetadata(entityManager.createQuery(query));
}
```
ตรงกลางของวิธีการเพิ่ม applyFetchMode(root);เพื่อใช้โหมดการดึงข้อมูลเพื่อให้ Hibernate สร้างแบบสอบถามด้วยการรวมที่ถูกต้อง

(น่าเสียดายที่เราจำเป็นต้องคัดลอกเมธอดทั้งหมดและเมธอดส่วนตัวที่เกี่ยวข้องจากคลาสพื้นฐานเนื่องจากไม่มีจุดขยายอื่น ๆ )

ดำเนินการapplyFetchMode:

private void applyFetchMode(Root<T> root) {
    for (Field field : getDomainClass().getDeclaredFields()) {

        Fetch fetch = field.getAnnotation(Fetch.class);

        if (fetch != null && fetch.value() == FetchMode.JOIN) {
            root.fetch(field.getName(), JoinType.LEFT);
        }
    }
}

Question 5

" FetchType.LAZY" จะเริ่มทำงานสำหรับตารางหลักเท่านั้น หากในรหัสของคุณคุณเรียกใช้วิธีการอื่นใดที่มีการอ้างอิงตารางหลักระบบจะเริ่มการค้นหาเพื่อรับข้อมูลตารางนั้น (เลือกหลายไฟ)

" FetchType.EAGER" จะสร้างการรวมของตารางทั้งหมดรวมถึงตารางหลักที่เกี่ยวข้องโดยตรง (ใช้JOIN)

เมื่อมีการใช้งาน: สมมติว่าคุณ compulsorily ต้องใช้ขึ้นอยู่กับ Informartion FetchType.EAGERตารางแม่แล้วเลือก FetchType.LAZYหากท่านต้องการข้อมูลสำหรับบันทึกบางเพียงแล้วการใช้งาน

จำไว้ว่าFetchType.LAZYจำเป็นต้องมีโรงงานเซสชันฐานข้อมูลที่ใช้งานอยู่ที่ตำแหน่งในรหัสของคุณซึ่งหากคุณเลือกที่จะดึงข้อมูลตารางหลัก

เช่นสำหรับLAZY:

.. Place fetched from db from your dao loayer
.. only place table information retrieved
.. some code
.. getCity() method called... Here db request will be fired to get city table info

ข้อมูลอ้างอิงเพิ่มเติม

Question 6

โหมดดึงข้อมูลจะใช้งานได้เมื่อเลือกวัตถุด้วยรหัสเท่านั้นentityManager.find()คือการใช้ เนื่องจาก Spring Data จะสร้างแบบสอบถามเสมอการกำหนดค่าโหมดดึงข้อมูลจึงไม่มีประโยชน์สำหรับคุณ คุณสามารถใช้การสืบค้นเฉพาะกับการรวมการดึงข้อมูลหรือใช้กราฟเอนทิตี

เมื่อคุณต้องการประสิทธิภาพที่ดีที่สุดคุณควรเลือกเฉพาะส่วนย่อยของข้อมูลที่คุณต้องการจริงๆ ในการทำเช่นนี้โดยทั่วไปขอแนะนำให้ใช้แนวทาง DTO เพื่อหลีกเลี่ยงการดึงข้อมูลที่ไม่จำเป็น แต่โดยปกติจะส่งผลให้เกิดข้อผิดพลาดค่อนข้างมากในการสร้างรหัสสำเร็จรูปเนื่องจากคุณต้องกำหนดแบบสอบถามเฉพาะที่สร้างแบบจำลอง DTO ของคุณผ่านทาง JPQL นิพจน์ตัวสร้าง

การคาดการณ์ Spring Data สามารถช่วยได้ที่นี่ แต่ในบางจุดคุณจะต้องมีโซลูชันเช่นBlaze-Persistence Entity Viewsซึ่งทำให้สิ่งนี้ค่อนข้างง่ายและมีคุณสมบัติอื่น ๆ อีกมากมายในปลอกแขนที่จะมีประโยชน์! คุณเพียงแค่สร้างอินเทอร์เฟซ DTO ต่อเอนทิตีโดยที่ getters แสดงถึงชุดข้อมูลย่อยที่คุณต้องการ วิธีแก้ปัญหาของคุณอาจมีลักษณะดังนี้

@EntityView(Identified.class)
public interface IdentifiedView {
    @IdMapping
    Integer getId();
}

@EntityView(Identified.class)
public interface UserView extends IdentifiedView {
    String getName();
}

@EntityView(Identified.class)
public interface StateView extends IdentifiedView {
    String getName();
}

@EntityView(Place.class)
public interface PlaceView extends IdentifiedView {
    UserView getAuthor();
    CityView getCity();
}

@EntityView(City.class)
public interface CityView extends IdentifiedView {
    StateView getState();
}

public interface PlaceRepository extends JpaRepository<Place, Long>, PlaceRepositoryCustom {
    PlaceView findById(int id);
}

public interface UserRepository extends JpaRepository<User, Long> {
    List<UserView> findAllByOrderByIdAsc();
    UserView findById(int id);
}

public interface CityRepository extends JpaRepository<City, Long>, CityRepositoryCustom {    
    CityView findById(int id);
}

ข้อจำกัดความรับผิดชอบฉันเป็นผู้เขียน Blaze-Persistence ดังนั้นฉันอาจจะลำเอียง

Question 7

ฉันอธิบายรายละเอียดเกี่ยวกับคำตอบของdream83619เพื่อจัดการกับ@Fetchคำอธิบายประกอบไฮเบอร์เนตที่ซ้อนกัน ฉันใช้วิธีเรียกซ้ำเพื่อค้นหาคำอธิบายประกอบในคลาสที่เชื่อมโยงกัน

ดังนั้นคุณต้องใช้ที่เก็บแบบกำหนดเองและgetQuery(spec, domainClass, sort)วิธีการแทนที่ น่าเสียดายที่คุณต้องคัดลอกวิธีการส่วนตัวที่อ้างอิงทั้งหมด :(

นี่คือรหัส~~วิธีการส่วนตัวที่คัดลอกจะถูกละไว้~~
แก้ไข:เพิ่มวิธีการส่วนตัวที่เหลือ

@NoRepositoryBean
public class EntityGraphRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> {

    private final EntityManager em;
    protected JpaEntityInformation<T, ?> entityInformation;

    public EntityGraphRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.em = entityManager;
        this.entityInformation = entityInformation;
    }

    @Override
    protected <S extends T> TypedQuery<S> getQuery(Specification<S> spec, Class<S> domainClass, Sort sort) {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        CriteriaQuery<S> query = builder.createQuery(domainClass);

        Root<S> root = applySpecificationToCriteria(spec, domainClass, query);

        query.select(root);
        applyFetchMode(root);

        if (sort != null) {
            query.orderBy(toOrders(sort, root, builder));
        }

        return applyRepositoryMethodMetadata(em.createQuery(query));
    }

    private Map<String, Join<?, ?>> joinCache;

    private void applyFetchMode(Root<? extends T> root) {
        joinCache = new HashMap<>();
        applyFetchMode(root, getDomainClass(), "");
    }

    private void applyFetchMode(FetchParent<?, ?> root, Class<?> clazz, String path) {
        for (Field field : clazz.getDeclaredFields()) {
            Fetch fetch = field.getAnnotation(Fetch.class);

            if (fetch != null && fetch.value() == FetchMode.JOIN) {
                FetchParent<?, ?> descent = root.fetch(field.getName(), JoinType.LEFT);
                String fieldPath = path + "." + field.getName();
                joinCache.put(path, (Join) descent);

                applyFetchMode(descent, field.getType(), fieldPath);
            }
        }
    }

    /**
     * Applies the given {@link Specification} to the given {@link CriteriaQuery}.
     *
     * @param spec can be {@literal null}.
     * @param domainClass must not be {@literal null}.
     * @param query must not be {@literal null}.
     * @return
     */
    private <S, U extends T> Root<U> applySpecificationToCriteria(Specification<U> spec, Class<U> domainClass,
        CriteriaQuery<S> query) {

        Assert.notNull(query);
        Assert.notNull(domainClass);
        Root<U> root = query.from(domainClass);

        if (spec == null) {
            return root;
        }

        CriteriaBuilder builder = em.getCriteriaBuilder();
        Predicate predicate = spec.toPredicate(root, query, builder);

        if (predicate != null) {
            query.where(predicate);
        }

        return root;
    }

    private <S> TypedQuery<S> applyRepositoryMethodMetadata(TypedQuery<S> query) {
        if (getRepositoryMethodMetadata() == null) {
            return query;
        }

        LockModeType type = getRepositoryMethodMetadata().getLockModeType();
        TypedQuery<S> toReturn = type == null ? query : query.setLockMode(type);

        applyQueryHints(toReturn);

        return toReturn;
    }

    private void applyQueryHints(Query query) {
        for (Map.Entry<String, Object> hint : getQueryHints().entrySet()) {
            query.setHint(hint.getKey(), hint.getValue());
        }
    }

    public Class<T> getEntityType() {
        return entityInformation.getJavaType();
    }

    public EntityManager getEm() {
        return em;
    }
}

Question 8

http://jdpgrailsdev.github.io/blog/2014/09/09/spring_data_hibernate_join.html
จากลิงค์นี้:

หากคุณใช้ JPA ที่ด้านบนของ Hibernate จะไม่มีวิธีใดที่จะตั้งค่า FetchMode ที่ Hibernate ใช้เป็น JOIN ได้อย่างไรก็ตามหากคุณใช้ JPA ที่ด้านบนของ Hibernate จะไม่มีวิธีตั้งค่า FetchMode ที่ Hibernate ใช้เป็น JOIN

ไลบรารี Spring Data JPA มี Domain Driven Design Specifications API ที่ช่วยให้คุณสามารถควบคุมลักษณะการทำงานของแบบสอบถามที่สร้างขึ้น

final long userId = 1;

final Specification<User> spec = new Specification<User>() {
   @Override
    public Predicate toPredicate(final Root<User> root, final 
     CriteriaQuery<?> query, final CriteriaBuilder cb) {
    query.distinct(true);
    root.fetch("permissions", JoinType.LEFT);
    return cb.equal(root.get("id"), userId);
 }
};

List<User> users = userRepository.findAll(spec);

Question 9

อ้างอิงจาก Vlad Mihalcea (ดูhttps://vladmihalcea.com/hibernate-facts-the-importance-of-fetch-strategy/ ):

ข้อความค้นหา JPQL อาจแทนที่กลยุทธ์การดึงข้อมูลเริ่มต้น หากเราไม่ประกาศอย่างชัดเจนว่าต้องการดึงข้อมูลอะไรโดยใช้คำสั่งการดึงข้อมูลเข้าร่วมด้านในหรือด้านซ้ายระบบจะใช้นโยบายการดึงข้อมูลเริ่มต้น

ดูเหมือนว่าแบบสอบถาม JPQL อาจแทนที่กลยุทธ์การดึงข้อมูลที่คุณประกาศไว้ดังนั้นคุณจะต้องใช้join fetchเพื่อโหลดเอนทิตีที่อ้างอิงบางส่วนอย่างกระตือรือร้นหรือเพียงแค่โหลดตาม id ด้วย EntityManager (ซึ่งจะเป็นไปตามกลยุทธ์การดึงข้อมูลของคุณ แต่อาจไม่ใช่วิธีแก้ปัญหาสำหรับกรณีการใช้งานของคุณ ).