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

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

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

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

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 lt T  ID extends Serializable gt  extends SimpleJpaRepository lt T  ID gt         private final EntityManager em      protected JpaEntityInformation lt T    gt  entityInformation       public EntityGraphRepositoryImpl JpaEntityInformation lt T    gt  entityInformation  EntityManager entityManager            super entityInformation  entityManager           this em   entityManager          this entityInformation   entityInformation              Override     protected  lt S extends T gt  TypedQuery lt S gt  getQuery Specification lt S gt  spec  Class lt S gt  domainClass  Sort sort            CriteriaBuilder builder   em getCriteriaBuilder            CriteriaQuery lt S gt  query   builder createQuery domainClass            Root lt S gt  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 lt String  Join lt      gt  gt  joinCache       private void applyFetchMode Root lt   extends T gt  root            joinCache   new HashMap lt  gt             applyFetchMode root  getDomainClass                    private void applyFetchMode FetchParent lt      gt  root  Class lt   gt  clazz  String path            for  Field field   clazz getDeclaredFields                  Fetch fetch   field getAnnotation Fetch class                if  fetch    null  amp  amp  fetch value      FetchMode JOIN                    FetchParent lt      gt  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  lt S  U extends T gt  Root lt U gt  applySpecificationToCriteria Specification lt U gt  spec  Class lt U gt  domainClass          CriteriaQuery lt S gt  query             Assert notNull query           Assert notNull domainClass           Root lt U gt  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  lt S gt  TypedQuery lt S gt  applyRepositoryMethodMetadata TypedQuery lt S gt  query            if  getRepositoryMethodMetadata      null                return query                     LockModeType type   getRepositoryMethodMetadata   getLockModeType            TypedQuery lt S gt  toReturn   type    null   query   query setLockMode type            applyQueryHints toReturn            return toReturn             private void applyQueryHints Query query            for  Map Entry lt String  Object gt  hint   getQueryHints   entrySet                  query setHint hint getKey    hint getValue                          public Class lt T gt  getEntityType             return entityInformation getJavaType               public EntityManager getEm             return em

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

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

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

[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