failed to lazily initialize a collection of role: could not initialize proxy - no Session error in @ManyToMany mappin annotation in Hibernate?

Question

Hi am new to java server side to create JSON API, am using ManytoMany mapping in hibernate to join the two tables.I have two classes one is Product.class and Offers.class.

Product.class

@Entity
@Table(name = "products")
public class Product {

@Column(name = "merchant_code")
private String merchant_code;

@Column(name = "branch_code")
private String branch_code;

@Column(name = "product_category_code")
private String product_category_code;

@Id @GeneratedValue
@Column(name = "product_code")
private String product_code;

@Column(name = "product_short_desc")
private String product_short_desc;

@Column(name = "product_long_desc")
private String product_long_desc;

@Column(name = "image")
private String image;

@Column(name = "price")
private String price;

@Column(name = "Active_Inactive")
private String Active_Inactive;

@ManyToMany(mappedBy = "offer_relation_code", fetch = FetchType.EAGER)
@Where(clause = "offer_type_code = 1")
private List<Offers> offer;

//here my getter setter

}

Offers.class

@Entity
@Table(name = "offers")
public class Offers {

@Id @GeneratedValue
@Column(name = "offer_code")
private int offer_code;

@Column(name = "offer_type_code")
private int offer_type_code;

@Column(name = "offer_relation_code")
private int offer_relation_code;

@Column(name = "branch_code")
private int branch_code;

@Column(name = "valid_from")
private String valid_from;

@Column(name = "valid_until")
private String valid_until;

@Column(name = "offer_value")
private int offer_value;

@Column(name = "offer_desc")
private String offer_desc;

//here my getter setter     

}

To fetch data

factory = cfg.configure().addAnnotatedClass(Product.class).buildSessionFactory(registry);

    Session session = factory.openSession();
    Transaction tx = null;

    try {

        tx = session.beginTransaction();

        Criteria criteria = session.createCriteria(Product.class);
        criteria.setFetchMode("product",FetchMode.JOIN);
        Criterion merchant_code_Criterion = Restrictions.eq("merchant_code", new String(merchant_code));
        Criterion branch_code_Criterion = Restrictions.eq("branch_code", new String(branch_code));
        LogicalExpression andExp = Restrictions.and(merchant_code_Criterion,branch_code_Criterion);
        criteria.add(andExp);

        search_products = (ArrayList<Product>) criteria.list();

        tx.commit();

    } catch (HibernateException e) {
        // TODO: handle exception
        if (tx != null)
            tx.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }

Am join the offer table with product table like @ManyToMany(mappedBy = "offer_relation_code", fetch = FetchType.EAGER) am search it in Google ,many of them said don't use EAGER, it leads to some issue, but when i am using @ManyToMany(mappedBy = "offer_relation_code", fetch = FetchType.LAZY) is shows error like failed to lazily initialize a collection of role: could not initialize proxy - no Session. When am using EAGER its working fine without error.Using EAGER is good or bad.Can any one Explain.

I'm sure, you could provide significally less fields in classes for demonstrating your question's idea. Suggest you to reduce you source in code in topic. — Andremoniy, Apr 09 '15 at 08:21

Predrag Maric · Accepted Answer · 2015-04-09T08:42:01.230

Both EAGER and LAZY have use cases when they are useful, they are not good or bad generally speaking.

When some relationship is marked as EAGER it means all of the data from that relation will be fetched from the database when the parent entity is fetched. One SQL will be used for all data.

With LAZY relationship, only the parent entity's data is fetched initially. The lazy relation is replaced with Hibernate's proxy class, which will fetch the child entity's data on first access to any of its properties, using a separate SQL statement. However, there has to be an active Hibernate session in order for this to work. When called outside of active session, you get the exception failed to lazily initialize a collection.

For @nToMany mappings, LAZY is the default which makes perfect sense because Many can really mean many, and there is a good chance you don't need all of the mapped data. So, it's generally a good idea to leave that at LAZY and fetch the data in services where needed. Hibernate has a utility method for initializing lazy relations, Hibernate.initialize(parent.getLazyChild()).

But, as I said in the beginning, it all depends on the use case and it's best if you know all the implications of EAGER and LAZY so you can make your own decision.

score 1 · Answer 2 · answered Apr 09 '15 at 08:34

Let's first talk about the two POJO's you have.

Offer class represent one table. In other words, it represents all the columns from just one table, with no reference to any other other table.

Product class also represents only one table, but then you have a reference to Offer class.

Now, if you would like to get records for product code 'abc'

EAGER: When using this, you are asking JPA to populate the POJO with data from product and also the corresponding data from offer table.
LAZY: When using this, you are asking JPA to populate POJO with data only from product table. Only when you call, getOffers() then another database call should be made to populate corresponding data from offer table.

You can use LAZY, when the data from a referenced table is not required that often. There is a good probability (>25%) that Offer data may never be shown.

You should use EAGER, when the data from a referenced table,is almost always, required.

For your error, in your final block you are calling session.close(). When you are using LAZY, the transaction is closed after initial fetch. And when you call getOffers(), JPA tries to make a db connection - but fails as it's using already closed connection/session.

score 0 · Answer 3 · answered Apr 09 '15 at 08:37

EAGER tells hibernate to always fetch all the components on the Many relation (all the Offers in your question), even in situations when you don't need them. With LAZY, you are responsible to get those Offers inside the transaction, when you really need them.

failed to lazily initialize a collection of role: could not initialize proxy - no Session error in @ManyToMany mappin annotation in Hibernate?

3 Answers3