基于struts2.5.2+hibernate5.2.2+spring4.3.2搭建SSH框架

现在在学习后端框架，最后的目标是希望搭建一个基于spring mvc + mybatis + spring的框架，因为之前接触过SSH，所以想从SSH开始，慢慢演化，也巩固一下自己的知识。

之前每次搭建SSH框架都要在网上查各种资料，而且我也发现各种资料基于的SSH版本都比较老，新版本就会遇到各种各样的问题，所以基于这次的搭建流程，写一下遇到的问题和解决方法。

基础需求

下载 Eclipse J2EE版

J2EE版带server和maven的配置，用起来比较方便，其他也没什么区别，普通版装插件也是可以达到一样效果的

下载tomcat

目前Eclipse J2EE版的server只支持tomcat 8 以下版本，我试过8.5.5也不支持，所以最好下7

安装mysql

具体流程可以从网上找，这个简单

创建数据库 create database test；

创建表

create table user(
userId int auto_increment,
userName varchar(16) not null,
password varchar(16) not null,
gender int not null,
primary key(userId)
);

配置Struts框架

安装struts的jar包

下载struts-2.5.2包

将包下面lib目录下的以下文件拷贝到项目的WEB-INF/lib下面，当然这里要先创建一个Dynamic Web Project，这个也简单，在Eclipse中点下一步下一步下一步就可以。

为什么是放在WEB-INF/lib下，而不放在项目的lib下，这是因为，web项目在发布后依赖包是去寻找WEB-INF目录下的各种包的。这里我后面遇到一个奇怪的问题，也加深了对这个配置的理解，具体什么问题以后再说。然后你把包放在WEB-INF/lib下的时候，eclipse会自动拷贝一份到项目的lib下，方便编程时候的依赖。

创建web.xml

在WEB-INF下面创建web.xml，配置struts监听，这个web.xml其实就是整个web项目的入口，所有的配置都是从这里开始，再跳转的其他地方。格式如下

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd"> <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>
<!--注意：千万不能写成：*.action ，如果需要：*.action应该配置在struts.xml中-->
</filter-mapping>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

其实熟悉j2ee的人知道，在struts之前，j2ee最基本的跳转是用servlet来做的，struts其实也要基于servlet来做，配置一个filter，name随意。然后在filter-mapping里配置满足一定条件的url请求都交给这个filter来处理，其实也就是struts来处理。这里我们配置为/*，也就是所有的请求都转发给struts处理，这是最简单的，如果需要特殊配置可以在这里再配置。

另外也要注意/* 和 /的区别，按照我个人的理解/*是所有的请求，包括/test.jsp和/test.html这种带后缀名的请求。/是不带后缀名的所有请求，像/test这样的。

创建struts.xml

然后所有的请求都给struts处理了，struts本身肯定还需要一个配置文件，来转发各种请求到相应的处理类，这个配置文件是struts.xml，放在src文件夹下，前面说过，web项目的配置文件都是在web-inf下面，为什么这个放在src文件夹下呢，这里就要说到一个eclipse发布映射的问题。

你项目里点右键，选属性，选Deployment Assembly，可以看到这是发包时候的映射关系，src文件夹会发布到WEB-INF/classes，而struts会默认到这个文件夹下面找配置文件。



回到正题，说一下struts的配置文件，格式如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd" >
<struts>
<package  name ="user_curd"  extends ="struts-default"  >
<global-results>
<!--  下面定义的结果对所有的Action都有效  -->
<result  name ="exception"> /error.jsp </result>
</global-results>

<global-exception-mappings>
<!--  指Action抛出Exception异常时，转入名为exception的结果。  -->
<exception-mapping  exception ="java.lang.Exception"  result ="exception" />
</global-exception-mappings>

<action  name ="test"  class ="TestAction">
</action>
</package>
</struts>

配置文件很好懂，下面的action部分就是请求转发，url中对\test的请求会转发到TestAction中处理

创建Action类

创建Action处理类，前面也说过了，请求会转发到某个类中进行处理，很显然，我们需要定义这样的类

在src中创建相应的类

package com.helloworld.test;

import java.io.PrintWriter;
import java.util.Date;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class TestAction extends ActionSupport
{
private String contentType = "text/html;charset=utf-8";
public String execute() throws Exception
{
//指定输出内容类型和编码
ServletActionContext.getResponse().setContentType(contentType);
//获取输出流，然后使用
PrintWriter out = ServletActionContext.getResponse().getWriter();
try{
//输出文本信息
out.print("Hello World");
out.print("Time: " + (new Date()).getTime());
out.flush();
out.close();
}catch(Exception ex){
out.println(ex.toString());
}
return SUCCESS;
}
}

execute方法就是处理请求的方法，具体的使用可以再查相关资料，本文只介绍搭建框架

发包运行

此时访问test应该会跳转到该类，然后输出信息

配置Struts时遇到的问题：

问题1

java.lang.ClassNotFoundException: org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

最新的Struts框架处理类的包名变了，其实碰到这类问题，自己去lib中看下类所在的位置就可以，每次版本更新可能会变一些东西

错误2

java.util.concurrent.ExecutionException: org.apache.catalina.LifecycleException: Failed to start component [StandardEngine[Catalina].StandardHost[localhost].StandardContext[/helloworld]]

这是因为lib包多了或少了，参照我前面lib库的文件，检查一下

错误3

Unable to load configuration. - bean - jar:file:/Users/zzw/Documents/j2eeworkspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/helloworld/WEB-INF/lib/struts2-gxp-plugin-2.5.2.jar!/struts-plugin.xml:8:162

和上个问题一样，这是因为引用包多了，其实不要觉得我把所有包都放进了就行了，如果包多了会做一些初始化的工作，而初始化的过程中就容易有问题

访问http://localhost:8080/helloworld/test成功

搭建Hibernate框架

Struts到目前为止就算成功了，接下来我们看引入Hibernate框架

官网下载hibernate 5.2.2

下载JDBC

http://www.mysql.com/products/connector/ 下载jdbc

配置Hibernate的Jar包

拷贝lib\required下的jar包到WEB-INFO\lib目录下，Hibernate就很好，把所有需要的包都放在了required文件夹下

创建hibernate.cfg.xml

创建hibernate的配置文件hibernate.cfg.xml，配置数据库连接等等，也是在src目录下，格式如下

<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/User</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">123</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
</session-factory>
</hibernate-configuration>

这是最简单的配置，连接数据库的

创建实体类

我们都知道hibernate是实体-关系映射，所以要创建实体类

package com.helloworld.test;

public class User {
private int userId;

private String userName;

private String passWord;

private int gender;

public int getUserId() {
return userId;
}

public void setUserId(int userId) {
this.userId = userId;
}

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;
}

public int getGender() {
return gender;
}

public void setGender(int gender) {
this.gender = gender;
}

}

就是对应数据库中一个表

配置映射关系

明显，这个实体类和表的映射关系也需要配置

添加User.hbm.xml文件映射表结构

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.helloworld.test.User">
<id name="userId">
<generator class="increment" />
</id>
<property name="userName" />
<property name="passWord" />
<property name="gender" />
</class>
</hibernate-mapping>

这个映射关系配置文件可以放在任何地方，因为下一步我们会在hibernate.xml配置文件中声明这个文件的位置，我目前是放在和User类一起的位置。

添加映射关系

按照上一步所说，我们需要把映射关系配置文件的路径配置到hibernate.cfg.xml中去，如下：要写清楚包名，位置，就mapping配置的那部分，如果有多个映射，依次添加

<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">zzw</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<mapping resource="com/helloworld/test/User.hbm.xml"/>
</session-factory>

</hibernate-configuration>

测试运行

Hibernate不需要发包web项目，可以本地测试，写一个Test类

package com.helloworld.test;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

public class HibernateTest {

public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();

//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();

//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setUserName("zzw");
user.setPassWord("zzw");

//保存User对象
session.save(user);
String hql = "from User";
Query query = session.createQuery(hql);
List<User> roles = query.list();
for(int i=0;i<roles.size();i++){
System.out.print("从数据库加载数据的用户名为"+roles.get(i).getUserName());
}
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}

}

}

执行成功，这样的话Hibernate框架也算搭建完成了。

DAO设计模型

提到Hibernate不得不提的是DAO设计模型，为了下一步Spring的配置更加清楚明了，这里我们也采用DAO的设计模型

基础概念

这里讲几个概念

POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。这里POJO其实就是User类

DAO (Data Access Object)是一个数据访问接口，数据访问：顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。

简单一点说，就是把数据库相关操作提到DAO中进行，与业务有关的逻辑放在Manager中，为了分层编程。举个例子来说，比如用户注册这个功能，用户注册的页面显示由RegisterAction负责，Action类中有Manager负责具体的业务，RegisterManager中有具体的业务方法register，Manager中有与数据库打交道的DAO类，RegisterManager中应该有UserDAO，负责所有对User表的操作，比如addUser，deleteUser等。这样说应该很容易理解吧，这是一种分层编程的思想，可以降低各个模块之间的耦合度，比如如果你想把用户注册改成管理员注册，只需要把UserDAO改成managerDAO就可以操作manager表了。就这样。DAO设计模式也是很推崇面向接口的编程，下面我用代码为大家讲解。

DAO类

1，首先声明接口

package com.helloworld.dao;

import org.hibernate.HibernateException;
import org.hibernate.Session;

public interface BaseDao {

public void saveObject(Object obj) throws HibernateException;

public Session getSession();

public void setSession(Session session);
}

跟数据库打交道需要获取hibernate的session，所以一个简单的base接口就是几个获取session的方法

然后我们定义HibernateSessionFactory用于在各个DAO中获取Session

package com.helloworld.daoImpl;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateSessionFactory {

private static final String CFG_FILE_LOCATION = "/Hibernate.cfg.xml";

private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();

private static final Configuration cfg = new Configuration()
.configure(CFG_FILE_LOCATION);

private static ServiceRegistry registry;

private static SessionFactory sessionFactory;

public static Session currentSession() throws HibernateException {
Session session = threadLocal.get();

if (session == null || session.isOpen() == false) {

if (sessionFactory == null) {
StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder()
.configure().build();
Metadata metadata = new MetadataSources(standardRegistry)
.getMetadataBuilder()
.applyImplicitNamingStrategy(
ImplicitNamingStrategyJpaCompliantImpl.INSTANCE)
.build();
sessionFactory = metadata
.getSessionFactoryBuilder().build();
}

session = sessionFactory.openSession();
threadLocal.set(session);

}

return session;
}

public static void closeSession() throws HibernateException {
Session session = threadLocal.get();
threadLocal.set(null);
if (session != null) {
session.close();
}
}

}

下面是跟User表打交道的UserDao

package com.helloworld.daoImpl;

import org.hibernate.HibernateException;
import org.hibernate.Session;

import com.helloworld.dao.BaseDao;

public class UserDao implements BaseDao{
private Session session;
public UserDao(){
session=HiberanateSessionFactory.currentSession();
}
@Override
public Session getSession() {
return session;
}

@Override
public void setSession(Session session) {
this.session = session;
}

@Override
public void saveObject(Object obj) throws HibernateException {
session.save(obj);
}
}

业务逻辑类

然后声明业务逻辑类UserManager，这里我只是举个最简单的例子,直接调用了DAO的getUsers方法，不要觉得没用，在日常事务中，我们需要在DAO方法前后做些处理，都是要在Manager中进行处理的。

package com.helloworld.manager;

import java.util.List;

import org.hibernate.HibernateException;

import com.helloworld.dao.BaseDao;
import com.helloworld.daoImpl.UserDao;
import com.helloworld.pojo.User;

public class UserManager {
private BaseDao dao;

public UserManager(){
dao = new UserDao();
System.out.println("UserManager IN");
}

public BaseDao getDao() {
return dao;
}

public void setDao(BaseDao dao) {
this.dao = dao;
}

public List<User> getUsers() throws HibernateException {
return dao.getUsers();
}
}

这时候就可以在测试类里用manager对象进行数据库操作了。比如

package com.helloworld.test;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

import com.helloworld.dao.BaseDao;
import com.helloworld.daoImpl.HibernateSessionFactory;
import com.helloworld.daoImpl.UserDao;
import com.helloworld.manager.UserManager;
import com.helloworld.pojo.User;

public class HibernateTest {

public static void main(String[] args) {
UserManager userManager=new UserManager();
userManager.getUsers()

}

}

DAO模型介绍到这。

搭建Spring框架，整合Struts和Hibernate

接下来用spring整合struts和hibernate

前面提到的DAO设计模式，在用到的时候new 一个DAO对象进行数据库操作，这是最简单的，但是你想想这样会浪费时间，浪费内存，因为没进行一次访问都要生成一个新的对象，其实全局都可以用一个DAO对象。Spring是干嘛的，Spring有两大特性，IoC和AoP，其中IoC中的一种方式便是依赖注入，Spring全局管理一些Bean，像Session，dao都可以是bean，然后你需要的时候就给你注入，这就是依赖注入。其他的特性可以自行百度，另外Spring其实是一套门路很深的框架，不然也不会在Struts和Hibernate都渐渐退居二线的时候，它依然坚挺在第一线。有机会我准备仔细看下Spring的实现原理，与大家分享一下。

总而言之，整个Spring的配置过程其实就是，配置bean，然后把bean配置到各个类中这样。

下载4.3.2release的spring

Spring官网改版后找了好久都没有找到直接下载Jar包的链接,下面汇总些网上提供的方法,亲测可用.

直接输入地址,改相应版本即可:http://repo.springsource.org/libs-release-local/org/springframework/spring/3.2.4.RELEASE/spring-framework-3.2.4.RELEASE-dist.zip

在1的方法上输入前面部分,有个树形结构可供选择:http://repo.springsource.org/libs-release-local/org/springframework/spring/

同样的,,有树形结构选择需要的包下载:http://repo.spring.io/milestone/org/springframework/

加入Spring的Jar包

将Spring内libs目录下包含所有的jar包（不需要复制结尾为sources和javadoc的jar包）到项目的lib目录下。

这里为了整合Struts还需要加入一个struts的包

记得加入struts-spring-plugin的jar包，不然struts无法使用spring管理的bean对象

创建Spring配置文件

编写Spring的配置文件applicationContext.xml。把该文件放在WEB-INF下，跟web.xml同目录。

这里我们使用C3P0来管理数据池，所以把Hibernate内lib/optional/c3p0下的c3p0-0.9.1.jar复制到lib不目下。

applicationContext的配置很复杂，所有的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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 
<!-- 定义数据源的信息 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="jdbcUrl">
<value>jdbc:mysql://localhost:3306/test</value>
</property>
<property name="user">
<value>root</value>
</property>
<property name="password">
<value>zzw</value>
</property>
<property name="maxPoolSize">
<value>80</value>
</property>
<property name="minPoolSize">
<value>1</value>
</property>
<property name="initialPoolSize">
<value>1</value>
</property>
<property name="maxIdleTime">
<value>20</value>
</property>
</bean>

<!--定义Hibernate的SessionFactory -->
<!-- SessionFactory使用的数据源为上面的数据源 -->
<!-- 指定了Hibernate的映射文件和配置信息 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>com/helloworld/pojo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="show_sql">true</prop>
<prop key="hibernate.jdbc.batch_size">20</prop>
</props>
</property>
</bean>

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

<bean id="userDao" class="com.helloworld.daoImpl.UserDao">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>

<!--用户注册业务逻辑类 -->
<bean id="userManager" class="com.helloworld.manager.UserManager">
<property name="dao">
<ref bean="userDao" />
</property>
</bean>

<!-- 用户注册的Action -->
<bean id="testAction" class="com.helloworld.action.TestAction">
<property name="manager">
<ref bean="userManager" />
</property>
</bean>

<!-- more bean definitions go here -->

</beans>

从配置文件我们看出，hibernate的datasource和session的配置完全被spring接管了，所以hibernate的配置文件是可以删掉的。

修改BaseDao和UserDao。

在引入Spring后，需要用Spring进行统一的事务管理，数据源和sessionFactory都交给Spring去生成，因此接口类和实现类BaseDao和UserDao都需要做相应的修改。Spring提供了HibernateDaoSupport类来完成对数据的操作，因此UserDao在实现BaseDao的同时还需要继承HibernateDaoSupport类。并将先前session的操作修改成HibernateTemplate（可通过getHibernateTemplate（）方法来获得）的操作。

package com.helloworld.dao;

import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.Session;

import com.helloworld.pojo.User;

public interface BaseDao {

public void saveObject(Object obj) throws HibernateException;

public List<User> getUsers() throws HibernateException;
}

package com.helloworld.daoImpl;

import java.util.List;

import org.hibernate.HibernateException;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.helloworld.dao.BaseDao;
import com.helloworld.pojo.User;

public class UserDao extends HibernateDaoSupport implements BaseDao{

public UserDao() {
System.out.println("UserDao IN");
}

@Override
public void saveObject(Object obj) throws HibernateException {
getHibernateTemplate().save(obj);
}

public List<User> getUsers() throws HibernateException{
List<User> users=getHibernateTemplate().loadAll(User.class);
return users;
}
}

其实HibernateDaoSupport也没干什么大事，就是前面说的session的set get方法，既然每个DAO都需要，那spring就提出来了呗，没什么神秘的。

修改业务逻辑实现类

也就是Manager的类，跟DAO一样。在没有加入Spring之前，业务逻辑实现类的Session的获得，dao的实例化，以及事务的管理都是该类执行管理的。加入Spring后，这些都交给Spring去管理。该类的dao的实例化由Spring注入。

修改用户注册的testAction类

同样，testAction类中的userManager的实例化也由Spring注入。可以仔细理解一下上面的applicationContext的配置文件，你需要某个对象，只要把该对象配置成bean，比如下面这样

<bean id="userManager" class="com.helloworld.manager.UserManager">
...
</bean>

然后用到这个bean的类配置成

<bean id="testAction" class="com.helloworld.action.TestAction">
<property name="manager">
<ref bean="userManager" />
</property>
</bean>

这样这个类里名字为manager的对象就会自动被注入userManager对象。记得需要有set方法，名字需对应。

删除多余类

删除Hibernate的配置文件Hibernate.cfg.xml和工厂类

HibernateSesseionFactory类。他们的工作已经交给Spring去做，已经不再有用。

修改web.xml

加载Spring。要想启动时加载Spring的配置文件，需要在web.xml中配置对应的监听器（listenser），并指定Spring的配置文件。

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 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_2_5.xsd"> 
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<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>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

修改Struts的配置文件struts.xml

把原来指定的名为register的action的class由原来的路径变为applicationContext.xml文件中该bean的id名，不需要再用具体的包名+类名。

包名加类名的方式会在每次访问的时候都生成一个action对应的对象，交给spring管理后，只会在最开始的时候生成一次。如下

<action  name ="test"  class ="testAction">

整个项目配置之后结构如图



在spring的配置中会遇到各种各样的问题，其他无非就是bean配置上写错了路径，类目，对象名，变量名，等等，所以仔细一点，认真检查一下，肯定能找到原因。

到此为止，SSH框架已经搭建好了，但是据我所知，这套框架目前的使用率已经在降低了，有以下几个原因：

struts除了可以做请求转发，还有页面标签，所以你如果只用请求转发的话，这个框架有点多余

现在spring推出了springMVC，是专门做请求转发用的，因为是spring自家推出的，所以和spring的协调性更好，而且在我使用中也感觉springMVC用起来更方便，轻量级

HIbernate框架管理数据库很强大，但是同样的问题，重量级。目前因为移动应用的兴起，请求并发量暴增的问题，Mybatis框架对于数据库管理更轻量级，更灵活。这两个框架说不上孰优孰劣，大家可以看下资料。

所以在下一篇文章中，准备先用SpringMVC代替struts。敬请期待