Spring SSH框架整合

Posted 2021-01-12 糖醋小瓶子

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring SSH框架整合相关的知识，希望对你有一定的参考价值。

前言：路漫漫其修远兮，吾将上下而求索-----------jgp

1 准备环境整合

　　所谓整合就是将不同的框架放在一个项目中，共同使用它们的技术，使它们发挥各自的优点，并形成互补。

　　1.1 准备数据库环境

　　创建名称为ssh的数据库，然后在该数据库中创建一个t_user表，t_user表中有id、username、password三个字段

CREATE DATABASE ssh;
USE ssh;
CREATE TABLE t_user(
id INT(10) NOT NULL AUTO_INCREMENT,
username VARCHAR(20) DEFAULT NULL,
password VARCHAR(20) DEFAULT NULL,
PRIMARY KEY(id)
);

　　1.2 配置Struts2环境

　　1.2.1 导入struts2相关jar包（13个）

　　1.2.2 添加log4j.properties文件

　　本项目需要添加一个log4j.properties文件，作为log4j日志技术的配置文件。

　　在添加log4j.properties文件之前，首先在项目中创建一个名为config的Source Folder(源文件夹），专门用于存放各种配置文件，是源文件夹，不是普通文件夹。

　　log4j.properties文件的具体内容如下：

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=d:\\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change \'info\' to \'debug\' ###

log4j.rootLogger=info, stdout

　　 1.2.3 在web.xml中配置核心过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee" 
         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
                              http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
    <!--配置Struts2核心控制器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>
            org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

　　1.2.4 在struts.xml配置文件

　　在config路径下添加struts2配置文件struts.xml

<?xml version="1.0" encoding="UTF-8"?>
     <!DOCTYPE struts PUBLIC
         "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
         "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- 开发模式 -->
    <constant name="struts.devMode" value="true"></constant>
    <package name="ssh" namespace="/" extends="struts-default">
    
    </package>
</struts>

　　1.3 配置Spring环境

　　配置完Struts2环境后，接下来配置Spring环境。

　　1.3.1 导入Spring的依赖jar包(14个）

　　1.3.2 核心配置文件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/aop 
                              http://www.springframework.org/schema/aop/spring-aop.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">
</beans>

　　1.3.3 在web.xml文件中配置Spring的监听器

　　添加完该配置后的web.xml文件如下

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    id="WebApp_ID" version="3.0">
    <!-- 监听器 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--配置Struts2核心控制器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>
            org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

　　1. 4 配置Hibernate环境

　　Struts2和Spring环境配置完毕后，接下来，对Hibernate的环境进行配置

　　1.4.1 导入运行Hibernate所需的jar包（12个）

　　在上述jar包中，javassist-3.12.0.GA.jar在struts2中已经添加过，所以在项目整合时不需要重新添加。

　　1.4.2 添加核心配置文件hibernate.cfg.xml

　　在项目的config文件夹中添加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>
        <!-- 1 基本4项 -->
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
         </property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ssh
             </property>
        <property name="connection.username">root</property>
        <property name="connection.password">1122</property>
        <!-- 2 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- 3 sql -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <!-- 4 取消bean校验 -->
        <property name="javax.persistence.validation.mode">none</property>
        <!-- 5整合c3p0 -->
        <property name="hibernate.connection.provider_class">
            org.hibernate.connection.C3P0ConnectionProvider
             </property>
         <!-- 可以添加映射文件 -->
    </session-factory>
</hibernate-configuration>

　　至此，Struts2、Spring和Hibernate的环境均准备完成，jar包个数为38个（13+14+12-1=38），完成后的项目结构如图：

2 Spring和Hibernate的整合

　　hibernate.cfg.xml文件是Hibernate中重要的配置文件，当Spring和Hibernate整合时，由于hibernate.cfg.xml文件中的配置信息可以交给Spring来管理

所以可以选择是否使用hibernate.cfg.xml文件，下面我们将从使用hibernate.cfg.xml文件和不使用hibernate.cfg.xml文件两种情况来进行整合测试。

　　2.1 介绍

　　Spring和Hibernate的整合，需要再添加一个支持整合的JAR包Spring-orm-3.2.2.RELEASE.jar，该jar包可以在下载的Spring解压目录的libs目录中找到。

　　在讲解Spring和Hibernate的整合前，首先需要了解三个重要的对象，具体如下：

- HibernateTemplate：相当于Hibernate的session可以直接操作PO类，依赖于sessionFactory。
- LocalSessionFactoryBean：获得SessionFactory。
- HibernateTransactionManager：Hibernate的事务管理器。

　　2.2 使用hibernate.cfg.xml文件

　　项目的结构如下：

　　2.2.1 Domain层

　　User.java

public class User {
    private Integer id;
    private String username;
    private String password;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

　　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 name="com.tcxpz.ssh_pro02.domain.User" table="t_user">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="username" column="username"></property>
        <property name="password" column="password"></property>
    </class>
</hibernate-mapping>

　　在User.hbm.xml映射文件编写完成后，需要在Hibernate的核心配置hibernate.cfg.cml中添加此映射文件的信息。

　　2.2.2 Dao层

　　UserDao.java

public interface UserDao {
    public void save(User user);
    public void update(User user);
    public void delete(User user);
    public User findById(Integer id);
    public List<User> findAll();
}

　　UserDaoImpl.java

public class UserDaoImpl implements UserDao{
    private HibernateTemplate hibernateTemplate;
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
    @Override
    public void save(User user) {
        this.hibernateTemplate.save(user);
    }
    @Override
    public void update(User user) {
        this.hibernateTemplate.update(user);
    }
    @Override
    public void delete(User user) {
        this.hibernateTemplate.delete(user);
    }
    @Override
    public User findById(Integer id) {
        return this.hibernateTemplate.get(User.class, id);
    }
    @Override
    public List<User> findAll() {
        return this.hibernateTemplate.find("from User");
    }
}

　　2.2.3 service层

　　UserService.java

public interface UserService {
    public void saveUser(User user);
    public void updateUser(User user);
    public void deleteUser(User user);
    public User findUserById(Integer id);
    public List<User> findAllUser();
}

　　UserServiceImpl.java

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void saveUser(User user) {
        this.userDao.save(user);
    }
    @Override
    public void updateUser(User user) {
        this.userDao.update(user);
    }
    @Override
    public void deleteUser(User user) {
        this.userDao.delete(user);
    }
    @Override
    public User findUserById(Integer id) {
        return this.userDao.findById(id);
    }
    @Override
    public List<User> findAllUser() {
        return this.userDao.findAll();
    }
}

　　2.2.4 Spring文件中进行配置

　　我们的测试程序需要从Spring容器中获得UserService实例对象，而UsersService依赖于UserDao,UserDao又依赖于HibernateTemplate，HibernateTmplate依赖于SessionFactory，

所以Spring容器需要创建SessionFactory实例对象，而创建这个对象需要注入configLocation属性。此外，我们还要对事务进行管理，要配置事务管理器。

　　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/aop 
                              http://www.springframework.org/schema/aop/spring-aop.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">
<!-- 1 配置SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 加载hibernate核心配置文件 -->
        <property name="configLocation" value="classpath:hibernate.cfg.xml">
        </property>
    </bean>
    <!-- 2 配置hibernate模板 -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <!-- 通过工厂获得session，操作PO类 -->
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 3 配置dao -->
    <bean id="userDao" class="com.tcxpz.ssh_pro02.dao.UserDaoImpl">
        <property name="hibernateTemplate" ref="hibernateTemplate">
        </property>
    </bean>
    <!-- 4 配置service -->
    <bean id="userService" class="com.tcxpz.ssh_pro02.service.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <!-- 事务管理 -->
    <!-- #1 事务管理器,就是平台，spring工具产生，依赖于使用 持久方案（hibernate、jdbc等） -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- #2 通知：增强事务 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="save*" />
            <tx:method name="update*" />
            <tx:method name="delete*" />
            <tx:method name="find*" read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!-- #3 切面：将切入点 与 通知 关联 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
            pointcut="execution(* com.tcxpz.ssh_pro02.service.*.*(..))"/>
    </aop:config>
</beans>

　　2.2.5 测试

　　TestApp.java

public class TestApp {
    @Test
    public void demo(){
        User user = new User();
        user.setUsername("jack");
        user.setPassword("12345678");
        String xmlPath = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.saveUser(user);
    }
}

　　测试结果：

　　其他方法的测试结果不再赘述了。

　　2.3 不使用hibernate.cfg.xml

　　如果不使用hibernate.cfg.xml的方式来整合Spring和Hibernate，那我们就要将hibernate.cfg.xml文件中的配置信息添加到applicationContext.xml文件中，

　　所以只需要完成两步即可：

　　(1) 将hibernate.cfg.xml文件中的配置信息转移到applicationContext.xml文件中（修改applicationContext.xml）

　　(2) 删除hibernate.cfg.xml文件（删除hibernate.cfg.xm）

　　修改后的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: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">
        <!-- 1 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssh"></property>
        <property name="user" value="root"></property>
        <property name="password" value="1122"></property>
    </bean>
        <!-- 2 配置SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="javax.persistence.validation.mode">none</prop>
                <prop key="hibernate.current_session_context_class">thread</prop>
            </props>
        </property>
        <property name="mappingResources" value="com/tcxpz/ssh_pro03/domain/User.hbm.xml"></property>
    </bean>
        <!-- 3配置hibernateTemplate -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
        <!-- 4 配置dao -->
    <bean id="userDao" class="com.tcxpz.ssh_pro03.dao.UserDaoImpl">
        <property name="hibernateTemplate" ref="hibernateTemplate"></property>
    </bean>
        <!-- 5 配置service -->
    <bean id="userService" class="com.tcxpz.ssh_pro03.service.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
        <!-- 事务管理 -->
        <!-- #1 事务管理器,就是平台，spring工具产生，依赖于使用 持久方案（hibernate、jdbc等） -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- #2 通知：增强事务 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="save*" />
            <tx:method name="update*" />
            <tx:method name="delete*" />
            <tx:method name="find*" read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!-- #3 切面：将切入点 与 通知 关联 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice"
            pointcut="execution(* com.tcxpz.ssh_pro03.service.*.*(..))"/>
    </aop:config>
</beans>

3 Spring和Struts2的整合

　　我们介绍了Spring和Hibernate的整合。在实际开发中，使用三大框架时，还需要将Spring和Struts2框架进行整合。

　　Spring与Struts2整合的目的是将Struts2中Action的实例化工作交给Spring进行统一管理。

　　3.1 介绍

　　在Spring和Struts2进行整合时，需要导入一个JAR包struts2-spring-plugin-2.3.24.jar，该jar文件可以在已下载的Struts2的解压包的lib目录中找到。

　　3.2 Spring创建Action

　　下面通过一个案例来讲解Spring创建Action的情况(对上面的案例继续拓展)。

　　3.2.1 创建action类

　　UserAction.java（UserAction类依赖于UserService类，需要在Spring容器创建user_action对象时进行注入）

public class UserAction extends ActionSupport implements ModelDriven<User>{
    private User user = new User();
    @Override
    public User getModel() {
        return this.user;
    }
    //UserAction依赖于UserService,需要注入UserService
    private UserService userService;
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public String add(){
        this.userService.saveUser(user);
        return "success";
    }
}

　　3.2.2 applicationContext.xml配置

　　因为我们要让Spring容器给我们创建UserAction的实例对象，所以需要在applicationContext.xml中进行配置，并且向user_action对象中注入userService对象

　　添加代码如下：

　　3.2.3 struts.xml配置

　　修改struts文件，将UserAction的信息加入到配置文件中。

　　3.2.4 添加测试页面

　　测试时需要用到两个页面，在WebRoot目录下添加index.jsp和成功页面success.jsp

　　index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!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>
        <form action="${pageContext.request.contextPath}/userAction_add"
            method="post">
            用户名：<input type="text" name="username" /> <br/> 
            密 &nbsp&nbsp&nbsp码：<input type="password" name="password" /> <br/> 
            <input type="submit" value="添加" />
        </form>
    </body>
</html>

　　success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!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>
    </body>
</html>

　　3.2.5 测试

　　启动Tomcat服务器，在浏览器成功访问后，会进入添加页面，在页面输入用户名“糖醋小瓶子”和密码“tcxpz”，然后单击“添加”按钮。

　　浏览器跳转到成功页面

　　在数据库中成功添加了一条记录

　　3.3 Struts2自己创建Action

　　上面的案例中，Action的创建工作是交给Spring框架来完成的，如果不想这样做，而是仍然由Struts2自身创建Action，

那么只用对上面的案例进行以下两个修改就行了

　　（1）删除applicationContext.xml中对user_action的配置

　　（2）修改struts.xml文件配置

　　其实很好理解，既然我们要让struts2自己来创建UserAction对象，那么肯定要删除applicationContext.xml中对于user_action的配置，

既然删除了applicationContext.xml中对于user_action的配置，那就要在struts.xml文件中进行配置，让他自己能够创建UserAction对象。

　　这就引出来一个问题，我们删除了applicationContext.xml中对于user_action的配置，那么在userAction对象中需要用到的userService对象谁来注入呢？

　　原来在struts-2.3.24\\src\\core\\src\\main\\resources\\org\\apache\\struts2\\default.properties文件下已经对struts2做了如下的配置

　　当struts2创建实例对象时，将会按照名称自动注入对象，这就要求我们在UserAction中的需要注入的属性名与applicationContext.xml文件中的对象名（id）相同。

　　4 注解　

　　这里也可以用注解的方式进行配置，但是感觉配置德乱七八糟的，还不如将所有的配置信息写在xml文件中，直观易维护。暂时就不测试了，以后需要的话再深究吧！　

以上是关于Spring SSH框架整合的主要内容，如果未能解决你的问题，请参考以下文章

SSH框架的整合详解

Spring SSH框架整合

SSH(struts2+spring+hibernate)三大框架整合

SSH框架的基本整合

SSH框架第三季 - Spring5入门与三大框架整合