Hibernate的连接数据库的方法

初级，最笨重的方法：  

Java的代码  

1. 包 com.svse.dao;  
2.   
3. 进口 的java.util.ArrayList;  
4. 进口 的java.util.List;  
5.   
6. 导入 的org.hibernate.Session;  
7. 进口 的SessoinFactory;  
8. 导入 org.hibernate.Transaction;  
9. 导入 org.hibernate.cfg.Configuration;  
10.   
11. 导入 com.svse.entity.TDept;  
12.   
13. / /部门数据处理  
14. 公共 类 DeptDao_1 {  
15.       
16.     / /全查询，   
17.     公共 列表的getAll（）{  
18.         列表AR =  新的 ArrayList（）;  
19.         / / 1，加载配置文件，连接数据库  
20.         配置配置   配置（元），配置（）;  
21.         / / 2，得到数据映射的工具：SessionFactory的;  
22.         SessionFactory中的SessionFactory = config.buildSessionFactory（）;  
23.         / / 3，得到动作处理工具会议，执行相应的动作;  
24.         届会议sessionFactory.openSession（）;  
25.           
26.         / / 4，使用会话工具执行动作;  
27.         AR = session.createQuery（“FROM TDept” ），列表（）;  
28.           
29.         / / 5，关闭工具  
30.         session.close（）;  
31.         返回 AR;  
32.     }  
33.       
34.     / /查询一个  
35.     公共 TDept getOne（INT  P_ID）{  
36.         DEPT TDept，=  新 TDept（）;  
37.           
38.         配置配置   配置（元），配置（）;  
39.         SessionFactory中的SessionFactory = config.buildSessionFactory（）;  
40.         届会议sessionFactory.openSession（）;  
41.           
42.         / /通过ID获取到一个对象; TDept.class使用到的Java的反射机制;  
43.         部中=（TDept）session.get（类 TDept. ，  新的 整数（P_ID），的）;  
44.           
45.         session.close（）;  
46.         返回 部;  
47.     }  
48.       
49.     / ************************************************* ************************ /  
50.     / ********** 
51.      *增，删，改 
52.      *安全性; 
53.      *    
54.      *  
55.      *  
56.      *  
57.      ************** /  
58.       
59.     / /增加  
60.     公共的 无效 addDept（TDept部）{  
61.         配置配置   配置（元），配置（）;  
62.         SessionFactory中的SessionFactory = config.buildSessionFactory（）;  
63.         届会议sessionFactory.openSession（）;  
64.         交易CTX = session.beginTransaction（）;  
65.           
66.         / /增加的session.save（部）;  
67.         的session.save（部）;  
68.           
69.         ctx.commit（）;  
70.         session.close（）;  
71.     }  
72.       
73.     / /修改  
74.     公共的 无效 更新（TDept部）{  
75.         配置配置   配置（元），配置（）;  
76.         SessionFactory中的SessionFactory = config.buildSessionFactory（）;  
77.         届会议sessionFactory.openSession（）;  
78.           
79.         / /开启事务  
80.         交易CTX = session.beginTransaction（）;  
81.           
82.         / /修改的update（）方法  
83.         session.update（部）;  
84.           
85.         / /提交事务  
86.         ctx.commit（）;  
87.         session.close（）;  
88.     }  
89.       
90.     / /删除  
91.     公共 无效 删除（部TDept）{  
92.         配置配置   配置（元），配置（）;  
93.         SessionFactory中的SessionFactory = config.buildSessionFactory（）;  
94.         届会议sessionFactory.openSession（）;  
95.           
96.         / /开启事务以保证数据的安全性;  
97.         交易CTX = session.beginTransaction（）;  
98.           
99.         / /动作：删除（）;操作  
100.         使用Session.delete（部）;  
101.           
102.         / /提交事务  
103.         ctx.commit（）;  
104.         session.close（）;  
105.     }  
106.       
107.     公共 静态 无效的 主要（字串[] args）{  
108.         DeptDao_1 DAO =  新 DeptDao_1（）;  
109.         System.out.println（dao.getAll（）的大小（））;  
110.     }  
111. }  

中级：较为简化的连接方法：  

Java的代码  

1. 包 com.svse.dao;  
2.   
3. 进口 的java.util.ArrayList;  
4. 进口 的java.util.List;  
5.   
6. 导入 的org.hibernate.Session;  
7. 进口 的SessoinFactory;  
8. 导入 org.hibernate.Transaction;  
9. 导入 org.hibernate.cfg.Configuration;  
10.   
11. 导入 com.svse.entity.TUser;  
12.   
13. / /使用封装类简化代码进行操作  
14. 公共 类 UserDao1 {  
15.   
16.     / /定义基本属性字段  
17.     私人 静态 配置配置=  NULL ;  
18.     私人 静态的 SessionFactory的SessionFactory =  空;  
19.     私人 静态 届会议=  NULL ;  
20.     私人 静态 交易CTX =  NULL ;  
21.   
22.     / /该内部类的特点：UserDao1这个实例化一次的时候自动的调用一次;  
23.     静态{  
24.         尝试{  
25.             配置  新的  配置（）配置（）;  
26.             SessionFactory的config.buildSessionFactory（）;  
27.             会话= sessionFactory.openSession（）;  
28.   
29.         } 赶上（例外）{  
30.             ex.printStackTrace（）;  
31.         }  
32.     }  
33.   
34.     / /增加  
35.     公共的 无效 ADDUSER（为TUser用户）{  
36.         CTX = session.beginTransaction（）;  
37.         的session.save（用户）;  
38.         ctx.commit（）;  
39.         session.close（）;  
40.     }  
41.   
42.     / /修改  
43.     公共 无效 UpdateUser两个（为TUser用户）{  
44.         CTX = session.beginTransaction（）;  
45.         session.update（用户）;  
46.         ctx.commit（）;  
47.         session.close（）;  
48.     }  
49.   
50.     / /删除  
51.     公共 无效 deluser命令（为TUser用户）{  
52.         CTX = session.beginTransaction（）;  
53.         使用Session.delete（用户）;  
54.         ctx.commit（）;  
55.         session.close（）;  
56.     }  
57.   
58.     / /全查询  
59.     公共 列表的getAll（）{  
60.         列表AR =  新的 ArrayList（）;  
61.         AR = session.createQuery（“FROM的TUser” ）。列表（）;  
62.         session.close（）;  
63.         返回 AR;  
64.     }  
65.   
66.     / /查询一个  
67.     公众 为TUser getOne（INT  U_ID）{  
68.         为TUser用户=  新 的TUser（）;  
69.         用户=（为TUser）session.get（TUser. 类新的 整数（U_ID））;  
70.         session.close（）;  
71.         返回 用户;  
72.     }  
73.   
74.   
75. }  

高级：最简单的方法，使用接口封装： 辅助类：

Java的代码  

1. 包 com.svse.util;  
2.   
3. 进口 org.hibernate.HibernateException;  
4. 导入 的org.hibernate.Session;  
5. 导入 org.hibernate.cfg.Configuration;  
6.   
7. / ** 
8.  *配置和Hibernate会话，提供了访问，绑在 
9.  *当前线程的执行。如下主题本地会话 
10.  *图案，见{@链接http://hibernate.org/42.html}。 
11.  * /  
12. 公共 类 HibernateSessionFactory {  
13.   
14.   
15.     私人 静态的 字符串CONFIG_FILE_LOCATION =  “/ hibernate.cfg.xml的” ;  
16.     私人 静态 最终 ThreadLocal的<Session> ThreadLocal的  新 ThreadLocal的<Session>的（）;  
17.     私人  静态 配置配置  新 配置（）;      
18.     私人 静态的 的SessoinFactory SessionFactory;  
19.     私人 静态 字符串CONFIGFILE = CONFIG_FILE_LOCATION;  
20.   
21.     静态 {  
22.         尝试 {  
23.             configuration.configure（CONFIGFILE）;  
24.             SessionFactory的configuration.buildSessionFactory（）;  
25.         }  赶上 （例外五）{  
26.             System.err的  
27.                     调用println（ “ 创建SessionFactory的％％％％％％％％错误” ）;  
28.             e.printStackTrace（）;  
29.         }  
30.     }  
31.     私人 HibernateSessionFactory（）{  
32.     }  
33.       
34.     / ** 
35.      *返回的ThreadLocal Session实例。懒初始化 
36.      *在<code>的SessionFactory </代码，如果需要的话。 
37.      * 
38.      * @返回会议 
39.      * @抛出HibernateException 
40.      * /  
41.     公共 静态 会话getSession（）  抛出 HibernateException的{  
42.         Session会话（会话）threadLocal.get（）;  
43.   
44.          （会话==  NULL  | |！session.isOpen（））{  
45.              （SessionFactory的==  NULL ）{  
46.                 rebuildSessionFactory（）;  
47.             }  
48.             会话=（SessionFactory的！=  空）？（sessionFactory.openSession）  
49.                     ：  空;  
50.             threadLocal.set（会话）;  
51.         }  
52.   
53.         返回 会话;  
54.     }  
55.   
56.     / ** 
57.      *重建hibernate会话工厂 
58.      * 
59.      * /  
60.     公共 静态的 无效 rebuildSessionFactory（）{  
61.         尝试 {  
62.             configuration.configure（CONFIGFILE）;  
63.             SessionFactory的configuration.buildSessionFactory（）;  
64.         }  赶上 （例外五）{  
65.             System.err的  
66.                     调用println（ “ 创建SessionFactory的％％％％％％％％错误” ）;  
67.             e.printStackTrace（）;  
68.         }  
69.     }  
70.   
71.     / ** 
72.      *关闭单个的Hibernate会话实例。 
73.      * 
74.      * @抛出HibernateException 
75.      * /  
76.     公共 静态 无效 关闭会话（）  抛出 HibernateException的{  
77.         Session会话（会话）threadLocal.get（）;  
78.         threadLocal.set（空）;  
79.   
80.          （会话！=  0 ）{  
81.             session.close（）;  
82.         }  
83.     }  
84.   
85.     / ** 
86.      *返回会话工厂 
87.      * 
88.      * /  
89.     公共 静态 的SessoinFactory的的getSessionFactory（）{  
90.         返回 SessionFactory的;  
91.     }  
92.   
93.     / ** 
94.      *返回会话工厂 
95.      * 
96.      *会话工厂将在未来的呼叫rebuilded 
97.      * /  
98.     公共 静态 无效 setConfigFile（字符串CONFIGFILE）{  
99.         HibernateSessionFactory.configFile = CONFIGFILE;  
100.         SessionFactory的=  NULL ;  
101.     }  
102.   
103.     / ** 
104.      *返回hibernate配置 
105.      * 
106.      * /  
107.     公共 静态的 配置getConfiguration（）{  
108.         返回 配置;  
109.     }  
110.   
111. }  

定义接口规则：  

Java的代码  

1. 包 com.svse.util;  
2.   
3. 导入 的org.hibernate.Session;  
4.   
5. / /结果定义规则  
6. 公共 接口 IHibernateSessionFactorySupport {  
7.       
8.     / /得到会话  
9.     公共 会话getSession（）;  
10.       
11.     / /开启事务  
12.     公共 无效 调用BeginTransaction（）;  
13.       
14.     / /提交事务  
15.     公共的 无效 commitTransaction（）;  
16.       
17.     / /关闭所有  
18.     公共的 无效 closeAll（）;  
19. }  

接口实现，编写规则：  

Java的代码  

1. 包 com.svse.util;  
2.   
3. 导入 的org.hibernate.Session;  
4. 导入 org.hibernate.Transaction;  
5.   
6. 公共 类实现  
7.         IHibernateSessionFactorySupport {  
8.   
9.     / /定义事务的对象：  
10.     私人 交易CTX =  空;  
11.       
12.     / /开启事务  
13.     公共 无效 调用BeginTransaction（）{  
14.         CTX =  getSession（）调用BeginTransaction（）;  
15.     }  
16.   
17.     / /提交事务  
18.     公共的 无效 commitTransaction（）{  
19.         尝试{  
20.             ctx.commit（）;  
21.         } 赶上（例外）{  
22.             ex.printStackTrace（）;  
23.             / /事务回滚  
24.             如果（ctx! = 空）{  
25.                 ctx.rollback（）;  
26.             }  
27.         } 最后{  
28.             HibernateSessionFactory.closeSession（）;  
29.         }  
30.     }  
31.       
32.     / /关闭所有调用自动生类中定义方法  
33.     公共的 无效 closeAll（）{  
34.         HibernateSessionFactory.closeSession（）;  
35.     }  
36.   
37.     / /得到会话  
38.     公共 会话getSession（）{  
39.           
40.         / /返回一个会话的对象  
41.         返回 HibernateSessionFactory.getSession的（）;  
42.     }  
43.   
44. }  

具体数据获取，访问数据库得到数据：  

Java的代码  

1. 包 com.svse.dao;  
2.   
3. 进口 的java.util.List;  
4.   
5. 导入 com.svse.entity.TUser;  
6. 导入 com.svse.util.HibernateSessionFactorySupportImpl;  
7.   
8. 公共 类扩展 HibernateSessionFactorySupportImpl的{  
9.       
10.     / /增加 - 涉及到数据的变化，需要使用事务  
11.     公共的 无效 ADDUSER（为TUser用户）{  
12.         / /第一步：开启事务  
13.         调用BeginTransaction（）;  
14.         / /第二步：执行动作  
15.         getSession（）。保存（用户）;  
16.         / /第三步：提交事务，并关闭相关的工具  
17.         commitTransaction（）;  
18.     }  
19.       
20.     / /修改  
21.     公共 无效 UpdateUser两个（为TUser用户）{  
22.         / /第一步：涉及到数据的安全性，先开启事务;  
23.         调用BeginTransaction（）;  
24.         / /第二步：获得会话对象并执行修改的动作;  
25.         getSession（）更新（用户）;  
26.         / /第三步：提交事务，并关闭相关的工具;  
27.         commitTransaction（）;  
28.     }  
29.       
30.     / /删除  
31.     公共 无效 deluser命令（INT  U_ID）{  
32.         / / 1，开启事务  
33.         调用BeginTransaction（）;  
34.         / / 2，执行动作  
35.         getSession（）。删除（getOne（U_ID））;  
36.         / / 3，提交事务并关闭相关的工具  
37.         commitTransaction（）;  
38.     }  
39.       
40.     / /查询一个  
41.     公众 为TUser getOne（INT  U_ID）{  
42.         / /第一步：获取会话对象执行动作，得到集合对象获取数据;  
43.         为TUser用户=（为TUser）  getSession（）。（TUser. 类新的 整数（U_ID））;  
44.         / /第二步：关闭会话工具;  
45.         closeAll（）;  
46.         返回 用户;  
47.           
48.     }  
49.       
50.     / /全查询  
51.     公共 列表的getAll（）{  
52.         列表AR =  getSession（）。createQuery（ “ 为TUser” ）名单（）;  
53.         closeAll（）;  
54.         返回 AR;  
55.     }  
56.       
57.     公共 静态 无效的 主要（字串[] args）{  
58.         UserDao2 DAO =：  新 UserDao2（）;  
59.         为TUser用户=  新 的TUser（）;  
60.         user.setUId（1 ）;  
61.         user.setUName（ “ 小红AA” ）;  
62.         user.setUPwd（“123” ）;  
63.         dao.updateUser（用户）;  
64.     }  
65. }