/** HibernateUtil.java **/
package util;

import org.hibernate.*;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.criterion.Criterion;

public class HibernateUtil {
   
    private static final SessionFactory ourSessionFactory;
    private static Session ourSession;
   
    static {
        try {
            ourSessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
            ourSession = HibernateUtil.getSessionFactory().openSession();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return ourSessionFactory;
    }
   
    public static Session getSession() {
       if (!ourSession.isOpen()) {
            ourSession = ourSessionFactory.openSession();
       }
        return ourSession;
    }
   
    public static<T> T findUniqueByCriteria(Class<?> persistentClass,
          Criterion... criterion)
    {
       Criteria criteria =
          getSession().createCriteria(persistentClass);

       for (Criterion c : criterion) {
          criteria.add(c);
       }

       return (T) criteria.uniqueResult();
    }
}

/** Person.java **/
package hello;

import javax.persistence.*;
import javax.persistence.Table;

@Entity
@Table(name = "person")
public class Person
{
    private String myName;
    private PersonInfo myPersonInfo;

    public Person() {}

    public Person(String name)
    {
        myName = name;
    }

    @Id
    @Column(name = "name")
    public String getName()
    {
        return myName;
    }

    public void setName(String name)
    {
        myName = name;
    }
   
    @OneToOne(cascade = CascadeType.ALL,  optional = true)
    @PrimaryKeyJoinColumn
    public PersonInfo getPersonInfo()
    {
        return myPersonInfo;
    }

    public void setPersonInfo(PersonInfo personInfo)
    {
        myPersonInfo = personInfo;
    }
}

/** PersonInfo **/
package hello;

import javax.persistence.*;
import org.hibernate.annotations.Parameter;

@Entity
@Table(name="person_info")
@Inheritance(strategy=InheritanceType.JOINED)
public class PersonInfo
{
    private String myPersonId;
    private Person myPerson;

    @Id @GeneratedValue(generator = "myForeignGenerator")
    @org.hibernate.annotations.GenericGenerator(
        name = "myForeignGenerator",
        strategy = "foreign",
        parameters = @Parameter(name = "property", value = "person"))
    @Column (name = "name")
    public String getPersonId()
    {
        return myPersonId;
    }

    public void setPersonId(String personId)
    {
        this.myPersonId = personId;
    }

    @OneToOne(cascade = CascadeType.ALL, optional = false)
    @PrimaryKeyJoinColumn
    public Person getPerson()
    {
        return myPerson;
    }

    public void setPerson(Person person)
    {
        myPerson = person;
    }
}

package hello;

import util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Expression;

public class HelloPerson
{
    private static Person save(Person person)
    {
        Transaction tx = null;
        Session sess = HibernateUtil.getSession();
        tx = sess.beginTransaction();
        sess.merge(person);
        tx.commit();
        return person;
    }
   
    public static void main(String[] args)
    {
        String name = "ravi";
      
        Criterion criterion = Expression.eq("name", name);
        Person person =
            HibernateUtil.findUniqueByCriteria(Person.class, criterion);
       
        if (person == null) {
           person = new Person(name);
           PersonInfo personInfo = new PersonInfo();
           person.setPersonInfo(personInfo);
           personInfo.setPerson(person);
        }

        save(person);
        save(person);
    }
}