框架整合——SSH（Struts2+Spring+Hibernate）+IDEA+Maven+MySQL+Tomcat

框架功能梳理

• Maven: 项目对象模型(POM) 通过一小段描述信息来管理JAR文件的工具。
• Spring (低耦合 高内聚): IoC，对成员变量的赋值的控制权从代码中反转到配置文件中；依赖注入，核心是一个利用反射的方式加载配置文件(app.xml)、创建对象(bean)的工厂模式（默认单例），用接口原理降低了耦合度；AOP，将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去，提高内聚（代码重用）；类似filter，用于场景如登陆时候在进入登录页面前写入日志，登录以后查看cookie等类似的操作，很常用的，尤其是跟数据库有关的，或者跟支付有关的程序肯定会在每一步前面插入日志，还有某些国际化项目会在每次跳转时候都转换字符集之类。
• Struts 2: 封装Servlet；请求和相应的分发跳转，页面数据的采集获得。
• Hibernate: 封装JDBC；数据库交互（连接、对持久化对象的操作）。

准备软件

• JDK (Java Development Kit )，其中包含JRE(Java Runtime Environment)；
• Intellij Idea: 最好用的Java IDE；
• MySQL 数据库：装好之后可直接在Idea 界面操作；

SSH三个框架的知识点

一、Hibernate框架

1. Hibernate的核心配置文件
   1.1 数据库信息、连接池配置
   1.2 Hibernate信息
   1.3 映射配置
   1.4 Hibernate核心配置文件
   如果单纯使用Hibernate框架，核心配置文件名称hibernate.cfg.xml并且一定要放在src下面，而hibernate和spring整合的时候，hibernate核心配置文件名称和位置没有固定要求的（因为到时候会有一个参数指定其位置）。
2. Hibernate映射配置文件
   2.1 实体类和数据库表映射关系：使用的是ORM思想
3. hibernate操作的步骤
   3.1 在Spring框架对hibernate框架进行封装，使用HibernateTemplate类

二、Struts2框架

1. Action相关的操作
   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
   属性封装
   模型驱动，要实现ModelDriven接口
   1.5 在action中操作域对象
   使用ServletActionContext获取域对象
   1.6 在web.xml中配置Struts提供的过滤器
2. 值栈
   值栈在开发中用得不多，掌握两点：
   2.1 向值栈中放数据
   set方法
   push方法
   定义变量生成get方法
   2.2 从值栈中获取数据
   在jsp中使用struts2标签+ognl获取
3. 拦截器
   3.1 AOP和责任链
   3.2 自定义拦截器
   自定义拦截器可以通过继承MethodFilerInterceptor创建

三、Spring框架

1. Spring框架核心配置文件
   1.1 名称和位置没有固定要求，官方推荐使用applicationContext.xml作为配置文件名
   1.2 在Spring核心配置文件中引入Schema约束
2. 创建对象
   2.1 xml配置方式：
   2.2 注解方式：四个注解，Component，Service，Controller，Repository
3. 注入属性
   3.1 xml配置方式
   3.2 注解方式：两个直接，Resource，Autowired
4. 使用ServletContext对象和监听器实现
   4.1 在服务器启动的时候，加载Spring，监听器的配置在web.xml中
   4.2 配置Spring的监听器
   4.3 指定Spring配置文件的位置
   4.4 要导入一个Spring整合web项目的jar包
5. AOP的思想以及JdbcTemplate的使用

SSH三大框架的整合思想

1. web应用的三层为：
- 1.1 web层，（struts2），Struts2框架用的最多的是action
- 1.2 service层（spring），spring中用的最多的是IoC和AOP，把对象的创建交给Spring进行管理
- 1.3 dao层（hibernate），hibernate则是用来操作数据库，进行CRUD
2. 哪么这三个框架应该是如何整合呢？
思想是两两整合：

• 2.1 struts2和Spring进行整合
  2.1.1 在struts中action的创建交给Spring进行创建，但是要注意action是多实例的。
  2.1.2 要注意导入spring整合Struts2的jar包
• 2.2 hibernate和Spring进行整合
  2.2.1 hibernate中的核心类是SessionFactory，这里要把SessionFactory的创建交给Spring进行管理
  2.2.2 Hibernate的核心文件中进行了数据库信息的配置，这里也要交给Spring进行处理
  2.2.3 为Dao对象配置持久层的Spring提供的Template
  2.2.4 注意导入Spring整合DAO层的ORM包

SSH三大框架的整合步骤

1.创建web工程

2.创建如下项目结构

3.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sao</groupId>
    <artifactId>MyFirstSSH</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <!-- 统一源码的编码方式 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 统一各个框架版本 -->
        <struts.version>2.5.10</struts.version>
        <spring.version>4.3.8.RELEASE</spring.version>
        <hibernate.version>5.1.7.Final</hibernate.version>
    </properties>
    <dependencies>
        <!-- Junit依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring 核心依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring整合ORM框架依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Struts2 核心依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Struts2和Spring整合依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Hibernate 核心依赖 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- MySQL 依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>
        <!-- C3P0 依赖 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5</version>
        </dependency>
        <!-- AspectJ依赖 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>
        <!-- SLF4J依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- 导入java ee jar 包 -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

4.web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 配置Struts2过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置过滤器解决中文乱码-->
    <filter>
        <filter-name>CharactorFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharactorFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 配置Spring的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 指定Spring配置文件所在路径 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>
</web-app>

5.spring.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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 使用annotation -->
    <context:annotation-config/>
    <!-- 开启包扫描，并注册注解 -->
    <context:component-scan base-package="com.sao.*"/>
    <!-- 引入属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 配置C3P0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 数据库连接相关信息 -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- 配置Hibernate的SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置Hibernate属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop><!-- 是否展示SQL -->
                <prop key="hibernate.hbm2ddl.auto">update</prop><!-- 是否自动创建表结构 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.connection.url">jdbc:mysql://localhost:3306/ssh</prop>
                <prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
            </props>
        </property>
        <!-- 扫描并加载注解过的实体类 -->
        <property name="packagesToScan" value="com.sao.entity"/>

    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <!-- 注入SessionFactory -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 配置事务增强 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 配置需要进行事务管理的方法，和事务传播行为 -->
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置切面 -->
    <aop:config>
        <!-- 配置切入点 com.sao.*.service.*+.*(..)
            * org.ssh.service.*+.*(..)
                *：表示方法的作用域，*表示所有
                org.sao.service.*：表示org.sao.service下的任何包
                org.sao.service.*+：表示org.sao.service下的任何包及其子包
                *(..)：*表示任何方法，(..)表示方法的任何参数
         -->
        <aop:pointcut id="pointcut" expression="execution(* com.sao.service.*+.*(..))"/>
        <!-- 适配切入点和事务增强 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

6.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>

    <!-- 默认访问页面 -->
    <package name="default" extends="struts-default" namespace="/">
        <default-action-ref name="default" />
        <action name="default">
            <result>index.jsp</result>
        </action>
    </package>

    <!-- 商品相关请求转发 -->
    <!-- Struts2在2.5版本后添加strict-method-invocation(严格方法访问)，默认为true，不能使用动态方法调用功能，故需设为false -->
    <package name="product" extends="struts-default" namespace="/"
             strict-method-invocation="false">
        <!-- 保存商品 -->
        <action name="product_*" class="productAction" method="{1}Product">
            <result>index.jsp</result>
            <result name="input">index.jsp</result>
        </action>
    </package>

    <!-- 引入资源文件 -->
    <constant name="struts.custom.i18n.resources" value="messageResource"></constant>

</struts>

7.jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/ssh?useSSL=true&characterEncoding=UTF-8
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=123456

8.log4j.properpies

#定义LOG输出级别  
log4j.rootLogger=INFO,Console,File  
#定义日志输出目的地为控制台  
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.Target=System.out  
#可以灵活地指定日志输出格式，下面一行是指定具体的格式  
log4j.appender.Console.layout = org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n  

#文件大小到达指定尺寸的时候产生一个新的文件  
log4j.appender.File = org.apache.log4j.RollingFileAppender  
#指定输出目录  
log4j.appender.File.File = logs/ssm.log  
#定义文件最大大小  
log4j.appender.File.MaxFileSize = 10MB  
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志  
log4j.appender.File.Threshold = ALL  
log4j.appender.File.layout = org.apache.log4j.PatternLayout  
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

9.messageResource.properpies

invalid.fieldvalue.price = 商品价格输入格式有误

10.创建数据库表

数据库表user

11.IntelliJ IDEA下自动生成Hibernate映射文件以及实体类

配置数据库

配置Hibernate

在com.sao.entity包下将自动创建实体类：

product.java

package com.sao.entity;

import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Product {
    private int id;
    private String name;
    private Double price;

    public Product() {
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    @Id
    @Column(name = "id", nullable = false)
    public int getId() {
        return id;
    }

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

    @Basic
    @Column(name = "name", nullable = true, length = 100)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Basic
    @Column(name = "price", nullable = true, precision = 0)
    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Product product = (Product) o;

        if (id != product.id) return false;
        if (name != null ? !name.equals(product.name) : product.name != null) return false;
        if (price != null ? !price.equals(product.price) : product.price != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (price != null ? price.hashCode() : 0);
        return result;
    }
}

12.ProductDao.java

package com.sao.dao;

import com.sao.entity.Product;

/**
 * 商品操作-持久层接口
 *
 */
public interface ProductDao {
    void saveProduct(Product product);
}

13.ProductDaoImpl.java

package com.sao.dao.impl;

import com.sao.dao.ProductDao;
import com.sao.entity.Product;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

/**
 * 商品信息-服务层实现
 *
 */
@Repository
public class ProductDaoImpl implements ProductDao {
    //HibernateTemplate是spring对hibernate使用的一个简单封装,事务的开启，关闭，都交给HibernateTemplate
    private HibernateTemplate template;
    @Autowired
    public ProductDaoImpl(SessionFactory sessionFactory) {
        this.template = new HibernateTemplate(sessionFactory);
    }

    public void saveProduct(Product product) {
        template.save(product);
    }
}

14.ProductService.java

package com.sao.service;


import com.sao.entity.Product;

/**
 * 商品操作-服务层接口
 *
 */
public interface ProductService {
    void saveProduct(Product product);
}

15.ProductServiceImpl.java

package com.sao.service.impl;

import com.sao.dao.ProductDao;
import com.sao.entity.Product;
import com.sao.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductDao productDao;

    public void saveProduct(Product product) {
        productDao.saveProduct(product);
    }
}

16.ProductAction.java
添加@Controller注解代表此时Action已交由Spring进行管理。但是Struts2对Action的默认作用域是多实例的(prototype),而Spring默认Bean的作用域是单实例的,所以需设置Action的作用域为多实例的

package com.sao.action;

import com.opensymphony.xwork2.ActionSupport;
import com.sao.entity.Product;
import com.sao.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 * 商品操作-控制层
 *
 */
@Controller
@Scope("prototype")
public class ProductAction extends ActionSupport {

    private static final long serialVersionUID = 1L;

    @Autowired
    private ProductService productService;

    private String pname;
    private double price;

    /**
     * 保存商品操作
     *
     * @return
     */
    public String saveProduct() {
        Product product = new Product(pname, price);
        productService.saveProduct(product);
        this.addActionMessage("保存成功...");
        return SUCCESS;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;

    }

    @Override
    public void validate() {
        if(pname == null || "".equals(pname.trim())) {
            this.addFieldError("pname", "商品名称不能为空");
        }
    }

}

17.index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>新增商品界面</title>
</head>
<body>
    <h1>新增商品</h1>
    <s:actionmessage/>
    <s:form action="product_save" method="post" namespace="/" theme="simple">
        <table width="600px">
            <tr>
                <th>商品名称</th>
                <td><s:textfield name="pname"/></td>
                <td><font color="red"><s:fielderror fieldName="pname"/></font></td>
            </tr>
            <tr>
                <th>商品价格</th>
                <td><s:textfield name="price"/></td>
                <td><font color="red"><s:fielderror fieldName="price"/></font></td>
            </tr>
            <tr>
                <th colspan="2">
                    <input type="submit" value="保存"/>
                </th>
                <th> </th>
            </tr>
        </table>
    </s:form>
</body>
</html>

测试：