spring和hibernate整合浅析

作为一个orm框架,hibernate对jdbc进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库.而通常情况下,我们都是把hibernate和spring整合使用.那么,整合使用有什么意义呢?下面做一个简单的测试.
现在我们分别使用hibernate的方法和spring为我们提供的方法来实现一个Dao接口,假设连接池的最大连接数为50.先看Dao层代码.

public interface UserDao {

	/**
	 * 根据主键查询user实体
	 */
	public User getById(long id);
}

用hibernate的方法实现.

@Repository("hibernateDao")
public class HibernateDaoImpl extends BaseDaoImpl implements UserDao {

	public User getById(long id) {
		Session s = getHibernateTemplate().getSessionFactory().openSession();
		return (User) s.get(User.class, id);
	}
}

为了达到测试的效果,在service层提供了两个方法.

@Service("hibernateService")
public class HibernateServiceImpl implements UserService {
	@Autowired
	private UserDao hibernateDao;

	public void cache() {
		for (int i = 0; i < 100; i++) {
			hibernateDao.getById(1);
			System.out.println("当前执行次数==========" + (i + 1));
		}
	}

	public void overflow() {
		for (int i = 0; i < 100; i++) {
			hibernateDao.getById(i);
			System.out.println("当前执行次数==========" + (i + 1));
		}
	}
}

我们先看看测试结果.

public class HibernateServiceTest extends TestCase {

	/**
	 * 装载spring 配置文件
	 */
	ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");

	/**
	 * 执行效果:打印50条sql,没有走缓存.执行到第51条的时候报错. 说明:1.用	 * hibernate
的getSessionFactory().openSession()方法每次都会开启一个新的session,而且执行完不会自动关闭
	 * 
	 */
	public void testCache() {
		UserService hibernateService = SpringContextUtil.getBean("hibernateService");
		hibernateService.cache();
	}

	/**
	 * 效果同上
	 */
	public void testOverflow() {
		UserService hibernateService = SpringContextUtil.getBean("hibernateService");
		hibernateService.overflow();
	}
}

下面再用spring提供的方法实现.

@Repository("springDao")
public class SpringDaoImpl extends BaseDaoImpl implements UserDao {

	public User getById(long id) {
		return getHibernateTemplate().get(User.class, id);
	}
}

.

同样在service层提供2个方法.

@Service("springService")
public class springServiceImpl implements UserService {
	@Autowired
	private UserDao springDao;

	public void cache() {
		for (int i = 0; i < 100; i++) {
			springDao.getById(1);
			System.out.println("当前执行次数==========" + (i + 1));
		}
	}

	public void overflow() {
		for (int i = 0; i < 100; i++) {
			springDao.getById(i);
			System.out.println("当前执行次数==========" + (i + 1));
		}
	}
}

再来看看测试结果.

public class SpringServiceTest extends TestCase {

	/**
	 * 装载spring 配置文件
	 */
	ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");

	/**
	 * 执行效果: 执行100次,只打印一条sql,后面的99次全部走缓存. 这说明   本service中的一个service方法用的是一个session
	 */
	public void testCache() {
		UserService springService = SpringContextUtil.getBean("springService");
		springService.cache();
	}

	/**
	 * 执行效果: 执行全部的100条sql
	 * 上面的结论,本service中的一个service方法用的是一个session,说明session只最后关闭一次
	 */
	public void testOverflow() {
		UserService springService = SpringContextUtil.getBean("springService");
		springService.overflow();
	}
}

这里,我们得到的是基于在spring配置文件中配置了aop事务管理的情况下的测试结果.具体代码如下:

   <!--设置事务管理 -->
   <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
      <property name="sessionFactory">
         <ref local="sessionFactory" />
      </property>
   </bean>

   <tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes>
         <tx:method name="cache*" />
         <tx:method name="update*" />
         <tx:method name="delete*" />
         <tx:method name="*" read-only="true" propagation="REQUIRED" />
      </tx:attributes>
   </tx:advice>

   <aop:config>
      <aop:pointcut id="serviceMethod" expression="execution(* *..service.*Service.*(..))" />
      <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod" />
   </aop:config>

关于事务,暂时不作介绍,上面有一段代码很关键.
<aop:config>
      <aop:pointcut id="serviceMethod" expression="execution(* *..service.*Service.*(..))" />
      <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod" />
   </aop:config>
这段代码意思是所有.service包中的所有Service类的方法,都是该aop的切点.都会执行
org.springframework.orm.hibernate3.HibernateTransactionManager类中相对应的方法,该类的具体实现先不介绍.那么,如果没有这段配置会发生什么呢?我们创建一个名为SpringManager的类.这样就不会受到这段配置文件的影响.代码跟SpringService一样.
测试结果如下:

public class SpringManagerTest extends TestCase {

	/**
	 * 装载spring 配置文件
	 */
	ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");

	/**
	 * 执行100次,不走缓存
	 */
	public void testCache() {
		UserManager springManager = SpringContextUtil.getBean("springManager");
		springManager.cache();
	}

	/**
	 * 执行100次,不走缓存
	 */
	public void testOverflow() {
		UserManager springManager = SpringContextUtil.getBean("springManager");
		springManager.overflow();
	}
}

根据上面的测试结果,我们可以得出如下结论:
1.hibernate中,我们每次都需要自己打开一个session,然后关闭.这样每次都不是同一个session,造成系统空间的浪费,代码量也较多.
2.spring提供的getHibernateTemplate()方法,每次都会打开一个session,但是会自动关闭.
3.配置了aop事务管理之后,Spring提供的getHibernateTemplate()方法使得同i个service方法中自始至终都只会有一个session.当方法执行结束后关闭.

上面多次提到缓存,这里的缓存,指的是session缓存,也就是一级缓存.上面SpringService中的第一个方法,执行100次,但是只打印了一条sql,原因就是查询结果已经在缓存当中存在.不需要再查询数据库.下面再写一个例子来更好的理解一级缓存.

@Service("springService")
public class SpringServiceImpl implements UserService {
	@Autowired
	private UserDao springDao;

	public void cache() {
		User user = new User();
		user.setName("name1");
		springDao.save(user);

		List<User> list = springDao.list();
		for (User user1 : list) {
			System.out.println(user1.getName());
		}
	}
}

首先向User当中加入name="name1".这时候方法没有执行完,session还没有提交,也就是说数据库中没有记录.用debug检查发现,代码执行到List<User> list = springDao.list();之后,数据库中没有记录,但是此时User不为null.执行System.out.println(user1.getName());之后,输出name1.这就是用法哦了一级缓存.一级缓存是session级别缓存,是自带的.当关闭session或者调用clear()方法的时候缓存就会清除.hibernate除了一级缓存之外还有二级缓存.同学们有兴趣可以去查阅相关资料.