SSH框架组合（Struts2+Spring+Hibernate）Maven+IDEA

1.概念

1.1、Struts2
背景
由出色稳定的框架struts1和WebWork框架整合而来。

• （struts1是Apache软件基金会赞助的一个开源项目，它通过采育好难过javaservlet/jsp技术，实现了基于java ee web应用的mvc设计模式的应用框架，是mvc经典设计模式中的一个经典产品。struts1结构简单小巧，十分易用，一度市场占有率超过20%，struts1框架，与jsp/servlet耦合非常紧密，这制约了它的发展，以至于被后来的框架陆续赶超）。
• （webwork是有Opensysphony组织开发的，是建立在成为xwork的command模式框架之上的强大的mvc框架，webwork晚于struts1，技术上更为先进，由于组织至猛毒，人们习惯等原因。webwork市场的反响不如struts1）
• struts2与struts1差别巨大，不能理解为struts1的升级版。
• struts2以xwork为核心，可以理解为webwork的升级版。
• 吸取了两大框架的优点
• 吸收了自动封装数据技术，简化了许多冗余代码
• 提高了开发效率和规范性
• 更好的实现了mvc架构
  概念
  解除了与servlet的强耦合性
  轻量级MVC框架，主要解决了请求分发的问题，重心在控制层和表现层。所谓轻量级，低侵入性，与业务代码的耦合度很低。即业务代码中基本不需要import它的包。struts2实现了MVC，并提供了一些列API，采用模式化方式简化业务开发过程。

1.2、Hibernate
ORM

• hibernate中一个比较重要的概念，全称是Object Relational Mapping（直译就是对象关系映射）。说白呢就是一个关系映射，把我们的实体类的对象映射到数据库中对应的表中去。然后我们只需要通过调用Session对象的save、update、delete、get、load等方法就可以对数据库表数据进行增删查改等操作。这个概念不难理解，但是我觉得是贯穿整个hibernate框架的重要思想。

hibernate的核心接口和类

• hibernate的核心接口和类一共有6个。分别是Session、SessionFactory、Transaction、Query、Criteria 和 Configuration
• Session： Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句)
• SessionFactory：SessionFactory接口负责初始化Hibernate。它充当数据存储源的代理，并负责创建Session对象。
• Transaction：Transaction 接口是一个可选的API，可以选择不使用这个接口，取而代之的是Hibernate 的设计者自己写的底层事务处理代码。 Transaction 接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA 中的UserTransaction、甚至可以是CORBA 事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移植。
• Query： Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。
• Criteria：Criteria接口与Query接口非常类似，允许创建并执行面向对象的标准化查询。值得注意的是Criteria接口也是轻量级的，它不能在Session之外使用。
• Configuration：Configuration 类的作用是对Hibernate 进行配置，以及对它进行启动。在Hibernate 的启动过程中，Configuration 类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。虽然Configuration 类在整个Hibernate 项目中只扮演着一个很小的角色，但它是启动hibernate 时所遇到的第一个对象。

2.创建项目

2.1、目录结构

配置文件：

• struts.xml
• spring.xml
• hibernate.cfg.xml（IDEA自动生成映射文件）

资源文件：

• jdbc.propertis
• log4j.properties
  

2.2、创建项目

• 记得勾上Create from archetype，才可选择。
• 注意：选择maven-archetype-webapp

3.配置文件

3.1、配置pom.xml

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>SSH_Test</groupId>
    <artifactId>SSH_Test</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SSH_Test Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <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>
    </dependencies>

    <build>
        <plugins>
            <!-- 统一源代码编译输出的JDK版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
            <!-- 打包时跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <!-- 集成Tomcat插件 -->
            <!--<plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/${project.artifactId}</path>
                </configuration>
            </plugin>-->
        </plugins>
        <finalName>SSH_Test</finalName>
    </build>

</project>

3.2、创建 jdbc.properties 并配置

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://***.***.*.**:3306/*****?useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=****

3.3、创建 log4j.properties 并配置

log4j.rootCategory=INFO, console

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %t %c{2}:%L - %m%n

3.4、创建 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.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">

    <!-- 开启包扫描，并注册注解 -->
    <context:component-scan base-package="com.ssh.*"/>

    <!-- 引入属性文件 -->
    <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>
            </props>
        </property>
        <!-- 扫描并加载注解过的实体类 -->
        <property name="packagesToScan" value="com.ssh.model"/>
    </bean>

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

    <!--
    REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
      SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
      MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。
      REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
      NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
      NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
      NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。
     -->
    <!-- 配置事务增强 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="save*" propagation="REQUIRED" />
            <!-- <tx:method name="*" propagation="true" />-->
        </tx:attributes>
    </tx:advice>

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

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

</beans>

3.5、创建 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>/</result>
        </action>
    </package>

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

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

</struts>

3.6、配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

  <!-- 配置Struts2过滤器 -->
  <filter>
    <filter-name>SSH_Test</filter-name>
    <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>SSH_Test</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>

3.7、自动生成 hibernate.cfg.xml

• 弹出的窗口中选择Hibernate的版本，然后点击OK

• 这时项目中多出了一个 hibernate.hbm.xml 配置文件
• 配置好数据库（5.配置数据库）后，hibernate.hbm.xml中，（数据连接URL和驱动会自动增加）配置如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
  <session-factory>
    <!--数据库连接url配置--> 
    <property name="connection.url">jdbc:mysql://***.***.*.***:3306/*****</property>
    <!--数据库驱动配置-->
    <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    <mapping class="com.ssh.dao.SuppliersEntity"/>
    <mapping resource="spring/SuppliersEntity.hbm.xml"/>
    <!-- <property name="connection.username"/> -->
    <!-- <property name="connection.password"/> -->

    <!-- DB schema will be updated if needed -->
    <!-- <property name="hbm2ddl.auto">update</property> -->
  </session-factory>
</hibernate-configuration>

4.创建JAVA目录，及工程结构

4.1、action类

package com.ssh.action;

import com.opensymphony.xwork2.ActionSupport;
import com.ssh.model.SuppliersEntity;
import com.ssh.service.SuppliersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import java.util.List;

@Controller
@Scope("prototype")
public class SuppliersAction extends ActionSupport {
    @Autowired
    private SuppliersService suppliersService;

    private String pname;
    private double price;

    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", "商品名称不能为空");
        }
    }

    /**
     * 保存商品操作
     *
     * @return
     */
    public String saveProduct() {
        System.out.println(pname);
        this.addActionMessage("保存成功...");
        List<SuppliersEntity> suppliersList = suppliersService.getSuppliersList();
        this.addActionMessage("从数据库中取出来的公司名："+suppliersList.get(0).getCompany());
        return SUCCESS;
    }

}

4.2、dao类

package com.ssh.dao;

import com.ssh.model.SuppliersEntity;

import java.util.List;

public interface SuppliersDao {

    public void saveSuppliers(SuppliersEntity suppliers);

    public List<SuppliersEntity> getSuppliersList();
}

4.3、dao.impl类

package com.ssh.dao.impl;

import com.ssh.dao.SuppliersDao;
import com.ssh.model.SuppliersEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class SuppliersDaoImpl implements SuppliersDao {
    private HibernateTemplate template;

    @Autowired
    public SuppliersDaoImpl(HibernateTemplate template) {
        this.template = template;
    }

    public HibernateTemplate getTemplate() {
        return template;
    }

    public void setTemplate(HibernateTemplate template) {
        this.template = template;
    }

    @Override
    public void saveSuppliers(SuppliersEntity suppliers) {

    }

    @Override
    public List<SuppliersEntity> getSuppliersList() {
        List suppliersList = getTemplate().find("From SuppliersEntity");
        return suppliersList;
    }
}

4.4、model类（5.配置数据库完后，自动生成）

4.5、service类

package com.ssh.service;

import com.ssh.model.SuppliersEntity;

import java.util.List;

public interface SuppliersService {

    public List<SuppliersEntity> getSuppliersList();
}

4.6、service.impl类

package com.ssh.service.impl;

import com.ssh.dao.SuppliersDao;
import com.ssh.service.SuppliersService;
import com.ssh.model.SuppliersEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class SuppliersServiceImpl implements SuppliersService {
    @Autowired
    private SuppliersDao suppliersDao;

    public List<SuppliersEntity> getSuppliersList() {
        return suppliersDao.getSuppliersList();
    }
}

4.7、resources.spring（Mapping）（5.配置数据库完后，自动生成）

4.8、webapp.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="suppliers_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>

5.配置数据库

• 配置数据库后测试连接是否成功，若成功后点击确定

• 点击窗口中的Persistence
• 右键项目，然后点击Generate Persistence Mapping，选择By Database Schema

• 选择数据源，配置实体类包，选择要生成的实体类（其中日期类型的只能手动修改为java.util.Date），然后点击OK

• 手动在resources下面创建包，来管理.hbm.xml

6.设置Tomcat

7.见证奇迹

祝愿各位，技术成长的道路上，不断摸索，不断创新，不断成长、
活着就是为了改变世界