How can I make a JPA OneToOne relation lazy

Question

In this application we are developing  we noticed that a view was particularly slow  I profiled the view and noticed that there was one query executed by hibernate which took 10 seconds even if there only were two object in the database to fetch  All OneToMany and ManyToMany relations were lazy so that wasn t the problem  When inspecting the actual SQL being executed  I noticed that there were over 80 joins in the query    Further inspecting the issue  I noticed that the problem was caused by the deep hierarchy of OneToOne and ManyToOne relations between entity classes  So  I thought  I ll just make them fetched lazy  that should solve the problem  But annotating either  OneToOne fetch FetchType LAZY  or  ManyToOne fetch FetchType LAZY  doesn t seem to work  Either I get an exception or then they are not actually replaced with a proxy object and thus being lazy   Any ideas how I ll get this to work  Note that I do not use the persistence xml to define relations or configuration details  everything is done in java code

User · Answer

To get lazy loading working on nullable one-to-one mappings you need to let hibernate do compile time instrumentation and add a @LazyToOne(value = LazyToOneOption.NO_PROXY) to the one-to-one relation.

Example Mapping:

@OneToOne(fetch = FetchType.LAZY)  
@JoinColumn(name="other_entity_fk")
@LazyToOne(value = LazyToOneOption.NO_PROXY)
public OtherEntity getOther()

Example Ant Build file extension (for doing the Hibernate compile time instrumentation):

<property name="src" value="/your/src/directory"/><!-- path of the source files --> 
<property name="libs" value="/your/libs/directory"/><!-- path of your libraries --> 
<property name="destination" value="/your/build/directory"/><!-- path of your build directory --> 

<fileset id="applibs" dir="${libs}"> 
  <include name="hibernate3.jar" /> 
  <!-- include any other libraries you'll need here --> 
</fileset> 

<target name="compile"> 
  <javac srcdir="${src}" destdir="${destination}" debug="yes"> 
    <classpath> 
      <fileset refid="applibs"/> 
    </classpath> 
  </javac> 
</target> 

<target name="instrument" depends="compile"> 
  <taskdef name="instrument" classname="org.hibernate.tool.instrument.javassist.InstrumentTask"> 
    <classpath> 
      <fileset refid="applibs"/> 
    </classpath> 
  </taskdef> 

  <instrument verbose="true"> 
    <fileset dir="${destination}"> 
      <!-- substitute the package where you keep your domain objs --> 
      <include name="/com/mycompany/domainobjects/*.class"/> 
    </fileset> 
  </instrument> 
</target>

User · Answer

The basic idea behing the XToOnes in Hibernate is that they are not lazy in most case   One reason is that  when Hibernate have to decide to put a proxy  with the id  or a null  it has to look into the other table anyway to join  The cost of accessing the other table in the database is significant  so it might as well fetch the data for that table at that moment  non-lazy behaviour   instead of fetching that in a later request that would require a second access to the same table   Edited  for details  please refer to ChssPly76  s answer  This one is less accurate and detailed  it has nothing to offer  Thanks ChssPly76

User · Answer

As already perfectly explained by ChssPly76  Hibernate s proxies don t help with unconstrained  nullable  one-to-one associations  BUT there is a trick explained here to avoid to set up instrumentation   The idea is to fool Hibernate that the entity class which we want to use has been already instrumented  you instrument it manually in the source code   It s easy   I ve implemented it with CGLib as bytecode provider and it works  ensure that you configure lazy  no-proxy  and fetch  select   not  join   in your HBM    I think this is a good alternative to real  I mean automatic  instrumentation when you have just one one-to-one nullable relation that you want to make lazy   The main drawback is that the solution depends on the bytecode provider you are using  so comment your class accurately because you could have to change the bytecode provider in the future  of course  you are also modifying your model bean for a technical reason and this is not fine

User · Answer

In native Hibernate XML mappings  you can accomplish this by declaring a one-to-one mapping with the constrained attribute set to true  I am not sure what the Hibernate JPA annotation equivalent of that is  and a quick search of the doc provided no answer  but hopefully that gives you a lead to go on

User · Answer

Most efficient mapping of a one-to-one association You can avoid all these problems and get rid of the foreign key column by using the same primary key value for both associated entities  You can do that by annotating the owning side of the association with  MapsId   Entity public class Book          Id      GeneratedValue     private Long id         OneToOne mappedBy    quot book quot   fetch   FetchType LAZY  optional   false      private Manuscript manuscript                 Entity public class Manuscript          Id     private Long id         OneToOne      MapsId      JoinColumn name    quot id quot       private Book book                Book b   em find Book class  100L   Manuscript m   em find Manuscript class  b getId      More Detail click on this url

User · Answer

For Kotlin devs  To allow Hibernate to inherit from the  Entity types that you want to be lazy-loadable they have to be inheritable open  which they in Kotlin by default are not  To work around this issue we can make use of the all-open compiler plugin and instruct it to also handle the JPA annotations by adding this to our build gradle  allOpen      annotation  quot javax persistence Entity quot      annotation  quot javax persistence MappedSuperclass quot      annotation  quot javax persistence Embeddable quot      If you are using Kotlin and Spring like me  you are most probably also using the kotlin-jpa no-args and kotlin-spring all-open compiler plugins already  However  you will still need to add the above lines  as that combination of plugins neither makes such classes open  Read the great article of L  o Millon for further explanations

User · Answer

First off  some clarifications to KLE s answer    Unconstrained  nullable  one-to-one association is the only one that can not be proxied without bytecode instrumentation  The reason for this is that owner entity MUST know whether association property should contain a proxy object or NULL and it can t determine that by looking at its base table s columns due to one-to-one normally being mapped via shared PK  so it has to be eagerly fetched anyway making proxy pointless  Here s a more detailed explanation  many-to-one associations  and one-to-many  obviously  do not suffer from this issue  Owner entity can easily check its own FK  and in case of one-to-many  empty collection proxy is created initially and populated on demand   so the association can be lazy  Replacing one-to-one with one-to-many is pretty much never a good idea  You can replace it with unique many-to-one but there are other  possibly better  options    Rob H  has a valid point  however you may not be able to implement it depending on your model  e g  if your one-to-one association is nullable    Now  as far as original question goes   A   ManyToOne fetch FetchType LAZY  should work just fine  Are you sure it s not being overwritten in the query itself  It s possible to specify join fetch in HQL and   or explicitly set fetch mode via Criteria API which would take precedence over class annotation  If that s not the case and you re still having problems  please post your classes  query and resulting SQL for more to-the-point conversation   B   OneToOne is trickier  If it s definitely not nullable  go with Rob H  s suggestion and specify it as such    OneToOne optional   false  fetch   FetchType LAZY    Otherwise  if you can change your database  add a foreign key column to owner table   do so  and map it as  joined     OneToOne fetch   FetchType LAZY   JoinColumn name  other entity fk   public OtherEntity getOther     and in OtherEntity    OneToOne mappedBy    other   public OwnerEntity getOwner     If you can t do that  and can t live with eager fetching  bytecode instrumentation is your only option  I have to agree with CPerkins  however - if you have 80    joins due to eager OneToOne associations  you ve got bigger problems then this  -

User · Answer

If the relation must not be bidirectional then an  ElementCollection might be easier than using a lazy One2Many collection

User · Answer

If the child entity is used readonly  then it s possible to simply lie and set optional false  Then ensure that every use of that mapped entity is preloaded via queries  public class App            OneToOne mappedBy    quot app quot   fetch   FetchType LAZY  optional   false    private Attributes additional   and String sql    quot      FROM App a LEFT JOIN FETCH a additional aa     quot        maybe even persisting would work

User · Answer

This question is quite old  but with Hibernate 5 1 10  there are some new better comfortable solution   Lazy loading works except for the parent side of a  OneToOne association  This is because Hibernate has no other way of knowing whether to assign a null or a Proxy to this variable  More details you can find in this article   You can activate lazy loading bytecode enhancement Or  you can just remove the parent side and use the client side with  MapsId as explained in the article above  This way  you will find that you don   t really need the parent side since the child shares the same id with the parent so you can easily fetch the child by knowing the parent id

User · Answer

Unless you are using Bytecode Enhancement  you cannot fetch lazily the parent-side  OneToOne association  However  most often  you don t even need the parent-side association if you use  MapsId on the client side   Entity name    quot PostDetails quot    Table name    quot post details quot   public class PostDetails          Id     private Long id         Column name    quot created on quot       private Date createdOn         Column name    quot created by quot       private String createdBy         OneToOne fetch   FetchType LAZY       MapsId     private Post post        public PostDetails            public PostDetails String createdBy            createdOn   new Date            this createdBy   createdBy                Getters and setters omitted for brevity    With  MapsId  the id property in the child table serves as both Primary Key and Foreign Key to the parent table Primary Key  So  if you have a reference to the parent Post entity  you can easily fetch the child entity using the parent entity identifier  PostDetails details   entityManager find      PostDetails class      post getId       This way  you won t have N 1 query issues that could be caused by the mappedBy  OneToOne association on the parent side

User · Answer

Here s something that has been working for me  without instrumentation    Instead of using  OneToOne on both sides  I use  OneToMany in the inverse part of the relationship  the one with mappedBy   That makes the property a collection  List in the example below   but I translate it into an item in the getter  making it transparent to the clients   This setup works lazily  that is  the selects are only made when getPrevious   or getNext   are called - and only one select for each call   The table structure   CREATE TABLE  TB ISSUE         ID             INT 9  NOT NULL AUTO INCREMENT       NAME           VARCHAR 255  NULL       PREVIOUS       DECIMAL 9 2  NULL     CONSTRAINT  PK ISSUE  PRIMARY KEY   ID      ALTER TABLE  TB ISSUE  ADD CONSTRAINT  FK ISSUE ISSUE PREVIOUS                   FOREIGN KEY   PREVIOUS   REFERENCES  TB ISSUE    ID      The class    Entity  Table name    TB ISSUE    public class Issue         Id      GeneratedValue strategy   GenerationType IDENTITY      protected Integer id        Column     private String name        OneToOne fetch FetchType LAZY      one to one  as expected      JoinColumn name  previous       private Issue previous          use  OneToMany instead of  OneToOne to  fake  the lazy loading      OneToMany mappedBy  previous   fetch FetchType LAZY         notice the type isnt Issue  but a collection  that will have 0 or 1 items      private List lt Issue gt  next       public Integer getId     return id        public String getName     return name         public Issue getPrevious     return previous           in the getter  transform the collection into an Issue for the clients     public Issue getNext     return next isEmpty     null   next get 0

[java] How can I make a JPA OneToOne relation lazy

Examples related to java

Examples related to hibernate

Examples related to jpa

Examples related to lazy-loading

Examples related to one-to-one