基于Annotation的Hibernate3.3+Spring2.5整合开发

 

现在，我们加入Spring的支持：把spring-framework-2.5.5\dist中的spirng.jar引进我们项目的lib目录来，还要添加aspectjweaver.jar包，以支持切面编程。

必要的配置文件还是要的：

applicationContext-common.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

 	<!– 配置SessionFactory,由Spring容器来管理Hibernate –>
    <!– 非Annotation时,使用org.springframework.orm.hibernate3.LocalSessionFactoryBean,
        它注入实体类的方式是setMappingResources(),而Hibernate Annotation所用的映射方式
        不是mapping resource,而是mapping class,这就要用到LocalSessionFactoryBean的子类
        AnnotationSessionFactoryBean了.因为org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean它支持实体的注入
        方式setAnnotatedClasses,即对应Hibernate中的mapping class.参见这两个类的源代码. –>
    <bean id=”sessionFactory”class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name=”configLocation”>
            			<value>classpath:hibernate.cfg.xml</value>
      		    </property>
    </brean>

 	  <!– 配置事务管理器 –>
       <bean id=”transactionManager”>
       		<property name=”sessionFactory”>
            		<ref bean=”sessionFactory” />
        	</property>
    	</bean>

 	<!– 配置事务的传播特性 –>
   	 <tx:advice id=”txAdvice” transaction-manager=”transactionManager”>
        		<tx:attributes>
            		<tx:method name=”save*” propagation=”REQUIRED” />
            		<tx:method name=”update*” propagation=”REQUIRED” />
            		<tx:method name=”delete*” propagation=”REQUIRED” />
            		<tx:method name=”*” read-only=”true” />
       	 	</tx:attributes>
   	 </tx:advice>

	<!– 那些类的哪些方法参与事务 –>
    	<aop:config>
        	<aop:pointcut id=”allServiceMethod” expression=”execution(* com.rong.dao.*.*.*(..))” />
        	<aop:advisor pointcut-ref=”allServiceMethod” advice-ref=”txAdvice” />
   	 </aop:config>
    
  	 <!– 使Spring关注Annotation –>
    	<context:annotation-config/>
    
   	 <!– 让Spring通过自动扫描来查询和管理Bean –>
    	<context:component-scan base-package=”com.rong”/>

 	<!– 
    		<bean id=”userDao”>
        		<property name=”sessionFactory” ref=”sessionFactory”/>
    		</bean>
   		 <bean id=”userService”>
        		<property name=”userDao” ref=”userDao”/>
    		</bean>
     	–>
</beans>

关键的两点：
<!– 使Spring关注Annotation –>
<context:annotation-config/>
    
<!– 让Spring通过自动扫描来查询和管理Bean –>
<context:component-scan base-package=”com.rong”/>
 

  

这样配置之后，就省去了上面注释掉的DAO层和Service层等配置代码。是不是很方便呢。
关于这一部分的XML代码，我们下面还会作解释。

 

来开发我们的DAO层吧,接口如下：

 

 

package com.rong.dao;

import java.util.List;
import com.rong.entity.User;

public interface UserDao {
    
    public void save(User user);
    
    public void delete(int id);
    
    public void update(User user);
    
    public List<User> query();
    
    public User get(int id);

}

 

 

DAO层的实现类：

 

 

package com.rong.dao;

import java.util.List;
import org.springframework.stereotype.Repository;
import com.rong.entity.User;

@Repository(“userDao”)        //声明此类为数据持久层的类
public class UserDaoBean extends MyHibernateDaoSupport implements UserDao {
    
    public void save(User user){
        super.getHibernateTemplate().save(user);
    }
    
    public void delete(int id){
        super.getHibernateTemplate().delete(super.getHibernateTemplate().load(User.class, id));
    }
    
    public void update(User user){
        super.getHibernateTemplate().update(user);
    }
    
    @SuppressWarnings(“unchecked”)
    public List<User> query(){
        return super.getHibernateTemplate().find(“from User”);
    }
    
    public User get(int id){
        return (User)super.getHibernateTemplate().get(“from User”, id);
    }

}

 

 大家可以看到，我们这里继承的不是HibernateDaoSupport,而是我自己编写的一个类MyHibernateDaoSupport。其代码如下：

 

package com.rong.dao;

import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class MyHibernateDaoSupport extends HibernateDaoSupport {
    
    @Resource(name=”sessionFactory”)    //为父类HibernateDaoSupport注入sessionFactory的值
    public void setSuperSessionFactory(SessionFactory sessionFactory){
        super.setSessionFactory(sessionFactory);
    }

}

 

 我们之所以要改写HibernateDaoSupport，是因我为，我们要为DAO层的类注入SessionFactory这个属性。以后，我们开发的DAO类，就可以直接重用这个MyHibernateDaoSupport了。其实，这样做是相当于配置文件方式的代码：

 

<bean id=”userDao”>
     <property name=”sessionFactory” ref=”sessionFactory”/>
</bean>

 

 我们既然要用annotation代替XML文件的，就要让它也能像原来那样使用sessionFactory,故为MyHibernateDaoSupport注入SessionFactory。子类继承这个类时，也继承其Annotation。这样，我们就可以实现SessionFactory的注入了。

 

到现在，我们再回过头来看applicationContext-common.xml中的

 <bean id=”sessionFactory”>
        <property name=”configLocation”>
            <value>classpath:hibernate.cfg.xml</value>
        </property>
 </bean>

  

 我们平时开发Hibernate与Spring整合时，常常会用到org.springframework.orm.hibernate3.LocalSessionFactoryBean来提供SessionFactory，而我们这里却要改成org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean。其实是这样的，我们在Hibernate.cfg.xml中配置的实体类映射的方式如下：

<!–
<mapping resource=”com/rong/entity/User.hbm.xml”/>
<!– 在Hibernate中注册User实体类,区别于上面注释掉的resource写法 –>
<mapping/>
–>

 

 要使Hibernate的实体类支持注解，去掉xxx.hbm.xml的文件，故我们所用的是mapping class方式，不是mapping resource的方法。然而，LocalSessionFactoryBean这个类，它采用的实体类映射方式是mapping resource，（详情可参见LocalSessionFactoryBean这个类的源代码）。如果我们在配置中仍然用这个类的话，Hibernate与Spring整合时，就会报错。而AnnotationSessionFactoryBean这个类在LocalSessionFactoryBean的基础上添加了mapping class方式实现实体类映射（详见AnnotationSessionFactoryBean类的源代码）。

 

我们再来看Service层的代码：

 

package com.rong.service;

import java.util.List;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.rong.dao.UserDao;
import com.rong.entity.User;

@Service(“userService”)        //声明此类为业务逻辑层的类
public class UserServiceBean implements UserService {
    
    @Autowired
    private UserDao userDao;

    public void save(User user){
        userDao.save(user);
    }

}

 我们用到的注解上面一般都作了注释，就不多叙。@Autowired和@Resource功能差不多，就是把对象注入，相当于<bean>配置的功能。

 

       好，就开发到这样，是不是忘记了什么？记得要配置web.xml，部分代码

 <!– 修改Spring配置文件的路径 –>
       <context-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath*:applicationContext-*.xml</param-value>
       </context-param>
    
       <!– 配置Spring –>
       <listener>
               <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
       </listener>

 

 其实，到现在为止，我们发觉我们的XML配置文件还是很多。其实，这样想想，上一阶段我们省去了xxx.hbm.xml这类的文件，这一阶段，我们少去了<bean id=”"><property name=”" ref=”">这样的配置项。