Spring+Hibernate+Struts(SSH)框架整合

SSH框架整合

　　前言：有人說，現在還是流行主流框架，SSM都出來很久了，更不要說SSH。我不以為然。現在許多公司所用的老項目還是ssh，如果改成主流框架，需要成本。再說比如金融IT這一塊，數據庫dao層還是推薦使用的是hibernate，因為能夠快速開發上手，除非是互聯網，因涉及到高並發，dao層用的是mybatis，數據交互效率較快。所以，SSH不容忽略。

一、什么是SSH

　　SSH是 struts+spring+hibernate的一個集成框架，是目前比較流行的一種Web應用程序開源框架。

集成SSH框架的系統從職責上分為四層：表示層、業務邏輯層、數據持久層和域模塊層，以幫助開發人員在短期內搭建結構清晰、可復用性好、維護方便的Web應用程序。其中使用Struts作為系統的整體基礎架構，負責MVC的分離，在Struts框架的模型部分，控制業務跳轉，利用Hibernate框架對持久層提供支持，Spring做管理，管理struts和hibernate。具體做法是：用面向對象的分析方法根據需求提出一些模型，將這些模型實現為基本的Java對象，然后編寫基本的DAO(Data Access Objects)接口，並給出Hibernate的DAO實現，采用Hibernate架構實現的DAO類來實現Java類與數據庫之間的轉換和訪問，最后由Spring做管理，管理struts和hibernate。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

---------百度百科

二、SSH所涉及的部分

　　

　　

三、快速部署環境

這里利用保存客戶的小Demo來演示整合SSH

　　1.導入所需jar包　

 　　1）. Struts2框架

         * struts-2.3.24\apps\struts2-blank\WEB-INF\lib\*.jar        -- Struts2需要的所有jar包

        * struts2-spring-plugin-2.3.24.jar                          ---Struts2整合Spring的插件包

 

 

　　2）. Hibernate框架

    * hibernate-release-5.0.7.Final\lib\required\*.jar          -- Hibernate框架需要的jar包

    * slf4j-api-1.6.1.jar                                       -- 日志接口

    * slf4j-log4j12-1.7.2.jar                                   -- 日志實現

    * mysql-connector-java-5.1.7-bin.jar                        -- MySQL的驅動包

 

 

　　3）. Spring框架

    * IOC核心包

    * AOP核心包

    * JDBC模板和事務核心包

    * Spring整合JUnit測試包

    * Spring整合Hibernate核心包

    * Spring整合Struts2核心包

 

　　2、在web.xml中配置spring與struts的相關代碼

　　1）配置struts2核心過濾器

　　這里定義為攔截所有

 <!-- 配置核心過濾器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
</filter-mapping>

　　2）配置spring的監聽器

　　當服務啟動時，就會先加載spring的配置文件

 <!-- 配置Spring框架整合WEB的監聽器 -->
     <listener>
           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

　　3）配置默認加載路徑

 <!-- 監聽器默認加載Web-INF文件下，需要配置參數來加載指定文件 -->
    <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext.xml</param-value>
</context-param>

　　總結：web.xml全部代碼為

<!-- 配置Spring框架整合WEB的監聽器 -->
     <listener>
           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 監聽器默認加載Web-INF文件下，需要配置參數來加載指定文件 -->
    <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
  <!-- 配置核心過濾器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

　　2、src下編寫相關配置文件

　　1)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: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.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
</beans>

　　2）hibernate:hibernate.cfg.xml

　　導入相關約束，並配置數據庫

　　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    
    <session-factory>
        <!-- 必須配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://192.168.174.130:3306/SSH</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        
        <!-- 可選配置 -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        
        <!-- 配置C3P0的連接池 -->
        <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        
        <!-- 不能配置綁定當前的線程的操作 -->
        <!-- 映射配置文件 -->
        <mapping resource="com/clj/domain/Customer.hbm.xml"/>
    </session-factory>
    
</hibernate-configuration>    

　　3）配置log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

　　4)struts2:struts.xml

　　導入相關約束

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
</struts>

　　總結：src所需配置文件如圖

　　

　　3、配置dao層

　　定義一個接口和其實現類

public interface CustomerDao {
    public void save(Customer customer);
}

public class CustomerDaoImpl  implements CustomerDao {
    public void save(Customer customer) {
        
    }

}

　　4、定義業務層接口和實現類

package com.clj.service;

import com.clj.domain.Customer;

public interface CustomerService {
    public void save(Customer customer);
}

package com.clj.service;

import org.springframework.transaction.annotation.Transactional;

import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
 * 客戶的業務層
 * @author Administrator
 *
 */
public class CustomerServiceImpl implements CustomerService{//用來保存客戶
    public void save(Customer customer) {
     
    }

}

　　5、定義pojo類

　　hibernate通過操作pojo類來操作數據庫表，做到對象關系映射

package com.clj.domain;

public class Customer {
    
    private Long cust_id;
    private String cust_name;
    private Long cust_user_id;
    private Long cust_create_id;
    private String cust_source;
    private String cust_industry;
    private String cust_level;
    private String cust_linkman;
    private String cust_phone;
    private String cust_mobile;
    
    public Long getCust_id() {
        return cust_id;
    }
    public void setCust_id(Long cust_id) {
        this.cust_id = cust_id;
    }
    public String getCust_name() {
        return cust_name;
    }
    public void setCust_name(String cust_name) {
        this.cust_name = cust_name;
    }
    public Long getCust_user_id() {
        return cust_user_id;
    }
    public void setCust_user_id(Long cust_user_id) {
        this.cust_user_id = cust_user_id;
    }
    public Long getCust_create_id() {
        return cust_create_id;
    }
    public void setCust_create_id(Long cust_create_id) {
        this.cust_create_id = cust_create_id;
    }
    public String getCust_source() {
        return cust_source;
    }
    public void setCust_source(String cust_source) {
        this.cust_source = cust_source;
    }
    public String getCust_industry() {
        return cust_industry;
    }
    public void setCust_industry(String cust_industry) {
        this.cust_industry = cust_industry;
    }
    public String getCust_level() {
        return cust_level;
    }
    public void setCust_level(String cust_level) {
        this.cust_level = cust_level;
    }
    public String getCust_linkman() {
        return cust_linkman;
    }
    public void setCust_linkman(String cust_linkman) {
        this.cust_linkman = cust_linkman;
    }
    public String getCust_phone() {
        return cust_phone;
    }
    public void setCust_phone(String cust_phone) {
        this.cust_phone = cust_phone;
    }
    public String getCust_mobile() {
        return cust_mobile;
    }
    public void setCust_mobile(String cust_mobile) {
        this.cust_mobile = cust_mobile;
    }
    @Override
    public String toString() {
        return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name
                + ", cust_user_id=" + cust_user_id + ", cust_create_id="
                + cust_create_id + ", cust_source=" + cust_source
                + ", cust_industry=" + cust_industry + ", cust_level="
                + cust_level + ", cust_linkman=" + cust_linkman
                + ", cust_phone=" + cust_phone + ", cust_mobile=" + cust_mobile
                + "]";
    }
    
}

　　6、定義Customer.hbm.xml

　　此配置文件關乎Customer這個pojo類，此文件需放在Customer pojo類同個包下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
<hibernate-mapping>
    
    <class name="com.clj.domain.Customer" table="cst_customer">
        <id name="cust_id" column="cust_id">
            <generator class="native"/>
        </id>
        
        <property name="cust_name" column="cust_name"/>
        <property name="cust_user_id" column="cust_user_id"/>
        <property name="cust_create_id" column="cust_create_id"/>
        <property name="cust_source" column="cust_source"/>
        <property name="cust_industry" column="cust_industry"/>
        <property name="cust_level" column="cust_level"/>
        <property name="cust_linkman" column="cust_linkman"/>
        <property name="cust_phone" column="cust_phone"/>
        <property name="cust_mobile" column="cust_mobile"/>
        
    </class>
    
</hibernate-mapping>    

　　項目構建大致圖

　　

 

四、demo之保存客戶初步演示

　　這里先初略的定義持久層交給heibernate，業務層交個struts2，創建實例交給spring

　　1、定義一個保存客戶的界面，利用form表單進行數據的提交

　　根據域名可知，這里利用的是struts2的通配符方式進行訪問

<FORM id=form1 name=form1
        action="${pageContext.request.contextPath }/customer_add.action"
        method=post>
           <!--table部分省略-->
</FORM>

　　2、在struts.xml中配置接受請求，根據action名和方法跳轉指定的action，執行指定的方法

　　spring整合struts2方式一：action由struts2框架管理

　　 * 因為導入的struts2-spring-plugin-2.3.24.jar 包自帶一個配置文件 struts-plugin.xml ，該配置文件中有如下代碼

        * <constant name="struts.objectFactory" value="spring" />   開啟一個常量，如果該常量開啟，那么下面的常量就可以使用

        * struts.objectFactory.spring.autoWire = name，該常量是可以讓Action的類來自動裝配Bean對象！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 配置包結構 -->
        <package name="crm" extends="struts-default" namespace="/">
            <!-- 配置客戶的Action -->
            <!--  方式一：aciton由struts2框架管理-->

　　　　　　<action name="customer_*" class="com.clj.web.action.CustomerAction" method="{1}"/> 
　　　　</package>
 </struts>

　　3、在spring的applicationContext.xml中配置相對應的bean以及事務

　　     這里利用spring中IOC(控制反轉)的特性，將創建實例的任務交給spring框架管理

    <bean id="customerService" class="com.clj.service.CustomerServiceImpl">
        <property name="customerDao" ref="customerDao"></property>
    </bean>
    <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl">
        <property name="hibernateTemplate" ref="hibernateTemplate"/>
    </bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <!-- 注入sessionFactory  -->
        <property name="sessionFactory"/>
    </bean>
</beans>

　　4、編寫持久層實現類相關代碼

　　這里利用hibernate提供的模板類，內部封轉了session，從而可以調用session中的方法

/**
 * 持久層
 * 
 * @author Administrator
 *
 */
public class CustomerDaoImpl  implements CustomerDao {
    //將數據保存到數據庫中(調用模板類(hibernate提供，內部封裝了session))
    private HibernateTemplate hibernateTemplate;
    
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    /**
     * 保存客戶
     */
    public void save(Customer customer) {
        System.out.println("持久層：保存客戶");
        hibernateTemplate().save(customer);
    }

}

　　5、編寫業務層實現類相關代碼

package com.clj.service;

import org.springframework.transaction.annotation.Transactional;

import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
 * 客戶的業務層
 * @author Administrator
 *
 */
@Transactional
public class CustomerServiceImpl implements CustomerService{
    private CustomerDao customerDao;
    
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }

    //用來保存客戶
    public void save(Customer customer) {
        System.out.println("業務層，保存客戶");
        customerDao.save(customer);
    }

}

　　6、編寫action相關代碼

　　這里通過struts2的模板類

package com.clj.web.action;

import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

/**
 * 客戶的控制層
 * @author Administrator
 *
 */
public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
    //不要忘記手動new
    private Customer customer=new Customer();
    public Customer getModel() {
        return customer;
    }
    //提供service成員屬性，提供set方法
    private CustomerService customerService;
    
    

    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }



    /**
     * 保存客戶
     * @return
     */
    public String add(){
        System.out.println("WEB層，保存客戶");
        //方式一：創建web的工廠（action由struts2創建）
        WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
        CustomerService cs=(CustomerService) context.getBean("customerService");
        //調用方法
        cs.save(customer);return NONE;
    }

    
}

五、項目優化之整合

　　1、 spring整合struts2方式二：action由spring框架管理

　　把具體的Action類配置文件applicatonContext.xml的配置文件中，但是注意：struts.xml需要做修改

<struts>
    <!-- 配置包結構 -->
        <package name="crm" extends="struts-default" namespace="/">
            <!-- 配置客戶的Action -->
            <!--  方式一：aciton由struts2框架管理
            <action name="customer_*" class="com.clj.web.action.CustomerAction" method="{1}"/>-->
            <!-- 方式二：action由spring管理，class標簽上只需要編寫srping配置bean的ID值既可以-->
             <action name="customer_*" class="customerAction" method="{1}"></action>
        </package>
</struts>

　　2、在applicationContext.xml中配置Action類

　　　注意：1）Spring框架默認生成CustomerAction是單例的，而Struts2框架是多例的。所以需要配置 scope="prototype"

　　　　　　2）此時沒有struts2的自動裝配，在action需要手動配置customerService屬性，並在action類中生成set方法

<!-- 配置客戶模塊 -->
    <!-- 強調：配置的Aciton,必須是多列的 -->
    <bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype">
        <!--注意：struts管理action時，基於其中有個struts-plugin的jar包，其中更改了一個
        常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法
        但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入
        -->
        <property name="customerService" ref="customerService"></property>
</bean>

　　3、.配置事務

　　 spring整合hibernate方式一：（帶有hibernate.cfg.xml的配置文件。強調：不能加綁定當前線程的配置）

　　以前玩hibernate時，hibernate.cfg.xml都是由hibernate框架管理，其配置文件能生成sessionFactory,持久層加載此配置文件獲取sessionFactory，從而創建工廠生成session，進行數據的增刪改成，此時其配置文件應該交給spring管理，充分利用spring的IOC特性

　　

　　Spring框架提供了一個HibernateDaoSupport的工具類，以后DAO都可以繼承該類！！在引入hibernate核心配置文件之前，得讓dao層繼承一個父類HibernateDaoSupport，此父類內部封裝了事務模板

　　看源碼：

　　1）修改相對應的持久層實現類，讓他繼承HibernateDaoSupport

package com.clj.dao;

import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.clj.domain.Customer;
/**
 * 持久層
 * 繼承HibernateDaoSupport，內部封裝了HibernateTemplate
 * @author Administrator
 *
 */
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    //將數據保存到數據庫中(調用模板類(hibernate提供，內部封裝了session))
    /*private HibernateTemplate hibernateTemplate;
    
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }*/

    /**
     * 保存客戶
     */
    public void save(Customer customer) {
        System.out.println("持久層：保存客戶");
        this.getHibernateTemplate().save(customer);
    }

}

　　2）修改業務層讓，開啟事務注解

package com.clj.service;

import org.springframework.transaction.annotation.Transactional;

import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
 * 客戶的業務層
 * @author Administrator
 *
 */
@Transactional
public class CustomerServiceImpl implements CustomerService{
    private CustomerDao customerDao;
    
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }

    //用來保存客戶
    public void save(Customer customer) {
        System.out.println("業務層，保存客戶");
        customerDao.save(customer);
    }

}

 

　　3）修改applicationContext.xml文件

　　先引入hibernate配置文件

<!-- 編寫bean,名稱都是固定的，由spring提供，用來加載hibernate.cfg.xml的配置文件-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 配置路徑：當啟動服務器時 ，該對象就會被創建，從而加載hibernate.cfg.xml文件，從而生成sessionFactory對象-->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>

　　配置平台事務管理：用來管理事務，注意現在使用的是Hibernate框架，所以需要使用Hibernate框架的事務管理器

<!-- 先配置平台事務管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入事務，session能夠管理事務，工廠能夠創建session -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

　　開啟事務注解

　　<!-- 開啟事務的注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

 　　去除模板類配置，並為持久層配置sessionFactory

<!-- 以后，Dao都需要繼承HibernateDaoSupport，注入sessionFactory -->
    <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl">
        <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
        <!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)-->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

　　全部代碼如下

<?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.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 編寫bean,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <!-- 配置路徑：當啟動服務器時 ，該對象就會被創建，從而加載hibernate.cfg.xml文件，從而生成sessionFactory對象-->
        <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
    </bean>
    
    <!-- 先配置平台事務管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入事務，session能夠管理事務，工廠能夠創建session -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <!-- 開啟事務的注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <!-- 配置客戶模塊 -->
    <!-- 強調：配置的Aciton,必須是多列的 -->
    <bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype">
        <!--注意：struts管理action時，基於其中有個struts-plugin的jar包，其中更改了一個
        常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法
        但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入
        -->
        <property name="customerService" ref="customerService"></property>
    </bean>
    <bean id="customerService" class="com.clj.service.CustomerServiceImpl">
        <property name="customerDao" ref="customerDao"></property>
    </bean>
    <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl">
        <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
        <!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)-->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 配置模板類(hibernate框架提供的，內部封裝了session)，此時交給spring管理,如果持久層繼承了HibernateDaoSupport，則無需配置-->
    <!-- <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        注入sessionFactory 
        <property name="sessionFactory"/>
    </bean>-->
</beans>

 　　4）修改action類

　　　　因為注入了業務層實現類，所以此時可以直接調用業務層方法，無須加載bean

　　

package com.clj.web.action;

import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;

/**
 * 客戶的控制層
 * @author Administrator
 *
 */
public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
    //不要忘記手動new
    private Customer customer=new Customer();
    public Customer getModel() {
        return customer;
    }
    //提供service成員屬性，提供set方法
    private CustomerService customerService;
    public void setCustomerService(CustomerService customerService) {
        this.customerService = customerService;
    }
    /**
     * 保存客戶
     * @return
     */
    public String add(){
        System.out.println("WEB層，保存客戶");
        //方式一：創建web的工廠（action由struts2創建）
        /*WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
        CustomerService cs=(CustomerService) context.getBean("customerService");
        //調用方法
        cs.save(customer);*/
        customerService.save(customer);
        return NONE;
    }
}

　　spring整合hibernate方式二：（不帶有hibernate.cfg.xml的配置文件）

　　這里准備刪除hibernate的核心配置文件，在刪除之前，需要將其配置文件中的相關內容配置到spring的applicatioinContext.xml文件中取

　　1、查看hibernate.cfg.xml文件中的相關內容

  　　  * 數據庫連接基本參數（4大參數）

   　　 * Hibernate相關的屬性

   　　 * 連接池

    　　* 映射文件

　　2、引入配置

　　引入連接池

<!-- 先配置C3p0的連接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

　　修改對應的sessionFactory:因為已經沒有了hibernate.cfg.xml的配置文件，所以需要修改該配置，注入連接池

　　引入對象映射文件：因為已經沒有了hibernate.cfg.xml的配置文件，不會掃描到該配置文件，需要注入

    <!-- 編寫bean,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!--先加載連接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 加載方言，加載可選項 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        
        <!-- 引入映射的配置文件 -->
        <property name="mappingResources">
            <list>
                <value>com/clj/domain/Customer.hbm.xml</value>
            </list>
        
        </property>
    </bean>

　　現在：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: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.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    <!-- 先配置C3p0的連接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
    
    <!-- 編寫bean,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!--先加載連接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 加載方言，加載可選項 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        
        <!-- 引入映射的配置文件 -->
        <property name="mappingResources">
            <list>
                <value>com/clj/domain/Customer.hbm.xml</value>
            </list>
        
        </property>
    </bean>
    
    <!-- 先配置平台事務管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入事務，session能夠管理事務，工廠能夠創建session -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <!-- 開啟事務的注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    
    <!-- 配置客戶模塊 -->
    <!-- 強調：配置的Aciton,必須是多列的 -->
    <bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype">
        <!--注意：struts管理action時，基於其中有個struts-plugin的jar包，其中更改了一個
        常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法
        但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入
        -->
        <property name="customerService" ref="customerService"></property>
    </bean>
    <bean id="customerService" class="com.clj.service.CustomerServiceImpl">
        <property name="customerDao" ref="customerDao"></property>
    </bean>
    <!-- 以后，Dao都需要繼承HibernateDaoSupport，注入sessionFactory -->
    <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl">
        <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
        <!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)-->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 配置模板類(hibernate框架提供的，內部封裝了session)，此時交給spring管理,如果持久層繼承了HibernateDaoSupport，則無需配置-->
    <!-- <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        注入sessionFactory 
        <property name="sessionFactory"/>
    </bean>-->
</beans>

　　此時可以安心的刪除hibernate.cfg.xml文件了

　　這樣SSH整合完畢

六、Hibernate模板常用方法

　　注意：以下代碼省略了接口中的演示(偷了個懶，相信初學者不會看不懂)

　　1）插入：

　　持久層

package com.clj.dao;

import java.util.List;

import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.clj.domain.Customer;
/**
 * 持久層
 * 繼承HibernateDaoSupport，內部封裝了HibernateTemplate
 * @author Administrator
 *
 */
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    @Override
    public void update(Customer customer) {
        // TODO Auto-generated method stub
        this.getHibernateTemplate().update(customer);
    }
}

　　業務層

package com.clj.service;

import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
 * 客戶的業務層
 * @author Administrator
 *
 */
@Transactional
public class CustomerServiceImpl implements CustomerService{
    private CustomerDao customerDao;
    
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }
 @Override
    public void update(Customer customer) {
        // TODO Auto-generated method stub
        customerDao.update(customer);
    }
}

　　測試類

package com.clj.test;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.clj.domain.Customer;
import com.clj.service.CustomerService;

/**
 * 測試Hiberante模板類的簡單方法
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
    @Resource(name="customerService")
    private CustomerService customerService;
    /**
     * 測試插入
     */
    @Test
    public void run1(){
        Customer customer=new Customer();
        customer.setCust_id(1L);
        customer.setCust_name("測試");
        customerService.update(customer);
    }
    
}

　　2）以下為指定查詢、查詢所有、離線查詢代碼

　　持久層

package com.clj.dao;

import java.util.List;

import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.clj.domain.Customer;
/**
 * 持久層
 * 繼承HibernateDaoSupport，內部封裝了HibernateTemplate
 * @author Administrator
 *
 */
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
    //將數據保存到數據庫中(調用模板類(hibernate提供，內部封裝了session))
    /*private HibernateTemplate hibernateTemplate;
    
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }*/

    /**
     * 保存客戶
     */
    public void save(Customer customer) {
        System.out.println("持久層：保存客戶");
        this.getHibernateTemplate().save(customer);
    }

    @Override
    public void update(Customer customer) {
        // TODO Auto-generated method stub
        this.getHibernateTemplate().update(customer);
    }

    /**
     * 通過主鍵查詢
     */
    public Customer getById(Long id) {
        return this.getHibernateTemplate().get(Customer.class, id);
    }
    /**
     * 查詢所有
     */
    @Override
    public List<Customer> findAll() {
        String sql="from Customer";
        List<Customer> list=(List<Customer>) this.getHibernateTemplate().find(sql);
        return list;
    }
    /**
     * QBC離線查詢
     */
    @Override
    public List<Customer> findAllByQBC() {
        DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class);
        List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria);
        return list;
    }
}

　　業務層

package com.clj.service;

import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
 * 客戶的業務層
 * @author Administrator
 *
 */
@Transactional
public class CustomerServiceImpl implements CustomerService{
    private CustomerDao customerDao;
    
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }

    //用來保存客戶
    public void save(Customer customer) {
        System.out.println("業務層，保存客戶");
        customerDao.save(customer);
    }

    @Override
    public void update(Customer customer) {
        // TODO Auto-generated method stub
        customerDao.update(customer);
    }

    @Override
    public Customer getById(Long id) {
        // TODO Auto-generated method stub
        return customerDao.getById(id);
    }

    @Override
    public List<Customer> findAll() {
        return customerDao.findAll();
    }

    @Override
    public List<Customer> findAllByQBC() {
        // TODO Auto-generated method stub
        return customerDao.findAllByQBC();
    }
}

　　測試類

package com.clj.test;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.clj.domain.Customer;
import com.clj.service.CustomerService;

/**
 * 測試Hiberante模板類的簡單方法
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
    @Resource(name="customerService")
    private CustomerService customerService;
    /**
     * 測試插入
     */
    @Test
    public void run1(){
        Customer customer=new Customer();
        customer.setCust_id(1L);
        customer.setCust_name("測試");
        customerService.update(customer);
    }
    /**
     * 測試查詢指定的客戶
     */
    @Test
    public void run2(){
        Customer customer=customerService.getById(2L);
        System.out.println(customer);
    }
    /**
     * 查詢所有的客戶
     */
    @Test
    public void run3(){
        List<Customer> list=customerService.findAll();
        System.out.println(list);
    }
    /**
     * QBC(離線查詢)
     */
    @Test
    public void run4(){
        List<Customer> list=customerService.findAllByQBC();
        System.out.println(list);
    }
}

七、關於SSH延遲加載問題

　1. 使用延遲加載的時候，再WEB層查詢對象的時候程序會拋出異常！

    * 原因是延遲加載還沒有發生SQL語句，在業務層session對象就已經銷毀了，所以查詢到的JavaBean對象已經變成了托管態對象！

    * 注意：一定要先刪除javassist-3.11.0.GA.jar包（jar包沖突了）

 

　2. 解決辦法

　Spring框架提供了一個過濾器，讓session對象在WEB層就創建，在WEB層銷毀。只需要配置該過濾器即可

    * 但是：要注意需要在struts2的核心過濾器之前進行，spring監聽器之后配置

<!-- 解決延遲加載的問題 -->
         <filter>
            <filter-name>OpenSessionInViewFilter</filter-name>
            <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>OpenSessionInViewFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

　　3、演示延遲加載

　　持久層：調用load方法，此方法時延遲加載的

/**
     * 延遲加載
     */
    @Override
    public Customer loadById(long id) {
        // TODO Auto-generated method stub
        return this.getHibernateTemplate().load(Customer.class, id);
    }

　　業務層

@Override
    public Customer loadById(long id) {
        // TODO Auto-generated method stub
        return customerDao.loadById(id);
    }

　　測試類

@Test
    public void run5(){
        Customer customer=customerService.loadById(2L);
        System.out.println(customer);
    }