Hibernate4Step3

本着应用的目的快速学习Hibernate4框架

• Hibernate对象和常用方法

前面的话

本节主要介绍：

1. Hibernate中四种对象状态和关系
2. Session常用方法讲解
3. Hibernate中的OID和OID生成策略

Hibernate中四种对象状态和关系

临时状态（transient）：刚用new语句创建，还没有被持久化，并且不处于Session缓存中。处于临时状态的Java对象被称为临时对象。

持久化状态（persistent）：已经被持久化，并且加入到Session缓存中。处于持久化状态的Java对象被称为持久化对象。

删除状态（removed）：不再处于Session的缓存中，并且Session已经计划将其从数据库中删除。处于删除状态的Java对象被称为删除对象。

游离状态（detached）：已经被持久化，但不再处于Session的缓存中。处于游离状态的Java对象被称为游离对象。

public class StudentTest {
	
	public static void main(String[] args) {
		SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
		Session session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	    
	    Class c1=new Class(); // 临时对象1
	    c1.setName("08计本");
	    
	    Class c2=new Class();  // 临时对象2
	    c2.setName("09计本");
	    
	    session.save(c1); // 持久化对象
	    session.save(c2); // 持久化对象
	    
	    session.delete(c2); // 删除对象
	    
	    session.getTransaction().commit(); // 提交事务
	    session.close(); // 关闭session
	    
	    System.out.println(c1.getName()); // 游离对象
	    System.out.println(c2.getName()); // 删除对象
	}
}

四种对象状态的关系：

Session常用方法讲解

1. save()方法
2. 将一个临时对象转变成持久化对象；
3. load()方法 VS get()方法
   都是根据OID从数据库中加载一个持久化对象。
   区别1：假如数据库中不存在与OID对应的记录，Load()方法会抛出异常，而get()方法返回null；
   区别2：load()方法默认采用延迟加载策略，get()方法采用立即检索策略；
4. update()方法 将一个游离态对象转变为持久化对象；
5. saveOrUpdate()方法 包含了save()和update()方法；
6. merge()方法 合并对象
7. delete()方法 删除对象

public class StudentTest {

	private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
	private Session session;
	
	@Before
	public void setUp() throws Exception {
		session=sessionFactory.openSession(); // 生成一个session
	    session.beginTransaction(); // 开启事务
	}

	@After
	public void tearDown() throws Exception {
		 session.getTransaction().commit(); // 提交事务
		 session.close(); // 关闭session
	}

	@Test
	public void testSaveClassAndStudent() {
		Class c=new Class();
	    c.setName("08计本");
	   
	    Student s1=new Student();
	    s1.setName("张三");
	    s1.setC(c);
	    
	    Student s2=new Student();
	    s2.setName("李四");
	    s2.setC(c);
	   
	    session.save(s1);
	    session.save(s2);
	    
	}
	
	@Test
	public void testLoadClass(){
		// Class c=(Class)session.load(Class.class, Long.valueOf(2));
		Class c=(Class)session.load(Class.class, Long.valueOf(1));
		System.out.println(c.getStudents());
	}
	
	@Test
	public void testGetClass(){
		// Class c=(Class)session.get(Class.class, Long.valueOf(2));
		Class c=(Class)session.get(Class.class, Long.valueOf(1));
		System.out.println(c.getStudents());
	}
	
	@Test
	public void testUpdateClass(){
		Session session1=sessionFactory.openSession();
		session1.beginTransaction();
		Class c=(Class)session1.get(Class.class, Long.valueOf(1));
		session1.getTransaction().commit(); // 提交事务
		session1.close();
		
		Session session2=sessionFactory.openSession();
		session2.beginTransaction();
		c.setName("08计算机本科2");
		session2.update(c);
		session2.getTransaction().commit(); // 提交事务
		session2.close();
	}
	
	@Test
	public void testSaveOrUpdateClass(){
		Session session1=sessionFactory.openSession();
		session1.beginTransaction();
		Class c=(Class)session1.get(Class.class, Long.valueOf(1));
		session1.getTransaction().commit(); // 提交事务
		session1.close();
		
		Session session2=sessionFactory.openSession();
		session2.beginTransaction();
		c.setName("08计算机本科3");
		
		Class c2=new Class();
		c2.setName("09计算机本科3");
		session2.saveOrUpdate(c);
		session2.saveOrUpdate(c2);
		session2.getTransaction().commit(); // 提交事务
		session2.close();
	}
	
	@Test
	public void testMergeClass(){
		Session session1=sessionFactory.openSession();
		session1.beginTransaction();
		Class c=(Class)session1.get(Class.class, Long.valueOf(1));
		session1.getTransaction().commit(); // 提交事务
		session1.close();
		
		Session session2=sessionFactory.openSession();
		session2.beginTransaction();
		
		Class c2=(Class)session2.get(Class.class, Long.valueOf(1));
		c.setName("08计算机本科4");
	
		session2.merge(c);

		session2.getTransaction().commit(); // 提交事务
		session2.close();
	}
	
	@Test
	public void testDeleteStudent(){
		Student student=(Student)session.load(Student.class, Long.valueOf(1));
		session.delete(student);
	}
}

Tips：

1. 当要删除一个对象时，采用load()方法，会使性能更优，当要获取对象并操作该对象时，采用get()方法立即检索。
2. 如果使用update()方法更新一个游离态对象，而session缓存存在该对象（根据OID），则会抛出NonUniqueObjectException，此时采用merge()方法以达到更新效果。

关于Hibernate中的OID和OID生成策略

对象标识符OID

Hibernate用对象标识符（OID)来区分对象，我理解的就是ObjectID，意思就是对象对应数据库中表的主键。

Hibernate对象标识符生成策略

主键的分类 业务主键 VS 代理主键 代理主键时不具有业务性的；

1. increment 由Hibernate自动以递增的方式生成标识符，适用于代理主键；
2. identity 由底层数据库生成标识符，适用于代理主键；
3. sequence 由Hibernate根据底层数据库的序列来生成标识符，适用于代理主键；
4. hilo Hibernate根据high/low算法来生成标识符，适用于代理主键；
5. native 根据底层数据库对自动生成标识符的支持能力，来选择identity，sequence或hilo；

更多内容请参考别人写的博文：
hibernate中的OID说明