【SSH】Struts2(2.5.14)、Spring(5.0.3)、Hibernate(5.2.13)三大框架的整合项目入门示例

SSH的整合思想

Web层：Struts2

Service层：Spring

Dao层：Hibernate

基于中间的Spring框架分别与两个框架进行整合，即完成网页项目三大框架的整合

Spring和Struts整合原则

将Struts2的action对象创建过程交给Spring进行管理

Spring和Hibernate整合原则

1、将Hibernate数据库信息的配置交给Spring进行配置，也可以彻底在Spring中进行Hibernate的配置（不推荐）

<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>cn/entity/User.hbm.xml</value>
</list>
</property>

2、将sessionFactory对象的交给Spring进行管理

准备条件

Struts2框架：

http://struts.apache.org/download.cgi

struts-2.5.14.1-all.zip【选择GA标记的版本】，Struts2.3升级到Struts2.5的配置发生了很大的变化，详见描述，引入很多新特性，而且修复
4000
了重大漏洞（漏洞编号:S2-045）

struts-2.5.14.1-min-lib.zip为核心jar文件的压缩包，后续在这个压缩包里的jar文件基础上进行拓展

struts与spring框架进行整合时，需要再导入struts2-spring-plugin

由于struts2.5引入log4j2，还需要引入log4j.xml（压缩包\struts-2.5.14.1\src\core\src\test\resources）

Hibernate框架：

http://hibernate.org/orm/

hibernate-release-5.2.13.Final.zip【JDK8 JPA2.1】

jar文件在压缩包的lib/required目录，全部导入

Spring框架：

https://projects.spring.io/spring-framework/

spring-framework-5.0.3.RELEASE-dist.zip【JDK8】

jar文件在压缩包的libs目录中，除了javadoc(文档注释)、sources(源码)，剩下的就是需要导入的jar文件

其中，核心jar文件有4个：spring-beans、spring-context、spring-core、spring-expression

每个包的功能描述参考 http://blog.csdn.net/sunchen2012/article/details/53939253 根据项目需求拓展jar文件

以上都是基本的jar文件，对拓展包的有选择困难症的患者请全部导入，最后实现需求功能后进行优化时可以将没用的jar文件筛选出来从项目中去掉，IDEA参考，MyEclipse暂时没有发现这个功能，最多就是去除多余的import

最后别忘了数据库的jdbc驱动，我这里选择的是MySQL，jdbc for MySQL

以上版本是截至2018年2月15日（除夕夜）的最新GA正式发布版本，非测试版本，以下均为为基于此版本的基础项目的配置，已尽力排除各种异常，正常的完成运行，最后配图为证，以后也将基于这个demo项目进行探索新版本的配置

创建SSH项目

功能描述：使用action链接请求，自动向数据库中添加用户“张三”“李四”，并实现简单的转账功能

1、创建JavaEE网页项目，注意项目环境为JDK8



2、收集整理jar文件，并导入

antlr-2.7.7.jar

AspectJ-plugin-3.0.0.jar【需要补充的拓展，下载地址】

aspectjweaver.jar【AspectJ里包含，实现面向切面】

classmate-1.3.0.jar

commons-fileupload-1.3.3.jar

commons-io-2.5.jar

commons-lang3-3.6.jar

dom4j-1.6.1.jar

freemarker-2.3.26-incubating.jar

hibernate-commons-annotations-5.0.1.Final.jar

hibernate-core-5.2.13.Final.jar

hibernate-jpa-2.1-api-1.0.0.Final.jar

jandex-2.0.3.Final.jar

javassist-3.20.0-GA.jar

javassist-3.22.0-GA.jar

jboss-logging-3.3.1.Final.jar

jboss-transaction-api_1.2_spec-1.0.1.Final.jar

log4j-api-2.9.1.jar

mysql-connector-java-5.1.45-bin.jar

ognl-3.1.15.jar

spring-aop-5.0.3.RELEASE.jar

spring-aspects-5.0.3.RELEASE.jar

spring-beans-5.0.3.RELEASE.jar

spring-context-5.0.3.RELEASE.jar

spring-context-indexer-5.0.3.RELEASE.jar

spring-context-support-5.0.3.RELEASE.jar

spring-core-5.0.3.RELEASE.jar

spring-expression-5.0.3.RELEASE.jar

spring-instrument-5.0.3.RELEASE.jar

spring-jcl-5.0.3.RELEASE.jar

spring-jdbc-5.0.3.RELEASE.jar

spring-jms-5.0.3.RELEASE.jar

spring-messaging-5.0.3.RELEASE.jar

spring-orm-5.0.3.RELEASE.jar

spring-oxm-5.0.3.RELEASE.jar

spring-test-5.0.3.RELEASE.jar

spring-tx-5.0.3.RELEASE.jar

spring-web-5.0.3.RELEASE.jar

spring-webflux-5.0.3.RELEASE.jar

spring-webmvc-5.0.3.RELEASE.jar

spring-websocket-5.0.3.RELEASE.jar

struts2-core-2.5.14.1.jar

struts2-spring-plugin-2.5.14.1.jar



3、创建基本的包结构

这里由于是演示项目，省去了接口和抽象类的创建，直接使用实现类

src:.
└─com
├─action
│      UserAction.java
├─dao
│      UserDao.java
├─entity
│      User.java
└─service
UserService.java

UserAction.java

package com.action;

import com.entity.User;
import com.opensymphony.xwork2.ActionSupport;
import com.service.UserService;

public class UserAction extends ActionSupport {

//创建Service对象，使用spring注入
private UserService userService;

public void setUserService(UserService userService) {
System.out.println("UserAction的setUserService方法\n\t" + userService);
this.userService = userService;
}

public UserAction() {
super();
System.out.println("UserAction构造方法");
}

public String add() {
System.out.println("UserAction的add方法");
User user=new User();
//添加张三信息
user.setId(1);
user.setName("张三");
user.setSal(1000.0);
userService.add(user);

//添加李四信息
user.setId(2);
user.setName("李四");
user.setSal(1200.0);
userService.add(user);

return NONE;//无返回，可以不用配置Result
}

public String sal() throws Exception {
System.out.println("UserAction的sal方法");
userService.sal();//执行转账功能
return NONE;
}
}

UserService.java

package com.service;

import com.dao.UserDao;
import com.entity.User;

public class UserService {

//创建dao对象，使用spring注入
private UserDao userDao;

public void setUserDao(UserDao userDao) {
System.out.println("setUserDao方法\n\t" + userDao);
this.userDao = userDao;
}

public void add(User user) {
System.out.println("UserService的add方法\n\t"+user);
userDao.add(user);
}

public void sal() throws Exception {
System.out.println("UserService的delete方法");

User user;
//张三加300元
user = userDao.getSal(1);
user.setSal(user.getSal() + 300.0);
userDao.setSal(user);

user = userDao.getSal(2);
double sal = user.getSal();
if (sal < 300.0) {
//出现异常会自动回滚事务
throw new Exception(user.getName() + "余额不足");
}else{
//李四减300元
user = userDao.getSal(2);
user.setSal(user.getSal() - 300.0);
userDao.setSal(user);
}
}
}

UserDao.java

package com.dao;

import com.entity.User;
import org.springframework.orm.hibernate5.HibernateTemplate;

public class UserDao {

//创建Hibernate模板对象，使用spring注入
private HibernateTemplate hibernateTemplate;

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
System.out.println("UserDao的setHibernateTemplate方法\n\t" + hibernateTemplate);
this.hibernateTemplate = hibernateTemplate;
}

public UserDao() {
System.out.println("UserDao构造方法");
}

public void add(User user) {
System.out.println("UserDao的add方法\n\t" + user);
hibernateTemplate.save(user);
}

public User getSal(int id) {
System.out.println("UserDao的getSal方法\n\t" + id);
return hibernateTemplate.get(User.class, id);
}

public void setSal(User user) {
System.out.println("UserDao的setSal方法\n\t" + user);
hibernateTemplate.update(user);
}
}

User.java

package com.entity;

public class User {
//用户数据表的字段
private Integer id;
private String name;
private Double sal;

public User() {
System.out.println("User构造方法");
}

public Integer getId() {
System.out.println("User的getId方法\n\t" + id);
return id;
}

public void setId(Integer id) {
System.out.println("User的setId方法\n\t" + id);
this.id = id;
}

public String getName() {
System.out.println("User的getName方法\n\t" + name);
return name;
}

public void setName(String name) {
System.out.println("User的setName方法\n\t" + name);
this.name = name;
}

public Double getSal() {
System.out.println("User的getSal方法\n\t" + sal);
return sal;
}

public void setSal(Double sal) {
System.out.println("User的setSal方法\n\t" + sal);
this.sal = sal;
}
}

4、配置三个框架的配置文件

提示：这些配置文件在spring框架的管理下位置名称不固定

web.xml，默认位置在WEB-INF的目录中

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> 
<!--监听器，服务器启动时，ContextLoader创建事件捕获-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--配置Spring配置的位置-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:bean.xml</param-value>
</context-param>
<!--过滤器-->
<filter>
<filter-name>ssh</filter-name>
<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>ssh</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>

struts.xml，默认在src目录下

<?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>
<!-- 自动更新 -->
<constant name="struts.configuration.xml.reload" value="true"/>
<!--开启动态访问-->
<constant name="struts.enable.DynamicMethodInvocation" value="true"/>
<!--action对象交给spring框架管理-->
<constant name="struts.objectFactory" value="spring"/>

<!-- 配置action -->
<package name="demo" namespace="/" extends="struts-default">
<!--允许动态访问的方法规则，只允许add和sal方法 regex:.* 为解除全部方法请求的限制-->
<global-allowed-methods>add,sal</global-allowed-methods>
<!--action对象交给spring创建，class写spring里创建的action的id-->
<action name="*_*" class="{1}" method="{2}"/>
</package>
</struts>

bean.xml，默认在src目录下，默认名称applicationContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> 
<!--Spring的JDBC框架连接并操作数据库，必须导入spring-jdbc-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>

<!--数据库源注入到会话工厂对象中，必须导入spring-orm-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!--创建对象，注入连接池数据源-->
<property name="dataSource" ref="dataSource"/>
<!--指定hibernate配置的位置，可以在spring的配置中编写hibernate的配置-->
<property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>

<!--创建事务管理对象，使用事务执行数据库操作-->
<bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!--注入SessionFactory对象-->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!--指定需要执行事务的方法-->
<tx:advice id="txAdvice" transaction-manager="hibernateTransactionManager">
<tx:attributes>
<!--默认propagation="REQUIRED"-->
<tx:method name="find*" read-only="true" />
<tx:method name="search*" read-only="true" />
<tx:method name="query*" read-only="true" />
<tx:method name="save*" rollback-for="java.lang.Exception"/>
<tx:method name="delete*" rollback-for="java.lang.Exception"/>
<tx:method name="update*" rollback-for="java.lang.Exception"/>
<tx:method name="do*" rollback-for="java.lang.Exception"/>
<tx:method name="*" rollback-for="java.lang.Exception"/>
</tx:attributes>
</tx:advice>

<!--需要增强的service方法，添加事务-->
<aop:config>
<!-- 定义切入点 -->
<aop:pointcut id="serviceMethod" expression="execution(* com.service.*Service.*(..))"/>
<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>
</aop:config>

<!--创建Hibernate模板对象-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
<!--注入会话工厂对象-->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!--创建dao对象-->
<bean id="userDao" class="com.dao.UserDao">
<!--注入HibernateTemplate对象-->
<property name="hibernateTemplate" ref="hibernateTemplate"/>
</bean>

<!--创建service对象-->
<bean id="userService" class="com.service.UserService">
<!--注入dao对象-->
<property name="userDao" ref="userDao"/>
</bean>

<!--创建action对象，scope为多例模式-->
<bean id="userAction" class="com.action.UserAction" scope="prototype">
<!--注入service对象-->
<property name="userService" ref="userService"/>
</bean>
</beans>

hibernate.cfg.xml，默认在src目录下，在spring框架的管理下，名称可以随意，甚至配置都可以完全在spring里完成

<!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>
<!--1、配置数据库信息，已经交给SpringJDBC-->
<!--
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
-->
<!--2、配置hibernate信息-->
<!--日志中显示SQL语句-->
<property name="hibernate.show_sql">true</property>
<!--格式化SQL语句-->
<property name="hibernate.format_sql">true</property>
<!--请求的数据表不存在时自动创建数据表-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!--配置方言，针对不同的数据库进行适配-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</property>
<!--会话与线程识别绑定【使用Spring框架的HibernateTemplate整合时，一定要去掉这个配置】-->
<!--<property name="hibernate.current_session_context_class">thread</property>-->
<!--3、数据表与实体类关联映射-->
<mapping resource="com/entity/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>

User.hbm.xml，实体类与数据库的对应关系的配置，位置在entity包中，与实体名称匹配对应

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--实体类与数据表的配置-->
<class name="com.entity.User" table="`USER`">
<!--实体类属性与主键字段的配置-->
<id name="id" column="`ID`">
<!--主键生成方式，由程序向数据库提供-->
<generator class="assigned"/>
</id>
<!--其他字段的配置-->
<property name="name" column="`NAME`"/>
<property name="sal" column="`SAL`"/>
</class>
</hibernate-mapping>

log4j2.xml，这是Struts2.5引入的log4j的升级版本，在压缩包的示例中可以找到

<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
<Appenders>
<Console name="STDOUT" target="SYSTEM_OUT">
<PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L) - %m%n"/>
</Console>
</Appenders>
<Loggers>
<Root level="info">
<AppenderRef ref="STDOUT"/>
</Root>
<Logger name="org.apache.struts2.views.xslt" level="debug"/>
</Loggers>
</Configuration>

将以上配置文件配置路径到项目中





5、将项目部署到服务器

使用的是Apache tomcat 9.0.5



6、创建war包，并将项目各部分文件放置到位



7、启动项目，控制台无异常，网页自动打开跳转到index.jsp



8、访问特定连接，触发action

MySQL中创建好数据库即可，数据表不存在会自动创建，配置中已设置

链接：/userAction_add



链接：/userAction_sal



转账到没钱时的情况



没有编写异常页面，由于异常被事务捕获，在struts.xml的package中加入可能会无效，建议在action中加入判断，抛出新的异常