Hibernate基础使用：CRUD方法及实体对象的三种状态

hibernate的实体对象有三种状态，而实体对象是被Session管理：

(1)瞬态：刚刚被创建出来时的状态；

(2)持久化：被Session管理时的状态，能够和数据库同步；

(3)脱管：过去被Session管理，但是现在Session已关闭，虽然存在与数据库对应的记录，但是不能同步；

Session的入门常用方法

(1)Query query = session.createQuery(hql)：利用hql查询语句查询；

(2)Criteria critera = session.createCriteria(Class clazz);

(3)Transaction tx = session.beginTransaction();     //开始事务；tx.commit()提交事务；

(4)session.close(); //关闭Session，此后被session管理的持久化对象变为脱管状态；

(5)session.save(Object obj);    //添加

(6)session.update(Object obj);     //更新

(7)session.delete(Object obj);    //删除

(8)Object obj = session.get(Class clazz,Serialiazble id);    //根据主键查找记录并返回；

(9)Object obj = session.load(Class clazz,Serializable id);    //和get方法效果一样，但是是懒加载，即在不使用他之前他不会返回对象；

接下来，我们利用Session的方法，制作一个HibernateUtils类，此类能够在平时简化开发流程：

[java]  view plain  copy

1. package org.xiazdong.utils;  
2.   
3. import java.io.Serializable;  
4.   
5. import org.hibernate.HibernateException;  
6. import org.hibernate.Session;  
7. import org.hibernate.SessionFactory;  
8. import org.hibernate.Transaction;  
9. import org.hibernate.cfg.Configuration;  
10.   
11. public final class HibernateUtils {  
12.     private static SessionFactory factory;  
13.   
14.     public static Session getSession() {  
15.         return factory.openSession();  
16.     }  
17.   
18.     private HibernateUtils() { // 单例模式  
19.     }  
20.   
21.     static { // 载入虚拟机时执行一次  
22.         // configure默认加载hibernate.cfg.xml  
23.         // 如果不是hibernate.cfg.xml，则指定其他名字，此文件从classpath中找  
24.         Configuration config = new Configuration().configure();  
25.         factory = config.buildSessionFactory();  
26.     }  
27.   
28.     public static void add(Object obj) {  
29.         Session session = null;  
30.         Transaction tx = null;  
31.         try {  
32.             session = HibernateUtils.getSession();  
33.             tx = session.beginTransaction();  
34.             session.save(obj);  
35.             tx.commit();  
36.         } catch (HibernateException e) {  
37.             if (tx != null) { // 如果存在事务，则回滚  
38.                 tx.rollback();  
39.             }  
40.             throw e; // 抛出异常  
41.         } finally {  
42.             if (session != null) // 如果session存在，则关闭  
43.                 session.close();  
44.         }  
45.     }  
46.   
47.     public static void update(Object obj) {  
48.         Session session = null;  
49.         Transaction tx = null;  
50.         try {  
51.             session = HibernateUtils.getSession();  
52.             tx = session.beginTransaction();  
53.             session.update(obj);  
54.             tx.commit();  
55.         } catch (HibernateException e) {  
56.             if (tx != null) { // 如果存在事务，则回滚  
57.                 tx.rollback();  
58.             }  
59.             throw e; // 抛出异常  
60.         } finally {  
61.             if (session != null) // 如果session存在，则关闭  
62.                 session.close();  
63.         }  
64.     }  
65.   
66.     public static void delete(Object obj) {  
67.         Session session = null;  
68.         Transaction tx = null;  
69.         try {  
70.             session = HibernateUtils.getSession();  
71.             tx = session.beginTransaction();  
72.             session.delete(obj);  
73.             tx.commit();  
74.         } catch (HibernateException e) {  
75.             if (tx != null) { // 如果存在事务，则回滚  
76.                 tx.rollback();  
77.             }  
78.             throw e; // 抛出异常  
79.         } finally {  
80.             if (session != null) // 如果session存在，则关闭  
81.                 session.close();  
82.         }  
83.     }  
84.   
85.     public static Object get(Class clazz, Serializable id) {  
86.         Session session = null;  
87.         try {  
88.             session = HibernateUtils.getSession();  
89.             Object obj = session.get(clazz, id);  
90.             return obj;  
91.         } finally {  
92.             if (session != null) {  
93.                 session.close();  
94.             }  
95.         }  
96.     }  
97.   
98. }  

测试类：

[java]  view plain  copy

1. package org.xiazdong;  
2.   
3. import org.xiazdong.utils.HibernateUtils;  
4.   
5. public class UserTest {  
6.   
7.     public static void main(String[] args) {  
8.         User u = new User();  
9.         u.setName("xiazdong-1");  
10.         u.setAge(20);  
11.         HibernateUtils.add(u);  //使用add方法  
12.         //此语句  
13.         System.out.println("加入成功...");  
14.         u = (User) HibernateUtils.get(User.class,1);    //使用get方法  
15.         System.out.println("获取的姓名："+u.getName());  
16.     }  
17. }