SSH 组建轻量级架构 (二) -- 构建步骤

Spring 整合托管 控制层、用户逻辑层及持久层    利用 Spring 整合托管各分层，能减少各框架间解耦所带来的开销，更好体现了 Spring的注入机制和面向切面编程带来的便利。

ps.虽然也可以通过
     static ApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml");
     EcAccountDAO dao = (EcAccountDAO)ctx.getBean("EcAccountDAO");
来单独注入，但是网站访问量大的时候，多个 ctx 实例会造成极大的开销，不推荐使用。

 

Spring + Hibernate 持久层 applicationContext.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: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.0.xsd 
       http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd 
       http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"> 


<!-- 支持事务标记的Bean定义 tx 标记要配合上面的 smlns:ts 和 xsi. 使用   -->
   <!-- tx:annotation-driven 检查Bean是否支持事务，当检查到DAO类时的 @Transactional 标注，就自动加入事务管理功能。 -->
   <!-- transaction-manager="transactionManager"   指明使用的是 transactionManager 这个 bean 中定义的事务管理器 -->
   <!-- proxy-target-class="true"，属性值指定 代理的DAO 是 接口 还是 类 ，true表示类，false或默认表示是接口 -->
   <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>  



<!--     1、利用 MyEclipse 创建 SessionFactory 的向导   -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation"
            value="classpath:hibernate.cfg.xml">
        </property>
    </bean>


<!--     2、生成基于 Spring Hibernate Template 的 DAO   -->
<!-- 持久层Bean -->
   <bean id="EcConsignmentDAO" class="springdao.EcConsignmentDAO">
       <property name="sessionFactory">
           <ref bean="sessionFactory" />
       </property>
   </bean>
   <bean id="EcReckoningDAO" class="springdao.EcReckoningDAO">
       <property name="sessionFactory">
           <ref bean="sessionFactory" />
       </property>
   </bean>


<!-- 声明一个 Hibernate 3 的 事务管理器供代理类自动管理事务用 --> 
   <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
      <property name="sessionFactory"> 
         <ref local="sessionFactory" /> 
      </property> 
   </bean>
   
</beans>

Spring + Hibernate xxxxDAO 类的注记
    import org.springframework.transaction.annotation.Transactional; 
 
    @Transactional 
    public class EcReckoningDAO extends HibernateDaoSupport { 
     
    ..

 

Spring + Biz 用户逻辑层 applicationContext.xml
<!-- 用户业务Bean -->
<bean id="ecAccountBiz" class="biz.EcAccountBiz">

    <!-- 注入持久层Bean -->
    <property name="ecAccountLevelDAO">
        <ref local="EcAccountLevelDAO"/>
    </property>
    <property name="ecAccountDAO">
        <ref local="EcAccountDAO"/>
    </property>
    <property name="ecAccountStatusDAO">
        <ref local="EcAccountStatusDAO"/>
    </property>
</bean>

用户逻辑层 xxxxBiz类
public class EcAccountBiz {    
    /**//* 定义属性 */
    private EcAccountDAO ecAccountDAO;
    private EcAccountLevelDAO ecAccountLevelDAO;
    private EcAccountStatusDAO ecAccountStatusDAO;
    
    /**//* getXXX() and setXXX() */
    

    
    /** *//**
     * 根据 Id 获得等级信息
     * @param levelId         等级ID
     * @return        等级信息
     */
    public EcAccountLevel getLevel(int levelId) {     
        List list = getEcAccountLevelDAO().findAll();
        EcAccountLevel level = null;        
        if (list.size() > 0) {
            level = (EcAccountLevel)list.get(0);
        }
        
        return level;
    }

 

Spring + Struts Action控制层 struts-config.xml
  <action-mappings >
    <action
      attribute="regAccountForm"
      input="/join/index.jsp"
      name="regAccountForm"
      path="/regAccount"
      scope="request"
      type="com.yourcompany.struts.action.RegAccountAction">
      <forward
      name="success"
      path="/join/regsuccess.jsp"
      redirect="true" />
      <forward name="fail" path="/join/index22.jsp" />
    </action>

   .

  <!-- 以下写于配置文件尾 -->

  <!-- 加入了 Spring 的代理请求处理器(需要写在message-resources上方？) -->
  <controller
        processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />

  <message-resources parameter="com.yourcompany.struts.ApplicationResources" /> 
  
  <!-- 插件方式 是加载 Spring    -->
  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml" />
  </plug-in> 

Struts 控制层 xxxxAction类
public class RegAccountAction extends Action {
    private EcAccountBiz ecAccountBiz;

    /** *//** property accessors */
    public EcAccountBiz getEcAccountBiz() {
        return ecAccountBiz;
    }

    public void setEcAccountBiz(EcAccountBiz ecAccountBiz) {
        this.ecAccountBiz = ecAccountBiz;
    }

public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response) throws IOException {
    ..

        EcAccountLevel level = getEcAccountBiz().getLevel(1);        
        EcAccountStatus status = getEcAccountBiz().getStatus(1);
    ..

Spring 配置文件 applicationContext.xml
<!--  Struts Action 类 -->
<bean name="/regAccount" 
    class="com.yourcompany.struts.action.RegAccountAction">
    
    <!-- 注入业务逻辑Bean -->
    <property name="ecAccountBiz">
        <ref local="ecAccountBiz"/>
    </property>
</bean>

 

---

---

---

旧版的分割线

前言：        SSH 框架优点是： Struts 易于使用，用户群广。Spring 可以很容易实现AOP，并大大降低各框架间的耦合度。Hibernate 使用简单，并可以通过session得到Connection使用 JDBC 提高性能。
        缺点是： 需要编写大量的配置文件。 
        建议： 会用，并理解就好，不必特意的为追求框架而框架。 
        添加顺序： Struts --> Spring --> Hibernate
ps. 
        Spring 的开发大部分情况下就是编写 XML 配置文件来组织各种各样的 Bean和切面。将程序个部分 软连接 起来，通过使用注释或者 XML 配置文件方式，程序运行的时候 Spring 能够“按需”创建或者初始化所有的对象关系。(不要要重新编译程序，鼓励使用模块化的架构来维护应用)
            ++1、动态注入 Bean的值，号称不用编程赋值，用 XML 文件可以解决一切赋值语句。
ps2. 内容均来自 刘长炯 先生的《MyEclipse 6 Java 开发中文教程》一书，具体请访问 http://www.blogjava.net/beansoft/

 

Spring 整合 Hibernate        提供了调用类和事务管理功能，最实用的是支持自动事务管理功能(在方法前开始事务，在方法执行后提交，这就是 Spring 用 AOP 实现的自动事务代理功能)。
ps.我们需要做的是：
    1、利用 MyEclipse 创建 SessionFactory 的向导，
    2、以及在 Hibernate+Spring 反向工程的时候生成基于 Spring Hibernate Template 的 DAO，
    3、对生成的代码稍作修改（如自动提交事务问题），满足开发的需要即可。
大多数情况项目还不需要到精确控制事务 API。

A、类的调用
Spring 配置文件 applicationContext.xml
<!--     1、利用 MyEclipse 创建 SessionFactory 的向导   -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation"
            value="classpath:hibernate.cfg.xml">
        </property>
    </bean>


<!--     2、生成基于 Spring Hibernate Template 的 DAO   -->
   <bean id="EcConsignmentDAO" class="springdao.EcConsignmentDAO">
       <property name="sessionFactory">
           <ref bean="sessionFactory" />
       </property>
   </bean>
   <bean id="EcReckoningDAO" class="springdao.EcReckoningDAO">
       <property name="sessionFactory">
           <ref bean="sessionFactory" />
       </property>
   </bean>

B、用Spring 2.0 的 @Transactional 标注解决事务提交问题
    1、DAO 类加入标注，其开头部分的代码如下所示： 

    import org.springframework.transaction.annotation.Transactional; 
 
    @Transactional 
    public class StudentDAO extends HibernateDaoSupport { 
     

    2、修改 Spring 配置文件 applicationContext.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: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.0.xsd 
       http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd 
       http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"> 


<!-- 支持事务标记的Bean定义 tx 标记要配合上面的 smlns:ts 和 xsi. 使用   -->
   <!-- tx:annotation-driven 检查Bean是否支持事务，当检查到DAO类时的 @Transactional 标注，就自动加入事务管理功能。 -->
   <!-- transaction-manager="transactionManager"   指明使用的是 transactionManager 这个 bean 中定义的事务管理器 -->
   <!-- proxy-target-class="true"，属性值指定 代理的DAO 是 接口 还是 类 ，true表示类，false或默认表示是接口 -->
   <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>  

..

<!-- 声明一个 Hibernate 3 的 事务管理器供代理类自动管理事务用 --> 
   <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
      <property name="sessionFactory"> 
         <ref local="sessionFactory" /> 
      </property> 
   </bean>
   
</beans>

C、测试类
public static void main(String[] args) { 
      ApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml"); 
 
      StudentDAO dao = (StudentDAO)ctx.getBean("StudentDAO"); 
       
      Student user  = new Student(); 
      user.setPassword("密码"); 
      user.setUsername("spring 2 标注事务代理测试"); 
      user.setAge(200); 
       
      dao.save(user); 


/**//*    //原始 Hibernate ，需要手动加入事务功能，并控制会话的开关
      StudentDAO dao = new StudentDAO(); 
      Transaction tran = dao.getSession().beginTransaction(); 

      Student bean = new Student(); 
      bean.setUsername("张三"); 
      bean.setPassword("1234"); 
      bean.setAge(100); 

      dao.save(bean); 
      tran.commit(); 
      dao.getSession().close(); 
*/

}

    最简单的事务处理办法，可以最大化的利用 JDK 5 的标注功能并大大减少编码的难度。 

Spring 整合 Struts    通过修改配置文件实现在 Spring 管理下的 strutsAction。
    具体整合步骤： （薄膜，接口？）
    1、Struts 配置文件(插件或者其他形式) 载入Spring配置文件
    2、Struts 配置文件中每个Action 引用 Spring 总实现类 DelegatingActionProxy
    3、Spring配置文件中配置被替换的 StuctsBean

A、Struts 配置文件(struts-config.xml) 插件形式载入Spring配置文件
在 XML 文件尾加入：
    <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml" />
    </plug-in>

B、Struts 配置文件(struts-config.xml)里 Action 的 Type 用Spring 接口替换
    <action 
    path="/getGallery" 
    type="org.springframework.web.struts.DelegatingActionProxy">
      <forward name="returnGallery" path="/my/gallery.jsp" />
    </action>

C、Spring 配置文件中配置被替换的 StrutsBean   
    通过对 Struts.action.path 和 Spring.bean.name 的 name 进行匹配, 实现软接口和AOP的准备
    <bean 
    name="/getGallery" 
    class="com.yourcompany.struts.action.GetGalleryAction">
    </bean>

转载于:https://www.cnblogs.com/kiant71/archive/2008/09/06/1752073.html