How does the FetchMode work in Spring Data JPA

Question

I do have a relation between three model object in my project  model and repository snippets in the end of the post    When I call PlaceRepository findById it does fire three select queries     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   That s rather unusual behavior  for me   As far as I can tell after reading Hibernate documentation it should always use JOIN queries  There is no difference in the queries when FetchType LAZY changed to  FetchType EAGER in the Place class  query with additional SELECT   the same for the City class when FetchType LAZY changed to  FetchType EAGER  query with JOIN     When I use CityRepository findById suppressing fires two selects     SELECT   FROM city c where id   arg SELECT   FROM state s where id   city state id   My goal is to have a the sam behavior in all situations  either always JOIN or SELECT  JOIN preferred though     Model definitions   Place    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     City     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     Repositories    PlaceRepository  public interface PlaceRepository extends JpaRepository lt Place  Long gt   PlaceRepositoryCustom       Place findById int id       UserRepository    public interface UserRepository extends JpaRepository lt User  Long gt            List lt User gt  findAll        User findById int id       CityRepository    public interface CityRepository extends JpaRepository lt City  Long gt   CityRepositoryCustom           City findById int id

User · Answer

I elaborated on dream83619 answer to make it handle nested Hibernate @Fetch annotations. I used recursive method to find annotations in nested associated classes.

So you have to implement custom repository and override getQuery(spec, domainClass, sort) method. Unfortunately you also have to copy all referenced private methods :(.

Here is the code, ~~copied private methods are omitted.~~
EDIT: Added remaining private methods.

@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;
    }
}

User · Answer

I think that Spring Data ignores the FetchMode  I always use the  NamedEntityGraph and  EntityGraph annotations when working with Spring Data   Entity  NamedEntityGraph name    GroupInfo detail     attributeNodes    NamedAttributeNode  members    public class GroupInfo         default fetch mode is lazy     ManyToMany   List lt GroupMember gt  members   new ArrayList lt GroupMember gt                Repository public interface GroupRepository extends CrudRepository lt GroupInfo  String gt        EntityGraph value    GroupInfo detail   type   EntityGraphType LOAD    GroupInfo getByGroupName String name        Check the documentation here

User · Answer

Spring-jpa creates the query using the entity manager  and Hibernate will ignore the fetch mode if the query was built by the entity manager   The following is the work around that I used    Implement a custom repository which inherits from SimpleJpaRepository Override the method getQuery Specification lt T gt  spec  Sort sort     Override protected TypedQuery lt T gt  getQuery Specification lt T gt  spec  Sort sort         CriteriaBuilder builder   entityManager getCriteriaBuilder        CriteriaQuery lt T gt  query   builder createQuery getDomainClass          Root lt T gt  root   applySpecificationToCriteria spec  query       query select root        applyFetchMode root        if  sort    null            query orderBy toOrders sort  root  builder               return applyRepositoryMethodMetadata entityManager createQuery query        In the middle of the method  add applyFetchMode root   to apply the fetch mode  to make Hibernate create the query with the correct join    Unfortunately we need to copy the whole method and related private methods from the base class because there was no other extension point   Implement applyFetchMode   private void applyFetchMode Root lt T gt  root        for  Field field   getDomainClass   getDeclaredFields               Fetch fetch   field getAnnotation Fetch class            if  fetch    null  amp  amp  fetch value      FetchMode JOIN                root fetch field getName    JoinType LEFT

User · Answer

FetchType LAZY  will only fire for primary table  If in your code you call any other method that has a parent table dependency then it will fire query to get that table information   FIRES MULTIPLE SELECT    FetchType EAGER  will create join of all table including relevant parent tables directly   USES JOIN   When to Use  Suppose you compulsorily need to use dependant parent table informartion then choose FetchType EAGER  If you only need information for certain records then use FetchType LAZY   Remember  FetchType LAZY needs an active db session factory at the place in your code where if you choose to retrieve parent table information   E g  for 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   Additional reference

User · Answer

The fetch mode will only work when selecting the object by id i e  using entityManager find    Since Spring Data will always create a query  the fetch mode configuration will have no use to you  You can either use dedicated queries with fetch joins or use entity graphs   When you want best performance  you should select only the subset of the data you really need  To do this  it is generally recommended to use a DTO approach to avoid unnecessary data to be fetched  but that usually results in quite a lot of error prone boilerplate code  since you need define a dedicated query that constructs your DTO model via a JPQL constructor expression   Spring Data projections can help here  but at some point you will need a solution like Blaze-Persistence Entity Views which makes this pretty easy and has a lot more features in it s sleeve that will come in handy  You just create a DTO interface per entity where the getters represent the subset of data you need  A solution to your problem could look like this   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 lt Place  Long gt   PlaceRepositoryCustom       PlaceView findById int id      public interface UserRepository extends JpaRepository lt User  Long gt        List lt UserView gt  findAllByOrderByIdAsc        UserView findById int id      public interface CityRepository extends JpaRepository lt City  Long gt   CityRepositoryCustom           CityView findById int id       Disclaimer  I m the author of Blaze-Persistence  so I might be biased

User · Answer

http   jdpgrailsdev github io blog 2014 09 09 spring data hibernate join html  from this link   if you are using JPA on top of Hibernate  there is no way to set the FetchMode used by Hibernate to JOINHowever  if you are using JPA on top of Hibernate  there is no way to set the FetchMode used by Hibernate to JOIN   The Spring Data JPA library provides a Domain Driven Design Specifications API that allows you to control the behavior of the generated query   final long userId   1   final Specification lt User gt  spec   new Specification lt User gt          Override     public Predicate toPredicate final Root lt User gt  root  final       CriteriaQuery lt   gt  query  final CriteriaBuilder cb        query distinct true       root fetch  permissions   JoinType LEFT       return cb equal root get  id    userId          List lt User gt  users   userRepository findAll spec

User · Answer

According to Vlad Mihalcea  see https   vladmihalcea com hibernate-facts-the-importance-of-fetch-strategy        JPQL queries may override the default fetching strategy  If we don   t   explicitly declare what we want to fetch using inner or left join   fetch directives  the default select fetch policy is applied    It seems that JPQL query might override your declared fetching strategy so you ll have to use join fetch in order to eagerly load some referenced entity or simply load by id with EntityManager  which will obey your fetching strategy but might not be a solution for your use case

User · Answer

First of all   Fetch FetchMode JOIN  and  ManyToOne fetch   FetchType LAZY  are antagonistic because  Fetch FetchMode JOIN  is equivalent to the JPA FetchType EAGER  Eager fetching is rarely a good choice  and for predictable behavior  you are better off using the query-time JOIN FETCH directive  public interface PlaceRepository extends JpaRepository lt Place  Long gt   PlaceRepositoryCustom         Query value    quot 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 quot       Place findById  Param  quot id quot   int id      public interface CityRepository extends JpaRepository lt City  Long gt   CityRepositoryCustom         Query value    quot SELECT c FROM City c LEFT JOIN FETCH c state where c id    id quot          City findById  Param  quot id quot   int id

[java] How does the FetchMode work in Spring Data JPA

Examples related to java

Examples related to spring

Examples related to hibernate

Examples related to jpa

Examples related to spring-data-jpa