ssh整合，指的是Spring，hibernate，struts2 这3个框架结合一起，整合hibernate的时候，主要利用的是hibernate自身的持久层实现，而不是使用hibernate对JPA的实现方式。用ssh做crud的总思路如下

使用hibernate
- 可以不需要创建hibernate.cfg.xml文件，因为applicationContext文件已经配置好了
- 创建映射文件，并配置在applicationContext文件中
使用spring
- 创建applicationContext.xml文件
- 配置datasource，以便让项目使用数据库连接池功能
- 配置LocalSessionFactoryBean，以便创建SessionFactory对象
- 配置事务管理器，HibernateTransactionManager
- 配置事务环绕通知，以便给服务层的方法增加事务环绕功能
- 配置切面，以便真正创建代理，完成事务通知的织入
使用struts
- 创建struts.xml文件放置在类路径下
- 在里面正常的配置action，除了class属性的值设为bean的名字以外。

整合hibernate：
- 总目标是把SessionFactory，注入到dao类中。
- 并且开启事务支持（针对服务层）后，dao类的代码编写就可以省略掉事务方面的代码，以简化dao的编写。
- 在dao中利用的是Hibernate原生的接口类型（SessionFactory，Session这也是官方推荐的用法）
- 利用session.getCurrentSession,以便服务类调用多个dao时，每一个dao得到的是同一个session对象，也就是同一个Connection对象，这样才能保证事务。并且不需要手动的调用session.close方法来关闭。事务提交时会自动关闭连接
整合struts2
- 添加ContextLoaderListener以便创建一个Spring容器对象（ApplicationContex实例）
- 在struts.xml文件中配置action的class属性时，其值是spring配置文件中的bean的名字
- 利用struts-spring插件，改变默认struts框架实例化Action（也就是控制器类型）的默认规则，改由先从spring容器中取（容器对象已经由监听器创建出来了），取不到就按照原本的规则实例化Action类型
做CRUD
- 编写dao
- 编写service
- 编写控制器
- 配置struts.xml文件
- 配置applicationContext文件

创建Maven项目

正常的maven项目创建，创建好了之后，在pom文件中对插件进行设置

<build>
        <plugins>
          <!--用于设定源代码文件的编码，以及项目代码运行的目标jdk版本为1.8 -->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
<!-- 指定项目中web资源的根目录，用于maven打包时把此目录的所有内容拷贝到war中-->
            <plugin>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <warSourceDirectory>web</warSourceDirectory>
                </configuration>
            </plugin>
        </plugins>
    </build>

添加构面

这里完全可以不用做，主要是充分利用Idea开发工具的支持，以便方便我们后面的代码编写，文件配置等功能,主要添加下面几个构面

spring
hibernate
web
struts

使用Spring

这里主要指的是spring的基本使用，主要包含以下几个方面

添加基本的maven依赖
添加applicationContext.xml文件
把applicationContext.xml文件交给idea管理

添加spring的基本依赖

基本功能指的是Spring的容器管理，依赖注入，AOP功能

        <!-- 这个依赖可以让spring容器有bean管理，依赖注入，基本的切面配置功能，但不支持切点表达式以及其解析-->   
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
<!-- 让spring支持切点表达式功能--> 
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

创建spring配置文件

此文件一般命名为applicationContext.xml，如果名字这样命名，并且此文件放置在WEB-INF下面，那么后续使用ContextLoaderListener的时候，就不需要配置Context-param的contextConfigLocation值以指定Spring配置文件的位置了。

此时此刻，spring文件暂不配置任何内容。

Hibernate的基本使用

包含以下任务

添加hibernate的相关依赖
创建hibernate.cfg.xml文件
创建实体类
创建实体类的映射文件

Hibernate的依赖

不与spring整合，也不使用连接池的话，使用hibernate只需要下面的依赖即可

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.2.10.Final</version>
        </dependency

创建hibernate.cfg.xml文件

单独使用hibernate时，一般会创建这个文件，但与spring整合，这个文件是可以删掉的，因为配置信息都放在了applicationContext文件里面了。此文件的主要目标有3个

设定连接到的数据库
1. 驱动类名
2. url
3. username
4. password
设定hibernate特定的设置，比如开发时可能设置下面几项，生成环境就配置方言即可
1. 方言（dialect）
2. 显示sql
3. 格式化显示的sql语句
设置实体的映射文件，以便让Hibernate知道，要处理那些实体

上面的3个方面的配置，可以用一句话表示（或者记忆）：让此实体用数据库特定的sql语句保存到数据库或从数据库中读取数据到实体中 这句话也说明了Hibernate的本质：一个持久层的框架。

创建实体类

正常的POJO bean规范的要求编写，推荐用包装类型，比如下面

public class CategoryEntity {
    private int id;
    private String cname;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }
}

编写实体类的映射文件

    <class name="com.entity.CategoryEntity" table="category" schema="dbo" catalog="demo">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="cname" column="cname"/>
    </class>

struts2 的基本使用

包含以下几个任务

把项目转换为web项目
设置项目的包为war
添加相关依赖
创建struts.xml文件
在web.xml中配置struts2 的过滤器

struts web 项目设定

给项目添加web构面支持，并在pom文件中设定包为war包

<packaging>war</packaging>

添加struts基本依赖

        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.5.12</version>
        </dependency>

创建struts.xml文件

此文件一般名字为struts.xml文件，并放置在类路径下面，如果不这样命名，并且位置不是直接在类路径下面，需要给StrutsPrepareAndExecuteFilter 过滤器添加参数，以指定此文件。

设定struts的过滤器

此过滤器设置之后才能真正使用struts框架，url-pattern的配置，官方推荐的标准值为/*

<filter>
  <filter-name>struts2</filter-name>
  <filter-lass>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Spring 与Hibernate的整合

主要的任务有：

添加依赖
配置SessionFactory对象创建的工厂bean
配置事务

添加依赖

<!-- 这是一个数据库驱动的依赖 -->
<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>6.2.1.jre8</version>
</dependency>
<!-- 这个依赖是spring专门用来与其他持久层框架进行整合用的一个依赖
    里面有LocalSessionFactoryBean类型
-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

<!-- 此依赖有事务方面的通知，事务管理器等 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<!-- 这是dbcp连接池依赖，完全可以换别的连接池组件-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.2.0</version>
</dependency>

配置SessionFactory的创建

sessionFactory的配置，一般会利用连接池组件，所以配置SessionFactory主要就是配置连接池以及LocalSessionFactoryBean

设定数据库配置的properties文件

url=jdbc:sqlserver://localhost\.:1433;database=demo
driverclass=com.microsoft.sqlserver.jdbc.SQLServerDriver
username=sa
password

在applicationContext使用properties文件,local-override表示本地的设定优先，而不是让整个程序运行过程中的一些环境变量优先。

<context:property-placeholder location="classpath:db.properties" local-override="true"/>

配置连接池

    <context:property-placeholder location="classpath:db.properties" local-override="true"/>
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
      <!-- 配置驱动类，值来自于properties文件 -->
        <property name="driverClassName" value="${driverclass}"></property>
         <!-- 配置数据库的连接字符串，值来自于properties文件 -->
        <property name="url" value="${url}"></property>
         <!-- 配置连接到数据库的用户名，值来自于properties文件 -->
        <property name="username" value="${username}"></property>
               <!-- 配置连接到数据库的密码，值来自于properties文件 -->
        <property name="password" value="${password}"></property>

         <!-- 配置连接池中初始的连接数量 -->
        <property name="initialSize" value="5"></property>
      <!-- 配置连接池中最大空闲的连接数量 -->
        <property name="maxIdle" value="10"/>
      <!-- 配置连接池中最大的连接数量 -->
        <property name="maxTotal" value="10"/>
    </bean>

配置工厂bean

  <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" destroy-method="destroy">
    <!-- 关联的datasource -->
        <property name="dataSource" ref="dataSource"/>
       <!-- 设置被管理的实体映射文件，多个的话，可以继续加value子元素，
        或者利用通配符比如*.hbm.xml  
        -->
        <property name="mappingLocations">
            <list>
                <value>classpath:mappers/CategoryEntity.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                 <!-- 设置显示hibernate运行的sql语句，开发时用 -->
                <prop key="hibernate.show_sql">true</prop>  
              <!-- 设置格式化显示hibernate运行的sql语句，开发时用 -->
                <prop key="hibernate.format_sql">true</prop>
              <!-- 针对特定的数据库设置方言，便于hibernate对生成的sql进行优化 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServer2008Dialect</prop>
            </props>
        </property>
    </bean>

至此，SessionFactory对象就已经创建出来了，就可以注入到dao中了。

配置事务

配置事务管理,使用不同的持久层技术，采用的事物管理器是不同的。此管理器有commit，rollback功能，但本地事务都是基于所采用的持久层的事务功能，所以事物管理器需要知道所有的持久层的核心对象，比如下面的sessionFactory对象。

  <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager" >
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

配置事务用的环绕通知：此通知来自于spring-tx这个xsd文件，别配置到了cache文件去了，同时此环绕通知把事务的提交与回滚交给事务管理器去完成，所以需要知道事物管理器，如果事物管理器的名字为transactionManager是可以不用配置的。

下面的配置默认事务传播级别为Required，而且是碰到RuntimeException异常时，事务才会回滚。在spring与hibernate整合使用时，spring会对dao类的代码中抛出的异常有个转换功能，会转换为DataAccessException。此DataAccessException就是RuntimeException异常的子类型。不过hibernate 5这个版本已经把数据库的异常转换为运行时异常了，所以Spring没有这个异常转换功能也可以，但有些持久层框架或老版本的Hibernate抛出的异常不是运行时异常，那么Spring的这个异常转换功能就显得很重要了。

    <tx:advice id="transactionInterceptor" transaction-manager="transactionManager">
        <tx:attributes>
          <!-- 配置所有的get开头的方法 采用只读事务，只读事务不能做增删改操作（需要持久层框架以及jdbc驱动的支持才真正有效） 设置之后会起到一定的优化作用-->
            <tx:method name="get*" read-only="true"/>
            <tx:method name="delete*"/>
            <tx:method name="update*"/>
            <tx:method name="insert*"/>
        </tx:attributes>
    </tx:advice>

配置事务切面

   <aop:config>
     <!--针对所有服务层代码来配置切面，不是针对dao层，因为可能一个服务类的方法调用多个dao类的方法，配置在服务层，可以让多个dao的方法运行在一个事务下 -->
        <aop:pointcut id="allServices"
                      expression="execution(public * com.service.*.*(..))"/>
     <!-- 引用事务环绕通知，以及服务目标类的切点表达式-->
        <aop:advisor advice-ref="transactionInterceptor" pointcut-ref="allServices"/>
    </aop:config>

Spring与Struts2的整合

主要的任务

配置监听器
action的class设置为bean
整合的插件配置

配置监听器

配置监听器，是为了创建ApplicationContext对象

   <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

可选的配置上下文参数，用来指定spring配置文件的位置

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

这个监听器类来自于spring-web里面，所以需要添加下面的依赖

     <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

action配置

action的class属性值设定为spring中配置的控制类的名字

   <package name="demo" extends="struts-default">
     <!-- 设置控制器类中，可以访问的方法名-->
        <global-allowed-methods>list,delete,create,save,edit,update</global-allowed-methods>
        <action name="category*" class="categoryController" method="{1}">
            <result name="list">/category/list.jsp</result>
            <result name="create">/category/create.jsp</result>
            <result name="modify" type="redirectAction">categorylist</result>
            <result name="edit">/category/edit.jsp</result>
        </action>
    </package>

整合插件

此插件由struts框架提供，只需要加到类路径下面即可，所以只需要添加一个插件的依赖

   <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>2.5.12</version>
        </dependency>

CRUD操作

下面以单表的一个查询操作为例来说明ssh整合之后代码的编写方式

sql语句

create table category
(
    id int identity(1,1) primary key,
    cname nvarchar(10)
)

dao类的写法

父dao的代码，主要是让所有的子类都有sessionFactory，不用每个子类都去写sessionFactory

public  class BaseDao {
    private SessionFactory sessionFactory;
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
}

public class CategoryDao extends  BaseDao {

    public List<CategoryEntity> getAll(){
        Session session = getSessionFactory().getCurrentSession();
        return session.createQuery("from CategoryEntity ").list();
    }
}

applicationContext中的配置

<!-- 这里配置父dao，并设置为抽象，主要的目的是为了不能直接getBean的方式使用这个bean设置，与实际的BaseDao类型是不是抽象的无关-->  
<bean id="baseDao" abstract="true" class="com.dao.BaseDao">
          <!--注入sessionFactory，这样所有的子bean就都有sessionFactory可以用了 -->
        <property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!--parent设置的是父bean的名字，父bean的配置，此子bean就都可以使用了。 -->
<bean id="categoryDao" class="com.dao.CategoryDao" parent="baseDao">
</bean>

service类的写法

public class CategoryService {
  //这样用来注入dao的，最好是用接口隔离一下
    private CategoryDao categoryDao;

    public CategoryDao getCategoryDao() {
        return categoryDao;
    }

    public void setCategoryDao(CategoryDao categoryDao) {
        this.categoryDao = categoryDao;
    }

    public List<CategoryEntity> getAll(){
        return  categoryDao.getAll();
    }
}

spring中的配置

   <bean id="categoryService" class="com.service.CategoryService">
        <property name="categoryDao" ref="categoryDao"/>
    </bean>

控制器类的写法

父类控制器:主要是为了给所有的控制类提供公共的功能。

public class BaseController extends ActionSupport {

}

public class CategoryController extends BaseController implements ModelDriven<CategoryEntity>{
  //spring会注入service类型进来  
  private CategoryService categoryService;

    public CategoryService getCategoryService() {
        return categoryService;
    }

    public void setCategoryService(CategoryService categoryService) {
        this.categoryService = categoryService;
    }

    public String list(){
        List<CategoryEntity> categoryEntityList =  categoryService.getAll();
        ActionContext.getContext().put("categoryList",categoryEntityList);
        return "list";
    }
}