2021-06-04 Java对象在Hibernate下的4种状态和Session相关方法以及对象识别

最新推荐文章于 2026-06-26 13:39:18 发布
原创 最新推荐文章于 2026-06-26 13:39:18 发布 · 425 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#mysql #java #hibernate #session #数据库
本文介绍了在MyEclipse和MySQL环境下，使用Java和Hibernate进行数据库操作。涵盖Query查询接口，Java对象在Hibernate下的临时、持久、托管三种状态，Session相关方法如save、update等，还阐述了session缓存、与数据库同步、对象识别等内容，并给出了单元测试示例。

注：集成开发环境软件：MyEclipse（2017破解版）和mySQL（MySQL Server 8.0） 

 

一、Query（查询）

（1）Query（查询）接口允许你在数据库上执行查询并控制查询如何执行。查询语句使用HQL或者本地数据库的SQL方言编写。

（2）调用代码： Query query = session.createQuery(“from User”);

二、Java对象在Hibernate下的状态（临时/瞬间，持久，托管）

(1)瞬时对象

  • 瞬时对象(Transient Objects)：由new操作符创建，且尚未与Session 关联的对象被认定为瞬时(Transient)的，不和数据库的数据有任何关联关系。
  • 瞬时(Transient)对象没有被持久化到数据库中，也不会被赋予持久化标识(identifier)。
  • 如果瞬时(Transient)对象在程序中没有被引用，它会被垃圾回收器(garbage collector)销毁。
  • 由于此对象没有纳入Session的管理，那么此时该对象的任何变化都不会发出SQL语句。
  • 可以通过调用Session的持久方法(save(),saveOrUpdate()等)进行持久化操作时才会转变为持久对象,并拥有和数据库记录相同的id标识。
  • 持久对象(Persist Objects)：持久(Persistent)对象在数据库中有对应的记录，并拥有一个持久化标识(identifier)。

(2)持久对象

  • 持久对象可能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的Session作用范围内。
  • 它有持久化管理器Session统一管理，持久对象是在事务中进行操作的——Transaction实例执行commit()之后，与数据库进行同步。当事务提交时，通过执行SQL的INSERT、UPDATE和DELETE语句把内存中的状态同步到数据库中。
  • 持久化对象任何变化都会自动地发出SQL语句，也就是说该对象和数据库是实时联动(同步的)。

（3）托管对象 

  • 托管对象(Detached Objects)：与持久(Persistent)对象关联的Session被关闭后，对象就变为脱管(Detached)的。托管表示这个对象不能再与数据库保持同步，它们不再受Session管理。
  • 对脱管(Detached)对象的引用依然有效，对象可继续被修改。脱管(Detached)对象如果重新关联到某个新的Session上， 会再次转变为持久(Persistent)的(在Detached期间的改动将被持久化到数据库)。
  • 本质和瞬时对象相同，都没有纳入Session管理，自身的状态变化，不会自动地发出SQL语句，区别是：在数据库中有与之对应的记录 ；比瞬时对象多了一个数据库标识id。

三、Session相关方法

  • save()方法：把Java对象保存数据库中，把一个瞬时对象变成持久对象 。
  • update()方法：更新数据库中的Java对象，把一个托管对象变成持久对象 。
  • delete()方法：把Java对象从数据库中删除，把一个持久对象变成临时对象 。  
  • load()/get()方法：根据对象标识从数据库中加载Java对象，返回的对象都是处于持久化状态。
  • saveOrUpdate()方法同时包含了save() 和 update() 两个功能。 如果传入的参数是瞬时对象，就调用save()方法。 如果传入的对象是托管对象，就调用update()方法。
  • close()方法，session缓存被清空，缓存中的所有持久化对象都变为游离状态。
  • evict(): 能够从缓存中删除一个持久化对象，使它变为托管状态。
  • clear()：清除Session中所有缓存对象。

（注：装载对象——get 方法 和 load 方法的区别：

 1.Session的load()方法和get()方法都能够根据给定的OID(Object ID对象唯一标示符)从数据库中加载一个持久化对象到Session缓存中。

（1）如果没有符合条件的纪录，get返回一个null，load会抛出一个ObjectNotFoundException。

（2）get方法立即加载对象， load返回一个代理对象，延迟装载对象，只有在对象第一次被应用程序访问时，Hibernate才会从数据库中加载该对象。

2.在无法确认持久对象是否存在于数据库中时，开发者应当使用get()方法来获取持久对象，通过判断返回值时候为null来确认持久对象的存在与否。

3.load、get方法或其它查询方法返回的对象都在session的缓存中。所以如修改对象的属性，那么事务提交后，会将数据同步到数据库。）

四、session的缓存

每个Session实例可以看作为一个容器，具有缓存，每一个持久化对象都被纳入Session的缓存中。 数据库中的一条记录在一个Session中只能对应一个对象，不同的Session可以有不同的对象对应数据库中的同一个记录。

1.Session有如下两个作用：

  • 充当蓄水池的作用，减少程序访问数据库的次数。
  • 保证缓存中的数据与数据库同步。缓存毕竟不是数据库，它的数据有可能和数据库不一致，这时Hibernate会负责将缓存中的数据同步到数据库。

五、一个Session中不能同时存在两个ID相同的持久化对象

六、与数据库的同步

  •  脏数据：数据仅仅在内存中更新而没有同步到数据库中称为脏数据。
  • hibernate会监测脏数据，在尽可能迟的时候做同步的动作。（transparent transaction-level write-behind）
  • hibernate可以做到仅仅更新有变动的属性，但是需要在映射文件中设置dynamic-update=“true”，默认是false。这个功能用手工很难完成。

七、对象识别

对数据库而言，其识别一条记录唯一性的方式是根据主键值，如果手上有两条记录，它们拥有同样的主键值，则它们在数据库中代表同一个字段的记录。

对Java而言，要识别两个对象是否为同一个对象有两种方式

  • 内存地址识别(“= =”号识别)
  • 根据equals()、hasCode()中的定义    (默认Object类中定义的equals(Object o)方法也是按内存地址来比较的),源码如下：    public boolean equals(Object obj){              return  (this==obj);    }

一、Query（查询）

  1. 拷贝工程Hibernate2，修改工程名为hibernate3ManageObjects. 
  2. 单独测试一些方法（不使用main函数）:单元测试
  3. 扩展一个类TestCase,导包import TestCase（junit.framework）

  • 单独写一个方法testSaveUser() ，拷贝如下代码到方法里面

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
  • 测试Save()方法，右键-RunAs -JUnit Test

 

 再插入一条

testSaveUser() 

package cn.hrbust.dao;

import java.sql.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import cn.hrbust.pojo.User;
import junit.framework.TestCase;

public class manageUser extends TestCase{
	
	//保存用户对象
	public void testSaveUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
//		u.setName("李四");
//		u.setGender("男");
//		u.setAge(21);
//		u.setBirthday(Date.valueOf("2001-1-1"));
//		
//		u.setName("赵楠");
//		u.setGender("女");
//		u.setAge(2);
//		u.setBirthday(Date.valueOf("2002-6-17"));
//	
		u.setName("李洋洋");
		u.setGender("女");
		u.setAge(20);
		u.setBirthday(Date.valueOf("1999-8-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	
	
	
	public static void main (String[] args){

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

}
  • 测试query方法，右键testQueryUser()，RunAs -JUnit Test;

 

          //面向对象的方式去获取 集合元素   
            for(int i=0; i<users.size(); i++){ 
                User u=users.get(i);
                System.out.println(u.getName()+" "+u.getAge());
            }

testQueryUser() 

package cn.hrbust.dao;
import java.sql.Date;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import cn.hrbust.pojo.User;
import junit.framework.TestCase;

public class manageUser extends TestCase{
	//查询用户对象
	public void testQueryUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
	
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例	
		    ts=session.beginTransaction(); //开启事务
		    Query query=session.createQuery("from User");
		    List<User> users=query.list();		
			for(int i=0; i<users.size(); i++){
				User u=users.get(i);
				System.out.println(u.getName()+" "+u.getAge());
			}
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	
	
	
	
	
	//保存用户对象
	public void testSaveUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
//		u.setName("李四");
//		u.setGender("男");
//		u.setAge(21);
//		u.setBirthday(Date.valueOf("2001-1-1"));
//		
//		u.setName("赵楠");
//		u.setGender("女");
//		u.setAge(2);
//		u.setBirthday(Date.valueOf("2002-6-17"));
//	
		u.setName("李洋洋");
		u.setGender("女");
		u.setAge(20);
		u.setBirthday(Date.valueOf("1999-8-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	
	
	
	public static void main (String[] args){

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

}

          //访问集合元素，还可以用以下的方式         ： users集合
            for(User u :users){
                System.out.println(u.getName()+" "+u.getAge());
            }            

  • 测试 query方法

 

 

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import cn.hrbust.pojo.User;
import junit.framework.TestCase;

public class manageUser extends TestCase{
	//查询用户对象
	public void testQueryUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
	
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例	
		    ts=session.beginTransaction(); //开启事务
		    Query query=session.createQuery("from User");
		    List<User> users=query.list();	
		    //访问集合元素，还可以用以下的方式         ： users集合
		    for(User u :users){
		    	System.out.println(u.getName()+" "+u.getAge());
		    }
		    
		    //面向对象的方式去获取    
		    /*for(int i=0; i<users.size(); i++){ 
				User u=users.get(i);
				System.out.println(u.getName()+" "+u.getAge());
			}*/
		    
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	
	
	
	
	
	//保存用户对象
	public void testSaveUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
//		u.setName("李四");
//		u.setGender("男");
//		u.setAge(21);
//		u.setBirthday(Date.valueOf("2001-1-1"));
//		
//		u.setName("赵楠");
//		u.setGender("女");
//		u.setAge(2);
//		u.setBirthday(Date.valueOf("2002-6-17"));
//	
		u.setName("李洋洋");
		u.setGender("女");
		u.setAge(20);
		u.setBirthday(Date.valueOf("1999-8-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	
	
	
	public static void main (String[] args){

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

}

二、Java对象在Hibernate下的状态（临时/瞬间，持久，托管） 

（1）u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送 SQL  语句   

  
        u.setName("周青山");        //只有insert，不会update 

测试Save()方法，右键-RunAs -JUnit Test

（2）u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句 


            u.setName("董慧堂木"); 

事务提交 后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句

（3） 托管对象，testDetachedObjectUser()，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录

测试 testDetachedObjectUser()

testQueryUser()查看 

 

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.query.Query;

import cn.hrbust.pojo.User;
import junit.framework.TestCase;

public class manageUser extends TestCase{
	//查询用户对象
	public void testQueryUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
	
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例	
		    ts=session.beginTransaction(); //开启事务
		    Query query=session.createQuery("from User");
		    List<User> users=query.list();	
		    //访问集合元素，还可以用以下的方式         ： users集合
		    for(User u :users){
		    	System.out.println(u.getName()+" "+u.getAge());
		    }
		    
		    //面向对象的方式去获取    
		    /*for(int i=0; i<users.size(); i++){ 
				User u=users.get(i);
				System.out.println(u.getName()+" "+u.getAge());
			}*/
		    
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	

	
	
	//托管对象
		public void testDetachedObjectUser(){
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
			
			User u=new User();
//			u.setName("李四");
//			u.setGender("男");
//			u.setAge(21);
//			u.setBirthday(Date.valueOf("2001-1-1"));
//			
//			u.setName("赵楠");
//			u.setGender("女");
//			u.setAge(2);
//			u.setBirthday(Date.valueOf("2002-6-17"));
	
//			u.setName("李洋洋");
//			u.setGender("女");
//			u.setAge(20);
//			u.setBirthday(Date.valueOf("1999-8-27"));
			
			try {

				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				
			    ts=session.beginTransaction(); //开启事务
				session.save(u);//不开事务，不能保存到数据库
				ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
						
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
			
			//此时为托管对象，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录
			u.setName("谭苏"); //事务提交 后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句
			u.setAge(90);
			
			
			try {

				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				
			    ts=session.beginTransaction(); //开启事务
			    
//				session.update(u);
			    
				session.saveOrUpdate(u);

				ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
				
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
				sf.close();
			}
		}
		
	
	
	
	
	
	//保存用户对象
	public void testSaveUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
//		u.setName("李四");
//		u.setGender("男");
//		u.setAge(21);
//		u.setBirthday(Date.valueOf("2001-1-1"));
//		
//		u.setName("赵楠");
//		u.setGender("女");
//		u.setAge(2);
//		u.setBirthday(Date.valueOf("2002-6-17"));
//	
		u.setName("李洋洋");
		u.setGender("女");
		u.setAge(20);
		u.setBirthday(Date.valueOf("1999-8-27"));
		//u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送SQL语句
		u.setName("周青山"); //只有insert，不会update
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			//u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句
			//u.setName("董慧堂木");  //属性改变，持久化对象的属性变化会发送update语句
			
			ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
			u.setName("董慧堂木");
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	

	
	public static void main (String[] args){

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

}

三、Session相关方法

（1）get方法：查询一个对象

测试testGetUser()，对象标识是1的可以得到

   User u=session.get(User.class, 1);
   System.out.println(u.getName()+" "+u.getAge());

当前线程全部会更新 

查询 

//查询一个对象
	public void testGetUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 2);
		    System.out.println(u.getName()+" "+u.getAge());
		    u.setName("穆婷婷");
		    u.setAge(29);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}

 

（2） 方法：删除一个对象

        
            User u=session.get(User.class, 3);
            //get之后，u:是持久化对象。
            
            session.delete(u);
            //u:瞬时对象，准确来说是删除对象
    
            u.setName("方婷婷");
            u.setAge(20);

 

未删除前查询（刚才测试已经删除了第一个 ：蒋依依，这一步自行操作getUser 把第二个： 赵楠 变成 穆婷婷） 

删除第三个：方婷婷 

 

 查询

 testQueryUser()这里稍作更改可以看到序号

for(User u :users){
                System.out.println(u.getId()+" "+u.getName()+" "+u.getAge());
            } 

 

删除完成。 

//删除一个对象
	public void testDeleteUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 3);
		    //get之后，u:是持久化对象。
		    
		    session.delete(u);
		    //u:瞬时对象，准确来说是删除对象
	
		    u.setName("方婷婷");
		    u.setAge(20);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			//sf.close();
		}
	
	}

(3)evict 

 

调用evict 

  session.evict(u); //把对象脱离当前session的管理

//evict对象
	
	public void testEvictUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 2);
		    System.out.println(u.getName()+" "+u.getAge());
		    session.evict(u); //把对象脱离当前session的管理
		    u.setName("赵汉涵");
		    u.setAge(28);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}

四、session的缓存

  • 充当蓄水池的作用，减少程序访问数据库的次数。

getUser（）

 User u=session.get(User.class, 2);

 User u1=session.get(User.class, 2); 

可以直接从session获得，不用再次访问数据库 

 

 User u=session.get(User.class, 2);
 User u1=session.get(User.class, 4);

 

 

 

//查询一个对象
	public void testGetUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 2);
		    User u1=session.get(User.class, 4);
		    		
		    System.out.println(u.getName()+" "+u.getAge());
		    u.setName("穆婷婷");
		    u.setAge(29);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}

Session相关方法

（4）update（）方法

 testUpdateUser()

   u.setName("李洋洋");
   u.setName("杨丽丽");
   u.setAge(40);

 只发送一次update语句

查询 

更新一个持久化对象，名字不发生变化，不会发送update() 。

//更新一个持久化对象
	public void testUpdateUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 6);
		   
		    System.out.println(u.getName()+" "+u.getAge());
		    
//		    u.setName("李洋洋");
		    u.setName("杨丽丽");
//		    
//		    u.setAge(40);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}

 更新一个托管对象

 

查看

 

 

	//更新一个托管对象
		public void testUpdateDetachedUser(){
			Configuration cfg=null;
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
			User u=null;
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    u=session.get(User.class, 6);
			    System.out.println(u.getName()+" "+u.getAge());
			    
			    session.update(u);
			    ts.commit();
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
			
			//u:托管对象
			u.setName("杨力");
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    session.update(u);
			    ts.commit();
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
		
		}

 托管时不进行操作，还是会update

 user.hbm.xml 里面添加 select-before-update="true"

  <class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true">

user.hbm.xml 

​
<?xml version="1.0"?>
<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true">
        <id name="id"  column="id">
            <generator class="identity"/>          
        </id>
        <property name="name" column="username"/>
        <property name="gender" column="sex"/>
        <property name="age" /> 
        <property name="birthday" column="borndate"/>
     
    </class>
    

</hibernate-mapping>

​

 再次执行 testUpdateDetachedUser(),不再发送update；

（5）Get(）方法和Load（）方法

testGetAndLoadUser()： get和load的区别；

先查询一下

get方法立即加载

 数据库里面没有id值为1的对象了；

get方法，找一个没有的对象，run as->JUnit Test,报错：NullPointerException 空指针异常；

判断一下是否为空，再执行 ；

 Load方法延时加载

断点标记如图

testGetAndLoadUser()->Debug As ->2 JUnit Test 

点击上边框run->Step Over(重复此操作可以看得到get 和 load 出现）

 点击上边框run->Step Over

点击上边框run->Step Over 

点击上边框run->Step Over 

 点击上边框run->Step Over

 点击上边框run->Step Over

点击run-> terminate结束; 

 get返回具体对象；load返回代理对象，使用时才把u1相关值给出来；

load方法，找一个没有的对象，run as->JUnit Test,报错：ObjectNotFoundException

 

//get和load的区别
public void testGetAndLoadUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    //get立即加载
		    User u=session.get(User.class, 2); 
		    System.out.println("get方法加载对象");
		    if(u!=null){
		    	 //u:持久化对象		
			    System.out.println(u.getName()+" "+u.getAge());//NullPointerException：对象不存在，不能再调用对象的方法
		    }
		  
//		     Load方法延时加载
		    User u1=session.load(User.class, 1); 
		    System.out.println("load方法加载对象");
		    System.out.println(u1.getName()+" "+u1.getAge());
		    ts.commit();
			
		} catch (Exception e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

五、一个Session中不能同时存在两个ID相同的持久化对象

testTwoObjectsWithSameIdInOneSession()

创建 u1,纳入session管理，报错：NonUniqueObjectException: A different object with the same identifier value was already associated with the session 

 

解决方法：

先清除 session之前的对象u，实际上就是session不在管理这个u了再执行 runas ->JUnit Test

 session.evict(u);

 第二个select：因为配置了select-before-update

不是insert，而是update：u1是瞬时对象一定发insert，托管对象一定要发update；

因为有ID而且和数据库里面的主键是对应的，而且在数据库里面有记录，这两点保证u1是托管对象，所以发update

 

//session中不能同时存在两个有相同持久化标识的对象
	public void testTwoObjectsWithSameIdInOneSession(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    //get立即加载
		    User u=session.get(User.class, 2); 
		   //session中存在了oid是2的对象
		    
		   session.evict(u);  //先把u从session中清除
		   User u1=new User(); //u1是托管对象
		   u1.setId(2);
		   u1.setAge(30);
		   u1.setName("赵兵");
		   session.saveOrUpdate(u1);
		    ts.commit();
			
		} catch (Exception e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

 六、与数据库的同步

 1.动态更新

testUpdateObjectsWithDynamicUpdate()

testUpdateObjectsWithDynamicUpdate()->runas->JUnit Test; 更改名字的同时，所有属性都在发生改变

 

 查看

 只更改改变的属性，需要在ORM映射文件user.hbm.xml里面设置dynamic-update=“true”

 

user.hbm.xml

<?xml version="1.0"?>
<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-mapping PUBLIC
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="cn.hrbust.pojo.User" table="T_USER" select-before-update="true" dynamic-update="true">
        <id name="id"  column="id">
            <generator class="identity"/>          
        </id>
        <property name="name" column="username"/>
        <property name="gender" column="sex"/>
        <property name="age" /> 
        <property name="birthday" column="borndate"/>
     
    </class>
    

</hibernate-mapping>

再 testUpdateObjectsWithDynamicUpdate()->runas->JUnit Test;

 查看

//动态更新
		public void testUpdateObjectsWithDynamicUpdate(){
			Configuration cfg=null;
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
		
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    //get立即加载
			    User u=session.get(User.class, 2); 
			    System.out.println(u.getName()+" "+u.getAge());
			    u.setName("徐福记");
			    
			    ts.commit();
				
			} catch (Exception e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
				sf.close();
			}
			
		}

 七、对象识别

例子1：

Session session = sessions.openSession();

Person p1 = (Person)session.get(Person.class,1);

Person p2 =(Person)session.get(Person.class,1);

session.close(); System.out.println(p1 = = p2);

显示：true

例子2：

Session session1 = sessions.openSession();

Person p1 = (Person)session.get(Person.class,1);

session1.close(); Session session2 = sessions.openSession();

Person p2 = (Person)session.get(Person.class,1); 、

session2.close();

System.out.println(p1 == p2);

显示：false

 1.String对象识别testStringObjectIndentify()


                    User u1=session.get(User.class, 2); 
                    User u2=session.get(User.class, 2); 
                    System.out.println(u1==u2);  //同一个session引用相同

 

//String对象识别
			public void testStringObjectIndentify(){
				Configuration cfg=null;
				SessionFactory sf=null;
				Session session=null;
				Transaction ts=null; 
			
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
					
				    User u1=session.get(User.class, 2);
				    User u2=session.get(User.class, 2);
				    System.out.println(u1==u2);//同一个session引用相同
				    
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
					sf.close();
				}
				
			}

 

 

 2.User对象识别testUserObjectIndentify()

 

//User对象识别
			public void testUserObjectIndentify(){
				Configuration cfg=null;
				SessionFactory sf=null;
				Session session=null;
				Transaction ts=null; 
				User u1=null,u2=null;
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				    u1=session.get(User.class, 2); 
//				    User u2=session.get(User.class, 2); 
//				    System.out.println(u1==u2);
				  
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				
				
				
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				   
				    u2=session.get(User.class, 2); 
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				 System.out.println(u1==u2);
				 System.out.println(u1.equals(u2));
				
				
			}

使用==来比较两个对象的记录是否代表数据库中的同一条记录是不可行的。如果您要有必要比较通过查询后两个对象的内容是否相同，必须重写 equals()与hashCode()。 

 重写方法之一，equals()与hashCode()的方法是根据数据库的identity，就是透过getId()方法取得对象的id值并加以比较。  

 

 添加如下代码到User.java 

public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(obj==null){
            return false;
        }
        if(!(obj instanceof User)){
            return false;
        }
        
        User other=(User)obj;  //强制转换
        if(id!=other.id){
            return false;
        }
        if(age!=other.age){
            return false;
        }
        
        if(!name.equals(other.name)){
            return false;
        }
        if(gender!=null && (other.gender!=null)){
            if(!gender.equals(other.birthday)){
                return false;
            }
        }
        if(!birthday.equals(other.birthday)){
            return false;
        }
        return true;
    }


    public int hashCode() {        
        int result;        
        result = getName ().hashCode();        
        result = 29 * result + getBirthday().hashCode();    
        result = 29 * result + getAge();
        return result;    
        }
 

User.java 

package cn.hrbust.pojo;

import java.sql.Date;

public class User {
	private int id;   
	private String name;
	private String gender;
	int age;
	Date birthday;
	

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	if(gender!=null && (other.gender!=null)){
			if(!gender.equals(other.birthday)){
				return false;
			}
		}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	
	public boolean equals(Object obj){
		if(this==obj){
			return true;
		}
		if(obj==null){
			return false;
		}
		if(!(obj instanceof User)){
			return false;
		}
		
		User other=(User)obj;  //强制转换
		if(id!=other.id){
			return false;
		}
		if(age!=other.age){
			return false;
		}
		
		if(!name.equals(other.name)){
			return false;
		}
		if(!gender.equals(other.gender)){
			return false;
		}
		if(!birthday.equals(other.birthday)){
			return false;
		}
		return true;
	}
	public int hashCode() {        
		int result;        
		result = getName ().hashCode();        
		result = 29 * result + getBirthday().hashCode();    
		result = 29 * result + getAge();
		return result;    
		}

	
}

 再执行testUserObjectIndentify

 

//User对象识别
			public void testUserObjectIndentify(){
				Configuration cfg=null;
				SessionFactory sf=null;
				Session session=null;
				Transaction ts=null; 
				User u1=null,u2=null;
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				    u1=session.get(User.class, 4); 
//				    User u2=session.get(User.class, 2); 
//				    System.out.println(u1==u2);
				  
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				
				
				
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				   
				    u2=session.get(User.class, 4); 
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				 System.out.println(u1==u2);
				 System.out.println(u1.equals(u2));
				
				
			}

 manageUser.java

package cn.hrbust.dao;
//1814010809
import java.sql.Date;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import cn.hrbust.pojo.User;
import junit.framework.TestCase;

public class manageUser extends TestCase{
	//User对象识别
			public void testUserObjectIndentify(){
				Configuration cfg=null;
				SessionFactory sf=null;
				Session session=null;
				Transaction ts=null; 
				User u1=null,u2=null;
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				    u1=session.get(User.class, 4); 
//				    User u2=session.get(User.class, 2); 
//				    System.out.println(u1==u2);
				  
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				
				
				
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
				
				   
				    u2=session.get(User.class, 4); 
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
//					sf.close();
				}
				
				 System.out.println(u1==u2);
				 System.out.println(u1.equals(u2));
				
				
			}
			
			
			//String对象识别
			public void testStringObjectIndentify(){
				Configuration cfg=null;
				SessionFactory sf=null;
				Session session=null;
				Transaction ts=null; 
			
				try {
					sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
					session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				    ts=session.beginTransaction(); //开启事务
					
				    User u1=session.get(User.class, 2);
				    User u2=session.get(User.class, 2);
				    System.out.println(u1==u2);//同一个session引用相同
				    
				    ts.commit();
					
				} catch (Exception e) {  //捕获异常
					// TODO Auto-generated catch block
					e.printStackTrace();
					//异常：回滚
					if(ts!=null){
						ts.rollback();
						
					}
				}finally{
					sf.close();
				}
				
			}
			
			
	//动态更新
		public void testUpdateObjectsWithDynamicUpdate(){
			Configuration cfg=null;
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
		
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    //get立即加载
			    User u=session.get(User.class, 2); 
			    System.out.println(u.getName()+" "+u.getAge());
			    u.setName("徐福记");
			    
			    ts.commit();
				
			} catch (Exception e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
				sf.close();
			}
			
		}
		
		
		
	//session中不能同时存在两个有相同持久化标识的对象
	public void testTwoObjectsWithSameIdInOneSession(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    //get立即加载
		    User u=session.get(User.class, 2); 
		   //session中存在了oid是2的对象
		    
		   session.evict(u);  //先把u从session中清除
		   User u1=new User(); //u1是托管对象
		   u1.setId(2);
		   u1.setAge(30);
		   u1.setName("赵兵");
		   session.saveOrUpdate(u1);
		    ts.commit();
			
		} catch (Exception e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}
	
	
	//get和load的区别
	public void testGetAndLoadUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    //get立即加载
		    User u=session.get(User.class, 2); 
		    System.out.println("get方法加载对象");
		    if(u!=null){
		    	 //u:持久化对象		
			    System.out.println(u.getName()+" "+u.getAge());//NullPointerException：对象不存在，不能再调用对象的方法
		    }
		  
//		     Load方法延时加载
		    User u1=session.load(User.class, 1); 
		    System.out.println("load方法加载对象");
		    System.out.println(u1.getName()+" "+u1.getAge());
		    ts.commit();
			
		} catch (Exception e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}
	
	

	//删除一个对象
	public void testDeleteUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 3);
		    //get之后，u:是持久化对象。
		    
		    session.delete(u);
		    //u:瞬时对象，准确来说是删除对象
	
		    u.setName("方婷婷");
		    u.setAge(20);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			//sf.close();
		}
	
	}
	
	//evict对象
	
	public void testEvictUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 2);
		    System.out.println(u.getName()+" "+u.getAge());
		    session.evict(u); //把对象脱离当前session的管理
		    u.setName("赵汉涵");
		    u.setAge(28);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}
	
	//更新一个持久化对象
	public void testUpdateUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 6);
		   
		    System.out.println(u.getName()+" "+u.getAge());
		    
//		    u.setName("李洋洋");
		    u.setName("杨丽丽");
//		    
//		    u.setAge(40);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	
	}
	
	//更新一个托管对象
		public void testUpdateDetachedUser(){
			Configuration cfg=null;
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
			User u=null;
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    u=session.get(User.class, 6);
			    System.out.println(u.getName()+" "+u.getAge());
			    
			    session.update(u);
			    ts.commit();
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
			
			//u:托管对象
//			u.setName("杨力");
			try {
				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			    ts=session.beginTransaction(); //开启事务
				
			    session.update(u);   //当托管对象在托管期间没有变化
			    //由于配置了select-before-update属性，所以hibernate会先发一条sql语句，
			    //然后看一下对象状态是否真的发生变化，再决定是否更新
			    ts.commit();
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
		
		}
		
	
	//查询一个对象
	public void testGetUser(){
		Configuration cfg=null;
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
	
		try {
			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
		    ts=session.beginTransaction(); //开启事务
			
		    User u=session.get(User.class, 2);
		    User u1=session.get(User.class, 4);
		    //u:持久化对象		
		    System.out.println(u.getName()+" "+u.getAge());
		    u.setName("穆婷婷");
		    u.setAge(29);
		    ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}
	
	

	//查询用户对象
	public void testQueryUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
	
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例	
		    ts=session.beginTransaction(); //开启事务
		    Query query=session.createQuery("from User");
		    List<User> users=query.list();	
		    //访问集合元素，还可以用以下的方式         ： users集合
		    for(User u :users){
		    	System.out.println(u.getId()+" "+u.getName()+" "+u.getAge());
		    }
		    
		    //面向对象的方式去获取    
		    /*for(int i=0; i<users.size(); i++){ 
				User u=users.get(i);
				System.out.println(u.getName()+" "+u.getAge());
			}*/
		    
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	

	
	
	//托管对象
		public void testDetachedObjectUser(){
			SessionFactory sf=null;
			Session session=null;
			Transaction ts=null; 
			
			User u=new User();
//			u.setName("李四");
//			u.setGender("男");
//			u.setAge(21);
//			u.setBirthday(Date.valueOf("2001-1-1"));
//			
//			u.setName("赵楠");
//			u.setGender("女");
//			u.setAge(2);
//			u.setBirthday(Date.valueOf("2002-6-17"));
	
//			u.setName("李洋洋");
//			u.setGender("女");
//			u.setAge(20);
//			u.setBirthday(Date.valueOf("1999-8-27"));
			
			try {

				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				
			    ts=session.beginTransaction(); //开启事务
				session.save(u);//不开事务，不能保存到数据库
				ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
						
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
//				sf.close();
			}
			
			//此时为托管对象，有对象ID，没有Session管理，不会自动发送SQL语句，但数据库有对应的记录
			u.setName("谭苏"); //事务提交 后，session已经自动关闭了，有对象ID，属性改变，此时对象的属性变化不会发送update语句
			u.setAge(90);
			
			
			try {

				sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
				session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
				
			    ts=session.beginTransaction(); //开启事务
			    
//				session.update(u);
			    
				session.saveOrUpdate(u);

				ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
				
				
			} catch (HibernateException e) {  //捕获异常
				// TODO Auto-generated catch block
				e.printStackTrace();
				//异常：回滚
				if(ts!=null){
					ts.rollback();
					
				}
			}finally{
				sf.close();
			}
		}
		
	
	
	
	
	
	//保存用户对象
	public void testSaveUser(){
		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
//		u.setName("李四");
//		u.setGender("男");
//		u.setAge(21);
//		u.setBirthday(Date.valueOf("2001-1-1"));
//		
//		u.setName("赵楠");
//		u.setGender("女");
//		u.setAge(2);
//		u.setBirthday(Date.valueOf("2002-6-17"));
//	
		u.setName("李洋洋");
		u.setGender("女");
		u.setAge(20);
		u.setBirthday(Date.valueOf("1999-8-27"));
		//u:瞬时对象，没有对象ID，没有纳入session管理，他的任何任何变化不会自动发送SQL语句
		u.setName("周青山"); //只有insert，不会update
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			//u:持久对象，有对象ID，纳入session管理，他的任何任何变化会自动发送SQL语句
			//u.setName("董慧堂木");  //属性改变，持久化对象的属性变化会发送update语句
			
			ts.commit();      //事务提交 session已经自动关闭了，所以不会管 user update
			u.setName("董慧堂木");
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
	}
	

	
	public static void main (String[] args){

		SessionFactory sf=null;
		Session session=null;
		Transaction ts=null; 
		
		User u=new User();
		u.setName("李四");
		u.setGender("男");
		u.setAge(21);
		u.setBirthday(Date.valueOf("2001-1-1"));
		
		u.setName("赵楠");
		u.setGender("女");
		u.setAge(2);
		u.setBirthday(Date.valueOf("2002-6-17"));
//		
//		u.setName("方婷婷");
//		u.setGender("女");
//		u.setAge(20);
//		u.setBirthday(Date.valueOf("2002-9-27"));
		
		try {

			sf=HibernateUtil.getSessionFactory(); //sessionfactory单态模式		
			session=sf.getCurrentSession(); //保证每个读写线程有唯一的session实例
			
		    ts=session.beginTransaction(); //开启事务
			session.save(u);//不开事务，不能保存到数据库
			
			ts.commit();
			
		} catch (HibernateException e) {  //捕获异常
			// TODO Auto-generated catch block
			e.printStackTrace();
			//异常：回滚
			if(ts!=null){
				ts.rollback();
				
			}
		}finally{
			sf.close();
		}
		
	}

}

至此，完成。

[Java面试八]Hibernate总结以及在面试中的一些问题.
qq_35833843的博客
12-11 613
1.为什么要使用Hibernate开发你的项目呢？Hibernate的开发流程是怎么样的？ 为什么要使用 ①.对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 ②.Hibernate 是一个基于JDBC的主流持久化框架，是一个优秀的ORM 实现。他很大程度的简化DAO层的编码工作 ③.hibernate 的性能非常好，因
Hibernate学习笔记——第四天
绿芽在山顶
02-12 242
一、hibernate的查询方式 1.对象导航查询 根据id查询某个客户，再查询这个客户里面的所有联系人 @Test public void testSelect1(){ SessionFactory sessionFactory = null; Session session = null; Transaction transaction = null; try{...
Java 基础知识之 JDBC
大鹏的博客
02-02 746
JDBC 全称 Java DataBase Connection，是 Java 定义的一套访问关系型数据库的规范，实现由各数据库厂商来完成，通过这套 API，Java 开发者可以轻松的访问各数据库。
使用getSession()方法,使用完之后必须自己调用相应的 close方法!
weixin_38168918的博客
12-03 930
java新手级问题： 今天使用hibernate的： Session session = this.getSession();Query query = session.createQuery("update Links set index = index"+indexStr+" where id <> "+id); return query.executeUpd...
HibernateUtil 获取session工具类
u010398383的专栏
04-14 877
package com.util; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import org.hibernate.cfg.Configuration; /*用于创建SessionFactory的工具类，官方写法*/
hibernate中对象的3种状态----瞬时态、持久态、脱管态
二进制天堂
07-12 526
原帖在:http://www.blogjava.net/amigoxie/archive/2007/07/04/99342.htmlHibernate的对象有3种状态，分别为：瞬时态(Transient)、 持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。
Hibernate 系列 学习笔记 目录 (持续更新...)
weixin_34363171的博客
10-29 116
前言： 　　最近也在学习Hibernate，遇到的问题差不多都解决了，顺便把学习过程遇到的问题和查找的资料文档都整理了一下分享出来，也算是能帮助更多的朋友们了。 　　最开始使用的是经典的MyEclipse，后面我用的是JetBrains的IDEA了，个人比较喜欢这些快捷键。偷懒程序员必备啊，哈哈。 目录： Hibernate 系列 0...
OWASP TOP 10 2021深度解析：从漏洞原理到实战防御体系构建
weixin_30907935的博客
06-21 427
在Web应用安全领域，注入攻击和访问控制失效是长期存在的核心风险。注入攻击的本质是将不可信数据作为命令或查询的一部分执行，这不仅限于传统的SQL注入，也广泛存在于NoSQL、OS命令、LDAP等上下文中。其根本原理在于应用程序未对用户输入进行充分的验证、净化或安全处理，导致攻击者能够篡改程序逻辑、窃取数据或获取系统权限。从技术价值看，理解注入机制是构建安全应用的基石，它推动开发者采用参数化查询、安全API和白名单校验等防御性编码实践。访问控制失效则体现了现代复杂业务系统中权限管理的挑战，涉及水平越权、垂直越
OWASP Top 10 2021核心漏洞深度解析与实战防御指南
weixin_28622215的博客
06-25 63
Web应用安全是软件开发的基石，其核心在于理解并防范常见的安全风险。从基本原理上看，安全漏洞往往源于对用户输入、访问控制和系统配置的信任缺失。例如，注入攻击利用了应用程序将不可信数据作为命令或查询的一部分执行的缺陷，而失效的访问控制则源于系统未能正确执行权限验证。这些漏洞的技术价值在于，一旦被利用，可能导致数据泄露、服务中断乃至系统完全沦陷，对企业和用户造成不可估量的损失。在应用场景上，无论是电商、金融还是社交平台，任何涉及用户数据交互的Web服务都面临这些威胁。本文聚焦于行业权威的OWASP Top 10
Claude Code Opus 4.8：AI编程从补全到工程自治的范式跃迁
weixin_30617737的博客
06-21 395
AI辅助编程正从简单代码补全迈向可编程的工程协同范式。其核心在于大模型能否理解软件生命周期中的上下文约束、任务分解与质量闭环——这依赖于动态工作流（Dynamic Workflows）对多文件依赖图的实时建模能力，以及努力控制（Effort Control）对推理深度与成本的精准调度。这类技术不再仅服务于单点开发提效，而是支撑API协议重构、遗留系统迁移、CI/CD智能守门等真实工程场景，成为中小团队可落地的‘隐形架构师’。本文深入解析Claude Code + Opus 4.8如何通过四大底层能力重构人机
（课程设计）springboot宠物管理系统-毕业设计 附源码121654
ID3461074420的博客
09-02 6829
用户： 注册：首先检查用户名和邮箱是否存在，如不存在即可进行注册，并将用户输入的密码进行MD5加密，注册成功后提示注册成功，并将用户信息保存到数据库中。 登录：使用宠物医疗服务系统前是需要用户登录个人账号。 养宠资讯：用户登录宠物医疗服务系统首页时，可以浏览养宠资讯信息，根据不同地宠物可以查看每个不同宠物饲养地方式等，还可以将自己感兴趣的资讯点赞以及加入收藏列表中。 会员留言：用户可以在系统中的宠物信息栏内搜索宠物信息，具体包括：封面图、标题、分类、标签等。 宠物热点：用户可以浏览宠物列表，可以自行搜索某样
【课程设计】springboot车辆管理系统的设计与实现毕业设计源码031034
高级程序源的博客
12-07 861
驾驶员：资料修改，车辆信息，出车记录，还车记录，首页 管理员：用户管理。车辆管理，品牌分类，出车记录，还车记录。车辆分类，登录
（附源码）spring boot智能养老系统平台-毕业设计 课程设计 170900
Q_3461074420的博客
09-16 5456
本设计主要实现集人性化、高效率、便捷等优点于一身的智能养老系统平台，完成老人健康中心管理、会员用户管理、员工管理、老人管理、健康档案管理、慢病管理、干预随访、老人认领等功能模块。 智能养老系统平台采用Java技术，Mysql数据库存储数据，基于Springboot框架开发。
（附源码）spring boot智能停车场系统-毕业设计 课程设计 065415
Q_3461074420的博客
10-13 2961
本设计主要实现集人性化、高效率、便捷等优点于一身的智能停车场管理系统，完成首页、站点管理（轮播图、公告栏）用户管理（管理员、普通用户）内容管理（汽车资讯、资讯分类）更多管理（车位信息、停车信息、出库信息信息、IC卡信息）等功能模块。 智能停车场管理系统使用Java语言，采用基于 MVVM模式的springboot框架进行开发，使用 Eclipse 2017 CI 10 编译器编写，数据方面主要采用的是微软的MySQL关系型数据库来作为数据存储媒介，配合前台HTML+CSS 技术完成系统的开发。
DigitalOcean负载均衡器5大生产级避坑实战指南
weixin_30298497的博客
06-20 367
负载均衡器是现代Web服务的流量中枢，其核心原理涵盖健康检查、会话保持、SSL终止、空闲超时与多端口路由等关键机制。理解这些底层逻辑，不仅能避免连接中断、流量错配、登录态丢失等高频故障，更能支撑电商大促、WebSocket长连接、混合协议路由、跨区域灾备及滚动发布等真实业务场景。本文聚焦DigitalOcean Load Balancer在生产环境暴露出的典型行为边界与隐性约束，结合健康检查策略、Idle Timeout调优、X-Forwarded-*头处理、Cookie路径匹配等实操细节，提供可验证、可复
Mythos如何重构AI安全能力范式：从漏洞发现到攻击链建模
dielucui7698的博客
06-15 491
大模型在网络安全领域的应用正从代码理解迈向攻击链推理。Mythos并非简单提升代码分析准确率，而是通过图神经网络建模软件语义拓扑、动态计算预算分配（DCBA）与三层对抗训练闭环，实现对内存生命周期、并发控制点等高阶风险的系统性识别。其技术价值在于将人类白帽的隐性经验转化为可复用、可验证的推理路径，支撑零日挖掘、POC自动生成与全量攻击面测绘等关键场景。本文深入解析Mythos在SWE-bench Pro与CyberGym中的表现跃迁，及其在Glasswing沙箱中的工程化落地逻辑。
IntelliJ IDEA数据库工具链深度优化：从连接配置到SQL调试的7大实战瓶颈突破
最新发布
AlgoInk的博客
06-26 31
本文直击IDEA数据库管理痛点，系统梳理连接配置、SQL执行、数据可视化等7大实战瓶颈，提供高效调试、智能补全与跨库协作方案，适用于Java开发者日常开发与DBA运维场景。提升查询效率与协作体验，值得收藏。
Mythos模型：AI安全研究员的自主行动闭环与工程实践指南
weixin_33895657的博客
06-24 280
大语言模型正从‘回答问题’迈向‘自主执行任务’，其核心在于构建‘认知-行动’闭环能力。这类模型不再仅依赖参数规模提升，而是通过深度上下文理解、工具链自主编排与对抗性思维内生化，在代码审计、漏洞挖掘与攻防模拟中实现质变。以Mythos为代表的新一代AI安全智能体，已在SWE-bench Pro、CyberGym等权威基准中展现远超传统模型的实战表现，其技术价值体现在对存量系统脆弱性的穿透式识别与可验证利用链生成。典型应用场景覆盖DevSecOps前置威胁建模、SRE预测性加固、红蓝对抗沙箱演练等工程环节。本文
hibernate调用mysql存储过程，java面试大全笔记
m0_63102527的博客
11-13 481
在存储过程的参数列表里面，in修饰的参数代表输入参数，out修饰的代表输出参数。 使用hibernate调用上面两个存储过程： （1）调用第一个存储过程 1 package com.test; 2 3 import java.sql.CallableStatement; 4 import java.sql.Connection; 5 import java.sql.ResultSet; 6 import java.sql.SQLException; 7 8 import org.hibernate.Ses
java的事务管理详解_Java事务管理学习之Hibernate详解
weixin_34418334的博客
02-28 247
环境与版本hibernate 版本：hibernate 4.2.2 (下载后的文件名为hibernate-release-4.2.2.final.zip，解压目录hibernate-release-4.2.2.final)数据库： oracle 10g导入lib\required 中的所有jar 包理论说明1、sessionfactory负责创建session，sessionfactory是线程安...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_43337482

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值