抽时间 总结junit3和junit4的相关测试方法 ，junit4采用的是annotations
junit3 命名规范： 测试类 xxxTest 测试方法void testxxx() ，方法中可以用断言assertEquals(expected, actual).
测试类需要继承TestCase ， 在工程中新建一个source folder，在其中建好包，包名最好和要测的类所在的包一样。
1.用Junit 3 编写一个测试类SessionTest来测试 & 探索Hibernate 三种对象的生命周期
熟悉hibernate的CRUD操作，主要方法有：get()、load()、save()、delete()、update()
package com.wyx.hibernate;
import java.util.Date;
import junit.framework.TestCase;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.wyx.hibernate.utils.HibernateUtils;
/**
* 使用junit做测试多个方法比较方便，junit中还有setup()和Deardown()，用来初始化和销毁
* setup()一般放的是
* @author bird
*/
public class SessionTest extends TestCase{
//public 无return
public void testHello(){
System.out.println("----------SessionTest.testHello()----------");
//throw new java.lang.RuntimeException();
//this.assertEquals("hello", "no hello");
}
public void testSession(){
Session session = HibernateUtils.getSession();
Transaction ts = session.beginTransaction();
User u = new User();
try {
//Transient状态
//uid不需要赋值，自动赋值
u.setName("李四");
u.setPassword("123");
u.setCreateTime(new Date());
u.setExpireTime(new Date());
session.save(u);//单步调试表明，在执行完save()后，uid的值才产生
System.out.println("---------mark-----------");
//save()后变成persistent状态
u.setName("王五");
//persistent状态的时候，不需要手动update，hibernate会自动和数据库同步
//session.update(u);
ts.commit();
} catch (HibernateException e) {
e.printStackTrace();
ts.rollback();
}finally{
HibernateUtils.closeSession(session);
}
//Detached状态
u.setName("张三");
try {
session = HibernateUtils.getSession();
session.beginTransaction();
session.update(u);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
ts.rollback();
}finally{
HibernateUtils.closeSession(session);
}
}
}
运行结果：
----------SessionTest.testHello()----------
---------mark-----------
Hibernate: insert into User (name, password, createTime, expireTime, id) values (?, ?, ?, ?, ?)
Hibernate: update User set name=?, password=?, createTime=?, expireTime=? where id=?
Hibernate: update User set name=?, password=?, createTime=?, expireTime=? where id=?
运行结果表明，一个对象处于Persistent状态时，当属性发生改变的时候，Hibernate会自动和数据库同步，Hibernate只是把这些数据放在缓存中处理，而且是在commit()提交的时候才执行所有的数据库操作。
产生多条sql语句的原因是：hibernate在修改数据之前要先照一个快照，接下来修改了对象u.setName("王五")，在commit的时候，需要清理缓存(内从中的对象)，脏数据是指没有提交的数据，commit()之前清理缓存的这个过程中要执行脏数据对比，脏数据对比的主要工作是处理哪些数据要发成insert，哪些数据要发成update语句。
当session关闭的时候，session已经不再管理u对象，u对象虽然变成了Detached状态，但是数据库中该条记录依然存在，当执行update的时候，数据库中u对应的那条记录name字段又变成了“张三”，update之后，该u对象又变成了Persistent状态的。
接着在SessionTest中写一个方法，运行：
public void testReadByGetMethod(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
//将数据库中对应id的那条记录取出来存在User对象中，此时立即产生sql语句
User u =(User)session.get(User.class, "402881fa2edaffe9012edaffea5c0001");
System.out.println("-------------mark----------------");
//修改u , persistent状态的时候，不需要手动update，hibernate会自动和数据库同步
u.setName("jeff");
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
运行结果：
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.password as password0_0_, user0_.createTime as createTime0_0_, user0_.expireTime as expireTime0_0_ from User user0_ where user0_.id=?
-------------mark----------------
Hibernate: update User set name=?, password=?, createTime=?, expireTime=? where id=?
public void testReadByGetMethod1(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
User u =(User)session.get(User.class, "adfsafa");
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
} 运行结果：Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.password as password0_0_, user0_.createTime as createTime0_0_, user0_.expireTime as expireTime0_0_ from User user0_ where user0_.id=?
调试跟踪表明，u对象值为null，但是单元测试没有报错，所以采用get()加载数据，如果数据中不存在相应的数据，返回null。
public void testReadByLoadMethod1(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
//不会发出查询sql，因为load方法实现了lazy()
//懒加载 or 延迟加载，真正使用这个对象的时候，才加载(发出sql语句)
//hibernate延迟加载实现原理是代理方式
User u =(User)session.load(User.class, "402881e62ed3df84012ed3df85510001");
System.out.println("----------mark------------");
System.out.println("u.name: " + u.getName());
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}
运行结果：
----------mark------------
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.password as password0_0_, user0_.createTime as createTime0_0_, user0_.expireTime as expireTime0_0_ from User user0_ where user0_.id=?
u.name: jeff
代理类是使用CGLIB工具生成代理类，代理类继承了User。
public void testReadByLoadMethod2(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
//采用load加载数据，如果数据库中没有相应数据，
//那么抛出ObjectNotFoundException的异常
User u =(User)session.load(User.class, "adadfafdf");
System.out.println("----------mark------------");
System.out.println("u.name: " + u.getName());
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}运行结果：
----------mark------------
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.password as password0_0_, user0_.createTime as createTime0_0_, user0_.expireTime as expireTime0_0_ from User user0_ where user0_.id=?
org.hibernate.ObjectNotFoundException: No row with the given identifier exists: [com.wyx.hibernate.User#adadfafdf]
从上述get和load的测试方法可见：
1. get()不支持lazy， load()是支持lazy的(懒加载)；
2. get()查询数据的时候，查不到返回null。而load()抛出org.hibernate.ObjectNotFoundException。注意，执行load方法的时候是不会报错的，在调用保存load的那个对象时才会抛出异常。
测试update():
public void testUpdate1(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
//虽然是我们自己new出来的，但是id在数据库中存在，所以这属于手动构造的 Detached 对象
User u = new User();
u.setId("402881e62ed40ec1012ed40ec2f10001");
u.setName("小明");
u.setPassword("123");
session.update(u);
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}测试结果：
Hibernate: update User set name=?, password=?, createTime=?, expireTime=? where id=?
虽然手动构造的Detached对象可以update到数据库，但是，万一有字段没setvalue就会更新空数据进DB，所以最好的做法还是操作一个从数据库get或load的对象，因为该对象已经填充了值。
测试Delete():
public void testDelete(){
Session session = HibernateUtils.getSession();
try {
session.beginTransaction();
User u = (User)session.load(User.class, "402881e62ed40ec1012ed40ec2f10001");
session.delete(u);
session.getTransaction().commit();
} catch (HibernateException e) {
session.getTransaction().rollback();
e.printStackTrace();
}finally{
HibernateUtils.closeSession(session);
}
}测试结果：
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.password as password0_0_, user0_.createTime as createTime0_0_, user0_.expireTime as expireTime0_0_ from User user0_ where user0_.id=?
Hibernate: delete from User where id=?
在删除一条记录的时候，操作的也是对象，所以把对象根据id用get或load获取到，然后session.delete(u);
小结：
transient状态的特征：
1. 在数据库中没有与之匹配的记录；
2. 没有纳入session的管理；
Persistent状态的特征：
1. 对象在数据库中有与之匹配的记录；
2. 纳入了session的管理；
3. 在清理缓存(脏数据检查)的时候，会和数据库同步(内存检查、清理缓存的目的是：看缓存发生有没有变化，从而判断到底发什么hql语句，eg：在save完了后，修改了对象，发了两条：一条insert一条update，这就是脏数据检查的好处)；
Detached状态的特征：
1. 在数据库中有与之匹配的记录；
2. 没有纳入session的管理；
在实际应用中，我们经常需要根据表中的非id字段查询一个对象(一条记录)，或者全部的数据，就要用到HQL。
1338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
