spring和hibernate调整浅析

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 {@Autowiredprivate 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 {@Autowiredprivate 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" />      </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 {@Autowiredprivate 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除了一级缓存之外还有二级缓存.同学们有兴趣可以去查阅相关资料.

查看更多 下一篇