Struts2+Spring2.5.6+Hibernate3+Freemarker整合(一)



Struts2+Spring2.5.6+Hibernate3+Freemarker整合(一)。本部分是整合S2SH+Freemarker,后台用Spring来管理各个bean,Hibernate来做数据库持久化,前端呈现用Freemarker。整合中对Struts2,Hibernate,Spring都是采用Annotation来进行注解类。
首先在ApplicationContext.xml中配置连接池,采用c3p0来配置。

Java代码  收藏代码
  1. <!– 数据库连接池 –>
  2.     <bean id=”dataSource” class=”com.mchange.v2.c3p0.ComboPooledDataSource”>
  3.         <property name=”jdbcUrl” value=”jdbc:mysql://localhost:3306/test” />
  4.         <property name=”user” value=”root” />
  5.         <property name=”password” value=”zhangting” />
  6.         <property name=”driverClass” value=”com.mysql.jdbc.Driver” />
  7.         <!– 最大连接数 –>
  8.         <property name=”maxPoolSize” value=”20″ />
  9.         <!– 最小连接数 –>
  10.         <property name=”minPoolSize” value=”5″ />
  11.         <!– 验证等待请求是否超时–>
  12.         <property name=”checkoutTimeout” value=”120″ />
  13.     </bean>

然后对hibernate的一些个相关properties做好相应的配置。

Java代码  收藏代码
  1. <!– hibernateProperties –>
  2.     <bean id=”hibernateProperties”
  3.         class=”org.springframework.beans.factory.config.PropertiesFactoryBean”>
  4.         <property name=”properties”>
  5.             <props>
  6.                 <prop key=”hibernate.show_sql”>true</prop>
  7.                 <prop key=”hibernate.dialect”>org.hibernate.dialect.MySQLDialect</prop>
  8.                 <prop key=”hibernate.hbm2ddl.auto”>update</prop>
  9.                 <prop key=”hibernate.cache.provider_class”>org.hibernate.cache.EhCacheProvider</prop>
  10.                 <!– 开启使用二级缓存 –>
  11.                 <prop key=”hibernate.cache.use_second_level_cache”>true</prop>
  12.                 <!– 使用查询缓存 –>
  13.                 <prop key=”hibernate.cache.use_query_cache”>true</prop>
  14.             </props>
  15.         </property>
  16.     </bean>

对于Hibernate的一些相关配置差不多就配置好了。然后将这些东西都注入到sessionFactory中。采用Hibernate的Annotation来持久化对象,所以要将这些bean注入到AnnotationSessionFactoryBean这个类中。

Java代码  收藏代码
  1. <!– hibernate-annotation sessionFactory  注入配置 –>
  2.     <bean id=”sessionFactory”
  3. class=”org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean”>
  4.         <property name=”dataSource” ref=”dataSource” />
  5.         <property name=”hibernateProperties” ref=”hibernateProperties” />
  6.         <property name=”packagesToScan”>
  7.             <list>
  8.                 <value>com.person.model</value>
  9.             </list>
  10.         </property>
  11.     </bean>

packagesToScan是扫描相应包下的持久化类,现在已经完成了一部分Spring与Hibernate的整合了。接下来做的就是编写一个DAO层。

Java代码  收藏代码
  1. import java.util.List;
  2. /**
  3.  *
  4.  * @author 张廷 2011-3-24下午01:43:36
  5.  *
  6.  */
  7. public interface BaseDao {
  8.     public void insert(Object stu);
  9.     public void update(Object stu);
  10.     public List findAll(String hql);
  11.     public Object findById(Class clazz, Integer id);
  12.     public void delete(Object stu);
  13. }

写好接口后,接下来就要写一个对这个接口的实现类,在这之中我都是采用Spring的Annotation来对每个bean进行声明。在DAO层中使用Spring包中HibernateTemplate来操作数据库,毕竟人家都已经写好了,不用白不用。既然使用了Spring,我们当然还是选择Spring来帮我们管理类,接着配置HibernateTemplate。

Java代码  收藏代码
  1. <!– hibernateTemplate实现 –>
  2.     <bean id=”hibernateTemplate” class=”org.springframework.orm.hibernate3.HibernateTemplate”>
  3.         <property name=”sessionFactory” ref=”sessionFactory” />
  4.     </bean>

接下来写DAO实现类

Java代码  收藏代码
  1. @Component
  2. public class BaseDaoImplHibernate implements BaseDao {
  3.     @Autowired
  4.     private HibernateTemplate hibernateTemplate;
  5.     public void delete(Object stu) {
  6.         hibernateTemplate.delete(stu);
  7.     }
  8.     public List findAll(String hql) {
  9.         hibernateTemplate.setCacheQueries(true);
  10.         return hibernateTemplate.find(hql);
  11.     }
  12.     public Object findById(Class clazz, Integer id) {
  13.         // Object obj = hibernateTemplate.load(clazz, id);
  14.         return hibernateTemplate.get(clazz, id);
  15.     }
  16.     public void insert(Object stu) {
  17.         hibernateTemplate.save(stu);
  18.     }
  19.     public void update(Object stu) {
  20.         hibernateTemplate.update(stu);
  21.     }
  22.     public HibernateTemplate getHibernateTemplate() {
  23.         return hibernateTemplate;
  24.     }
  25.     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
  26.         this.hibernateTemplate = hibernateTemplate;
  27.     }
  28. }

既然使用了Spring的Annotation来声明bean,别忘了配置component-scan。

Java代码  收藏代码
  1. <context:annotation-config />
  2.     <context:component-scan base-package=”com” />

接下来写Hibernate持久化类,使用Hibernate的Annotation来声明持久化类。

Java代码  收藏代码
  1. @Entity
  2. @Table(name = ”Student”)
  3. public class Student {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.AUTO)
  6.     private Integer stuId;
  7.     private String stuNumber;
  8.     private String stuName;
  9.     private int age;
  10.     private String birth;
  11.     /*省略getter与setter*/
  12. }

别忘了还要声明事务,让Spring来帮我们管理事务,事务的配置可以选择XML或者Annotation,由于XML来配置事务更加的方便,而且更加的简便,所以我们采用XML的方式来声明事务。

Java代码  收藏代码
  1. <!– 事务 begin –>
  2.     <bean id=”transactionManager”
  3.         class=”org.springframework.orm.hibernate3.HibernateTransactionManager”>
  4.         <property name=”sessionFactory” ref=”sessionFactory” />
  5.     </bean>
  6.     <aop:config>
  7.         <aop:pointcut id=”businessService”
  8.             expression=”execution(public * com.service..*.*(..))” />
  9.         <aop:advisor advice-ref=”txAdvice” pointcut-ref=”businessService” />
  10.     </aop:config>
  11.     <tx:advice id=”txAdvice” transaction-manager=”transactionManager”>
  12.         <tx:attributes>
  13.             <tx:method name=”find*” read-only=”true” />
  14.             <tx:method name=”add*” propagation=”REQUIRED” />
  15.             <tx:method name=”update*” propagation=”REQUIRED” />
  16.             <tx:method name=”del*” propagation=”REQUIRED” />
  17.         </tx:attributes>
  18.     </tx:advice>
  19.     <!– 事务 end –>

Hibernate+Spring的整合已经完成了,用junit写个测试类来测试一下

Java代码  收藏代码
  1. public class HibernateTemplateTest {
  2.     private static ApplicationContext ctx;
  3.     static{
  4.         ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”);
  5.     }
  6.     @Test
  7.     public void testDelStu() {
  8.         BaseDao dao = (BaseDao) ctx.getBean(“baseDaoImplHibernate”);
  9.         List<Student> list = dao.findAll(“from Student”);
  10.         for(Student stu : list)
  11.             System.out.println(stu.getStuName());
  12.     }
  13. }

下面是结果:

http://z276356445t.iteye.com/blog/975460
测试已经通过了,在下一篇中会介绍Spring+hibernate+struts2+freemarker的整合