Hibernate: persist an object containing a list with more objects

[Joachim Rohde]

After years of using iBatis I'm giving Hibernate a shot. My problem is that I'm not able to figure out how to persist an object which contains a list of other objects which are containing a back reference.

In my small little test-application I have an object called CD and an object called Track. Each CD should contain a list of tracks (one-to-many) and each Track should contain a back reference to the CD object to which it belongs to.

After trying out a few examples which I found on the internet and reading hours the documentation I'm desparated because I can't get it work.

Here's what I've got so far:

My trivial database schema contains only two tables:

table: cd
cdId (primary key)
name (a varchar)

table: track
trackId (primary key)
cdId (foreign key)

My CD-object:

@Entity
@Table(name = "cd")
public class CD implements Serializable
{

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long cdId;
    private String name = "";

    public Long getCdId()
    {
        return cdId;
    }

    public void setCdId(Long cdId)
    {
        this.cdId = cdId;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    @OneToMany(mappedBy="cd", cascade = {CascadeType.ALL, CascadeType.MERGE, CascadeType.PERSIST}, fetch = FetchType.EAGER)
    @JoinColumn(name = "cdId")
    private List<Track> tracks;

    public List<Track> getTracks()
    {
        return tracks;
    }

    public void setTracks(List<Track> tracks)
    {
        this.tracks = tracks;
    }
}

My track-object:

@Entity
@Table(name = "track")
public class Track implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long trackId;

    @Id
    @ForeignKey(name = "fkUserGenerator")
    @GeneratedValue(generator = "fkUserGenerator")
    @org.hibernate.annotations.GenericGenerator(name = "fkUserGenerator", strategy = "foreign", parameters =
    {
        @Parameter(name = "property", value = "cd")
    })
    @Column(name = "cdId")
    private Long cdId;


    @ManyToOne(cascade = {CascadeType.ALL, CascadeType.MERGE, CascadeType.PERSIST}, targetEntity = CD.class, optional=true)
    @JoinColumn(name = "cdId", insertable = false, updatable = false)
    private CD cd;

    public Long getCdId()
    {
        return cdId;
    }

    public void setCdId(Long cdId)
    {
        this.cdId = cdId;
    }


    public Long getTrackId()
    {
        return trackId;
    }

    public void setTrackId(Long sceneId)
    {
        this.trackId = sceneId;
    }

    public CD getCd()
    {
        return cd;
    }

    public void setCd(CD cd)
    {
        this.cd = cd;
    }

}

My test-application:

public class App
{
    public static void main(String[] args)
    {
        App mgr = new App();
        List cds = mgr.listCds();
        for (int i = 0; i < cds.size(); i++)
        {
            CD theCd = (CD) cds.get(i);
            System.out.println("CD: " + theCd.getName());
            if (theCd.getTracks() != null)
            {
                System.out.println("Number of Tracks: " + theCd.getTracks().size());
                if (theCd.getTracks().size() > 0)
                {
                    System.out.println("CD-Name: " + theCd.getTracks().get(0).getCd().getName());
                }

            }
        }
        
        mgr.newCd();
    }

	// return every cd-object out of the db
    private List listCds()
    {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        List result = session.createQuery("from CD").list();


        session.getTransaction().commit();
        return result;
    }

	// create a new cd with tracks in the db
    private void newCd()
    {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        Track track = new Track();
        session.getTransaction().commit();

        session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        Track track2 = new Track();
        session.getTransaction().commit();


        session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();

        CD cd = new CD();
        cd.setName("test");
        track.setCd(cd);

        track2.setCd(cd);
        List<Track> tracks = new ArrayList<Track>();
        tracks.add(track);
        tracks.add(track2);

        cd.setTracks(tracks);

        session.save(cd);

        session.getTransaction().commit();
    }
}

My hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
  "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/cds</property>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <mapping class="de.adelio.pmdb.model.CD"/>
        <mapping class="de.adelio.pmdb.model.Track"/>

    </session-factory>

</hibernate-configuration>

And the HibernateUtil-class which I copied from somewhere:

public class HibernateUtil
{
    private static final SessionFactory sessionFactory;

    static
    {
        try
        {
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex)
        {
            // Log exception!
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static Session getSession() throws HibernateException
    {
        return sessionFactory.openSession();
    }
}

If I insert some data manually in the database the loading of the objects works perfectly. I can load a CD and the tracks are automatically loaded as well, just as expected.
If I try to save a CD-object with only one track included in the list it ALSO works as expected. Both objects are persisted and Hibernate sets the correct foreign-key (the field cdId in table track). But as soon as there are more objects in my list, I encounter a NonUniqueObjectException (Exception in thread "main" org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session).
I understood (I guess) that the problem is that my CD-object which I associate in the newCD()-method (via track.setCd(cd);) with a track is not unique in the hibernate-session.

Due to the fact that none of those objects exists in the database I can't load them from the database into the hibernate-session. I also tried to play around with evict() and merge() and also trying out a hell lot of annotation-combinations but none of them worked.

So how is this solved in general? Do I have to persist first the CD-object, load it again and then persist the Track-objects?

Sorry for this lengthy post but this really bugs me since days and I'm having the feeling is just small thing I don't see yet. And I don't know if the annotations are completly wrong or if the newCD()-method has to look differently. So, any hints for solving this problem are really really appreciated.

Joachim

[Mark Spritzler]

Well, that is quite a bit there for something pretty simple.

So I would have this basic.

 
@Entity
public class CD implements Serializable {
    @Id
    @GeneratedValue
    private Long id;
  
    // I would not eager fetch any collection in mapping, it should always be Use Case query driven
    @OneToMany(mappedBy="cd", cascade = {CascadeType.ALL, CascadeType.MERGE, CascadeType.PERSIST})
    private List<Track> tracks;

    ...Getters and Setters and also implement equals and hashcode
}
   

@Entity
public class Track implements Serializable {

    @Id
    @GeneratedValue
    private Long id;

    // Fetch lazy is only there if you import the JPA version, because in JPA it eager fetches ManyToOne's by default, and again this should
    // Be Use Case query driven.
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn
    private CD cd;

    //... getters and setters as well as implementing equals and hashcode
}

Also, in the latest versions of Hibernate, you no longer need the HibernateSingleton class anymore, just call sessionFactory.getCurrentSession()

That is all you need to make a call like
session.saveOrUpdate(cd);

to save the cd and all of its tracks.

Good Luck and above all, simplify, simplify, simplify

Mark

[Joachim Rohde]

How cool, it works. Thanks a lot. Even though I was not able yet to implement the lazy-loading, but I guess I have to read a bit more documentation for that.

But I still have a question though: if the HibernateSingleton class is not needed anymore and calling just sessionFactory.getCurrentSession() is considered best-practice now, where should I instantiate the sessionFactory object? Should it be instantiated in the constructor of each class, where I need access to the database? Or what's considered best-practice?