基于 MyEclipse6.0 的SSH 整合 -...

基于 MyEclipse6.0 的 SSH 整合

Version 1.1

2008-4-20


Galaxy.org 教程系列 1

目录

0. 概述 ................................................................................................................................................................. 2

1. 准备环境 ......................................................................................................................................................... 2

2. 创建工程 ....................................................................................................................................................... 10

3. 添加 Struts 支持 ......................................................................................................................................... 11

4. 添加 Spring 支持 ......................................................................................................................................... 13

5. 配置数据源 ................................................................................................................................................... 17

6. 添加 Hibernate 支持 ................................................................................................................................... 28

7. 添加 Hibernate 反向工程 ........................................................................................................................... 35

8. 修改目录结构 ............................................................................................................................................... 39

9. 测试 Spring 和 Hibernate 的整合 ............................................................................................................. 41

10. 整合 Struts 和 Spring ................................................................................................................................ 51

11. 测试 SSH 的整合 ........................................................................................................................................... 52



0. 概述

在一些普通应用中，使用 Java EE 的 EJB 等重量级组件并不适合。好在我们有许多开源框架为我们完成

这一系列的工作。其中最著名的框架组合即是 SSH。这里的 SSH 指的是 Struts + Spring + Hibernate。虽然现

在 Struts2 已经出现一段时间，但是习惯上我们仍然会把 Struts1.x 称为 Struts，Struts2.x 称为 Struts2。所以

我们延续业界的称呼，仍然将 SSH 中的 S 解释为 Struts1.x。

MyEclipse 是 Eclipse 的一个优秀插件，用于 Java EE 的开发，提供了诸如数据库管理、文件配置管理等

的一站式服务。然而对于 SSH 的整合，仅仅使用 MyEclipse 是无法成功实现的。这或许是 MyEclipse 的 Bug，

因为它自带的部分库文件并不能按照预期进行整合，需要我们手工干预。因此，我们编写这个教程，希望

对于 SSH 整合技术的学习尽微薄之力。

本教程使用 MyEclipse6.0 构建 SSH 项目。对于教程中的描述，其它版本的 MyEclipse 可能并不适合。另

外需要指出的是，SSH 的整合有很多方法，这里只介绍其中的一种。

作为 Java EE 的开发，我们使用 Tomcat 作为 Web 容器，使用 MySQL 作为数据库。

1. 准备环境

进行本教程中描述的实验，我们需要事先准备学习环境。下面是我们需要使用的软件环境：

Eclipse3.3

MyEclipse6.0

Tomcat6.0

MySQL5.1

需要指出的是，各个软件的版本号并不一定需要和上面列出的相同。但是，由于我们编写本教程时的

实验环境是由上述各版本系统搭建的，因此不能确保其它版本的软件是不是能够正常运行。另外由于

MyEclipse 中已经附带了 SSH 所需要的各种库文件，所以我们一般不再需要另外的准备。

对于软件的设置，我们将 MySQL 数据库编码设置为 UTF-8。具体方法为：

安装好 MySQL 后，打开 MySQL Server Instance Config Wizard，请根据下面的图示进行设置：

1) 启动 MySQL 配置向导界面，点击 Next 继续；



图表 1 MySQL 服务器编码设置（1）

2) 由于已经存在 MySQL 实例，因此系统会提示我们是重新配置实例(Reconfigure Instance)，还是删除

该实例(Remove Instance)。对于新安装的 MySQL 数据库则没有这一选项。这里我们选择重新配置即

可；


3) 选择配置方式，“Detailed Configuration（手动精确配置）”、“Standard Configuration（标准配置）”，



我们选择“Detailed Configuration”；


4) 选择服务器类型，“Developer Machine（开发测试类，MySQL占用很少资源）”、“Server Machine（服

务器类型，MySQL占用较多资源）”、“Dedicated MySQL Server Machine（专门的数据库服务器，MySQL

占用所有可用资源）”，根据自己需要的类型选择。这里我们选择“Developer Machine”；




5) 选择MySQL数据库的大致用途，“Multifunctional Database（通用多功能型，好）”、“Transactional

Database Only（服务器类型，专注于事务处理，一般）”、“Non-Transactional Database Only（非事务

处理型，较简单，主要做一些监控、记数用，对MyISAM数据类型的支持仅限于non-transactional），

根据自己的需要而选择。这里我们按照默认选择“Multifunctional Database”；


6) 对InnoDB Tablespace进行配置，就是为InnoDB 数据库文件选择一个存储空间，如果修改了，要记

住位置，重装的时候要选择一样的地方，否则可能会造成数据库损坏。当然，对数据库做个备份

就没问题了，这里不再详述。这里没有修改，使用默认位置，直接点击“Next”继续；




7) 选择一般MySQL访问量，即同时连接的数目，“Decision Support(DSS)/OLAP（20个左右）”、“Online

Transaction Processing(OLTP)（500个左右）”、“ManualSetting（手动设置，输入一个数值）”，这里选

“Decision Support(DSS)/OLAP”，点击“Next”继续；


8) 是否启用TCP/IP连接，设定端口，如果不启用，就只能在自己的机器上访问MySQL数据库。这里按



照默认设置即可。在这个页面上，还可以选择“启用标准模式”（Enable Strict Mode），这样MySQL

就不会允许细小的语法错误。如果还是个新手，建议取消标准模式以减少麻烦。但熟悉MySQL以后，

尽量使用标准模式，因为它可以降低有害数据进入数据库的可能性。点击“Next”继续；


9) 这里是MySQL设置服务器编码的地方。第一个是西文编码，第二个是多字节的通用utf8编码，都不

是通用的编码。我们选择第三个，然后在Character Set那里选择“utf-8”，当然也可以用“GB2312”

或”GBK”，区别就是GBK的字库容量大，包括了GB2312的所有汉字，并且加上了繁体字、和其它

字体——使用MySQL的时候，在执行数据操作命令之前运行一次“SET NAMES GBK;”（运行一次就

行了，GBK可以替换为其它值，视这里的设置而定），就可以正常的使用汉字（或其它文字）了，

否则不能正常显示汉字。点击“Next”继续；




10) 选择是否将MySQL安装为windows服务，还可以指定Service Name（服务标识名称），是否将mysql

的bin目录加入到Windows PATH（加入后，就可以直接使用bin下的文件，而不用指出目录名，比如

连接，“mysql.exe -uusername-ppassword;”就可以了，不用指出mysql.exe的完整地址）。如果不是

全新安装后的第一次设置，这里是不允许全部设置的。保留默认选项，点击“Next”继续；




11) 这一步询问是否要修改默认root用户（超级管理员）的密码（默认为空），“New root password”，

如果要修改，就在此填入新密码（如果是重装，并且之前已经设置了密码，在这里更改密码可能

会出错，请留空，并将“Modify SecuritySettings”前面的勾去掉，安装配置完成后另行修改密码），

“Confirm（再输一遍）”内再填一次，防止输错。“Enable root access from remote machines（是否

允许root用户在其它的机器上登陆，如果要安全，就不要勾上，如果要方便，就勾上它）”。最后“Create

An Anonymous Account（新建一个匿名用户，匿名用户可以连接数据库，不能操作数据，包括查询）”，

一般就不用选择了，设置完毕，点击“Next”继续。




12) 确认设置无误，如果有误，按“Back”返回检查。最后点击“Execute”使设置生效。


通过以上步骤，我们就设置好了 MySQL 的服务器编码。

2. 创建工程



打开 MyEclipse，需要注意的是这里应该处于 MyEclipse Java Enterprise 视图。新建一个 Web Project，输

入适当的工程名字，这里我们输入 SSH，修改 Context root URL 为 ssh。这个 URL 是使用 MyEclipse 部署时，

浏览器访问站点时的根路径，如果你的工程名中包含空格，那么这个 URL 必须修改为没有空格的地址。根

据需要选择是否添加 JSTL，最后 Finish 即可。

图表 13 新建 Web Project

确定之后 MyEclipse 会生成名为 SSH 的项目，其中生成的目录结构如下所示：

图表 14 目录结构

3. 添加 Struts 支持

在刚刚创建的 SSH 工程上面右击，在弹出的菜单中选择 MyEclipse -> Add Struts Capabilities…，添加 Struts



的支持。

图表 15 添加 Struts 支持文件

在弹出的对话框中选择 Struts 1.2，修改 Base package for new classes 成所需的包名，其余保持原状，Finish

即可。



图表 16 修改包名

此时已经完成 Struts 的配置，相关的文件添加如下：


4. 添加 Spring 支持



在 SSH 工程上面右击，在弹出的菜单中选择 MyEclipse -> Add Spring Capabilities…，添加 Spring 的支持。

图表 18 添加 Spring 支持文件

在弹出的对话框中选择 Spring 2，选择 MyEclipse Libraries，按照图示选择相关的库。由于 Spring 采取最

小化库发布的方式，使得 Spring 的库文件彼此都是分离的，因而我们需要自己选择需要的库。这里，AOP

需要在添加 Hibernate 的事务处理时使用，Core 是 Spring 的核心库，Persistence core 和 Persistence JDBC 库

作为 Spring 持久化的支持，Web 允许 Spring 和 Struts 整合，其余保持原状，点击 Next。



图表 19 配置 Spring 的支持库

在这里添加 Spring 的配置文件，可以将 Folder 更改为 Web-Root/WEB-INF 目录。这是为 struts 整合准备

的。其实，Spring 的配置文件可以放在 WEB-INF 的任意目录中，具体的位置都需要在 web.xml 中进行配置。

这里仅仅采用最简便的方法，将配置文件放到 WEB-INF 下面。然后 Finish 即可。



图表 20 Add Spring Capabilities

此时已经完成 Spring 的配置，相关的文件添加如下：




5. 配置数据源

在 MyEclipse 右上角选择 MyEclipse Database Explorer，打开数据库管理视图。

图表 22 打开数据库管理视图

在左侧的 DB Browser 点击右键，选择 New…，打开 Database Driver 对话框。



图表 23 添加数据库驱动

在 Database Driver 对话框中按照如下配置选择数据库驱动。首先选择 Driver Template，在这里我们选择

MySQL。Driver Name 是以后配置时使用的驱动名字，用以区分驱动，这里使用 MySQL 即可。然后根据实际

情况填写 URL，User name 和 Password。点击 Add JARs 添加数据库驱动文件。为方便配置，可以选择 Save

password 保存密码。配置完毕后 Finish 即可。



图表 24 Database Driver

此时左侧的 DB Browser里面会出现 MySQL，这个名字就是刚刚配置的 Driver name。点击 open connection

按钮，在确认 MySQL 服务已经启动的情况下，可以在 MyEclipse 里面建立与 MySQL 的连接。如果能够建立

连接，说明驱动添加成功，否则请检查驱动是否正确，或者 MySQL 服务有没有正常运行。

图表 25 添加驱动成功



图表 26 数据库连接成功

MyEclipse 为我们提供了一站式管理。在这里，我们利用 MyEclipse 建立一个数据库。首先选中 MySQL

下面的 Connected to MySQL，右击，在菜单中选择 Create Database。

图表 27 创建数据库

在弹出的对话框中填写数据库信息。这里我们填写 Database Name 为 ssh，Character Set 选择为 utf8，

Collation 选为 utf8_unicode_ci。填写完毕后 Finish 即可。



图表 28 填写数据库信息

现在，我们需要在 ssh 数据库里面建立一个测试用的表格。这里我们新建一个名为 user 的表格。这个

表格只有四个字段：id、name、password 和 purview，分别是用户编号、名字、密码和权限。下面给出在

MyEclipse 中新建表格的步骤：

1) 在刚刚建立的数据库 ssh 中，打开 TABLE,点击右键，选择 New Table；

图表 29 新建表格（1）

2) 在弹出的对话框中填写表名。切换到 Columns 选项卡，点击下面的 Add 按钮；




3) 在弹出的对话框中依次添加 id、name、password 和 purview 列，完成后点击 Finish；




此时打开 ssh 数据库下面的 TABLE，就会出现刚刚建立的 user 表。



图表 33 user 数据表

此时数据源已经配置完毕了。最后我们向表里面添加一条记录{1, admin, admin, MANAGER}，用来以后

的测试。在这里，我们使用 SQL 语句来实现这一目标，具体做法是：

1) 在数据库 ssh 的表 user 上面点击右键，选择 Generate -> Select Statement；



图表 34 使用 SQL 语句（1）

2) 在 SQL Editor 视图中填写如下的 SQL，

insert into user(name, password, purview) values ('admin', 'admin',

'MANAGER');

然后点击运行按钮即可。


3) 查看表格内容时可以在表格上面点击右键，有 Edit Data 选项，点击后即可。




6. 添加 Hibernate 支持

当配置完数据源后，就可以添加 Hibernate 支持了。切换到 MyEclipse Java Enterprise 视图，在 SSH 工程

上面右击，在弹出的菜单中选择 MyEclipse -> Add Hibernate Capabilities…，添加 Hibernate 的支持。



图表 38 添加 Hibernate 支持文件

1) 我们选择 Hibernate3，全部按照默认设置即可，然后点击 Next；



图表 39 配置 Hibernate（1）

2) 在对话框中选择 Spring configuration file，表示我们希望将 Hibernate 托管给 Spring 进行管理。这是

将 Hibernate 与 Spring 进行整合的基础。然后点击 Next；




3) 在出现的对话框中选择 Existing Spring configuration file。因为我们已经添加了 Spring 的配置文件，

所以这里选择的是已存在的配置文件。MyEclipse会自动找到存在的那个文件。然后在 SessionFactory

ID 中输入 Hibernate 的 SessionFactory 在 Spring 配置文件中的 Bean ID 的名字，这里我们输入

sessionFactory 即可。然后点击 Next；




4) 在出现的对话框中的 Bean Id 里面输入数据源在 Spring 中的 Bean ID 的名字，这里我们输入

dataSource。然后在 DB Driver 里面选择我们刚刚配置好的 MySQL，MyEclipse 会将其余的信息自动

填写到表格里面。然后点击 Next；




5) 在出现的对话框中取消 Create SessionFactory class。点击 Finish 即可。




此时 Hibernate 的支持已经添加完毕。MyEclipse 会自动打开 Spring 的配置文件。



我们可以看一下 MyEclipse 在 Spring 的配置文件中为我们完成了什么配置。首先有一个 ID 为 dataSource

的 Bean，这就是我们配置的数据源；然后有一个 ID 为 sessionFactory 的 Bean，这是由 Spring 管理的 Hibernate

的 Session Factory。MyEclipse 会自动为 Hibernate 添加数据库方言为 MySQLDialect。

7. 添加 Hibernate 反向工程

至此我们已经完成了 SSH 的添加，但现在只是将所有需要的文件放到了一起，并没有完成所有的配置。

现在我们要完成的是 Hibernate 的反向工程。我们知道，Hibernate 提供了 ORM（Object Relation Mapping）

机制，即将关系型数据库映射为面向对象的实现。现在要做的是将数据库的表格映射为对象，这里会有大

量的配置文档，但 MyEclipse 可以很方便的完成这些工作。

首先切换到 MyEclipse DataBase Explorer 视图，在需要使用的数据表格上面点击右键，选择 Hibernate

Reverse Engineering...。这里我们使用刚刚建立的 ssh 数据库中的 ssh 表。



图表 44 Hibernate 反向工程

在打开的对话框中修改 Java src folder 为我们建立的/SSH/src，这里需要选择到 src 文件夹，并且需要填

写 Java package，这是 MyEclipse 生成的类所在的包，我们将其取名为 obj。然后选择 Java Data Object，建立

POJO 类。然后选择 Java Data Access Object。其中，POJO 类是数据库表格所对应的 Java 类，JDO 类是 MyEclipse

自动生成的对数据库的一些操作。这里会封装一些常用的操作，简化我们的编写。填写完成后点击 Next。



图表 45 建立 Hibernate 反向工程

在出现的对话框中选择 ID Generator，然后点击 Finish 即可。



图表 46 Hibernate Reverse Engineering

此时 SSH 项目的目录结构如下所示。其中的 User.Java 是 MyEclipse 生成的 POJO 类，是使用面向对象的

Java 语言对数据库表格进行的抽象，User.hbm.xml 是将数据库表格中的字段和 POJO 类的属性进行映射的定

义，UserDAO.java 封装了一些 MyEclipse 自动生成的对数据库的操作。




8. 修改目录结构

这时我们修改一下文件目录，使之更好的组织。我们看到 MyEclipse 将生成的 POJO 类和 DAO 类混杂在

一起，这是不符合业务层次的，所以我们建立一个 dao 包，将 DAO 类与 POJO 类分开。然后我们在 struts

包下面建立 action 和 form 包，用来管理 Struts 的 Action 和 Form。实际上，我们应该按照业务逻辑将 Action

和 Form 分开管理，而不是放在一个 struts 包下面，但这里我们仅仅实现一个登录等简单功能，并没有十分

复杂的业务逻辑，所以我们并不将它们进一步分离，但实际工程中是应该这么做的。为了将实现与接口进

行解耦，我们建议在 dao 包下面添加接口，然后建立 dao.impl 包，将实际的 DAO 类放在这里。DAO 类是直

接与数据库打交道的类，为了对业务逻辑进行封装，我们将业务全部写在 service 类里面，和 dao 一样，我

们先建立 service 包，里面添加业务接口，具体的实现放在 service.impl 里面。




现在我们的目录结构已经比较合理了：



9. 测试 Spring 和 Hibernate 的整合

这里我们首先对 Spring 和 Hibernate 的集成做下测试。这里的测试关系到对数据库的操作，不涉及业务

逻辑。另外，我们的测试代码按照正常的流程去写，也就是说，这里的测试代码完全可以放到正式业务中

使用。

首先在 dao 下面新建接口 IUserDAO.java。我们可以手工添加，但是 Eclipse 为我们提供的更方便的方法。

具体操作是，打开 org.galaxy.ssh.dao.impl.UserDAO，点击右键，选择 Refactor -> Extract Interface…。

JSP

Form

Action Service interface

Service

implementation DAO interface

DAO

implementation Object

POJO

图表 49 目录组织示意图



图表 50 导出接口

在弹出的对话框里面填写接口名字为 IUserDAO，然后按照需要选择，这里我们按照下图只选择几项就可以

了：



图表 51 添加接口方法

完成后点击确定即可。生成的接口 IUserDAO 位于 org.galaxy.ssh.dao.impl 下面，通过 move 命令将它移动到

org.galaxy.ssh.dao 下面即可。

在 service 包下面建立接口 IUserService，具体代码如下：

在 service.impl 下面新建 UserService 类，实现 IUserService 接口：

package org.galaxy.ssh.service;

import org.galaxy.ssh.obj.User;

public interface IUserService {

public User getUserById(Integer id);

public User getUserByName(String name);

public void addUser(User user);

}



这里我们的目的是将业务逻辑和 DAO 类解耦。我们使用 service 包下面的类封装起与数据库实际打交道的

DAO 类，从而将业务逻辑与数据库操作类分离。

现在我们的类已经准备好，下面需要把这些类在 Spring 里面进行注册，以便 Spring 替我们进行类的管

理。

首先打开 WEB-INF 下面的 Spring 配置文档 applicationContext.xml，点击右键，选择 Spring -> New Bean…。

package org.galaxy.ssh.service.impl;

import org.galaxy.ssh.dao.IUserDAO;


import org.galaxy.ssh.service.IUserService;

public class UserService implements IUserService {

private IUserDAO userDAO;

public User getUserById(Integer id) {

return userDAO.findById(id);

}

public User getUserByName(String name) {

List list = userDAO.findByName(name);

if(list.size() == 0) {

return null;

} else {

return (User)list.get(0);

}

}

public void addUser(User user) {

userDAO.save(user);

}

public IUserDAO getUserDAO() {

return userDAO;

}

public void setUserDAO(IUserDAO userDAO) {

this.userDAO = userDAO;

}

}



图表 52 新建 Bean

在弹出的对话框中，输入 Bean ID，这是以后我们在 Spring 上下文中需要使用的名字。Spring 根据这个

名字找到对应的 Bean，由容器将其实例化出来。然后找到需要添加的类，将其完整类名填写到 Bean class

里面。



图表 53 配置 Spring Bean

注意到我们的 UserService 类有一个属性 IUserDAO，所以我们需要对 Spring 注册这个属性。这是需要选

择 Properties 选项卡，点击 Add…按钮。在弹出的对话框中填入 Name 为 userDAO。注意，这里的属性名必

须和类中的一致，否则将会出现找不到属性的错误。Spring Type 选择 ref。这是与属性的性质相关的。ref

表示这个属性类型是类。如果是一个基本数据类型或者固定的字符串，可以用 value；其他一些选项请具体

参阅 Spring 的文档。Reference Type 指这个属性如何找到。因为我们选择的是 ref 属性，因而 Spring 需要为

这个属性创建相应的类实例，从而对这个属性分配内存空间，这就要求我们指定这个类的 Bean ID。由于我

们的属性是 IUserDAO，可以用一个 UserDAO 对象初始化，于是我们寻找 Spring 配置文档，找到 UserDAO 的

Bean ID 是 UserDAO，于是这里我们填写 UserDAO。



图表 54 添加属性

全部完成之后点击 Finish 即可。

最后我们建立一个 test 包，新建一个 Test 类，然后编写测试代码：

运行该类，我们会得到下面结果：

package org.galaxy.ssh.test;



import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Test {

public static void main(String[] args) {

ApplicationContext ctx = new

FileSystemXmlApplicationContext("/WebRoot/WEB-INF/applicationContext.xml");

IUserService service = (IUserService)ctx.getBean("userService");

User user = service.getUserById(1);

System.out.println(user.getName());

}

}



这是 MyEclipse 的一个 Bug，我们可以在 applicationContext.xml 里面看到，

数据源使用的是 org.apache.commons.dbcp.BasicDataSource，但是这个类并没有被 MyEclipse 添加

到路径中，所以会有 NoClassDefFoundError。解决的办法是，到

http://commons.apache.org/downloads/download_pool.cgi

页面，下载 Binary 文件 1.3.tar.gz 或者 1.3.zip。当然，你也可以下载源代码，然后自行编译，不过我们不去

做这一步了。

图表 55 commons-pool 下载页面

下载后进行解压缩，可以看到里面的文件如下所示：

<bean id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName"

value="com.mysql.jdbc.Driver">

</property>

<property name="url"

value="jdbc:mysql://localhost:3306/"></property>

<property name="username" value="root"></property>

<property name="password" value="root"></property>

</bean>

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error

creating bean with name 'dataSource' defined in file […]: Instantiation of bean failed; nested

exception is java.lang.NoClassDefFoundError: org/apache/commons/pool/impl/GenericObjectPool

Caused by: java.lang.NoClassDefFoundError: org/apache/commons/pool/impl/GenericObjectPool

http://commons.apache.org/downloads/download_pool.cgi



图表 56 commons-pool-1.3

我们将 commons-pool-1.3.jar 文件复制到 SSH/WebRoot/WEB-INF/lib 文件夹下，然后将其添加到工程路

径，具体操作为：在 SSH 工程上面点右键，选择 Build Path -> Add External Archives...。

图表 57 Add External Archives...

在弹出的浏览文件对话框里找到刚刚复制到 SSH/WebRoot/WEB-INF/lib 文件夹下的

commons-pool-1.3.jar，然后选择打开即可。此时，在 SSH 项目的 Referenced Libraries 下面应该有

commons-pool-1.3.jar，表明已经添加到项目路径之中。



图表 58 添加成功

此时再去运行 Test 类，会有如下的结果：

可以看到，其中的admin就是从数据库中读取的id为1的记录的name值。因此我们可以说，Spring和Hibernate

已经能够顺利的整合了。我们可以在org.galaxy.ssh.dao.impl.UserDAO中清楚的看到，其中的

Hibernate的代码已经完全委托给了Spring进行管理，这就是Spring和Hibernate进行整合的实质，就是将

Hibernate委托给Spring进行管理。

同时，我们可以看到前面有两条红色的log4j的警告，这是由于我们没有在项目中配置log4j的缘故，这

并不影响我们的项目的正常运行，但是应该在实际项目中配置好log4j，以便对项目的运行情况进行记录。

然后我们修改Test类，使用如下的代码：

log4j:WARN No appenders could be found for logger

(org.springframework.context.support.FileSystemXmlApplicationContext).

log4j:WARN Please initialize the log4j system properly.

admin



可以看到数据库中新增加了一条记录，证明我们的插入操作也是可行的。

此时的 Hibernate 插入并不支持事务处理。我们可以在 Spring 配置文件中利用 Spring AOP 机制添加事务

处理，或者是在 Hibernate 代码中添加相应的处理代码。这里不再详述。

10. 整合 Struts 和 Spring

Struts 和 Spring 有三种整合方式。其核心是让 Struts 能够访问到交给 Spring 进行托管的类，因此只要我

们可以让 Struts 从 Spring 获得需要的类就可以了。

为了达到这个目标，我们创建一个类：

package org.galaxy.ssh.struts.action;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

import org.springframework.web.struts.ActionSupport;

public class BaseAction extends ActionSupport {

protected Object getBean(String id){

WebApplicationContext ctx =

WebApplicationContextUtils.getWebApplicationContext(this.servlet.getServletCon

text());

return ctx.getBean(id);

}

}

package org.galaxy.ssh.test;



import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Test {

public static void main(String[] args) {

ApplicationContext ctx = new

FileSystemXmlApplicationContext("/WebRoot/WEB-INF/applicationContext.xml");

IUserService service = (IUserService)ctx.getBean("userService");

User user = new User();

user.setName("user");

user.setPassword("user");

user.setPurview("USER");

service.addUser(user);

}

}



这个 BaseAction 类继承自 ActionSupport 类，后者是 Spring 中对应着 Struts 的 Action 的类。ActionSupport

类中提供了访问WebApplicationContext的简便方法，而后者是在web程序中获取 Spring托管的类的上下文。

以后我们编写的 Struts中的 Action继承自这个 BaseAction，就可以利用 getBean 在我们的 Action中获取 Spring

托管的类。

为了让 Web 容器能够初始化 Spring，我们需要修改 web.xml 文件，增加以下内容：

此时我们已经完成了 Struts 和 Spring 的整合。

11. 测试 SSH 的整合

为了测试 Struts 和 Spring 的整合，我们需要首先创建基于 Struts 的 JSP 页面。打开 WEB-INF 下面的

struts-config.xml，单击右键，选择 New -> Form, Action and JSP。

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/applicationContext.xml</param-value>

</context-param>

<servlet>

<servlet-name>SpringContextServlet</servlet-name>

<servlet-class>

org.springframework.web.context.ContextLoaderServlet

</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>



图表 59 添加 Form, Action and JSP

在弹出的对话框中添加 User case，然后点击 Add 生成 Properties 代码。这会由 MyEclipse 自动生成相应

的 Form 代码。输入完成后选择 JSP 选项卡，选上 Create JSP form，修改路径，然后点击 Next。



图表 60 编辑 Struts Form



图表 61 让 MyEclipse 创建 JSP 页面

在出现的对话框中修改 Path，将 Superclass 更改为前面定义的 org.galaxy.ssh.struts.action.BaseAction，然

后将 Input Source 修改为自己需要的路径。完成后 Finish 即可。



图表 62 创建 Action

在 WebRoot 下面创建一个 Welcome.jsp 文件，其代码如下所示：



然后在 struts-config.xml 点击右键，选择 New -> Forward，准备创建一个 ActionForward。

图表 63 新建 Forward

在弹出的对话框中，选择 Local Action Forward，通过 Browser 填写 Action Path，然后填写 Name 和 Path，

完成后点击 Finish 即可。

<%@ page contentType="text/html; charset=utf-8" language="java" %>

<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<title>Seccess</title>

</head>

<body>

welcome!

</body>

</html>



图表 64 定义新的 Forward

在 org.galaxy.ssh.struts.action.LoginAction 中填写如下的代码：



点击服务器旁边的下拉箭头，

图表 65 选择服务器

在弹出的对话框左侧的树状菜单中找到 Tomcat 6.x，选中 Enable，然后通过 Browser 找到 Tomcat home

directory 的文件夹，即是本地 Tomcat 的安装目录，MyEclipse 会自动填写下面两个目录地址。

package org.galaxy.ssh.struts.action;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;



import org.galaxy.ssh.struts.form.LoginForm;

public class LoginAction extends BaseAction {

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response) {

LoginForm loginForm = (LoginForm) form;

String name = loginForm.getName();

String password = loginForm.getPassword();

String purview = loginForm.getPurview();

ActionForward forward = mapping.getInputForward();

IUserService service = (IUserService) getBean("userService");

User userFromDB = service.getUserByName(name);

if(userFromDB.getPassword().equals(password)

&& userFromDB.getPurview().equals(purview)){

forward = mapping.findForward("success");

}

return forward;

}

}



图表 66 Tomcat

然后选择 Tomcat 6.x 的 JDK 节点，通过 Add 按钮选择本地安装的 JDK。注意，这里需要选择 JDK，而不是 JRE。

完成后点击 OK 即可。



图表 67 Tomcat JDK

此时在服务器按钮下面已经能够看到 Tomcat 6.x 的条目，我们选择 Start，启动 Tomcat。

图表 68 启动服务器

选择 Deploy 按钮，

图表 69 部署

在弹出的对话框中选择需要部署的工程，这里我们选择的是 SSH，然后点击 Add 按钮。



图表 70 部署项目

在弹出的对话框中选择 Server 为 Tomcat 6.x，点击 Finish 即可。



图表 71 部署项目

修改 WebRoot 下的 login.jsp：



完成后保存，此时 MyEclipse 会自动进行部署，如果没有的话请手动部署。

打开浏览器输入地址：

http://localhost:8080/ssh/login.jsp

就可以看到我们的页面。然后在 name 里面输入 admin，password 里面输入 damin，权限选择“管理员”，

点击 submit 按钮。

<%@ page contentType="text/html; charset=utf-8" language="java" %>

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean"%>

<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<title>JSP for LoginForm form</title>

</head>

<body>

<html:form action="/login">

name : <html:text property="name"/><html:errors property="name"/><br/>

password : <html:password property="password"/><html:errors

property="password"/><br/>

purview : <html:select property="purview"><html:option value="MANAGER">

管理员</html:option><html:option value="USER">用户

</html:option></html:select><html:errors property="purview"/><br/>

<html:submit/><html:cancel/>

</html:form>

</body>

</html>

http://localhost:8080/ssh/login.jsp



图表 72 登录页面

此时页面出现 welcome 字样：

图表 73 welcome

回忆起我们的代码中，使用 Spring 获得 service 下面的 bean，然后使用 Hibernate 代码对数据库进行操作。

所以我们说，Struts、Spring 和 Hibernate 已经能够协同工作了。

基于 MyEclipse6.0 的SSH 整合 -...

Documents

Transcript of 基于 MyEclipse6.0 的SSH 整合 -...