Hiberante3学习之路第一节 原创

   最近在忙于Hibernate3授课的讲解,闲来之余对每一次授课的内容做个总结,供正在或将要学习Hibernate3框架技术的学员参考,愿从中有所收获......

一、Hibernate环境搭建
1、建立一个普通的java项目，首先进行数据库连接，选择myeclipse Database Explorer 界面，在空白处右键new新建连接，连接的驱动模型Driver template选择MySQL Connector,加载驱动，下一步选择你要加载的数据库，连接后台成功后回到java界面。
2、安装配置的三项准备工作
1、添加hibernate库
 

Java代码

1. 将下载目录/hibernate3.jar和/lib下的hibernate运行时必须的包加入classpath中：antlr.jar, cglib.jar , asm.jar , commons-collections.jar , commons-logging.jar , jta.jar , dom4j.jar   
2. 将hibernatejar包文件添加到java项目中    

将下载目录/hibernate3.jar和/lib下的hibernate运行时必须的包加入classpath中：antlr.jar, cglib.jar , asm.jar , commons-collections.jar , commons-logging.jar , jta.jar , dom4j.jar
将hibernatejar包文件添加到java项目中	

2、添加hibernate配置文件
配置文件hibernate.cfg.xml和hibernate.properties，XML和properties两种，这两个文件的作用一样，提供一个即可，推荐XML格式，下载目录/etc下是示例配置文件。
可以在配置文件指定：数据库的URL、用户名、密码、JDBC驱动类、方言等。
启动时Hibernate会在CLASSPATH里找这个配置文件。
命名的语法格式，名字是固定的并且位于src目录下

Java代码

1. hibernate.cfg.xml   
2. <hibernate-configuration>   
3. <session-factory>   
4.     <!-- 连接数据库名称 是在myeclipse中设置的 -->   
5.     <property name="myeclipse.connection.profile">localhost</property>   
6.     <!-- 数据库连接的URL -->   
7.     <property name="connection.url">   
8.         jdbc:mysql://localhost:3306/houtai   
9.     </property>   
10.     <!-- 数据库的用户名和密码 -->   
11.     <property name="connection.username">root</property>   
12.     <property name="connection.password">root</property>   
13.     <!-- 数据库的驱动 -->   
14.     <property name="connection.driver_class">   
15.         com.mysql.jdbc.Driver   
16.     </property>   
17.     <!-- 数据库的方言 -->   
18.     <property name="dialect">   
19.         org.hibernate.dialect.MySQLDialect   
20.     </property>   
21.      <!-- 显示sql语句的操作 -->   
22.     <property name="show_sql">true</property>   
23.     <!-- 创建表    
24.     <property name="hibernate.hbm2ddl.auto">create</property>   
25.     -->   
26.     <!-- 添加映射文件 -->   
27.     <mapping resource="edu/hiber/User.hbm.xml" />   
28. </session-factory>   
29. </hibernate-configuration>  

hibernate.cfg.xml
<hibernate-configuration>
<session-factory>
	<!-- 连接数据库名称 是在myeclipse中设置的 -->
	<property name="myeclipse.connection.profile">localhost</property>
	<!-- 数据库连接的URL -->
	<property name="connection.url">
		jdbc:mysql://localhost:3306/houtai
	</property>
	<!-- 数据库的用户名和密码 -->
	<property name="connection.username">root</property>
	<property name="connection.password">root</property>
	<!-- 数据库的驱动 -->
	<property name="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<!-- 数据库的方言 -->
	<property name="dialect">
		org.hibernate.dialect.MySQLDialect
	</property>
	 <!-- 显示sql语句的操作 -->
    <property name="show_sql">true</property>
    <!-- 创建表 
	<property name="hibernate.hbm2ddl.auto">create</property>
	-->
	<!-- 添加映射文件 -->
	<mapping resource="edu/hiber/User.hbm.xml" />
</session-factory>
</hibernate-configuration>

3、添加对应表的实体类和映射文件
映射文件(hbm.xml，对象模型和关系模型的映射)。在/eg目录下有完整的hibernate示例。
实体类和数据库表是通过hbm.xml配置文件来完成
命名语法格式：

Java代码

1. 类名.hbm.xml 与实体类在同一个包中   
2. User.hbm.xml   
3. <hibernate-mapping package="hiber">   
4.     <!—name实体类名，table对应数据库表的表名-->   
5.     <class name="User" table="user" catalog="hoteldb">   
6.         <id name="id"><!—user表中有一个id的属性-->   
7.             <!—generator 引用  native代表主键自动增长 -->   
8.             <generator class="native" />   
9.         </id>   
10. <!—property成员属性-->   
11.         <property name="name" length="40" />         
12. <property name="pass" />   
13.         <property name="birthday" />   
14.     </class>   
15. </hibernate-mapping>  

类名.hbm.xml 与实体类在同一个包中
User.hbm.xml
<hibernate-mapping package="hiber">
	<!—name实体类名，table对应数据库表的表名-->
	<class name="User" table="user" catalog="hoteldb">
		<id name="id"><!—user表中有一个id的属性-->
			<!—generator 引用  native代表主键自动增长 -->
			<generator class="native" />
		</id>
<!—property成员属性-->
		<property name="name" length="40" />		
<property name="pass" />
		<property name="birthday" />
	</class>
</hibernate-mapping>

在这里有一个面试常考的题就是数据库的主键生成策略
数据库的主键:
代理主键:  没有业务逻辑含义
自然主键:  有业务逻辑含义
主键生成策略：
Hibernate 提供的内置标识符生成器OID

Java代码

1. increment: 适用于代理主键, 由Hibernate自动以递增的方式生成标识符, 每次递增为1  
2. identity:  适用于代理主键, 由底层数据库生成标识符. 前提是底层数据库支持自动增长字段类型   
3. sequence:  适用于代理主键, Hibernate根据底层数据库的序列生成标识符. 前提是底层数据库支持序列   
4. hilo:      适用于代理主键, Hibernate根据hi/low算法生成标识符. Hibernate把特定的字段作为"high".默认情况下选用hibernate_unique_key表的next_hi字段   
5. native:    适用于代理主键, 根据底层数据库对自动生成标识符的支持能力, 来选择identify, sequence, 或hilo   
6. uuid.hex:  适用于代理主键, Hibernate采用128位的UUID(Universal Identification)算法生成标识符. UUID算法能够在网络环境中生成唯一的字符串标识符. 这种标识符生成策略并不流行, 因为字符串类型的主键比整数类型的主键占用更大的数据库空间               
7. assigned:  适用于自然主键, 由Java应用程序生成标识符.为了能让Java应用程序设置OID,不要把方法声明为private类型.  

increment: 适用于代理主键, 由Hibernate自动以递增的方式生成标识符, 每次递增为1
identity:  适用于代理主键, 由底层数据库生成标识符. 前提是底层数据库支持自动增长字段类型
sequence:  适用于代理主键, Hibernate根据底层数据库的序列生成标识符. 前提是底层数据库支持序列
hilo:      适用于代理主键, Hibernate根据hi/low算法生成标识符. Hibernate把特定的字段作为"high".默认情况下选用hibernate_unique_key表的next_hi字段
native:    适用于代理主键, 根据底层数据库对自动生成标识符的支持能力, 来选择identify, sequence, 或hilo
uuid.hex:  适用于代理主键, Hibernate采用128位的UUID(Universal Identification)算法生成标识符. UUID算法能够在网络环境中生成唯一的字符串标识符. 这种标识符生成策略并不流行, 因为字符串类型的主键比整数类型的主键占用更大的数据库空间            
assigned:  适用于自然主键, 由Java应用程序生成标识符.为了能让Java应用程序设置OID,不要把方法声明为private类型.

二、创建数据库
1、在hibernate.cfg.xml配置文件中写创建数据库命令

Java代码

1. <!—创建表 -->   
2. <property name="hibernate.hbm2ddl.auto">create</property>   
3. 它有4个属性：   
4.     create : 会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变   
5. create-drop : 根据model类生成表,但是sessionFactory一关闭,表就自动删除   
6. update : 最常用的属性，也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行   
7. validate : 只会和数据库中的表进行比较,不会创建新表,但是会插入新值  

<!—创建表 -->
<property name="hibernate.hbm2ddl.auto">create</property>
它有4个属性：
	create : 会根据你的model类来生成表,但是每次运行都会删除上一次的表,重新生成表,哪怕2次没有任何改变
create-drop : 根据model类生成表,但是sessionFactory一关闭,表就自动删除
update : 最常用的属性，也根据model类生成表,即使表结构改变了,表中的行仍然存在,不会删除以前的行
validate : 只会和数据库中的表进行比较,不会创建新表,但是会插入新值

2、添加实体类和数据库表的映射

Java代码

1. <!-- 添加映射文件 -->   
2.     <mapping resource="edu/hiber/User.hbm.xml" />   
3. 同时添加show_sql属性   
4. <!-- 显示sql语句的操作 -->   
5. <property name="show_sql">true</property>  

<!-- 添加映射文件 -->
	<mapping resource="edu/hiber/User.hbm.xml" />
同时添加show_sql属性
<!-- 显示sql语句的操作 -->
<property name="show_sql">true</property>

3、创建表

Java代码

1. /**解析配置文件configure()默认解析hibernate.cfg.xml文件并返回Configuration的对象*/  
2. Configuration cfg=new Configuration().configure();   
3. /**根据cfg对象创建一个SchemaExport的对象*/  
4. SchemaExport se=new SchemaExport(cfg);   
5. /**创建表的操作*/  
6. se.create(true, true);  

/**解析配置文件configure()默认解析hibernate.cfg.xml文件并返回Configuration的对象*/
Configuration cfg=new Configuration().configure();
/**根据cfg对象创建一个SchemaExport的对象*/
SchemaExport se=new SchemaExport(cfg);
/**创建表的操作*/
se.create(true, true);

三、操作数据库
操作表（增删改查）

Java代码

1. package hiber;   
2.   
3. import java.util.Date;   
4.   
5. import org.hibernate.SessionFactory;   
6. import org.hibernate.Transaction;   
7. import org.hibernate.cfg.Configuration;   
8. import org.hibernate.Session;   
9.   
10. public class TestHiber {   
11.     /**插入的方法*/  
12.     public boolean insert() {   
13.         boolean flag = false;   
14.         /**  
15.          * 采用Configuration对象configure方法解析hibernate.cfg.  
16.          * xml文件并返回一个Configuration的对象  
17.          */  
18.         Configuration cfg = new Configuration().configure();   
19.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
20.         SessionFactory sf = cfg.buildSessionFactory();   
21.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
22.         Session session = sf.openSession();   
23.         /** 定义个事务对象 */  
24.         Transaction tx = null;   
25.         try {   
26.             // 开始事务   
27.             tx = session.beginTransaction();   
28.             User entity=new User("sha","123",new Date());   
29.             //执行事务   
30.             session.save(entity);   
31.             //提交事务   
32.             tx.commit();   
33.             flag=true;   
34.         } catch (Exception e) {   
35.             //如果出现导常则回滚事务   
36.             if(tx!=null){   
37.                 tx.rollback();   
38.             }   
39.             e.printStackTrace();   
40.         }finally{   
41.             //不管事务执行成功与否都要关闭session   
42.             session.close();   
43.         }   
44.         return flag;   
45.     }   
46.     /**查询的方法*/  
47.     public User findById(int id){   
48.         User user = new User();   
49.         /**  
50.          * 采用Configuration  
51.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
52.          */  
53.         Configuration cfg = new Configuration().configure();   
54.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
55.         SessionFactory sf = cfg.buildSessionFactory();   
56.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
57.         Session session = sf.openSession();   
58.         try{   
59.             user = (User)session.load(User.class, id);   
60.         }catch(Exception ex){   
61.             ex.printStackTrace();   
62.         }   
63.         return user;   
64.     }   
65.        
66.        
67.        
68.     /**查询的方法*/  
69.     public User findByGId(int id){   
70.         User user = new User();   
71.         /**  
72.          * 采用Configuration  
73.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
74.          */  
75.         Configuration cfg = new Configuration().configure();   
76.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
77.         SessionFactory sf = cfg.buildSessionFactory();   
78.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
79.         Session session = sf.openSession();   
80.         try{   
81.             user = (User)session.get(User.class, id);   
82.         }catch(Exception ex){   
83.             ex.printStackTrace();   
84.         }finally{   
85.           session.close();   
86.         }   
87.         return user;   
88.     }   
89.        
90.     /**更新的方法*/  
91.   
92.     public boolean  update(User entity) {   
93.         boolean flag = false;   
94.         /**  
95.          * 采用Configuration  
96.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
97.          */  
98.         Configuration cfg = new Configuration().configure();   
99.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
100.         SessionFactory sf = cfg.buildSessionFactory();   
101.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
102.         Session session = sf.openSession();   
103.         /** 定义个事务对象 */  
104.         Transaction tx = null;   
105.         try {   
106.             // 开始事务   
107.             tx = session.beginTransaction();   
108.             entity.setName("lihui");   
109.             // 执行事务   
110.             session.update(entity);   
111.             // 提交事务   
112.             tx.commit();   
113.             flag =true;   
114.         } catch (Exception ex) {   
115.             /** 如果出现异常则回滚事务 */  
116.             if (tx != null) {   
117.                 tx.rollback();   
118.             }   
119.             ex.printStackTrace();   
120.         }finally{   
121.             /**不管事务执行成功与否都要关闭session*/  
122.             session.close();   
123.         }   
124.   
125.         return flag;   
126.     }   
127.        
128.     /**删除操作*/  
129.     public boolean  delete(User entity) {   
130.         boolean flag = false;   
131.         /**  
132.          * 采用Configuration  
133.          * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象  
134.          */  
135.         Configuration cfg = new Configuration().configure();   
136.         /** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */  
137.         SessionFactory sf = cfg.buildSessionFactory();   
138.         /** 采用sf对象中的openSession的方法创建连接并打开操作的session */  
139.         Session session = sf.openSession();   
140.         /** 定义个事务对象 */  
141.         Transaction tx = null;   
142.         try {   
143.             // 开始事务   
144.             tx = session.beginTransaction();   
145.             // 执行事务   
146.             session.delete(entity);   
147.             // 提交事务   
148.             tx.commit();   
149.             flag =true;   
150.         } catch (Exception ex) {   
151.             /** 如果出现异常则回滚事务 */  
152.             if (tx != null) {   
153.                 tx.rollback();   
154.             }   
155.             ex.printStackTrace();   
156.         }finally{   
157.             /**不管事务执行成功与否都要关闭session*/  
158.             session.close();   
159.         }   
160.   
161.         return flag;   
162.     }   
163.        
164.     public static void main(String[] args) {   
165.         TestHiber th = new TestHiber();   
166.         boolean insert=th.insert();   
167.         if(insert){   
168.             System.out.println("插入成功");   
169.         }   
170.         User entity = th.findById(1);   
171.         boolean flag  = th.delete(entity);   
172.         if(flag){   
173.             System.out.println("删除成功");   
174.         }else{   
175.             System.out.println("删除失败");   
176.         }   
177.     }   
178. }  

package hiber;

import java.util.Date;

import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.Session;

public class TestHiber {
	/**插入的方法*/
	public boolean insert() {
		boolean flag = false;
		/**
		 * 采用Configuration对象configure方法解析hibernate.cfg.
		 * xml文件并返回一个Configuration的对象
		 */
		Configuration cfg = new Configuration().configure();
		/** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */
		SessionFactory sf = cfg.buildSessionFactory();
		/** 采用sf对象中的openSession的方法创建连接并打开操作的session */
		Session session = sf.openSession();
		/** 定义个事务对象 */
		Transaction tx = null;
		try {
			// 开始事务
			tx = session.beginTransaction();
			User entity=new User("sha","123",new Date());
			//执行事务
			session.save(entity);
			//提交事务
			tx.commit();
			flag=true;
		} catch (Exception e) {
			//如果出现导常则回滚事务
			if(tx!=null){
				tx.rollback();
			}
			e.printStackTrace();
		}finally{
			//不管事务执行成功与否都要关闭session
			session.close();
		}
		return flag;
	}
	/**查询的方法*/
	public User findById(int id){
		User user = new User();
		/**
		 * 采用Configuration
		 * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
		 */
		Configuration cfg = new Configuration().configure();
		/** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */
		SessionFactory sf = cfg.buildSessionFactory();
		/** 采用sf对象中的openSession的方法创建连接并打开操作的session */
		Session session = sf.openSession();
		try{
			user = (User)session.load(User.class, id);
		}catch(Exception ex){
			ex.printStackTrace();
		}
		return user;
	}
	
	
	
	/**查询的方法*/
	public User findByGId(int id){
		User user = new User();
		/**
		 * 采用Configuration
		 * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
		 */
		Configuration cfg = new Configuration().configure();
		/** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */
		SessionFactory sf = cfg.buildSessionFactory();
		/** 采用sf对象中的openSession的方法创建连接并打开操作的session */
		Session session = sf.openSession();
		try{
			user = (User)session.get(User.class, id);
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
		  session.close();
		}
		return user;
	}
	
	/**更新的方法*/

	public boolean  update(User entity) {
		boolean flag = false;
		/**
		 * 采用Configuration
		 * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
		 */
		Configuration cfg = new Configuration().configure();
		/** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */
		SessionFactory sf = cfg.buildSessionFactory();
		/** 采用sf对象中的openSession的方法创建连接并打开操作的session */
		Session session = sf.openSession();
		/** 定义个事务对象 */
		Transaction tx = null;
		try {
			// 开始事务
			tx = session.beginTransaction();
			entity.setName("lihui");
			// 执行事务
			session.update(entity);
			// 提交事务
			tx.commit();
			flag =true;
		} catch (Exception ex) {
			/** 如果出现异常则回滚事务 */
			if (tx != null) {
				tx.rollback();
			}
			ex.printStackTrace();
		}finally{
			/**不管事务执行成功与否都要关闭session*/
			session.close();
		}

		return flag;
	}
	
	/**删除操作*/
	public boolean  delete(User entity) {
		boolean flag = false;
		/**
		 * 采用Configuration
		 * 对象configure方法解析hibernate.cfg.xml文件并返回一个Configuration的对象
		 */
		Configuration cfg = new Configuration().configure();
		/** 根据cfg对中的buildSessionFactory()方法来创一个SessionFactory工厂 */
		SessionFactory sf = cfg.buildSessionFactory();
		/** 采用sf对象中的openSession的方法创建连接并打开操作的session */
		Session session = sf.openSession();
		/** 定义个事务对象 */
		Transaction tx = null;
		try {
			// 开始事务
			tx = session.beginTransaction();
			// 执行事务
			session.delete(entity);
			// 提交事务
			tx.commit();
			flag =true;
		} catch (Exception ex) {
			/** 如果出现异常则回滚事务 */
			if (tx != null) {
				tx.rollback();
			}
			ex.printStackTrace();
		}finally{
			/**不管事务执行成功与否都要关闭session*/
			session.close();
		}

		return flag;
	}
	
	public static void main(String[] args) {
		TestHiber th = new TestHiber();
		boolean insert=th.insert();
		if(insert){
			System.out.println("插入成功");
		}
		User entity = th.findById(1);
		boolean flag  = th.delete(entity);
		if(flag){
			System.out.println("删除成功");
		}else{
			System.out.println("删除失败");
		}
	}
}

三、通过Myeclipse工具自动添加hibernate类库文件,利用Myeclipse工具反向生成配置文件与Domain Class
1、项目右键，添加类库文Myeclipse，选择Add HibernateCapabilites，选择hibernate核心文件，自动在src目录下创建hibernate的默认配置文件，在DBDriver选择自己配置的链接地址，会自动创建一个hibernateSessionFactroy，我们只需添加一个路径（包）完成。就会自动创建一个hibernate.cfg.xml配置文件，里面自动配置好数据库链接的属性，还会自动创建一个hibernateSessionFactroy的类。
2、反向生产Domain Class和User.hbm.xml文件
首先到myeclipse Database Explorer窗口，选择uesr表右键选择hibernateReverseEngineering反向工程，选择反向的项目，选择创建user对应的javabean，下一步选择主键生成策略Id Generator这里选择native，完成，切换到java窗口。
3、操作表（增删改查）

Java代码

1. package hiber.test;   
2.   
3. import java.sql.Timestamp;   
4. import java.util.Date;   
5.   
6. import org.hibernate.Session;   
7. import org.hibernate.Transaction;   
8.   
9. import hiber.bean.User;   
10. import hiber.sf.HibernateSessionFactory;   
11.   
12. public class TestUser {   
13.   
14.     /**插入方法*/  
15.     public void insert() {   
16.         /** 直接利用HibernateSessionFactory得到session对象 */  
17.         Session session = HibernateSessionFactory.getSession();   
18.         Transaction tx = null;   
19.         try {   
20.             /** 获取当前session的事务 */  
21.             tx = session.getTransaction();   
22.             /** 开始事务 */  
23.             tx.begin();   
24.             /** 瞬时状态对象 */  
25.             User entity = new User("yq", "123", new Timestamp(System   
26.                     .currentTimeMillis()));   
27.   
28.             /** 执行插入操作 */  
29.             session.save(entity);   
30.             /** 持久状态对象 */  
31.   
32.             /** 事务提交 */  
33.             tx.commit();   
34.         } catch (Exception ex) {   
35.             if (tx != null)   
36.                 tx.rollback();/**事务回滚*/  
37.             ex.printStackTrace();   
38.   
39.         } finally {   
40.             /**关闭session*/  
41.             session.close();   
42.         }   
43.         /** 脱管状态对象..... */  
44.     }   
45.         /**查询的方法*/  
46.     public User findByLId(int id){   
47.         User entity = new User();   
48.         /**获取session对象*/  
49.         Session session = HibernateSessionFactory.getSession();   
50.         try{   
51.         /**执行操作*/  
52.             entity = (User)session.load(User.class, id);   
53.         }catch(Exception ex){   
54.             ex.printStackTrace();   
55.         }finally{   
56.             /**关闭session*/  
57.             session.close();   
58.         }   
59.         return entity;   
60.     }   
61.   
62.         /**查询的方法*/  
63.     public User findByGId(int id){   
64.         User entity = new User();   
65.         /**获取session对象*/  
66.         Session session = HibernateSessionFactory.getSession();   
67.         try{   
68.         /**执行操作*/  
69.             entity = (User)session.get(User.class, id);   
70.         }catch(Exception ex){   
71.             ex.printStackTrace();   
72.         }finally{   
73.             /**关闭session*/  
74.             session.close();   
75.         }   
76.         return entity;   
77.     }   
78.        
79.         /**更新方法*/  
80.     public void update(User entity) {   
81.         /** 直接利用HibernateSessionFactory得到session对象 */  
82.         Session session = HibernateSessionFactory.getSession();   
83.         Transaction tx = null;   
84.         try {   
85.             /** 获取当前session的事务 */  
86.             tx = session.getTransaction();   
87.             /** 开始事务 */  
88.             tx.begin();   
89.                
90.             /** 执行更新操作 */  
91.             session.update(entity);   
92.             /** 持久状态对象 */  
93.   
94.             /** 事务提交 */  
95.             tx.commit();   
96.         } catch (Exception ex) {   
97.             if (tx != null)   
98.                 tx.rollback();/**事务回滚*/  
99.             ex.printStackTrace();   
100.   
101.         } finally {   
102.             /**关闭session*/  
103.             session.close();   
104.         }   
105.         /** 脱管状态对象..... */  
106.     }   
107.        
108.         /**删除的方法*/  
109.     public void delete(User entity) {   
110.         /** 直接利用HibernateSessionFactory得到session对象 */  
111.         Session session = HibernateSessionFactory.getSession();   
112.         Transaction tx = null;   
113.         try {   
114.             /** 获取当前session的事务 */  
115.             tx = session.getTransaction();   
116.             /** 开始事务 */  
117.             tx.begin();   
118.                
119.             /** 执行更新操作 */  
120.             session.delete(entity);   
121.             /** 持久状态对象 */  
122.   
123.             /** 事务提交 */  
124.             tx.commit();   
125.         } catch (Exception ex) {   
126.             if (tx != null)   
127.                 tx.rollback();/**事务回滚*/  
128.             ex.printStackTrace();   
129.   
130.         } finally {   
131.             /**关闭session*/  
132.             session.close();   
133.         }   
134.         /** 脱管状态对象..... */  
135.     }   
136.        
137.     public static void main(String[] args) {   
138.         TestUser tu = new TestUser();   
139.         User entity = tu.findByLId(2);   
140.         entity.setName("redarmy");   
141.         tu.delete(entity);   
142.        
143.     }   
144.   
145. }  

package hiber.test;

import java.sql.Timestamp;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.Transaction;

import hiber.bean.User;
import hiber.sf.HibernateSessionFactory;

public class TestUser {

	/**插入方法*/
	public void insert() {
		/** 直接利用HibernateSessionFactory得到session对象 */
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			/** 获取当前session的事务 */
			tx = session.getTransaction();
			/** 开始事务 */
			tx.begin();
			/** 瞬时状态对象 */
			User entity = new User("yq", "123", new Timestamp(System
					.currentTimeMillis()));

			/** 执行插入操作 */
			session.save(entity);
			/** 持久状态对象 */

			/** 事务提交 */
			tx.commit();
		} catch (Exception ex) {
			if (tx != null)
				tx.rollback();/**事务回滚*/
			ex.printStackTrace();

		} finally {
			/**关闭session*/
			session.close();
		}
		/** 脱管状态对象..... */
	}
		/**查询的方法*/
	public User findByLId(int id){
		User entity = new User();
		/**获取session对象*/
		Session session = HibernateSessionFactory.getSession();
		try{
		/**执行操作*/
	        entity = (User)session.load(User.class, id);
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			/**关闭session*/
			session.close();
		}
		return entity;
	}

		/**查询的方法*/
	public User findByGId(int id){
		User entity = new User();
		/**获取session对象*/
		Session session = HibernateSessionFactory.getSession();
		try{
		/**执行操作*/
	        entity = (User)session.get(User.class, id);
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			/**关闭session*/
			session.close();
		}
		return entity;
	}
	
		/**更新方法*/
	public void update(User entity) {
		/** 直接利用HibernateSessionFactory得到session对象 */
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			/** 获取当前session的事务 */
			tx = session.getTransaction();
			/** 开始事务 */
			tx.begin();
			
			/** 执行更新操作 */
			session.update(entity);
			/** 持久状态对象 */

			/** 事务提交 */
			tx.commit();
		} catch (Exception ex) {
			if (tx != null)
				tx.rollback();/**事务回滚*/
			ex.printStackTrace();

		} finally {
			/**关闭session*/
			session.close();
		}
		/** 脱管状态对象..... */
	}
	
		/**删除的方法*/
	public void delete(User entity) {
		/** 直接利用HibernateSessionFactory得到session对象 */
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			/** 获取当前session的事务 */
			tx = session.getTransaction();
			/** 开始事务 */
			tx.begin();
			
			/** 执行更新操作 */
			session.delete(entity);
			/** 持久状态对象 */

			/** 事务提交 */
			tx.commit();
		} catch (Exception ex) {
			if (tx != null)
				tx.rollback();/**事务回滚*/
			ex.printStackTrace();

		} finally {
			/**关闭session*/
			session.close();
		}
		/** 脱管状态对象..... */
	}
	
	public static void main(String[] args) {
		TestUser tu = new TestUser();
		User entity = tu.findByLId(2);
		entity.setName("redarmy");
		tu.delete(entity);
	
	}

}

*

这里也有一个面试常考的问题就是对象的状态

Java代码

1. 对象的状态有三种：   
2. 1、瞬时(transient)：数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来且与session没有关联的对象。   
3. 2、持久(persistent)：数据库中有数据与之对应，当前与session有关联，并且相关联的session没有关闭，事务没有提交；持久对象状态发生改变，在事务提交时会影响到数据库(hibernate能检测到)。   
4. 3、脱管(detached)：也称游离，数据库中有数据与之对应，但当前没有session与之关联；脱管对象状态发生改变，hibernate不能检测到。   
5. 瞬时对象可以通过sava或savaorupdate方法转换成持久化对象，对象可以通过get，load，find，iterate方法转换成持久化对象。   
6. 持久化对象可以通过delete方法转换成瞬时对象，可以通过evict，close，clear方法转换成脱管对象。   
7. 脱管对象可以通过savaorupdate，update，lock方法转换成持久化对象。  

对象的状态有三种：
1、瞬时(transient)：数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来且与session没有关联的对象。
2、持久(persistent)：数据库中有数据与之对应，当前与session有关联，并且相关联的session没有关闭，事务没有提交；持久对象状态发生改变，在事务提交时会影响到数据库(hibernate能检测到)。
3、脱管(detached)：也称游离，数据库中有数据与之对应，但当前没有session与之关联；脱管对象状态发生改变，hibernate不能检测到。
瞬时对象可以通过sava或savaorupdate方法转换成持久化对象，对象可以通过get，load，find，iterate方法转换成持久化对象。
持久化对象可以通过delete方法转换成瞬时对象，可以通过evict，close，clear方法转换成脱管对象。
脱管对象可以通过savaorupdate，update，lock方法转换成持久化对象。

希望以上内容对学员学习hibernate有所帮助,以上内容属redarmy_chen版权所有,如要转发请注明出处。愿你有所收获！