Hibernate中Session中的核心方法

package zhang.hibernate.tests;

import java.sql.Connection;
import java.sql.SQLException;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import zhang.hibernate.domian.Person;

public class TestHibernate {
private SessionFactory sessionFactory = null;
private Session session = null;
private Transaction transaction = null;

// 注意:junit测试框架在执行每一个Test方法之前,都会执行这个方法

@Before
public void init() {
	// 1.Configuration: 代表了Hibernate的配置信息
	Configuration configuration = new Configuration().configure();
	// 2.注册Hibernate的服务
	ServiceRegistry serviceRegistry = 
			new ServiceRegistryBuilder().applySettings(configuration.getProperties())
										.buildServiceRegistry();
	// 3.获取sessionFactory对象: 制造Session的工厂对象
	sessionFactory = configuration.buildSessionFactory(serviceRegistry);
	// 4.获取Session对象Hibernate的核心方法,由session对象调用
	session = sessionFactory.openSession();
	// 5.开启事务
	transaction = session.beginTransaction();
}
// 注意:junit测试框架在执行每一个Test方法之后,都会执行这个方法
@After
public void destroy() {
	// 6.提交事务
	transaction.commit();
	// 7.关闭Session对象
	session.close();
	// 8.关闭SessionFartory对象
	sessionFactory.close();
}
//通过hibernate,调用存储过程
@Test
public void testDoWork(){
	session.doWork(new Work() {
		@Override
		public void execute(Connection connection) throws SQLException {
			System.out.println(connection);
		}
	});
}
/**
 * Evict():
 * 从session缓存中将对象移除
 */
@Test
public void testEvict(){
	Person person1=(Person) session.get(Person.class, 11);
	Person person2=(Person) session.get(Person.class, 12);
	
	person1.setName("AA");
	person2.setName("BB");
	session.evict(person1);
}
/**
 * delete():删除,若数据数据库中有对应的OID则执行删除操作,如果没有对应的记录的话,抛出异常
 * 可以通过设置hibernate的配置文件,是删除后的OID值为null:use_identifier_rollback设置为true,默认是false
 */
@Test
public void testdelete(){
	Person person =new Person(12,"pp");
	person.setId(7);
	session.delete(person);
	System.out.println(person);
}
/**
 * SaveOrUpdate():
 * 		1.执行更新或者保存操作,判定的标准是OID是否为空,如果为空,进行Save操作,如果不为空,进行Update操作
 * 		2.如果update不为空的话,并且数据表中没有对应的记录的话,会抛出一个异常
 */
@Test
public void testSaveOrUpdate(){
	Person person =new Person(11, "Mom");
	person.setId(600);
	session.saveOrUpdate(person);
}
/**
 * Update():
 * 1.若更新一个持久化对象,不需要显示的调用update()方法,因为在执行transaction.commit()的时候 ,会调用session的flush
 *   方法,会自动的发送一条update语句.
 * 2.如果要更新一个游离对象,需要显示的调用update()方法,将游离对象转化成一个持久化对象.
 * 	  游离对象:在数据库中存在,但是在session中不存在.
 * 3.需要注意:
 * 	      1).无论游离对象和数据库中的记录是否一致的话,都会发送update语句.
 * 		  2).在hibernate和触发器协同工作的时候,如何使其不盲目的发送sql语句?,在hbm.xml中配置class节点中
 * 			  配置: select-before-update="true"
 * 		  3).若数据表中没有没有对应的记录,还调用了update方法,将会抛出一个异常	
 * 		  4).在将一个游离对象转化成一个持久化对象的时候,如果在此之前Session中已经存在相同OID的持久化对象的话
 * 			  会抛出一个异常.	
 */		
@Test
public void testupdate2(){
	Person person=new Person(12, "UU");
	person.setId(7);
	session.update(person);
}
@Test
public void testUpdate(){
	Person person=(Person) session.get(Person.class, 7);
	transaction.commit();
	session.close();
	
	session = sessionFactory.openSession();
	transaction = session.beginTransaction();
	Person person2=(Person) session.get(Person.class, 7);
	session.update(person);
}
@Test
public void testsave(){
	Person person =new Person(11, "PPP");
	session.save(person);
	System.out.println(person);
}
/**
 * get()和load()的区别:
 * 	1.执行 get()方法,会立即加载对象.
 * 	2.执行 load()方法,不会立即加载对象,而是会获得一个代理对象.
 * 	(get()是立即检索,load()是延迟检索)
 * 
 * 	3.如果数据库中没有对应的记录,Session没有关闭,且要使用对象的时候:
 * 	  get()返回null,load()抛出一个异常.
 * 	4.load()方法可能会抛出一个懒加载异常: LazyInitializationException 原因: 在初始化代理对象之前关闭了session对象
 */
@Test
public void testLoad(){
	Person person=(Person)session.load(Person.class, 6);
	System.out.println(person.getClass().getName());
	session.close();
	System.out.println(person);
}
@Test
public void Testget(){
	Person person=(Person)session.get(Person.class, 6);
	session.close();
	System.out.println(person);
}
/**
 * Persist()方法:与Save()方法一样,都会向数据库发送一条insert语句
 * 与save()方法的区别:如果在调用 Persist() 方法之前对象存在id,则不能执行Insert操作,会抛出一个异常
 * 
 * 异常信息:org.hibernate.PersistentObjectException
 */
@Test
public void testPersist(){
	Person person =new Person();
	person.setAge(23);
	person.setName("Jake");
	//person.setId(100);
	System.out.println(person);
	session.persist(person);
	System.out.println(person);
}
/**
 * save()方法:
 * 1.将一个临时对象转变成一个持久化对象.
 * 2.Hibernate会自动的位对象分配一个ID.
 * 3.在save()方法之前设置 ID 是无效的.
 * 4.持久化对象的 ID 是不能够修改的
 * 5.在 save() 方法执行的时候,会立刻会发送一条 insert 语句
 */
@Test
public void TestSave(){
	Person person =new Person();
	person.setAge(22);
	person.setName("Rose");
	System.out.println(person);
	session.save(person);
	System.out.println(person);
	//person.setId(100);
	
}
/**
 * refresh():在查询数据库的过程中,要使session中的对象是最新的话,可以使用 refresh() 方法
 * 会自动的发送一条 select 语句给数据库,使 session 中的对象和数据库最新的状态相对应.
 */
@Test
public void testrefresh(){
	Person person =(Person) session.get(Person.class, 2);
	System.out.println(person);
	session.refresh(person);
	System.out.println(person);
}
/**
 * Clear():清理 Session 的缓存:在执行该方法的时候,Session中所有存取的对象都将被清理
 * 因此:在这个例子中,将会发送 select 语句.
 */
@Test
public void testClear() {
	Person person = (Person) session.get(Person.class, 2);
	System.out.println(person);
	session.clear();
	Person person2 = (Person) session.get(Person.class, 2);
	System.out.println(person2);
}
/**
 * flush():Hibernate为了使数据库中的对象和Session中的对象保持一致,在执行transaction.commit()方法之前,如果
 * 感知到session中的对象发生改变的话,会调用session.flush()方法,向数据库发送一条update语句,但是不会提交事务.
 * 
 * 注意:1.在没用提交事务,和没有显示的调用flush方法,也有可能会进行 flush() 操作 1).执行 HQL 或 QBC
 * 查询,会先进行 flush 操作,以得到数据库的最新的记录
 * 2).在进行save()操作的时候,将会立即的发送insert语句,而不会等到事务提交的时候在发送,原因是hibernate要得到主键值.
 */
@Test
public void testflush2() {
	Person person = new Person(12, "Tomcat");
	session.save(person);
}
@Test
public void testflush() {
	Person person = (Person) session.get(Person.class, 2);
	person.setName("java");
	// session.flush();//手动的执行flush方法
	Person person2 = (Person) session.createCriteria(Person.class).uniqueResult();
	System.out.println(person2);
}
/**
 * 1.Session一级缓存: 调用session的get(),从数据库中获取一个对象,Hibernate会将这个对象保存在Session中
 * 因此第二次执行get()方法的时候,如果Session中存在该对象,会Hibernatae会先从Session获取,
 * 所以只会执行一次SELECT语句. 2.作用:减少查询数据库的次数,提高效率.
 */
@Test
public void testSessionCache() {
	Person person = (Person) session.get(Person.class, 1);
	System.out.println(person);
	Person person1 = (Person) session.get(Person.class, 1);
	System.out.println(person1);
}
/**
 * get():从数据库中获取一个对象
 */
@Test
public void testget() {
	Person person = (Person) session.get(Person.class, 1);
	System.out.println(person);
}
/**
 * save():向数据库中保存一个对象
 */
@Test
public void testSave() {
	Person person = new Person(22, "justinerbier");
	session.save(person);
}
/**
 * Hibernate的核心API方法
 */
@Test
public void test() {
	SessionFactory sessionFactory = null;
	Configuration configuration = new Configuration().configure();
	ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
			.buildServiceRegistry();
	sessionFactory = configuration.buildSessionFactory(serviceRegistry);
	Session session = sessionFactory.openSession();
	Transaction transaction = session.beginTransaction();

	Person person = new Person(12, "zhangyukang");
	session.save(person);

	transaction.commit();
	session.close();
	sessionFactory.close();
}

}