SSH——struts2、spring、hibernate三大框架的纯配置式的整合？

一、SSH三个框架的知识点：

1、Hibernate框架：

   1.1、Hibernate的核心配置文件： 数据库信息、连接池配置、 Hibernate信息、映射配置（实体类和数据库表映射关系：使用的是ORM思想）、Hibernate核心配置文件。

  1.2、hibernate操作的步骤：在Spring框架对hibernate框架进行封装，使用HibernateTemplate类。

2、Struts2框架：

  1.1、action创建三种方式： 

          写一个POJO，并在其中写上 public String execute();方法、

          创建一个类并实现Action接口、

          使用的最多的方法是集成类ActionSupport。

  1.2、配置action访问路径： 创建struts.xml配置文件，这个文件名称和位置固定src下面。

  1.3、配置访问action的多个方法：使用通配符的方式配置比较常见。

  1.4、在action获取表单提交数据：

          获取request对象，Struts2提供的API有ActionContext和ServletActionContext、

          属性封装、

扫描二维码关注公众号，回复： 4188506 查看本文章

          模型驱动，要实现ModelDriven接口。

  1.5、在action中操作域对象：使用ServletActionContext获取域对象。

  1.6、在web.xml中配置Struts提供的过滤器。

  1.7、值栈：

           向值栈中放数据： set方法、push方法、定义变量生成get方法。

           从值栈中获取数据： 在jsp中使用struts2标签+ognl获取。

  1.8、拦截器：

          AOP和责任链。

          自定义拦截器：可以通过继承MethodFilerInterceptor创建。

3、Spring框架：

 1.1、Spring框架核心配置文件：

         名称和位置没有固定要求，官方推荐使用applicationContext.xml作为配置文件名、

         在Spring核心配置文件中引入Schema约束。

 1.2、创建对象：

         xml配置方式：<bean id="" class="" />、

         注解方式：四个注解，Component，Service，Controller，Repository

 1.3、注入属性：

         xml配置方式、

         注解方式：两个直接，Resource，Autowired

 1.4、使用ServletContext对象和监听器实现：

        在服务器启动的时候，加载Spring，监听器的配置在web.xml中、

        配置Spring的监听器、

        指定Spring配置文件的位置、

        要导入一个Spring整合web项目的jar包。

二、SSH三大框架的整合思想：

web应用分为三层：

    dao层（hibernate），hibernate则是用来操作数据库，进行CRUD。

    service层（spring），spring中用的最多的是IOC和AOP，把对象的创建交给Spring进行管理。

    web层（struts2），Struts2框架用的最多的是action。

三大框架整合思想：两两整合。

 hibernate和Spring进行整合：

    hibernate中的核心类是SessionFactory，这里要把SessionFactory的创建交给Spring进行管理、

    hibernate的核心文件中进行了数据库信息的配置，这里也要交给Spring进行处理、

    为Dao对象配置持久层的Spring提供的Template、

    注意导入Spring整合DAO层的ORM包。

 struts2和Spring进行整合：

    在struts中action的创建交给Spring进行创建，但是要注意action是多实例的、

    要注意导入spring整合Struts2的jar包。

三、SSH三大框架的整合过程：

1、导入依赖：

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <!--servlet的版本号-->
        <servlet-version>4.0.0</servlet-version>
        <!--mysql的版本号-->
        <mysql-version>5.1.46</mysql-version>
        <!--c3p0的版本号-->
        <c3p0-version>0.9.5.2</c3p0-version>
        <!--hibernate的版本号-->
        <hibernate-version>5.2.13.Final</hibernate-version>
        <!--struts2的版本号-->
        <struts2-version>2.5.16</struts2-version>
        <!--spring的版本号-->
        <spring-version>4.3.13.RELEASE</spring-version>
    </properties>

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--配置servlet的依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet-version}</version>
        </dependency>

        <!--配置mysql的依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-version}</version>
        </dependency>

        <!--配置c3p0的依赖-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0-version}</version>
        </dependency>

        <!--配置hibernate的依赖-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate-version}</version>
        </dependency>

        <!--配置struts2的依赖-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts2-version}</version>
        </dependency>

        <!--配置struts2-spring的桥接包-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts2-version}</version>
        </dependency>

        <!--配置spring的依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-version}</version>
        </dependency>

在build里面加上：

<resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

2、搭建Hibernate环境：

     创建实体类（User）：

/**
 * 用户表的实体类（实体类名必须和数据库表一致）
 */
public class User implements Serializable {

    /**
     * 用户编号（这里的属性名称必须和数据库表的列名一致，不然无法映射）
     */
    private String user_id;
    /**
     * 用户姓名
     */
    private String user_name;

    /**
     * 用户密码
     */
    private String user_pwd;

    /**
     * 用户类型
     */
    private String user_type;

    public User() {
    }

    public User(String user_id, String user_name, String user_pwd, String user_type) {
        this.user_id = user_id;
        this.user_name = user_name;
        this.user_pwd = user_pwd;
        this.user_type = user_type;
    }

    public String getUser_id() {
        return user_id;
    }

    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public String getUser_pwd() {
        return user_pwd;
    }

    public void setUser_pwd(String user_pwd) {
        this.user_pwd = user_pwd;
    }

    public String getUser_type() {
        return user_type;
    }

    public void setUser_type(String user_type) {
        this.user_type = user_type;
    }

    @Override
    public String toString() {
        return "User{" +
                "user_id='" + user_id + '\'' +
                ", user_name='" + user_name + '\'' +
                ", user_pwd='" + user_pwd + '\'' +
                ", user_type='" + user_type + '\'' +
                '}';
    }
}

     配置实体类和数据库表的映射关系（User.hbm.xml）：

<?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指定POJO类和数据库表之间的对应-->
    <class name="com.zking.pojo.User" table="User">
        <!-- id指定数据库中表的主键,以及主键生成策略 -->
        <id name="user_id" column="user_id">
            <generator class="native"></generator>
        </id>
        <!-- property指定表字段和POJO中的属性的对应 -->
        <property name="user_name" column="user_name"></property>
        <!-- 用户密码 -->
        <property name="user_pwd" column="user_pwd"></property>
        <!-- 用户类型 -->
        <property name="user_type" column="user_type"></property>
    </class>
</hibernate-mapping>

      创建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>
        <!--显示sql语句-->
        <property name="show_sql">true</property>
        <!--格式化sql语句-->
        <property name="format_sql">true</property>
    </session-factory>
</hibernate-configuration>

3、搭建Spring环境：

   创建Spring的核心配置文件（applicationContext-public.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:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <!-- 1、配置数据库连接池(c3p0) -->
    <bean id="c3p0DataSource"
          class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--用户名 -->
        <property name="user" value="root"></property>
        <!-- 密码 -->
        <property name="password" value="sasa"></property>
        <!-- 驱动 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <!-- 数据库连接地址 -->
        <property name="jdbcUrl"
                  value="jdbc:mysql://localhost:3306/chencao?characterEncoding=utf-8"></property>
        <!-- 初始化连接数 -->
        <property name="initialPoolSize" value="3"></property>
        <!-- 最大连接数 -->
        <property name="maxPoolSize" value="100"></property>
    </bean>

    <!-- 2、配置sessionFactory -->
    <bean id="sessionFactoryBean"
          class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 引入数据源 -->
        <property name="dataSource" ref="c3p0DataSource"></property>
        <!-- 加载hibernate配置文件 -->
        <property name="configLocation"
                  value="classpath:hibernate.cfg.xml"></property>
        <!-- 加载hibernate的映射文件 -->
        <property name="mappingLocations"
                  value="classpath:com/zking/pojo/*.hbm.xml"></property>
    </bean>

    <!-- 3、配置事务 -->
    <bean id="hibernateTransactionManager"
          class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactoryBean"></property>
    </bean>

    <!-- 4、配置事务的属性 -->
    <tx:advice id="myAdvice"
               transaction-manager="hibernateTransactionManager">
        <tx:attributes>
            <!-- 哪些方法需要事务处理(add* 以add开头的方法全部都需要进入事务) -->
            <!--propagation="REQUIRED" 必须执行 -->
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="edit*" propagation="REQUIRED"/>
            <tx:method name="remove*" propagation="REQUIRED"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5、配置事务的切点 -->
    <aop:config>
        <!-- 事务的切点：第一个*代表返回值，第二个*代表dao下子包，第三个*代表方法名，"(..)"代表方法参数 -->
        <aop:pointcut
                expression="execution(* com.zking.biz.*.*(..))"
                id="myCut"/>
        <!-- 事务切入点和事务属性挂钩 -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="myCut"/>
    </aop:config>

</beans>

     BaseDao.java文件（生成sessionFactory）：

public class BaseDao {

    /**
     * 首先在静态代码块中生成出sessionFactory
     */
    private static SessionFactory sessionFactory;

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void setSessionFactory(SessionFactory sessionFactory) {
        BaseDao.sessionFactory = sessionFactory;
    }

    /**
     * @return Session
     * @Title: getSession
     * @Description: 获取session
     */
    public Session getSession() {
        return sessionFactory.getCurrentSession();
    }

}

     IUserDao.java文件（dao包的接口）：

/**
 * 用户表dao包的接口
 */
public interface IUserDao {

    /**
     * @param user
     * @return User
     * @Title: UserLogin
     * @Description: 用户登录的方法
     */
    public User UserLogin(User user);

}

     UserDaoImpl.java文件（dao包接口的实现类）：

/**
 * 用户表dao包的实现类
 */
public class UserDaoImpl extends BaseDao implements IUserDao {

    @Override
    public User UserLogin(User user) {
        //这里使用的是hibernate的hql语句，from后面接的User是实体类名，而不是数据库表名
        return (User) getSession().createQuery("from User  where user_name=:user_name and user_pwd=:user_pwd")
                .setParameter("user_name", user.getUser_name()).setParameter("user_pwd", user.getUser_pwd()).uniqueResult();
    }

}

     IUserBiz.java文件（biz包的接口）：

/**
 * 用户表biz包的接口
 */
public interface IUserBiz {

    /**
     * 用户登录的方法
     * @param user
     * @return
     */
    public User UserLogin(User user);

}

     UserBizImpl.java文件（biz包接口的实现类）：

/**
 * 用户表biz包的实现类
 */
public class UserBizImpl implements IUserBiz {

    /**
     * 实例化dao包接口
     */
    private IUserDao iud;

    public IUserDao getIud() {
        return iud;
    }

    public void setIud(IUserDao iud) {
        this.iud = iud;
    }

    @Override
    public User UserLogin(User user) {
        return iud.UserLogin(user);
    }
}

      applicationContext-dao.xml（注入dao包的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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <!-- dao包获取hibernate的sessionFactory -->
    <bean id="baseDao"
          class="com.zking.dao.BaseDao">
        <property name="sessionFactory" ref="sessionFactoryBean"></property>
    </bean>

    <bean id="userDaoImpl"
          class="com.zking.dao.impl.UserDaoImpl">
    </bean>

</beans>

        applicationContext-biz.xml（注入biz包的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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    
    <!-- biz包获取dao包的方法 -->
    <bean id="userBizImpl"
          class="com.zking.biz.impl.UserBizImpl">
        <property name="iud" ref="userDaoImpl"></property>
    </bean>

</beans>

       applicationContext-action.xml（注入action包的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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

    <!-- action包获取biz包的方法 -->
    <!--注意action是多实例的，因此我们这里把scope配置为prototype的-->
    <bean id="UserAction"
          class="com.zking.action.UserAction" scope="prototype">
        <property name="iub" ref="userBizImpl"></property>
    </bean>
</beans>

3、搭建struts2环境：

  创建struts.xml配置文件：

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

<struts>
    <!--name：包名，extends：固定值-->
    <package name="user" extends="struts-default">

        <!--name：页面访问名称，class：为applicationContext-action.xml配置文件的bean对象的id值（Spring IoC中获取的）-->
        <action name="UserAction" class="UserAction" method="UserLogin">
            <!--成功则跳转到index.jsp页面，否则跳转到404.jsp页面，type：是否要转发，默认为转发-->
            <result name="success">/index.jsp</result>
            <result name="error">/404.jsp</result>
        </action>

    </package>
</struts>

  创建Action（UserAction.java文件）：

/**
 * 用户表action包的实现类
 */
public class UserAction extends ActionSupport implements ModelDriven<User> {

    /**
     * 实例化User对象
     */
    private User user = new User();

    @Override
    public User getModel() {
        return user;
    }

    /**
     * 实例化biz包的接口
     */
    private IUserBiz iub;

    public IUserBiz getIub() {
        return iub;
    }

    public void setIub(IUserBiz iub) {
        this.iub = iub;
    }

    /**
     * @return void
     * @Title: UserLogin
     * @Description: 用户登录的方法
     */
    public String UserLogin() {
        if (iub.UserLogin(user) != null) {
            return SUCCESS;
        }
        return ERROR;
    }

}

在web.xml中配置struts2的过滤器和spring的拦截器：

    <!-- 加载spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext-*.xml</param-value>
    </context-param>

    <!-- 加载struts2：配置struts2的过滤器 -->
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

四、SSH三大框架的总结：

配置集中化： 将Struts2和Hibernate中的核心配置往Spring中转移，最明显的是Action和SessionFactory的配置。