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

使用hibernateweb
- 能够不须要建立hibernate.cfg.xml文件，由于applicationContext文件已经配置好了spring
- 建立映射文件，并配置在applicationContext文件中sql
使用spring数据库
- 建立applicationContext.xml文件express
- 配置datasource，以便让项目使用数据库链接池功能apache
- 配置LocalSessionFactoryBean，以便建立SessionFactory对象session
- 配置事务管理器，HibernateTransactionManagerapp
- 配置事务环绕通知，以便给服务层的方法增长事务环绕功能框架
- 配置切面，以便真正建立代理，完成事务通知的织入
使用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"; } }