Hibernate Lazy Loading Interceptor returning NULL

The behavior you’re seeing is because of how Hibernate uses proxies for lazy-loaded associations.

When you call sourceA.getCsOfA(), Hibernate doesn’t always return a fully populated C instance. Instead it returns a proxy object with a hibernate_interceptor attached. That proxy only knows how to fetch the data if/when you call a method. If you access fields directly (sourceC.cId), Hibernate never gets a chance to initialize the proxy, so you see null.

public C(String id, C sourceC) {
    this.aId = id;
    this.cId = sourceC.getCId();  // calls through proxy → Hibernate loads the value
}

and this does not:

public C(String id, C sourceC) {
    this.aId = id;
    this.cId = sourceC.cId;       // bypasses proxy → null
}

So the difference is not between cId and getCId() on a “normal” object, but on a proxy. With proxies you must use getters (or initialize the entity/collection before copying).

About the three options you listed:

1. Swapping the order of copying Bs and Cs – this only works because loading B forces Hibernate to touch its cOfB, which indirectly initializes some C proxies. That’s a side effect, not something you should rely on.

2. Making cOfB eager – fixes the null problem, but it can explode into unnecessary joins and N+1 queries. It solves one issue but creates others.

3. Using getters in the constructors – this is the correct fix. Hibernate proxies exist exactly for this use case, and getters are the hook Hibernate uses to trigger lazy loading.

So what’s wrong with the original code is that you’re directly accessing fields of a proxy. The safe approach is to either initialize the associations before copying (e.g. Hibernate.initialize(sourceA.getCsOfA())) or to always go through getters in your copy constructor.

Mapping should be:

@Entity
class A {
    @Id
    String aId;

    @OneToMany(mappedBy = "aOfB", fetch = FetchType.LAZY)
    List<B> bsOfA;

    @OneToMany(mappedBy = "aOfC", fetch = FetchType.LAZY)
    List<C> csOfA;

    public A(String id) {
        this.aId = id;
    }
}

@Entity
class B {
    @EmbeddedId
    BId id;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("aId")
    A aOfB;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumns({
        @JoinColumn(name="aId", referencedColumnName="aId"),
        @JoinColumn(name="cId", referencedColumnName="cId")
    })
    C cOfB;

    public B(String newAId, B sourceB) {
        this.id = new BId(newAId, sourceB.getId().getBId());
    }
}

@Entity
class C {
    @EmbeddedId
    CId id;

    @ManyToOne(fetch = FetchType.LAZY)
    @MapsId("aId")
    A aOfC;

    @OneToMany(mappedBy = "cOfB", fetch = FetchType.LAZY)
    List<B> linkedBsToC;

    public C(String newAId, C sourceC) {
        this.id = new CId(newAId, sourceC.getId().getCId());
    }
}

@Embeddable
class BId implements Serializable {
    String aId;
    String bId;
}

@Embeddable
class CId implements Serializable {
    String aId;
    String cId;
}