Rule Definition
In a lazy association, the associated object or collection is fetched when it's first accessed. This results in a new request to the database (unless the associated object is cached). This option is almost always used for collection mappings (it should be the default, and we recommend that you consider it as a default for all your collection mappings). Generally, the performance benefits are such that you will want to use lazy instantiation wherever possible (compared with the massive task of reading in all of the entities concerned) When eager fetching is used, the associated object or collection is fetched together with the owning object, using an SQL outer join, and no further database request is required. But the issue is that it will always be done like this and if the number of rows is high, the performance will be affected.

Remediation
You need to make sure to use the right FetchType for your use case to avoid common Hibernate performance issues. For most use cases, the FetchType.LAZY is a good choice. EAGER fetching tells Hibernate to get the related entities with the initial query. This can be very efficient because all entities are fetched with only one query. But in most cases it just creates a huge overhead because you select entities you don’t need in your use case. You can prevent this with FetchType.LAZY. This tells Hibernate to delay the initialization of the relationship until you access it in your business code. The drawback of this approach is that Hibernate needs to execute an additional query to initialize each relationship.

Violation Code Sample

<hibernate-mapping >
  
  <class name="A" table ="A"> 
    <id name="id">
      <generator class="increment"/>
    </id>

    // VIOLATION 
    <set name="b_items" lazy="false" table ="B"> 
      <key column="B_ID"/>
      <one-to-many class="B"/>
    </array>
  </class>

</hibernate-mapping>

Sample-2 Using annotations

@Entity
@Table(name = "USER")
public class UserLazy implements Serializable { 
    @Id
    @GeneratedValue
    @Column(name = "USER_ID")
    private Long userId;
 
    @OneToMany(fetch = FetchType.EAGER, mappedBy = "user")  //VIOLATION
    private Set<OrderDetail> orderDetail = new HashSet();
    //standard getters and setters
}

Fixed Code Sample

<hibernate-mapping >
  
  <class name="A" table ="A"> 
    <id name="id">
      <generator class="increment"/>
    </id>

    // FIXED
    <set name="b_items" lazy="true" table ="B"> 
      <key column="B_ID"/>
      <one-to-many class="B"/>
    </array>
  </class>

</hibernate-mapping>

Remediation sample for Sample-2 (annotation)

@Entity
@Table(name = "USER")
public class UserLazy implements Serializable { 
    @Id
    @GeneratedValue
    @Column(name = "USER_ID")
    private Long userId;
 
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")  //FIXED
    private Set<OrderDetail> orderDetail = new HashSet();
    //standard getters and setters
}

Hibernate in Action (ISBN 1932394-15-X) p 148 https://thoughts-on-java.org/entity-mappings-introduction-jpa-fetchtypes/ https://howtodoinjava.com/hibernate/lazy-loading-in-hibernate/