`

基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (2)

    博客分类:
  • SHH
阅读更多

 基于Annotation的SSH整合开发,其实,并没有我当初想像中那么顺利。真正去做的时候,才发觉有许多问题。但不要紧,探索一下吧。在探索过程中学到知识,才是最重要的。
        言归正传,现在,我们加入Spring的支持:把spring-framework-2.5.5\dist中的spirng.jar 引进我们项目的lib目录来,还要添加\lib\aspectj\下的两个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/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
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
>
            
    
<!--  配置SessionFactory,由Spring容器来管理Hibernate  -->
    
<!--  非Annotation时,使用org.springframework.orm.hibernate3.LocalSessionFactoryBean,
        它注入实体类的方式是setMappingResources(),而Hibernate Annotation所用的映射方式
        不是mapping resource,而是mapping class,这就要用到LocalSessionFactoryBean的子类
        AnnotationSessionFactoryBean了.因为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 >
    
</ bean >

    
<!--  配置事务管理器  -->
    
< bean  id ="transactionManager"
        class
="org.springframework.orm.hibernate3.HibernateTransactionManager" >
        
< 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" class="com.rong.dao.UserDaoBean">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <bean id="userService" class="com.rong.service.UserServiceBean">
        <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"  class ="com.rong.dao.UserDaoBean" >
        
< property  name ="sessionFactory"  ref ="sessionFactory" />
    
</ bean >
        我们既然要用annotation代替XML文件的,就要让它也能像原来那样使用sessionFactory,故为MyHibernateDaoSupport注入SessionFactory。子类继承这个类时,也继承其Annotation。这样,我们就可以实现SessionFactory的注入了。
         到现在,我们再回过头来看applicationContext-common.xml中的
     < bean  id ="sessionFactory"
        class
="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" >
        
< 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中配置的实体类映射的方式如下:(详见基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (1)  
         <!--
        <mapping resource="com/rong/entity/User.hbm.xml"/>
         
-->
         
         
<!--  在Hibernate中注册User实体类,区别于上面注释掉的resource写法  -->
         
< mapping  class ="com.rong.entity.User" />
        要使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 >

        是不是真的成功了?用Junit测试一下吧,我测试过是没问题的,由于篇幅,Junit的测试代码就不贴出来了。自己练习一下吧!
        其实,到现在为止,我们发觉我们的XML配置文件还是很多。其实,这样想想,上一阶段我们省去了xxx.hbm.xml这类的文件,这一阶段,我们少去了<bean id="" class=""><property name="" ref="">这样的配置项。而这些,正是我们项目开发中,大量使用的配置。而只要书写简单的Annotation注解,就可以省去这样,我们何乐而不用。而那些我们保留的XML配置文件(如:数据库连接,事务),这样是写死的,一个项目就写一次或复制过来用,我们保留它又何妨?

        好,暂时到这里,我们还有下一阶段的基于Annotation的SSH整合开发,我们将会以一个用户注册的例子,把Struts2的注解带到我们的整合开发中来。一起期待吧!

分享到:
评论

相关推荐

    基于Annotation的Struts2.0+Hibernate3.3+Spring2.5图文教程整合开发.doc

    【基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发】 这篇文档主要介绍了一个使用注解(Annotation)进行Struts2.0、Hibernate3.3和Spring2.5整合开发的教程。这种集成方式相比传统的XML配置,可以简化...

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

    总的来说,基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发利用注解简化了配置,提高了开发效率,使得代码更加可读,降低了出错的可能性。然而,需要注意的是,虽然注解使得配置文件减少,但过多的注解也...

    基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (1)

    标题中的“基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发”指的是使用注解的方式将三个流行的Java企业级框架——Struts2、Hibernate和Spring进行集成开发。这样的集成有助于简化配置,提高代码的可读性...

    Struts1.3 + Hibernate3.3 + Spring3.0 Annotation整合

    Struts1.3、Hibernate3.3和Spring3.0是经典的Java企业级开发框架,它们的整合在早期Web应用开发中非常常见。这三种框架的结合提供了模型-视图-控制器(MVC)架构、对象关系映射(ORM)以及依赖注入(DI)和面向切面...

    struts2.0+hibernate3.0+spring2.0整合(2)

    Struts2.0、Hibernate3.0和Spring2.0是Java Web开发中经典的三大框架,它们的整合是企业级应用开发的常见实践。Struts2作为MVC(Model-View-Controller)框架,主要负责处理HTTP请求并调度业务逻辑;Hibernate是一个...

    struts2.1 + spring 2.5 + hibernate 3.2 增删改查

    总结来说,"struts2.1 + spring 2.5 + hibernate 3.2 增删改查"的例子涵盖了Web应用开发中的核心部分:前端请求处理(Struts2)、业务逻辑管理(Spring)和数据库操作(Hibernate)。这个例子为初学者提供了一个很好...

    struts1.3+spring2.5+hibernate3.3 组合开发 annotation实现

    Struts1.3、Spring2.5 和 Hibernate3.3 是经典的 Java Web 开发框架组合,它们在企业级应用中广泛使用。这个组合被称为“SSH”(Struts-Spring-Hibernate),它允许开发者构建可扩展且松耦合的后端系统。在本项目中...

    Struts2+Spring2.5+Hibernate3+Freemarker框架整合

    整合S2SH+Freemarker+oscache,后台用Spring管理各个bean,Hibernate做数据库持久化,viewer用Freemarker。整合中对Struts2,Hibernate,Spring都采用Annotation进行注解类。

    Spring2.5+Struts2.0+hibernate3.0+Dwr+jquery+displayTag

    2 利用struts2 的LoginAction-validation.xml 3 在bean里把service包;暴露DWR,写了一个验证用户名的流程 4 采用jpa作为POJO,还是减少配置 5 加入display的分页,并且是物理分页 打开后自已建表sql.txt jdbc....

    基于Struts2.18+Spring2.5+Hibernater3.3+Annotation注解开发的电子商务网站demo

    这个“基于Struts2.18+Spring2.5+Hibernate3.3+Annotation注解开发的电子商务网站demo”是一个很好的学习资源,可以帮助开发者加深对这些框架的理解并熟悉实际应用。 1. **Struts2.18**:Struts2是MVC(模型-视图-...

    Struts2+Spring2.5+Hibernate3+Freemarker整合

    整合S2SH+Freemarker,后台用Spring管理各个bean,Hibernate做数据库持久化,viewer用Freemarker。整合中对Struts2,Hibernate,Spring都采用Annotation进行注解类。

    java8+tomcat8+struts2.5+spring4.3+hibernate5.2框架搭建详细过程

    在搭建一个基于Java8 + Tomcat8 + Struts2.5 + Spring4.3 + Hibernate5.2 的项目前,首先需要对开发环境进行配置。 **1. Java8**: 作为项目的运行基础环境,确保已安装Java8,并正确设置JAVA_HOME等环境变量。 **2....

    MyEclipse8.6+Struts2.1+Spring3.0+Hibernate3.3环境搭建.doc

    本文档主要介绍了如何在MyEclipse 8.6环境中搭建一个基于Struts2.1、Spring3.0和Hibernate3.3的Java Web应用开发环境。以下是各个部分的详细说明: 1. 创建Web Project项目 在MyEclipse中创建Web Project是开始...

    Struts2+Spring2.5+Hibernate3+annotation 整合程序

    总之,"Struts2+Spring2.5+Hibernate3+annotation"的整合是Java Web开发中的经典组合,利用注解可以显著提升开发体验,减少配置文件的复杂性,使得项目结构更加清晰。如果你希望深入了解Java Web开发或者优化现有...

    struts+spring+hibernate三大框架整合

    SSH三大框架,即Struts、Spring和Hibernate,是Java Web开发中的常用技术组合,它们各自负责不同的职责:Struts作为MVC模式中的Controller层,处理用户请求并转发到相应的业务逻辑;Spring则作为核心容器,负责依赖...

    Struts2+Spring2.5+Hibernate3全注解实例详解

    超级详细的SSH2项目实例详解,并且附带两个项目详解。两种注解实现方式。...在JavaEE企业级开发中,以SSH2框架为核心的应用非常广,大象根据项目实践经验,通过二个实例,详细的为大家讲解如何实现全注解式的开发。

Global site tag (gtag.js) - Google Analytics