hibernate之session的方法小插曲

在hibernate中分别设置了四种状态：

临时态，持久态，游离态和删除态

同时hibernate也对应的设置了懒加载特性，即是当需要去取数据的采取数据库查询，否则就到session的缓存区中取

对应的相关方法

package hibernate_d_sessionfunction;

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

public class App {

	private static SessionFactory sessionFactory = new Configuration()//
							.configure()//
							.addClass(User.class)// 添加Hibernate实体类（加载对应的映射文件）
							.buildSessionFactory();
		
	
   		 // save()：把临时状态变为持久化状态（交给Session管理）
		 // 会生成：insert into ...
	@Test
	public void testAdd(){
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
		User user = new User(); // 临时状态
		user.setName("test");
		session.save(user); // 变为了持久化状态

		
		tx.commit();
		session.close();
		
		user.setName("李四"); // 游离状态
		System.out.println(user.getName()); // 游离状态
	}
	
	
		// update()：把游离状态变为持久化状态
		// 会生成：update ...
		// 在更新时，对象不存在就报错
	@Test
	public void testUpdate(){
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
		User user = (User) session.get(User.class, 1);
		System.out.println(user.getName()); // 持久化状态

		// session.clear(); // 清除Session中所有的对象
		session.evict(user); // 清除Session中一个指定的对象

		user.setName("newname3");
		session.update(user);
		System.out.println("----");
		// session.flush(); // 刷出到数据库

		// --------------------------------------------
		session.getTransaction().commit(); // 
		session.close();
		
		tx.commit();
		session.close();
	}
	
		// saveOrUpdate()：把临时或游离状态转为持久化状态
		// 会生成：insert into 或 update ...
		// 在更新时，对象不存在就报错
		// 本方法是根据id判断对象是什么状态的：如果id为原始值（对象的是null，原始类型数字是0）就是临时状态，如果不是原始值就是游离状态。
		
	@Test
	public void testSaveOrUpdate(){
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
		User user = new User();
		user.setId(3); // 自己生成一个游离状态对象
		user.setName("newName");

		session.saveOrUpdate(user);
		
		tx.commit();
		session.close();
	}
	
		// delete()：把持久化或游离转为删除状态
		// 会生成：delete ...
		// 如果删除的对象不存在，就会抛异常
	@Test
	public void testDelete(){
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
				// User user = (User) session.get(User.class, 2); // 持久化

				User user = new User();
				user.setId(300);

				session.delete(user);
				session.flush();

				System.out.println("---");
		
		tx.commit();
		session.close();
	}
	
		// get()：获取数据，是持久化状态
		// 会生成：select ... where id=?
		// 会马上执行sql语句
		// 如果数据不存在，就返回null
		@Test
		public void testGet() throws Exception {
			Session session = sessionFactory.openSession();
			session.beginTransaction();
			// --------------------------------------------

			User user = (User) session.get(User.class, 1); // 持久化
			System.out.println(user.getClass());
			// System.out.println("---");
			// System.out.println(user.getName());

			// --------------------------------------------
			session.getTransaction().commit();
			session.close();
		}


		// load()：获取数据，是持久化状态
		// 会生成：select ... where id=?
		// load()后返回的是一个代理对象，要求类不能是final的，否则不能生成子类代理，就不能使用懒加载功能了。
		// 让懒加载失效的方式：一、把实体写成final的；二、在hbm.xml中写<class ... lazy="false">
		// 不会马上执行sql语句，而是在第1次使用非id或class属性时执行sql。
		// 如果数据不存在，就抛异常：ObjectNotFoundException
		@Test
		public void testLoad() throws Exception {
			Session session = sessionFactory.openSession();
			session.beginTransaction();
			// --------------------------------------------

			User user = (User) session.load(User.class, 1);
			System.out.println(user.getClass());
			System.out.println("---");
			System.out.println(user.getId());
			System.out.println(user.getName());
			// System.out.println(user.getName());

			// --------------------------------------------
			session.getTransaction().commit();
			session.close();
		}
		
		// 操作大量数据，要防止Session中对象过多而内存溢出
		@Test
		public void testBatchSave() throws Exception {
			Session session = sessionFactory.openSession();
			session.beginTransaction();
			// --------------------------------------------

			for (int i = 0; i < 30; i++) {
				User user = new User();
				user.setName("测试");
				session.save(user);

//				if (i % 10 == 0) {
//					session.flush(); // 先刷出
//					session.clear(); // 再清空
//				}
			}

			// --------------------------------------------
			session.getTransaction().commit();
			session.close();
		}
	
}

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
        
        <!-- 
		lazy属性：默认为true，默认可以懒加载。
		 -->
        <hibernate-mapping package="hibernate_d_sessionfunction">
        	<class name="User" table="users" lazy="true">
        		<id name="id">
        			<generator class="native" />
        		</id>
      
      			<property name="name" />
      			
      			
      			
      			
        	</class>
        </hibernate-mapping>

四种状态的解释：

临时状态：
与数据库没有对应，跟Session没有关联。
一般是新new出的对象。


持久化状态：
对象在Session的管理之中，最终会有对应的数据库记录。
特点：
1，有OID
2，对对象的修改会同步到数据库。


游离状态：
数据库中有对应记录，但对象不在Session管理之中。
修改此状态对象时数据库不会有变化。


删除状态：
执行了delete()后的对象。

在session的方法get()与load()，这两种方法都是去取的数据

但是也是有区别的

get 立即加载 返回的值是真实对象或null 数据为空时返回null
load 延迟加载 返回的值是代理对象 数据为空时抛异常