hibernate中session的常见方法说明

HibernateUtil类：

package sun.util;

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

public class HibernateUtil {
	private static HibernateUtil instance = new HibernateUtil();
	private SessionFactory sf;

	private HibernateUtil() {
		Configuration cfg = new Configuration().configure();
		sf = cfg.buildSessionFactory();
	}

	public static HibernateUtil getInstance() {
		return instance;
	}

	public Session getSession() {
		return sf.openSession();
	}
}

测试类：

package sun.test;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.jdbc.Work;
import org.junit.Test;

import sun.domain.Employee;
import sun.util.HibernateUtil;

public class TestHibernateSession {
	private HibernateUtil util;

	@Test
	public void testSessionCache() {
		Session session = HibernateUtil.getInstance().getSession();
		Employee e = (Employee) session.get(Employee.class, 1L);
		Employee e1 = (Employee) session.get(Employee.class, 1L);
		/*
		 * 仅仅发送了一条sql ： select employee0_.EMP_ID as EMP1_0_0_, employee0_.NAME
		 * as NAME0_0_, employee0_.EMAIL as EMAIL0_0_, employee0_.AGE as
		 * AGE0_0_, employee0_.BIRTH_DATE as BIRTH5_0_0_ from EMP employee0_
		 * where employee0_.EMP_ID=?
		 * 
		 * 返回结果：true
		 * 
		 * 结论：session上存在一级缓存，第二次查询的数据直接从一级缓存中查询，而不会再次发送sql语句.
		 */
		System.out.println(e == e1);
		session.close();
	}

	@Test
	public void testSessionClear() {
		Session session = HibernateUtil.getInstance().getSession();
		Employee e = (Employee) session.get(Employee.class, 1L);
		// clear会直接清除一级缓存中的数据，所以第二次获取数据会重新发送sql
		session.clear();
		Employee e1 = (Employee) session.get(Employee.class, 1L);
		System.out.println(e == e1);
		session.close();
	}

	@Test
	public void testSessionEvict() {
		Session session = HibernateUtil.getInstance().getSession();
		Employee e = (Employee) session.get(Employee.class, 1L);
		/*
		 * evict将某个特定的对象从一级缓存中删除。
		 * 
		 * 注意：delete方式直接删除数据库中的数据，而evict和clear只处理一级缓存中的数据.
		 */
		session.evict(e);
		Employee e1 = (Employee) session.get(Employee.class, 1L);
		System.out.println(e == e1);
		session.close();
	}

	@Test
	public void testSessionDoWork() {
		Session session = HibernateUtil.getInstance().getSession();
		/*
		 * doWork方法是我们能够拿到session上的connection，从而完成一些事情.
		 * 
		 * 注意：session.connection方法功能一样，但是connection方法存在安全问题，
		 * 例如拿到connection后直接session已经关闭，而后便继续使用
		 * connection对象，就会出错。doWork方法很好的避免了这种问题。
		 */
		session.doWork(new Work() {

			@Override
			public void execute(Connection connection) throws SQLException {
				/*
				 * 必要再这里关闭连接和提交事务，而应该交给session处理
				 */
			}
		});
		session.close();
	}

	@Test
	public void testSessionFlush() {
		Session session = HibernateUtil.getInstance().getSession();
		Transaction tx = session.beginTransaction();
		Employee e = (Employee) session.get(Employee.class, 1L);
		/*
		 * 发送两条sql：
		 * 
		 * 1、select employee0_.EMP_ID as EMP1_0_0_, employee0_.NAME as NAME0_0_,
		 * employee0_.EMAIL as EMAIL0_0_, employee0_.AGE as AGE0_0_,
		 * employee0_.BIRTH_DATE as BIRTH5_0_0_ from EMP employee0_ where
		 * employee0_.EMP_ID=?
		 * 
		 * 2、update EMP set NAME=?, EMAIL=?, AGE=?, BIRTH_DATE=? where EMP_ID=?
		 * 
		 * 说明；如果没有调用session.flush()方法，提交事务时，即调用tx.commit()方法时，hibernate会发送一条update语句
		 * ，自动更新session一级缓存中的脏数据（ 即已经被修改过的数据），
		 * 如果直接调用session.flush()方法，则在此时会发送一条update语句
		 * ，会直接刷新一级缓存中的脏数据到数据库，而不是提交事务时才发送update.
		 */
		e.setName("嘿嘿1");
		System.out.println("----------before flush-----------");
		session.flush();
		System.out.println("----------before commit-----------");
		tx.commit();
		session.close();
	}

	@Test
	public void testSessionGetIdentifier() {
		Session session = HibernateUtil.getInstance().getSession();
		Employee e = (Employee) session.get(Employee.class, 1L);
		/*
		 * 获取对象的主键，从对象映射文件中获取，在自己实现二级缓存的时候有用
		 */
		Serializable s = session.getIdentifier(e);
		System.out.println(s);
		session.close();
	}

	@Test
	public void testSessionMerge() {
		Session session = HibernateUtil.getInstance().getSession();
		Transaction tx = session.beginTransaction();
		// Employee e = (Employee) session.get(Employee.class, 1L);
		// e.setName("呵呵");
		Employee e = new Employee();
		e.setName("王五");
		e.setAge(25);
		e.setEmail("wangwu@baidu.com");
		try {
			e.setBirthDate(new SimpleDateFormat("yyyy-MM-dd")
					.parse("1986-01-01"));
		} catch (ParseException e1) {
			e1.printStackTrace();
		}
		/*
		 * merge 合并，即保存或更新对象.数据库存在则更新，否则新增.
		 * 
		 * 该方法功能同saveOrUpdate
		 */
		session.merge(e);

		tx.commit();
		session.close();
	}

	@Test
	public void testSessionPersist() {
		Session session = HibernateUtil.getInstance().getSession();
		Transaction tx = session.beginTransaction();

		Employee e = new Employee();
		e.setName("赵六");
		e.setAge(25);
		e.setEmail("zhaoliu@gmail.com");
		/*
		 * 功能同save，区别：如果没有开启事务，save方法任然会发送一条sql，但是没有事务最终被回滚；而persist方法如果没有开启事务，
		 * 不会发送sql，提高了性能(JPA的方法).
		 */
		session.persist(e);
		tx.commit();
		session.close();
	}
}

增删改查：

package sun.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Before;
import org.junit.Test;

import sun.domain.Employee;
import sun.util.HibernateUtil;

public class TestHibernate extends TestHibernateSession {
	private HibernateUtil util;

	@Before
	public void test() {
		util = HibernateUtil.getInstance();
	}

	@Test
	public void testSave() {

		Session s = util.getSession();
		Transaction tx = s.beginTransaction();
		Employee e = new Employee();
		e.setName("张三");
		e.setEmail("zhangsan@126.com");
		try {
			e.setBirthDate(new SimpleDateFormat("yyyy-MM-dd")
					.parse("2010-10-10"));
		} catch (ParseException e1) {
			e1.printStackTrace();
		}
		e.setAge(20);
		// 保存
		s.save(e);
		tx.commit();

		s.close();
	}

	@Test
	public void testUpdate() {
		Session s = util.getSession();
		Transaction tx = s.beginTransaction();

		Employee e = (Employee) s.get(Employee.class, 1L);
		e.setName("李四");
		// 更新
		s.update(e);
		tx.commit();
		s.close();
	}

	@Test
	public void testGet() {
		Session s = util.getSession();
		// 获取
		Employee e = (Employee) s.get(Employee.class, 1L);
		System.out.println(e);
	}

	@Test
	public void testList() {
		Session s = util.getSession();
		// 查询多条数据
		Query q = s.createQuery("SELECT e FROM Employee e");
		@SuppressWarnings("unchecked")
		List<Employee> es = q.list();
		System.out.println(es);
	}
}