Transcript 第2章 为开发做好准备

第2章 为开发做好准备
安徽理工大学计算机科学与工程学院
2.1 MyEclipse开发环境的搭建
2.2 开发第一个Java Project
2.3 开发第一个Web Project
2.4 开发第一个Struts2程序
2.5
2.6
2.7
2.8
开发第一个Hibernate程序
开发第一个Spring程序
开发Struts 2、Spring集成程序
开发Hibernate、 Spring集成程序
2.9 开发Struts 2、Hibernate、Spring集成程序
2015/7/18
School of Computer Science & Engineering
1
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
1. 配置JRE
JRE是Java的运行环境，JDK是Java的开发环境。
因此，编写Java程序的时候需要JDK，而运行Java程
序的时候需要JRE。在JDK里面已经包含了JRE，因此
也可以正常运行Java程序。
在MyEclipse中内嵌了Java编译器。在这里指定
自己安装的JDK。
打开MyEclipse。选择菜单
WindowPreferences…，出现如图2-1所示对话框。
2015/7/18
School of Computer Science & Engineering
2
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
图2-1 MyEclipse配置
2015/7/18
School of Computer Science & Engineering
3
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
2．配置MyEclipse与Tomcat集成
启动MyEclipse，选择菜单
WindowsPreferences命令，显示MyEclipse配
置对话框，单击左边目录树中的
“MyEclipseApplication
ServersTomcatTomcat 6.x”选项，在右面激活
Tomcat 6.x，设置Tomcat的路径，如图2-2所示。
2015/7/18
School of Computer Science & Engineering
4
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
图2-2 MyEclipse中的服务器配置
2015/7/18
School of Computer Science & Engineering
5
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
图2-3 配置Tomcat
2015/7/18
School of Computer Science & Engineering
6
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
在MyEclipse的工具栏点击“startstop/restart
MyEclipse Server”按钮，选择Tomcat 6.xStart，
如图2-4所示。
从MyEclipse工具栏启动Tomcat
图2-4 启动Tomcat
2015/7/18
School of Computer Science & Engineering
7
2.1 MyEclipse开发环境的搭建
安徽理工大学计算机科学与工程学院
在控制台会出现启动Tomcat的信息。打开浏览
器，输入http://localhost:8080/，如果配置成功，
则出现Tomcat首页，如图2-5所示。
图2-5 Tomcat首页
2015/7/18
School of Computer Science & Engineering
8
2.2 开发第一个Java Project
安徽理工大学计算机科学与工程学院
 2.2.1 开发步骤
这里，将开发第一个Java Project。运行结果为
在控制台打印“Hello World”，如图2-6所示：
图2-6 程序运行结果
2015/7/18
School of Computer Science & Engineering
9
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
项目完成后的目录树如图2-7所示。
图2-7 项目目录树
开发的主要步骤如下:
步骤1: 创建Java Project
步骤2: 创建包
2015/7/18
School of Computer Science & Engineering
10
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
步骤3: 创建类
步骤4: 运行
具体过程如下:
● 步骤1 创建Java Project
选择菜单“FileNewJava Project”，创建
一个Java Project，出现如图2-8所示对话框，为
新建的Java Project输入名称：MyProject，其它
选项保持默认，选择“Finish”。
2015/7/18
School of Computer Science & Engineering
11
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
输入项目名称
图2-8 创建一个Java Project
2015/7/18
School of Computer Science & Engineering
12
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
此时，MyEclipse生成了一个名为MyEclipse的工程，
如图2-9所示。
图2-9 MyProject工程
JRE System Library存放的是环境运行需要的
类库。
2015/7/18
School of Computer Science & Engineering
13
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
src是一个源代码文件夹（source folder），
它与一般的文件夹（folder）不同之处在于src用
来存放Java源代码。只要把Java源代码放入src
中，MyEclipse会自动编译src中的源代码。而
folder一般都放一些不需要编译的东西，比如Jar
包或者其它文件。自己写的代码都需要放入src文
件夹。
2015/7/18
School of Computer Science & Engineering
14
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
● 步骤2 创建包
右击src文件夹，选择NewPackage，如图210，输入包名com.apex.demo，选择“Finish”。将
看到如图2-7所示的一个包。
选择源代码文件夹
输入包名称
图2-10 输入包名
2015/7/18
School of Computer Science & Engineering
15
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
●
步骤3 创建类
选中src，右击src，出现菜单，选择NewClass，
出现如图2-11所示对话框。
类所在包
输入类名
图2-11 New Java Class
2015/7/18
School of Computer Science & Engineering
16
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
选择“Finish”，文件保存时，会自动编译。
MyClass.java代码如下：
package com.apex.demo;
public class MyClass {
public static void main(String[] args) {
System.out.println("Hello
World");
}
}
2015/7/18
School of Computer Science & Engineering
17
2.2.1 开发步骤
安徽理工大学计算机科学与工程学院
● 步骤4 运行
在Package Explorer中选中MyClass.java，右键
Run AsJava Application, 运行结果如图2-12所示。
图2-12 运行结果
2015/7/18
School of Computer Science & Engineering
18
2.2.2 知识点：包、目录和JAR文件
安徽理工大学计算机科学与工程学院
包（package）是Java中一个独特而非常重要的概
念。它是一种Java文件的组织方式，一组特定的文
件组织在一个包中完成一个或者一组特定的功能。
包也不仅仅是一种文件组织方式，同时也和Java的
语言的规范关联起来。比如，protected限定的方法
在同一个包内是可见的，但是别的包就无法访问到。
每一个Java程序都要声明自己属于哪个包，在程
序文件的开头加上package包名。包可以组织成一个
体系，形成一个树状结构的体系，只要以“.”分割每
个名字即可。例如：java.lang、java.util。包名
可以任意制定，但通常以小写字母表示，并以com
（公司）、org（组织）等开头，例如com.sun.***。
2015/7/18
School of Computer Science & Engineering
19
2.2.2 知识点：包、目录和JAR文件
安徽理工大学计算机科学与工程学院
既然Java定义了包的概念，那么Java的源程序文件和
编译产生的class文件都必须按照包的概念来组织目录结
构。即，当在程序中声明了所属的包的时候，程序文本
本身必须存放在包对应的目录中。例如，2.2.1提到的
MyClass.java属于包com.apex.demo，所以MyClass.java
文件必须存放在目录\com\apex\demo\下，相应的编译生
成的MyClass.class文件也在目录\com\apex\demo下。
开发一个Java应用程序将编写大量的源文件，这些文
件虽然按照“包”的要求有序地组织在一起，但是一旦
文件很多，在部署应用的时候依然显得很杂乱。因此，
一种将一个或者一组包的class文件包装到一个文件中去
的方法就产生了，就是JAR。JAR其实是将一组文件压缩
打包成一个文件，文件的后缀为jar。
2015/7/18
School of Computer Science & Engineering
20
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
这里，将开发一个Web项目，当用户在浏览器中
输入
http://localhost:8080/myWebProject/index.js
p时，服务器会返回给用户一句话：“Hello
World”，如图2-13所示。
图2-13 Web项目的运行效果
2015/7/18
School of Computer Science & Engineering
21
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
工程最后的目录树如图2-14所示
图2-14 工程目录树
主要的步骤如下:
步骤1：创建Web Project
步骤2：创建JSP
步骤3：部署
步骤4：运行浏览
2015/7/18
School of Computer Science & Engineering
22
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
● 步骤1 创建Web Project
启动MyEclipse，选择菜单FileNewWeb
Project，为Web Project起名为myWebProject，
其它的可以选择默认，出现如图2-15所示对话
框。
2015/7/18
School of Computer Science & Engineering
23
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
输入项目名称
图2-15 创建Web Project
2015/7/18
School of Computer Science & Engineering
24
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
最简单Web项目只需要一个子目录WEB-INF。
WEB-INF是一个很重要的目录，把Web项目的配
置文件web.xml放在这个目录下。通常在其下创
建lib和classes，在lib中放置应用依赖的Java
库文件或者自己编写的JAR包。在classes中通
常放自己所编写的编译后的java class文件。
web.xml是一个Web项目的配置文件。
2015/7/18
School of Computer Science & Engineering
25
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
● 步骤2 创建JSP
在MyEclipse菜单栏中，选择FileNew File。输入
新文件名“index.jsp”。由于MyEclipse会自动创建一个
缺省的index.jsp文件，所以不需要再创建。双击打开
这个文件，将其修改成以下内容。
index.jsp代码如下：
<%@ page language="java" pageEncoding="ISO8859-1"%>
<html>
<head> </head>
<body>
Hello World
</body>
</html>
2015/7/18
School of Computer Science & Engineering
26
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
● 步骤3：部署
如图2-16所示，选择工具栏中的按钮“Deploy
MyEclipse J2EE Project to Server”，将新建的
Web项目部署到Tomcat中。
图2-16 部署按钮
2015/7/18
School of Computer Science & Engineering
27
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
选择项目为myWebProject，选择Add按钮，选择
Tomcat 6.X作为我们的服务器。如图2-17所示，
按OK。
选择要部署的项目
选择要部署到的服务器
图2-17 部署Web Project
2015/7/18
School of Computer Science & Engineering
28
2.3 开发第一个Web Project
安徽理工大学计算机科学与工程学院
● 步骤4: 运行浏览
启动Tomcat 6.x。在浏览器中输入
http://localhost:8080/myWebProject/index.jsp，
将看到如图2-18所示画面。
图2-18 myWebProject运行结果
2015/7/18
School of Computer Science & Engineering
29
2.4 开发第一个Struts2程序
安徽理工大学计算机科学与工程学院
 2.4.1 概述
Apache Struts 2是一个为企业级应用打造的优
秀的、可扩展的WEB框架。该框架旨在充分精简应
用程序的开发周期，从而减少创建、发布直到应用
所花费的时间。
在对Struts 2做详细介绍之前，这里先来感受
一下，将开发一个Web Project。用户输入姓名和
密码，如图2-19所示。如果输入和密码是“scott”
和“tiger”，则进入欢迎页面；反之，进入失败页
面。
2015/7/18
School of Computer Science & Engineering
30
2.4.1 概述
安徽理工大学计算机科学与工程学院
项目最后的目录树如图2-20所示。
图2-19 用户登录界面
图2-20 项目目录树
2015/7/18
School of Computer Science & Engineering
31
2.4.1 概述
安徽理工大学计算机科学与工程学院
开发的步骤如下：
步骤1：下载Struts2框架
步骤2：创建Web Project
步骤3：加载Struts2包
步骤4：修改web.xml
步骤5：创建login.jsp
步骤6：实现控制器
步骤7：配置struts.xml
步骤8:：创建登录成功失败页面
步骤9：部署
2015/7/18
School of Computer Science & Engineering
32
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤1 下载Struts 2框架
MyEclipse 6没有对Struts 2的支持，所以需要自己下
载Struts 2开发包。登录http://struts.apache.org/。下
载Struts 2的完整版，本书使用的是struts-2.0.11。将下
载的Zip文件解压缩，它是一个典型的Web结构，该文件夹
包含如下文件结构如图2-21所示。
图2-21 Strust 2.0.11 文件结构
2015/7/18
School of Computer Science & Engineering
33
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
apps：包含基于Struts 2的示例应用，对学习
者来说是非常有用的资料。
docs：包含Struts 2的相关文档，如Struts 2
的快速入门、Struts 2的文档、以及API文档等
内容。
j4：包含了让Struts 2支持JDK 1.4的JAR文件。
lib：包含Struts 2框架的核心类库，以及
Struts 2的第三方插件类库。
src：包含Struts 2框架的全部源代码。
2015/7/18
School of Computer Science & Engineering
34
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤2: 打开MyEclipse，创建Web Project，命
名项目的名称为struts2。
● 步骤3: 加载Strut 2包
将下载的Struts 2包解压后得到的lib文件夹下的
Struts2-core-2.0.11.jar， xwork-2.0.1.jar和
ognl-2.6.11.ar，common-logging-1.0.4.jar，
freemarker-2.3.8.jar五个必须的jar包复制到WEBINF/lib路径下。大部分时候，使用Struts 2的Web应
用并不需要利用到Struts 2的全部特性。
在目录树中，选中刚刚创建的struts2工程，右击，
选择Build PathConfigure Build Path…，出现如
图2-22所示的对话框。选择Add External JARs将下载
的五个jar包添加到项目中。
2015/7/18
School of Computer Science & Engineering
35
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
选择Java Build Path
添加项目外JAR包
图2-22 添加Jar包
2015/7/18
School of Computer Science & Engineering
36
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
主要类描述如下：
common-logging.jar：用于能够插入任何其它的
日志系统。
ognl.jar:OGNL：表达式语言。
struts2-core.jar：Struts 2框架类库。
xwork.jar：Xwork项目，Struts 2就是在此基础
上构建的。
freemarker.jar：所有的UI标记模板。
● 步骤4: 修改web.xml
打开WebRoot/WEB-INF/web.xml，修改成如下代码：
2015/7/18
School of Computer Science & Engineering
37
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
<?xml version="1.0" encoding="UTF-8"?>
<web-app 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">
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2015/7/18
School of Computer Science & Engineering
38
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤5 创建login.jsp
从用户请求开始，在WebRoot下创建一个简单的表单提
交页面login.jsp，方法是：右击webRoot选择newjsp，
在File Name中输入文件名“login.jsp”。
login.jsp代码如下：
<%@ page language="java" pageEncoding="gb2312"%>
<html>
<head><title>登录页面</title></head>
<body>
<form action="login.action" method="post">
用户登录<br>
姓名:<input type="text" name="username"/><br>
密码:<input type="text" name="password"/><br>
<input type="submit" value="登录"/>
</form>
</body>
</html>
当表单提交给login.action时，Struts 2的FilterDispacher将自动起作
用，将用户请求转发到对应的Struts 2 Action。
2015/7/18
School of Computer Science & Engineering
39
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤6 实现控制器
在src目录下创建一个新类LoginAction.java，代
码如下：
上面的Action类是一个普通的Java类。该类定义了
两个属性：username和password。类变量的命名必须
与在login.jsp中使用的文本输入框的命名严格匹配。
在Struts 2中，类变量总是在调用execute()方法之前
被设置（通过setUsername()，setPassword()方法），
这意味着在execute()方法中可以使用这些类变量，因
为在execute方法执行之前，它们已经被赋予了正确的
值。
2015/7/18
School of Computer Science & Engineering
40
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤7 配置struts.xml
在src下生成文件struts.xml（注意文件位置和大小写）
里面代码如下：
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration
2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="struts" extends="struts-default">
<action name="login" class="LoginAction">
<result name="error">/error.jsp</result>
<result name="success">/welcome.jsp</result>
</action>
</package>
</struts>
2015/7/18
School of Computer Science & Engineering
41
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
映射文件定义了name为login的Action。即当Action负
责处理login.actionURI的客户端请求，该Action将调用自
身的execute方法处理用户请求，如果execute方法返回
success字符串，请求被转发到/welcome.jsp页面，如果
execute方法返回error字符，则请求被转发到/error.jsp
页面。
● 步骤8: 创建登录成功失败页面
经过上面的步骤，这个Struts 2应用几乎可以运行了，
但还需要为该Web应用增加两个JSP文件，两个JSP文件分别
是error.jsp页面和welcome.jsp页面，将这两个jsp页面文
件放在Web-Root下。
2015/7/18
School of Computer Science & Engineering
42
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
welcome.jsp的代码如下：
<%@ page language="java" pageEncoding="gb2312"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<head><title>成功页面</title></head>
<body>
<s:property value="username" />已经
成功登录!
</body>
</html>
代码中第二行标签库定义将前缀s和uri之间建立映射关
系。前缀s指明了所有Struts 2标签在使用的时候以“s:”开
头。
2015/7/18
School of Computer Science & Engineering
43
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
<s:property value="username">是一个使用自定义
property标签的JSP页面。这个property标签包含一个value属
性值，通过设置value的值，标签可以从action中获得相应表达
式的内容，这是通过在action中创建了一个名为getUsername()
的方法得来的。将以上的代码保存在welcome.jsp文件中。
error.jsp的代码如下：
<%@ page language="java" pageEncoding="gb2312"%>
<html>
<head><title>失败页面</title></head>
<body>
登录失败!
</body>
</html>
2015/7/18
School of Computer Science & Engineering
44
2.4.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤9 部署
将应用程序部署到服务器上。启动tomcat，运行
程序，在浏览器输入：
http://localhost:8080/struts2/login.jsp。
2015/7/18
School of Computer Science & Engineering
45
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
1．Servlet
Java Web应用中最重要的概念就是Servlet。
Servlet是用Java编写的服务器端程序，是由服务器
端调用和执行的Java类。Servlet运行在Servlet引擎管
理的Java虚拟机中，被来自客户机的请求唤醒，能简单
地处理客户端的请求。
为了运行Servlet，首先需要一个JVM来提供对Java
的基本支持，一般需要安装JRE(Java Runtime
Environment)或JDK(Java Develop Kit, JRE是其中的
一个子集)。其次，需要Servlet API的支持。一般的
Servlet引擎都自带Servlet API。
当容器通过web.xml文件得知配置了Servlet以后，
通过配置所指定的class路径构造Servlet实例。
2015/7/18
School of Computer Science & Engineering
46
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
Servlet的周期：初始化服务消亡。初始化在构造实例的
时候有容器调用init方法完成，初始化在Servlet的整个生命周
期中只进行一次。服务在发生请求时进行，发生一次请求就进行
一次服务。消亡通常发生在容器关闭的时候，消亡的时候容器会
调用destroy方法，destroy方法在Servlet的整个生命周期中也
只调用一次。
当容器启动的时候会构造一个用来请求处理http请求的线程
池，并在适当的时候构造出每一个Servlet实例。当有请求发生
的时候，容器就从线程池中取出一个线程来处理这个请求，如果
这个请求需要一个Servlet来处理，容器就会将请求传递给对应
的Servlet来处理，并将处理的结果返回给处理线程，处理线程
将结果返回给请求者，然后线程返回到线程池中等待别的请求。
2015/7/18
School of Computer Science & Engineering
47
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
2．Filter
在项目中的web.xml中，有一个名词Filter，这
是什么呢?它起了什么作用呢?
…
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
…
2015/7/18
School of Computer Science & Engineering
48
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
Filter过滤器是Java中常用的一项技术，过滤
器是用户请求和处理程序之间的一层处理程序。这
层程序可以对用户请求和处理程序响应的内容进行
处理。利用过滤器的这个特点可以用于权限控制，
编码转换等场合。
2015/7/18
School of Computer Science & Engineering
49
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
Servlet过滤器是在Java Serlvet规范中定义的，
它能够对过滤器关联的URL请求和响应进行检查和修
改。Servlet过滤器能够在Servlet被调用之前检查
Request对象，修改Request Header和Request内容；
在Servlet被调用之后检查Response对象，修改
Response Header和Response内容。Servlet过滤器
过滤的URL资源可以是Servlet、JSP、HTML文件，或
者是整个路径下的任何资源。多个过滤器可以构成
一个过滤器链，当请求过滤器关联的URL的时候，过
滤器链上的过滤器链会挨个发生作用。图2-23说明
了过滤器的概念。
2015/7/18
School of Computer Science & Engineering
50
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
请求
正常的请求
浏览器
Web
服务器
响应
加过滤器的请求
浏览器
请求
过滤器
响应
请求
加过滤器链的请求 浏览器
Web
服务器
响应
请求
过滤器1
响应
请求
请求
过滤器2
响应
Web
服务器
响应
图2-23 过滤器处理请求的过程
2015/7/18
School of Computer Science & Engineering
51
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
图中显示了正常请求，加过滤器请求和加过滤器链
的请求处理过程。过滤器可以对Request对象和
Response对象进行处理。所有的过滤器类都必须实现
java.Servlet.Filter接口，这个接口含有3个过滤器
类必须实现的方法：
（1）init(FilterConfig)
这是Servlet过滤器的初始化方法，Servlet容器创
建Servlet过滤器实例后将调用这个方法。在这个方
法中可以通过FilterConfig参数读取web.xml文件中
的Servlet过滤器的初始化参数。
（2）doFilter(ServletRequest，
ServletResponse，FilterChain)
2015/7/18
School of Computer Science & Engineering
52
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
这个方法完成实际的过滤操作，当用户请求与过滤器关联的URL
时，Servlet容器将先调用过滤器的doFilter方法，在返回响应之
前也会调用此方法。FilterChain参数用于访问过滤器链上的下一
个过滤器。
（3）destroy()
Servlet容器在销毁过滤器实例前调用该方法，这个方法可以释
放Servlet过滤器占用的资源。
过滤器编写完成后，要在web.xml进行配置，格式如下：
<filter>
<filter-name>过滤器名称</filter-name>
<filter-class>过滤器对应的类</filter-class>
<!—初始化参数-->
<init-param>
<param-name>参数名称</param-name>
<param-value>参数值</param-value>
</init-param>
</filter>
2015/7/18
School of Computer Science & Engineering
53
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
过滤器必须和特定URL关联才能发挥作用，过滤器的关
联方式有3中：与一个URL关联、与一个URL目录下的所有
资源关联、与一个Servlet关联。下面，在web.xml中配置
过滤器与URL关联。
（1）与一个URL资源关联：
<filter-mapping>
<filter-name>过滤器名</filter>
<url-pattern>xxx.jsp</url.pattern>
</filter-mapping>
（2）与一个URL目录下的所有资源关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<url-pattern>/*</url-pattern>
2015/7/18
School of Computer Science & Engineering
54
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
</filter-mapping>
（3）与一个Servlet关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<Servlet-name>Servlet名称</Servlet-name>
</filter-mapping>
2015/7/18
School of Computer Science & Engineering
55
2.4.3 知识点：Servlet、Filter简介
安徽理工大学计算机科学与工程学院
前面讲述了过滤器的基本概念，那么过滤器有
什么用处呢?
常常利用过滤器完成以下功能：
（1）权限控制，通过过滤器实现访问的控制，
当用户访问某个连接或者某个目录的时候，可以
利用过滤器判断用户是否有访问权限。
（2）字符集处理，可以在过滤器中处理
request和response的字符集，而不用在每个
Servlet或者JSP中单独处理。
（3）其它使用的一切场合，过滤器非常有用，
我们可以利用它完成很多适合的工作，如计数器、
数据加密、访问触发器、日志、用户使用分析等。
2015/7/18
School of Computer Science & Engineering
56
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
Struts 2的配置可以分成单个单独的文件，
如图2-24所示。
图2-24 框架元素的配置文件
2015/7/18
School of Computer Science & Engineering
57
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
其中web.xml是Web部署描述符，包括所有必须的
框架组件。struts.xml是Struts 2的主要配置文件。
struts.properties是Struts 2框架的属性配置。
web.xml
web.xml并不是Struts 2框架特有的文件。作为
部署描述文件，web.xml是所有Java Web应用程序
都需要的核心配置文件。
Struts 2框架需要在web.xml文件中配置一个前
端控制器FilterDispatcher，用于对Struts框架进
行初始化，以及处理所有的请求。
FilterDispatcher是一个servlet过滤器，它是
整个Web应用的配置项，如下是一个
FilterDispatcher的例子：
2015/7/18
School of Computer Science & Engineering
58
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
<web-app version=”2.4”
xmlns=http://java.sun.com/xml/ns/j2ee
xmlns:xsi=http://www.w3.org/2001/XkMLSchema-instance
xsi:schemaLocation=http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd>
<filter>
<filter-name>struts2</filter-name>
<filterclass>org.apache.struts2.dispatcher.FilterDispatcher</filterclass>
</fiter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2015/7/18
School of Computer Science & Engineering
59
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
2．struts.properties文件
Struts 2提供了很多可配置的属性，通过这些属
性的设置，可以改变框架的行为，从而满足不同
Web应用的需求。这些属性可以在
struts.properties文件中进行设置，
struts.properties是标准的Java属性文件格式，
“＃”号作为注释符号，文件内容由键(key)－值
(value)对组成。
struts.properties文件必须位于classpath下，
通常放在Web应用程序的/WEB-INF/classes目录下。
2015/7/18
School of Computer Science & Engineering
60
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
Struts 2在default.properties文件（位于struts2core-2.0.11.jar）中给出了所有的属性的列表，并对其
中一些属性设置了默认值。如果开发人员创建了
struts.properties文件，那么在该文件中的属性设置会
覆盖default.properties文件中的属性设置。
在开发环境中，以下几个属性是可能会被修改的：
● struts.i18n.reload=true 激活重新载入国际化文
件的功能
● struts.devMode=true 激活开发模式，提供更全面
的调试功能
2015/7/18
School of Computer Science & Engineering
61
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
● struts.configuration.xml.reload=true 激活重
新载入XML配置文件的功能，当文件被修改以后，就不需
要你载入Servlet容器中的整个Web应用了。
● struts2.url.http.port=8080 配置服务器运行的
端口
3．stuts.xml文件
struts.xml是Struts 2框架的核心配置文件，主要用
于配置和管理开发人员编写的action。struts.xml文件通
常放在Web应用程序WEB-INF/classes目录下，在该目录下
的struts.xml将被Struts 2框架自动加载。
2015/7/18
School of Computer Science & Engineering
62
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
struts.xml文件是一个XML文件，所以最开始的
元素就是XML版本和编码信息。接下来则是XML的文
档类型定义（DTD）。DTD提供了XML文件中各个元
素应使用结构的信息，而这些最终会被XML解析器
或者编辑器使用。
<?xml version=”1.0” eccoding=”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=”struts2” extends=”struts-default”
namespace=”/struts2”>
…
</package>
</struts>
<struts>标签，位于Struts2配置的最外层，其它标签都是包含在它里面的。
2015/7/18
School of Computer Science & Engineering
63
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
● Package元素
Struts 2中的包类似于Java中的包，提供了将
action、result、result类型、拦截器和拦截器栈
组织为一个逻辑单元的一种方式，从而简化了维护
工作，提供了重用性。
与Java中的包不同的是，Struts 2中的包可以
扩展另外的包，从而“继承”原有包的所有定义，
并可以添加自己包特有的配置，以及修改原有包的
部分配置，从这一点上看，Struts 2中的包更像
Java中的类。
2015/7/18
School of Computer Science & Engineering
64
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
package元素有一个必须的属性name，指定包的名
字，这个名字将作为引用该包的键。要注意的是，包
的名字必须是唯一的，在一个struts.xml文件中不能
出现两个同名的包。package元素的extends属性是可
选的，允许一个包继承一个或多个先前定义的包中的
配置。package元素的abstract属性是可选的，将其设
置为true，可以把一个包定义为抽象的。抽象包不能
有action定义，它只能作为“父”包，被其他的包所
继承。
下面是一个包定义的例子。
2015/7/18
School of Computer Science & Engineering
65
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
<?xml version=”1.0” encoding=”GBK” ?>
<!DOCTYPE struts PUBLIC
”-//Apache Software Foundation//DTD Struts Configuration 2.0//EN”
http://struts.apache.org/dtds/struts-2.0.dtd>
<struts>
<!—定义了一个名为default的包，继承自struts-default.xml文件中定义的
struts-default抽象包
<package name=”default” extends=”struts-default”>
<action name=”viewSource”
class=”org.apache.struts2.showcase.source.ViewSourceAction”>
<result>viewSource.jsp</result>
</action>
</package>
<!—定义了一个名为skill的包，继承自先前定义的default包
<package name=”skill” extends=”default” namespace=”/skill”>
<action name=”list”
class=”org.apache.struts2.showcase.action.SkillAction” method=”list”>
<result>/empmanager/listSkills.jsp</result>
</action>
</package
</struts>
2015/7/18
School of Computer Science & Engineering
66
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
● Namespace属性
package元素的 namespace属性可以将包中的
action配置为不同的名称空间。
当Struts 2接收到一个请求的时候，它会将请求
URL分为namespace和action名字两部分，Struts 2
会从struts.xml中查找namespace/action这个命名
对，如果没有找到，Struts 2就会在默认的名称空
间中查找相应的action名。
默认的命名空间用空字符串” ”来表示，当在
定义包中没有使用namespace属性，那么就指定了默
认的名称空间。
下面是一个Struts 2文档中给出的名称空间的例
子。
2015/7/18
School of Computer Science & Engineering
67
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
<!—default包在默认的名称空间
<package name=”default”>
<action name=”foo” class=”mypackage.simpleAction”>
<result name=”success”
tpe=”dispachter”>greeting.jsp</result>
</action>
<action name=”bar” class=”mypackage.simpleAction”>
<result name=”success”
type=”dispatcher”>bar.jsp</result>
</action>
2015/7/18
School of Computer Science & Engineering
68
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
</package>
<!—mypackage1包在根命名空间
<package name=”mypackage1” namespace=”/”>
<action name=”moo” class=”mypackage.simpleAction”>
<result name=”success”
type=”dispatcher”>moo.jsp</result>
</action>
</package>
<!—mypackage2包在/barspace名称空间
<package name= ”mypackage2” namespace=”/barspace”>
<action name=”bar” class=”mypackage.simpleAction”>
<result name=”success”
type=”dispatcher”>bar2.jsp</result>
</action>
</package>
2015/7/18
School of Computer Science & Engineering
69
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
如果请求/barspace/bar.action，框架将首先
查找/barspace名称空间，如果找到了，则执行bar
action；如果没有找到，则到默认的名称空间中继
续查找。在本例中，/barspace名称中有名为bar的
action，因此它会被执行。
如果请求/barspace/foo.action，框架会在
/barspace名称空间中查找foo这个action。如果找
不到，框架会到默认命名空间中去查找。在本例子
中，/barspace名称空间中没有foo这个action，因
此默认空间中的/foo.action将被找到并执行。
2015/7/18
School of Computer Science & Engineering
70
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
如果请求/moo.action，框架会在根名称空间‘/’中查
找moo action，如果没有找到再到默认名称空间中查找。
● Action元素
Struts 2的核心功能是action，对于开发人员来说，
使用Strtus2框架，主要的编码工作就是编写action类。
action类通常都要实现com.opensymphony.xwork2.Action
接口，并实现该接口中的execute()方法。
当然，Struts 2并不要求所编写的action类一定要实
现Action接口，也可以使用一个普通的Java类作为一个
action，只要该类提供一个返回类型为String的无参的
public方法。
2015/7/18
School of Computer Science & Engineering
71
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
在实际开发中，action类很少直接实现Action接口，通常都是
从com.opensymphony.xwork2.ActionSuppoort类继承。
ActionSupport实现了Action接口和其他一些 可选的接口，提供了
输入验证、错误信息存取，以及国际化的支持，选择从
ActionSupport继承，可以简化action的开发。
开发好action后，就需要配置acton映射，以告诉Struts 2框架，
针对某个URL的请求应该交由哪一个action进行处理。
当一个请求匹配某个action的名字时，框架就使用这个映射来
确定如何处理请求。如：
<action name=”login” class=”org.apex.struts2.acion.LoginAction”>
<result>/success.jsp</result>
<result name=”error”>/error.jsp</result>
</action>
2015/7/18
School of Computer Science & Engineering
72
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
class属性是Action实现类的完整类名。在执行
action时，默认调用的是execute()方法。如上面
例子中请求login.action时，将调用
org.apex.struts2.action.LoginAction实例的
execute()方法。
也可以通过action元素的method属性来指定
action调用的方法所指定的方法。在struts.xml文
件中，可以为同一个action类配置不同的别名，并
使用method属性，如：
2015/7/18
School of Computer Science & Engineering
73
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
<package name=”default” extends=”struts-default”>
<!—请求/list，调用NewsAction的execute方法
<action name=”list” class=”org.apex.struts2.action.NewsAction”>
<result>/listNews.jsp</result>
</action>
<!—请求/create，调用NewsAction的create方法
<action name=”create” class=”org.apex.struts2.action.NewsAction”
method=”create”>
<result type=”redirect”>/list.action</result>
</action>
<!—请求/edit，调用NewsAction的edit方法
<action name=”edit” class=”org.apex.struts2.action.NewsAction”
method=”edit”>
<result>/editNews.jsp</result>
</action>
<!—请求/delete，调用NewsAction的delete方法
<action name=”delete”class =”org.apex.struts2.action.NewsAction”
method=”delete”>
<result type=”redirect”>/list.action</result>
</action>
</package>
2015/7/18
School of Computer Science & Engineering
74
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
● Result元素
一个result代表了一个可能的输出。当Action类
的方法执行完成时，它返回一个字符串类型的结果
码，框架根据这个结果码选择对应的result，向用
户输出。
在com.opensymphony.xwork2.Action接口中定义
了一组标准的结果代码，可提供开发人员使用，如
下所示：
public interfact Action{
public static final String SUCCESS = ”success”;
public static final Strng NONE = ”none” ;
public static final String ERROR = ”error”;
public static final String INPUT = ”input”;
public static final String LOGIN = ”login”;
}
2015/7/18
School of Computer Science & Engineering
75
2.4.4 知识点：Struts 2配置
安徽理工大学计算机科学与工程学院
除了这些预定义的结果码以外，开发人员也可以
定义其他的结果码来满足自身应用程序的需要。
如下所示：
<package name=”default” extends=”struts-default”>
<action name=”login”>
<result>/success.jsp</result>
<result name=”error”>/error.jsp</result>
</action>
</package>
2015/7/18
School of Computer Science & Engineering
76
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
一个请求在Struts 2框架被处理大致分为以下几个步
骤，如图2-25所示：
（1）客户端初始化一个指向Servlet容器（例如
Tomcat）的请求；
（2）这个请求经过一系列的过滤器（Filter）（这些
过滤器中有一个叫做ActionContextCleanUp的可选过滤器，
这个过滤器对于Struts2和其它框架的集成很有帮助，例
如：SiteMesh Plugin）；
（3）接着FilterDispatcher被调用，
FilterDispatcher询问ActionMapper来决定这个请求是否
需要调用某个Action；
（4）如果ActionMapper决定需要调用某个Action，
FilterDispatcher把请求的处理交给ActionProxy；
2015/7/18
School of Computer Science & Engineering
77
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
（5）ActionProxy通过Configuration Manager询问框
架的配置文件，找到需要调用的Action类；
（6）ActionProxy创建一个ActionInvocation的实例
（7）ActionInvocation实例使用命名模式来调用，在
调用Action的过程前后，涉及到相关拦截器
（Intercepter）的调用；
（8）一旦Action执行完毕，ActionInvocation负责根
据struts.xml中的配置找到对应的返回结果。返回结果通
常是（但不总是，也可能是另外的一个Action链）一个需
要被表示的JSP或者FreeMarker的模版。在表示的过程中
可以使用Struts 2 框架中继承的标签，在这个过程中需
要涉及到ActionMapper。
2015/7/18
School of Computer Science & Engineering
78
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
图2-25 Struts 2工作机制
2015/7/18
School of Computer Science & Engineering
79
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
在本节的例子中，当浏览器发送请求
http://localhost:8080/struts2/login.action请
求的时候，在服务器上发生了如下事件：
（1）服务器接收到login.action的请求，根据
web.xml文件的配置，所有的请求都会被
org.apache.struts2.dispatcher.FilterDispatch
er过滤，FilterDispatcher.FilterDispatcher是
Struts 2框架的入口点。
（2） Struts2框架查找login.action对应的
Java类，发现是LoginAction.java.之后，Struts
2框架实例化了一个LoginAction类，并调用了这个
类
2015/7/18
School of Computer Science & Engineering
80
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
（3）execute方法设置了username和password
的内容，并且返回SUCCESS。框架设定返回SUCCESS
的话，找到相应的welcome.jsp，并通知服务器将
welcome.jsp作为返回内容。如果返回ERROR的话，
则返回error.jsp。
（4） 在welcome.jsp被处理的过程中，
<s:property value="username"/>标签的内容被替
换为LoginAction的getUsername()方法调用的结果。
（5） 根据welcome.jsp（或者error.jsp）内
容生成的HTML内容被发回到请求的浏览器，
图2-26显示了处理流程。
2015/7/18
School of Computer Science & Engineering
81
2.4.4 知识点：Struts 2工作机制
安徽理工大学计算机科学与工程学院
图2-26 应用的处理流程
2015/7/18
School of Computer Science & Engineering
82
2.5 开发第一个Hibernate程序
安徽理工大学计算机科学与工程学院
 2.5.1 概述
Hibernate是对象/关系映射（ORM）的一个解决
方案。简单地说就是将Java中对象及对象之间的
关系映射至关系数据库中的表格及表格之间的关
系。Hibernate提供了整个过程自动转换的方案。
Hibernate是Java应用和关系数据库之间的关系，
负责Java对象和关系数据之间的映射。Hibernate
内部封装了通过JDBC访问数据库的操作，向上层
应用提供了面向对象的数据访问API。
2015/7/18
School of Computer Science & Engineering
83
2.5 开发第一个Hibernate程序
安徽理工大学计算机科学与工程学院
这里将演示如何将一个内存的User类型的对象
user进行持久化处理，变为表格user中的一条记
录，如图2-27所示。
图2-27 Hibernate持久化
2015/7/18
School of Computer Science & Engineering
84
2.5.1 概述
安徽理工大学计算机科学与工程学院
项目最后的目录树如图2-28所示。
图2-28 项目目录树
程序主要步骤：
步骤1：在数据库MySQL中创建表user，用于记
录用户的名称和密码
步骤2：在MyEclipse中创建对MySQL的连接
2015/7/18
School of Computer Science & Engineering
85
2.5.1 概述
安徽理工大学计算机科学与工程学院
步骤3：在MyEclipse中创建Java Project，命
名为hibernate
步骤4：添加Hibernate支持包到项目中
步骤5：生成数据库表对应的Java数据对象和
映射文件
步骤6：创建测试类。
2015/7/18
School of Computer Science & Engineering
86
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
● 步骤1 在数据库MySQL中创建表user，用
于记录用户的名称和密码。
CREATE DATABASE test;
use test;
CREATE TABLE user(
id int(10) not null auto_increment,
username varchar(10) not null,
password varchar(10) not null,
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=GBK;
● 步骤2 在MyEclipse中创建对MySQL的连接
启动MyEclipse，选择菜单WindowOpen
PerspectiveMyEclipse Database Expoer，打
开MyEclipse Database浏览器，右击菜单，选择
New…，如图2-29所示，
2015/7/18
School of Computer Science & Engineering
87
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
创建一个新的数据库连接
图2-29 MyExlipse Database浏览器，创建一个新的连接
2015/7/18
School of Computer Science & Engineering
88
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
出现如图2-30所示的对话框，编辑数据库连接驱动。
连接到本机3306端口的test数据库
图2-30 编辑数据库连接驱动
2015/7/18
School of Computer Science & Engineering
89
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
编辑完成以后，在MyEclipse Database浏览器中，
选中刚才创建的mysql数据库连接，选择Open
connection..，打开名为mysql的数据连接，如图
2-31所示。
图2-31 打开数据库连接
● 步骤3在MyEclipse中创建Java Project，命
名为hibernate。
2015/7/18
School of Computer Science & Engineering
90
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
●步骤4 添加Hibernate Capabilites到项目中。
右击项目hibernate，选择MyEclipseAdd
Hibernate Capabilites…来启动向导，将出现
Hibernate配置向导。首先出现图2-32所示对话框，
选择Hibernate框架所需要的类库。
2015/7/18
School of Computer Science & Engineering
91
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
要添加到项目中的Hibernate版本支持功能,为了最大限度
的使用MyEclipse Hibernate工具, 推荐Hibernate 3.1
选择需要的类库集合, 这个示例中Core类
库集足够了
选中的类库将会添加到项目的构造路径中,但是相应的
JAR文件不会复制到项目中.这些JAR文件将会在发布
程序时复制。
选中的类库JAR文件将会被复制到项目并添加
到构造路径中。
图2-32 添加JAR包
2015/7/18
School of Computer Science & Engineering
92
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
选择“Next”按钮，进入如图2-33所示界面。
用于创建Hibernate配置文件。
定义配置文件的名称和路径
图2-33 创建hibernate.cfg.xml
2015/7/18
School of Computer Science & Engineering
93
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
选择“Next”，进入如图2-34所示界面，指定
Hibernate数据库连接细节。由于在前面已经配置一个
名为mysql的数据库连接，所以这里只需要选择DB
Driver为mysql即可。
2015/7/18
School of Computer Science & Engineering
94
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
图2-35 创建SessionFactory类来简化Hibernate会话处理
2015/7/18
School of Computer Science & Engineering
95
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
点击“Finish”。通过这些步骤，项目中增加了
一些Hibernate JAR包和一个hibernate.cfg.xml配
置文件，一个HibernateSessionFactory.java类。
● 步骤5 生成数据库表对应的Java数据对象和
映射文件
首先在MyEclispse下创建一个名为vo的包，这个
包将用来存放与数据库表格对应的Java类User。
2015/7/18
School of Computer Science & Engineering
96
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
从主菜单栏，选中WindowsOpen
PerspectiveOtherMyEclipse Database
Explorer，打开MyEclipse Database Explorer视
图。打开前面创建的mysql数据连接，选中数据库
表user，右击，选择菜单Hibernate Reverse
Engineering…，如图2-36所示，将启动Hibernate
Reverse Engineering向导。
图2-36 Hibernate反向工程菜单
2015/7/18
School of Computer Science & Engineering
97
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
将启动Hibernate Reverse Engineering向导，该向导
用于完成从已有的数据库表生成对应的Java类和相关映像
文件的配置的工作。
首先，如图2-37所示，选择生成的Java类和映像文件
所在的位置。
2015/7/18
School of Computer Science & Engineering
98
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
图2-37 生成Hibernate映射文件和Java类
2015/7/18
School of Computer Science & Engineering
99
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
POJO（Plain Old Java Object，简单的Java对象），
通常也称为VO（Value Obect，值对象）。使用POJO名
称是为了避免和EJB混淆起来，其中有一些属性及
getter setter方法的类。当然，如果有一个简单的运
算属性也是可以的，但不允许有业务方法。
例如，在程序中的User.java类就是一个POJO，它由
MyEclipse根据表user直接生成，代码如下：
点击“Next”，进入如图2-38所示界面，配置映像文
件的细节。
2015/7/18
School of Computer Science & Engineering
100
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
决定是否在类型映射属性中使用Java或者Hibernate类型
持久类实例的唯一主键生成器Java类
图2-38 配置反向工程细节
2015/7/18
School of Computer Science & Engineering
101
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
点击“Next”，进入如图2-39所示界面，主要用于配置
反向工程的细节。
包含反向工程时当前数据库引用的表格以
及其它引用到当前表的数据库表
生成关联到当前表格的关联表的尚未反向工程
过的代码,这些表在当前配置页面尚未被显示
图2-39 配置反向工程细节
2015/7/18
School of Computer Science & Engineering
102
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-35所示界面。Hibernate中有
一个与数据库打交道重要的类Session。而这个类是由工
厂SessionFactory创建的。这个接口询问是否需要创建
SessionFactory类，如果需要创建，还需要指定创建的位
置和类名。
2015/7/18
School of Computer Science & Engineering
103
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
图2-35 创建SessionFactory类来简化Hibernate会话处理
2015/7/18
School of Computer Science & Engineering
104
2.5.2 详细开发步骤
安徽理工大学计算机科学与工程学院
点击“Finish”。
● 步骤6创建测试类
创建一个新的Java类，用于向数据库插入一条
记录，并在控制台显示出来。
Test.java代码如下：
运行程序，结果如图2-40所示。
图2-40 运行结果
2015/7/18
School of Computer Science & Engineering
105
2.5.3 知识点：Hibernate：Configuration File配置文件
安徽理工大学计算机科学与工程学院
在src目录下，生成了一个hibernate.config.xml
文件，里面的主要内容如下：
<hibernate-configuration>
<session-factory>
<property name="connection.username">root</property>
<!- – 数据库URL-- >
<property name="connection.url">
jdbc:mysql://localhost:3306/test
</property>
<! - - SQL方言，这边设定的是MYSQL-->
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
2015/7/18
School of Computer Science & Engineering
106
2.5.3 知识点：Hibernate：Configuration File配置文件
安徽理工大学计算机科学与工程学院
<!—数据库使用者-->
<property
name="myeclipse.connection.profile">mysql</property>
<! – 数据库密码-- >
<property
name="connection.password">root</property>
<! - - 数据库JDBC驱动程序- ->
<property
name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
</session-factory>
</hibernate-configuration>
2015/7/18
School of Computer Science & Engineering
107
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
在Hibernate中，Session负责完成对象持久化操作。
Session实例的创建，大致需要以下三个步骤：
（1）初始化Hibernate配置管理类Configuration。
根据传入或者默认的配置文件(hibernate.cfg.xml)来
创建并初始化一个Configuration类的实例：
Configuration config=new
Configuration().configure();
（2）通过Configuration类实例创建Session的工厂类
SessionFactory：
SessionFactory
sessionFactory=config.buildSessionFactory();
（3）通过SessionFactory得到Session实例：
session=sessionFactory.openSession();
2015/7/18
School of Computer Science & Engineering
108
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
得到Session实例后，就可以在测试方法中加以使用。
1．Configuration
正如此名，Configuration类负责管理Hibernate的配
置信息。Hibernate运行时需要一些底层实现的基本信息。
这些信息包括：
● 数据库URL
● 数据库用户
● 数据库用户密码
● 数据库JDBC驱动类
● 数据库dialect，用于对特定数据库提供支持，其
中包含了针对特定数据库特性的实现，如Hibernate数据
库类型到特定数据库数据类型的映射等。
2015/7/18
School of Computer Science & Engineering
109
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
使用Hibernate必须首先提供这些基础信息以完成初
始化工作，为后续操作做好准备。这些属性在hibernate
配置文件hibernate.cfg.xml中加以设定，当调用：
Configuration config=new
Configuration().configure();
时，Hibernate会自动在目录下搜索
hibernate.cfg.xml文件，并将其读取到内存中作为后续
操作的基础配置。
2．SessionFactory
SessionFactory负责创建Session实例，可以通过
Configuration实例构建SessionFactory。
Configuration confg=new Configuration().configure();
SessionFactory
2015/7/18
School of Computer Science & Engineering
110
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
sessionFactory=config.buildSessionFactory();
Configuration实例config会根据当前的数据库配置
信息，构造SessionFacory实例并返回。SessionFactory
一旦构造完毕，即被赋予特定的配置信息。也就是说，
之后config的任何变更将不会影响到已经创建的
SessionFactory实例sessionFactory。如果需要使用基
于变更后的config实例的SessionFactory，需要从
config重新构建一个SessionFactory实例。同样，如果
应用中需要访问多个数据库，针对每个数据库，应分别
对其创建对应的SessionFactory实例。
2015/7/18
School of Computer Science & Engineering
111
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
SessionFactory中保存了对应当前数据库配置的所有
映像关系，同时也负责维护当前的二级数据缓存和
Statement Pool。由此可见，SessionFactory的创建过
程非常复杂、代价高昂，而这也意味着，在系统设计中
充分考虑到SessionFactory的重用策略。由于
SessionFactory采用了线程安全的设计，可由多个线程
并发调用。大多数情况下，一个应用中针对一个数据库
共享一个SessionFactory实例即可。
2015/7/18
School of Computer Science & Engineering
112
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
3．Session
Session是Hibernate持久化操作的基础，提供了众
多持久化方法，如save、update、delete等。通过这
些方法， 透明地完成对象的增删改查等操作。
同时，值得注意的是，Hibernate Session的设计是
非线程安全的，即一个Session实例同时只可由一个线
程使用，同一个Session实例的多线程并发调用将导致
难以预知的错误。
Session实例由SessionFactory构建：
Configuration config=new
Configuration().configure();
SessionFactory
sessionFactory=config.buldSessionFactory();
2015/7/18
School of Computer Science & Engineering
113
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
Session session=sessionFactory.openSession();
之后就可以调用Session提供的save、get、delete
等方法完成持久层操作：
● Save
//新增名为“Tom”的用户记录
User user=new User();
User.setName(“Tom”);
session.save(user);
● Get
//假设表user中存在id=1的记录
User user=(User)session.get(User.class, new
Integer(1));
2015/7/18
School of Computer Science & Engineering
114
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
● Delete
//假设表user中存在id=1的记录
User user=(User)session.get(User.class, new
Integer(1));
Session.delete(user);
//也可以通过Query接口进行基于HQL的删除操作
String hql="delete User where id=1";
Query query=session.createQuery(hql);
Query.executeUpdate();
Hibernate 3中的Session接口取消了find方法，
通过Query或Criteria接口进行数据查询。
2015/7/18
School of Computer Science & Engineering
115
2.5.4 知识点：Hibernate主要接口
安徽理工大学计算机科学与工程学院
通过Query接口进行数据查询：
String hql="from User user where user.name
like ? ";
Query query=session.createQuery(hql);
query.setParamter(0,”cartier”);
List list=query.list();
Iterator it=list.iterator();
while(it.hasNext()){
User user=(User)it.next();
System.out.println(user.getUsername());
}
2015/7/18
School of Computer Science & Engineering
116
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
Hibernate中，类－表映射主要包括3部分内容：
●表名－类名映射
●主键映射
●字段映射
前面实例中，创建的数据库表结构(user表)，
如图2-41所示。
user
id
int
<pk>
username varchar(10)
password varchar(10)
图2-41 user表结构
2015/7/18
School of Computer Science & Engineering
117
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
对应user表，有一个User类与之对应：
如何在User类与user表之间建立映射关系？显然，
需要通过某种媒介对类与表，类属性与表字段之间的
关系加以定义。Hiberante选用xml作为类表映像配置
媒介。为了描述类与表的映像关系，配置文件如下：
User.hbm.xml代码如下：
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "//Hiberante/Hibernate Mapping DTD 3.0//EN"
http://hibernate.sourceforge.net/hibernatemapping-3.0.dtd>
2015/7/18
School of Computer Science & Engineering
118
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
<hibernate-mapping>
配置文件根节点
<class name="vo.User" table="user" catalog="test">
类名、表名映射
<id name="id" type="java.lang.Integer">
id映射
<column name="id"/>
<generator class="native"/>
</id>
<property name="username" type="java.lang.String">
属性、字段映射
<column name="username" length="10" not-null="ture"/>
</property>
<property name="password" type="java.lang.String">
属性、字段映射
<column name="password" length="10" not-null="true"/>
</property>
</class>
</hibernate-mapping>
2015/7/18
School of Computer Science & Engineering
119
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
1. 类、表映像配置
<class name="vo.User" table="user"
catalog="test">
name属性指定映像类名为vo.User
table属性指定当前类对应数据库表user
通过这样的配置，Hibernate即可获知类与表的
映射关系，即每个User类对象对应user表中的一条
记录。
id映像配置
<id name="id" type="java.lang.Integer">
id映射
<column name="id"/>
<generator class="native"/>
</id>
2015/7/18
School of Computer Science & Engineering
120
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
id节点定义了实体类的标识(identity)，在这里也就是
对应库表主键的类属性，在本例中：name="id" 指定当
前映像类中的属性“id”对应了user表中的主键字段。
column="id"指定了当前映像表user的唯一标识（主键）
为“id”字段。在本例中，id字段是user表的一个自增型
字段，同时也是user表的主键，通过id字段可唯一定位
一条记录。
这样，在User类和user表之间建立了基于id进行识别
的唯一性能映像关系。Hibernate将根据User对象的id属
性确定与之对应的库表记录。
type="java.lang.Integer"：指定了当前字段的数据类
型。
2015/7/18
School of Computer Science & Engineering
121
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
<generator class="native"/>指定了主键生成方式。对
于不同的数据库和应用程序，主键生成方式往往不同。
在有的情况下，依赖数据库的自增字段（如本例中）生
成主键，而有的情况下，主键由应用逻辑生成。
2015/7/18
School of Computer Science & Engineering
122
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
Hibernate的主键策略分为3个大类
Hibernate对主键id赋值
应用程序自己对id赋值
由数据库对id赋值
● assign：应用程序自己对id赋值。当设置
<generator class="assigned"/>时，应用程序需要
自己负责主键id的赋值。例如下述代码：
User user=new User();
user.setId(new Integer(200001212));
user.setUsername(“tom”);
user.setPassword(“tom”);
session.save(user);
2015/7/18
School of Computer Science & Engineering
123
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
● native：由数据库对id赋值。当设置
<generator class="native"/>时，数据库负责主键
id的赋值，最常见的是int型的自增型主键。假如在
MySQL中建立表的id为auto_increment，则应用程序
可以如下编码：
User user=new User();
user.setUsername(“Tom”);
user.setPassword(“Tom”);
session.save(user);
● hilo：通过hi/lo算法实现的主键生成机制，
需要额外的数据库表保存主键生成历史状态。
2015/7/18
School of Computer Science & Engineering
124
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
● seqhilo： 与hilo类似，通过hi/lo算法实现的
主键生成机制，只是主键历史状态保存在sequence中，
适用于支持Sequence的数据库，如Oracle。
● increment：主键按数值顺序递增。此方式的实
现机制为在当前应用实例中维持一个变量，以保存这当
前的最大值，之后每次需要生成主键的时候将此值加1
作为主键。这种方式可能产生的问题是：如果当前有多
个实例访问同一个数据库，由于各个实例各自维护主键
状态，不同实例可能生成同样的主键，从而造成主键重
复异常。因此，如果同一个数据库有多个实例访问，这
种方式应该避免使用。
● identity：采用数据库提供的主键生成机制，如
SQL Server、MySQL中的自增主键生成机制。
2015/7/18
School of Computer Science & Engineering
125
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
● sequence：采用数据库提供的sequence机制生成
主键。如Oracle Sequence。
● native：由Hibernate根据数据库适配器的定义，
自动采用identity,hilo,sequence的其中一种作为主键
生成方式。
● Uuid.hex由Hibernate基于128位唯一值产生算法，
根据当前设备IP、时间、JVM启动时间、内部自增量等4
个参数生成十六进制数值（编码后长度为32位的字符串
表示）作为主键。
这种算法在最大程度上保证了产生ID的唯一性，即使
是在多实例并发运行的情况下。当然，重复的概率在理
论上依然存在，只是概率比较小。一般而言，利用
uuid.hex方式生成主键将提供最好的数据插入性能和数
2015/7/18
School of Computer Science & Engineering
126
据平台适应性。
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
● uuid.string与uuid.hex类，只是生成的主键
为进行编码（长度16位）。在某些数据库中可能出
现问题。
● foreign：使用外部表的字段作为主键。
● select： Hibernate 3中新引入的主键获取机
制，主要针对遗留系统的改造工程。
由于常用的数据库，如SQL Server、MySQL等，都
提供了易用的主键生成机制（如auto-increase字
段）。可以在数据库提供的主键生成机制上，采用
generator-class=native的主键生成方式。
属性、字段映像配置
属性、字段映射将映射类属性与库表字段相关联。
2015/7/18
School of Computer Science & Engineering
127
2.5.5 知识点：Hibernate实体映射基础
安徽理工大学计算机科学与工程学院
<property name="username" type="java.lang.String"> 属性、字段映射
<column name="username" length="10"not-null="ture"/>
</property>
其中：
name="username" 指定了映像类中的属性名为“username”，此
属性将被映像到指定的库表字段。
type="java.lang.String" 指定了映像字段的数据类型。
column name="username" 指定库表中对应映像类属性的字段名，
如字段名和属性名均为“username”。
这样，就将User类的username属性和库表user的username字段
相关联。Hibernate将把从user表中username字段读取的数据作为
User类的username属性值。同样在进行数据保存操作时，
Hibernate将User类的username属性写入user表的username字段中。
2015/7/18
School of Computer Science & Engineering
128
2.6 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
 2.6.1 知识点：Spring IoC
1．Dependency Insersion
Spring的核心概念是IoC（Inversion of
Control，反转控制）。初看IoC，从字面上不容易
理解它的含义，要了解IoC，要先从Dependency
Inversion开始了解。
例如，假设有一个需求，类Business需要调用
UsbDiskWriter的save（）方法，按照日常的做法，
得到如下代码：
2015/7/18
School of Computer Science & Engineering
129
2.6 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
public class UsbDiskWriter{
public void save(){…
//
把内容存储到USB盘中
}
public class Business{
UsbDiskWriter writer;
public Business(){
USBWriter writer=new UsbDiskWriter();
}
public void save(){
writer.sava();
}
}
2015/7/18
School of Computer Science & Engineering
130
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
由于Business类的方法save()依赖于类
UsbDiskWriter，如果某天要更换底层（被调用）类
为硬盘，则这个Business类没有办法重用，必须加
以修改才可以。如图2-42所示。
底层类的改变造成了高层类也必须改变，这不是
一个好的设计方式。在设计上，希望类都依赖于接
口，这样才可以重用高层的类。
USBDiskWriter
Business
FloppyWriter
图2-42 类之间的依赖关系
2015/7/18
School of Computer Science & Engineering
131
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
依赖反转的解释为高层类不依赖于底层类，而
是依赖于接口。下面新的代码：
public interface IWriter{
void write();
}
public class UsbDiskWriter implements{
public void write(){
//把内容保存在USB盘中.
}
}
public class Business{
IWriter writer;
public Business(){}
public void save(){
writer.save();
}
}
2015/7/18
School of Computer Science & Engineering
132
2.6.1 知识点：Spring IoC
Buisness
安徽理工大学计算机科学与工程学院
IWriter
UsbDiskWriter
FloppyWriter
图2-43 反转依赖
2015/7/18
School of Computer Science & Engineering
133
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
在新的代码中，Business类是可重用的，如果某
天需要将内容存储到FlppyWriter或者别的介质中，
只要继承IWriter就可以了，而不用修改Business。
如图2-43所示。
从这个角度来看，Dependency Inversion的意思
是高层类不依赖于底层(被调用)的类，而是依赖于
接口。
IoC的Control是控制的意思，其实这个背后的意
思也是一种依赖关系的转移。如果A依赖于B，其含
义是B拥有控制权。
如果想要转移这种关系，通过控制关系的转移，
可以获得高层类的重用性。这个控制权从实际的
2015/7/18
School of Computer Science & Engineering
134
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
UsbDiskWriter转移到抽象的IWriter接口上，使
得BusinessObject、FlppyWriter、UsbDiskWriter
这几个实现都依赖于接口IWriter。
2．Dependency Injection(依赖注入)
IoC是一个高层的概念，实现IoC有两种方式：
Depency Inject和Service Locator。Spring采用的
是Dependency Injection来实现IoC。
看下面代码：
public class Business{
private UsbDiskWriter writer=new UsbDiskWriter();
…
public void save(){
writer.save();
}
}
2015/7/18
School of Computer Science & Engineering
135
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
Business依赖于实际的UsbDiskWriter，为了让
Business获得重用性，不让Business直接依赖于实
际的UsbDiskWriter，而是依赖于抽象的接口：
public interface IWriter{
public void save();
}
public class Business{
private IWriter writer;
public void setWriter(IWriter writer){
this.writer=writer;
}
public void save(){
writer.save();
}
}
2015/7/18
School of Computer Science & Engineering
136
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
public class FloppyWriter implements IWriter{
public void save(){
…//存储到Floppy
}
}
pulbic class UsbDiskWriter implements IWriter{
public void save(){
…//存储到UsbDisk
}
}
2015/7/18
School of Computer Science & Engineering
137
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
如果Business想要与UsbDiskWriter类发生依赖
关系，可以这样建立：
business.setWriter(new UsbDiskWriter());
依赖注入有三种实现方式：Interface
injection、Setter in injection与Construtctor
injection，并分别称其为Type 1 IoC、Type 2
IoC与Type 3 IoC。
上面的Business所实现的是Type 2 IoC，通过
Setter注入依赖关系。Type 3 IoC，则是通过构建
来注入依赖关系，例如：
2015/7/18
School of Computer Science & Engineering
138
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
private IWriter writer;
public Business(IWriter writer){
this.writer=writer;
}
public void save(){
writer.save();
}
}
Spring鼓励的是Setter injection，但也允许
使用Construtctor injection，使用Setter或
Construtctor来注入依赖关系要根据需求而定。使
用Constructor的好处是：可以在构建类的同时一
同完成依赖关系的构建，然而如果要建立的类关系
很多，则会在构建类上留下一长串的参数，
2015/7/18
School of Computer Science & Engineering
139
2.6.1 知识点：Spring IoC
安徽理工大学计算机科学与工程学院
这时使用Setter是不错的选择；另一方面，
Setter可以有明确的名称可以了解注入的类会是什
么，像是setXXX()这样的名称会比构建类
Construtctor好。
Type 1 IoC具有很强的侵入性，在这里不做具
体介绍。
Spring的核心是个IoC容器，可以用Setter或
Construtctor的方式来实现。
2015/7/18
School of Computer Science & Engineering
140
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
．概述
以一个实例来讲解如何使用Spring框架，
该实例最后的运行结果如图2-44所示。
1
图2-44 运行结果
2015/7/18
School of Computer Science & Engineering
141
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
该实例最后的目录树，如图2-45所示。
图2-45 项目目录树
2015/7/18
School of Computer Science & Engineering
142
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
各步功能说明
步骤1：创建一个Java工程
步骤2：添加Spring的支持包
步骤3：在该工程中创建一个类，命名为
ShowMessage.java
步骤4：在Spring的配置文件中，以Bean的形
式来管理该类
步骤5：以依赖赋值的方式来构造该Bean对象
步骤6：通过上下文环境调用该Bean对象
2015/7/18
School of Computer Science & Engineering
143
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
2．具体的操作过程
● 步骤1 创建一个Java Project，名为
spring。
● 步骤2 添加Spring支持包。
在目录树中选中spring，点击菜单
MyEclipseAdd Spring Capabilites…，将出
现Spring向导，用于添加Spring需要的类库和配
置文件。
首先出现如图2-46所示对话框，选中所有的
JAR包。
2015/7/18
School of Computer Science & Engineering
144
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
选择Spring版本
添加Spring类库集合
选中的类库将会添加到项目的构造路径中,但是相应的JAR文件不会
复制到项目中.这些JAR文件将会在发布程序时复制。添加Spring库
选中的类库JAR文件将会被复制到项目并添加到构造路径中
图2-46 添加Spring库
2015/7/18
School of Computer Science & Engineering
145
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-47所示界面。
用于添加Spring的配置文件。
Spring配置文件的位置
Spring配置文件的名称
图2-47 创建Spring的配置文件
2015/7/18
School of Computer Science & Engineering
146
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
点击“Finish”。
● 步骤3: 在工程中创建一个类，命名为
ShowMessage.java，源程序如下：
public class ShowMessage {
private String message;
public void setMessage(String msg){
this.message=msg;
}
public String getMessage(){
return this.message;
}
public void show(){
System.out.println("Message:"+getMessage());
}
}
2015/7/18
School of Computer Science & Engineering
147
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
● 步骤4: 编写配置文件。
修改项目根目录下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"
xsi:schemaLocation="http://www.springframework.org/sche
ma/beans http://www.springframework.org/schema/beans/springbeans-2.0.xsd">
<bean id="myBean" class="ShowMessage">
<property name="message">
<value>Hello Spring!</value>
</property>
</bean>
</beans>
2015/7/18
School of Computer Science & Engineering
148
2.6.2 开发第一个Spring程序
安徽理工大学计算机科学与工程学院
●步骤5: 编写测试程序，命名为MyTest，代码如下：
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext ctx=new
FileSystemXmlApplicationContext("src/applicationContext.xml");
ShowMessage
sm=(ShowMessage)ctx.getBean("myBean");
sm.show();
}
}
运行MyTest，该程序将在控制台中输出字符串
“Message:Hello Spring!”。
2015/7/18
School of Computer Science & Engineering
149
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
容器是Spring框架的核心，Spring容器使用IoC管理
所有组成应用系统的组件。Spring有两种不同的容器：
BeanFactory（Bean工厂，由
org.springframework.beans.factory.BeanFactory接
口定义）是最简单的容器，提供了基础的依赖注入支持；
ApplicationContext（应用上下文，由
org.springframework.context.ApplicationContext接
口定义）建立在Bean工厂基础之上，提供了系统构架服
务，如：从属性文件中读取文本信息，向有关的事件监
听器发布事件。
1．BeanFactory
BeanFactory采用了工厂设计模式。这个类负责创建
和分发Bean，但是不像其它工厂模式的实现，
2015/7/18
School of Computer Science & Engineering
150
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
它们只是分发一种类型的对象，而Bean工厂是一个通
用的工厂，可以创建和分发各种类型的Bean。
在Spring中有几种BeanFactory的实现，其中最常使
用的是
org.springframework.bean.factory.xml.XmlBeanFact
ory。它根据XML文件中的定义装载Bean。
要创建XmlBeanFactory，需要传递一个
java.io.InputStream对象给构造函数。InputStream对
象提供XML文件给工厂。例如，下面的代码片段使用一
个java.io.FileInputStream对象把Bean XML定义文件
给XmlBeanFactory：
BeanFactory factory=new XmlBeanFactory(new
FileInputStream(" beans.xml"));
2015/7/18
School of Computer Science & Engineering
151
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
这行简单的代码告诉Bean工厂从XML文件中读取
Bean的定义信息，但是现在Bean工厂没有实例化
Bean，Bean被延迟载入到Bean工厂中，就是说
Bean工厂会立即把Bean定义信息载入进来，但是
Bean只有在需要的时候才被实例化。
为了从BeanFactory得到一个Bean，只要简单地
调用getBean()方法，把需要的Bean的名字当作参
数传递进去就行了。
MyBean myBean=(MyBean)factory.getBean("myBean");
当getBean()方法被调用的时候，工厂就会
实例化Bean并且使用依赖注入开始设置Bean的属
性。这样就在Spring容器中开始了Bean的生命周
期。
2015/7/18
School of Computer Science & Engineering
152
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
2 .ApplicationContext
BeanFactory对简单应用来说已经很好了，但是为了
获得Spring框架的强大功能，需要使用Spring的更加高
级的容器——ApplicationContext，应用上下文。
表面上，ApplicationContext和BeanFactory差不多。
两者都是载入Bean定义信息，装配Bean，根据需要分发
Bean.但是ApplicationContext提供了更多功能：
● 应用上下文提供了文本信息解析工具，包括对国
际化的支持
● 应用上下文提供了载入文本资源的通用方法，如
载入图片
● 应用上下文可以向注册为监听器的Bean发送事件
2015/7/18
School of Computer Science & Engineering
153
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
由于它提供的附加功能，几乎所有的应用系统都选择
ApplicationContext，而不是BeanFactory。
在ApplicationContext的诸多实现中，有三个常用的
实现：
● ClassPathXmlApplicationContext-从类路径中的
XML文件载入上下文定义信息，把上下文定义文件当成
类路径资源.
● FileSystemXmlApplicationContext-从文件系统
中的XML文件载入上下文定义信息
● XmlWebApplicationContext-从Web系统中的XML文
件载入上下文定义信息
2015/7/18
School of Computer Science & Engineering
154
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
如
ApplicationContext context=new
FileSystemXmlApplicationContext("c:/foo.xml");
ApplicationContext context=new
ClassPathApplicationContext("foo.xml");
ApplicationContext
context=WebApplicationContextUtils.getWebApplica
tionContext(request.getSession().getServletConte
xt());
使用FileSystemXmlApplicationContext和
ClassPathXmlApplicationContext的区别是：
FileSystemXmlApplicationContext只能在指定的路径
中寻找foo.xml文件，
2015/7/18
School of Computer Science & Engineering
155
2.6.3 知识点：Spring容器
安徽理工大学计算机科学与工程学院
而ClassPathXmlApplicationContext可以在整个类路
径中寻找foo.xml。
除了ApplicationContext提供的附加功能外，
ApplicationContext与BeanFactory的另一个重要区别
是关于单实例Bean是如何被加载的。Bean工厂延迟载入
所有的Bean，知道getBean()方法被调用时，Bean才被
创建。ApplicationContext则聪明一点，它会在上下文
启动后预载入所有的单实例Bean.通过预载入单实例
Bean，确保当需要的时候它们已经准备好了，应用程序
不需要等待它们被创建。
2015/7/18
School of Computer Science & Engineering
156
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
在Spring容器内拼凑Bean叫做装配。装配Bean
的时候，是在告诉容器需要哪些Bean以及容器如何
使用依赖注入，将它们配合起来。
1．使用XML装配
理论上，Bean装配可以从任何配置资源获得，
但实际上，XML是最常见的Spring应用系统配置源。
如下的XML文件展示了一个简单的Spring上下文
定义文件：
<?xml version="1.0" encoding="UTF-8"?>
…
<beans>
根元素
<bean id="foo" class="com.spring.Foo"/> Bean实例
<bean id="bar"class="com.spring.Bar"/>
Bean实例
</beans>
2015/7/18
School of Computer Science & Engineering
157
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
所有XML文件定义Bean，上下文定义文件的根元
素<beans>。<beans>有多个<bean>子元素。每个
<bean>元素定义了一个Bean（任何一个Java对象）
如何被装配到Spring容器中。
这个简单的Bean装配XML文件在Spring中配置了
两个Bean，叫做foo和bar。
2．添加一个Bean
在Spring中对一个Bean的最基本配置包括Bean
的ID和它的全称类名。向Spring容器中添加一个
Bean只要求向XML文件中添加一个<bean>元素。
<bean id="foo" class="com.spring.Fo"/>
2015/7/18
School of Computer Science & Engineering
158
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
● 原型与单实例
Spring中的Bean缺省情况下是单实例模式。在容
器分配Bean的时候，它总是返回同一个实例。但是，
如果想每次向ApplicationContext请求一个Bean的
时候总是得到一个不同的实例，需要将Bean定义为
原型模式。
<bean>的singleton属性告诉
ApplicationContext这个Bean是不是单实例Bean，
缺省是true，但是把它设置为false的话，就把这
个Bean定义成了原型Bean。
<bean id="foo" class="com.spring.Foo" singleton="false"/>
2015/7/18
←―――原型Bean
School of Computer Science & Engineering
159
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
● 实例化与销毁
当一个Bean实例化的时候，有时需要做一些初始化的
工作，然后才能使用。同样，当Bean不再需要，从容器中
删除的时候，需要按顺序做一些清理工作。因此，Spring
可以在创建和拆卸Bean的时候调用Bean的两个生命周期方
法。
在Bean的定义中设置自己的init-method，这个方
法在Bean被实例化的时候马上被调用，同样，也可以设置
自己的destroy-method，这个方法在Bean从容器中删除之
前调用。
2015/7/18
School of Computer Science & Engineering
160
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
一个典型的例子是连接池Bean。
public class MyConnectionPool{
…
public void initalize(){//initialize connection pool}
public void close(){ //release connections}
…
}
2015/7/18
School of Computer Science & Engineering
161
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
Bean的定义如下：
<bean id="connectionPool" class="com.spring.MyConnectionPool“
init-method=“initializ” ←当Bean被载入容器的时候调用initialize方法
destroy-method="close"/> ←当Bean从容器中删除时候调用close方法
按这样配置，MyConnectionPool被实例化后，
initialize()方法马上被调用，给Bean初始化池的机
会。在Bean从容器中删除之前，close()方法将释放数
据库连接。
3．通过Set方法注入依赖
Set注入依赖是一种基于标准命名规范的设置
Bean属性的技术。JavaBean规范规定使用对应的set和
get方法来设置和获得Bean的属性值。（Spring还提供
了另外一种依赖注入方式：构造函数注入，本书不再
讨论）。
2015/7/18
School of Computer Science & Engineering
162
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
如：
public class Business{
IWriter writer;
…
public void setWriter(IWriter writer){
this.writer=writer;
}
public IWriter getWriter(){
return writer;
}
}
2015/7/18
School of Computer Science & Engineering
163
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
在<bean>元素的子元素<property>指明了使用
set方法来注入，在<property>元素中，可以定义
要装配的属性以及要注入的值，可以注入任何东西，
从基本类型到集合类，甚至应用系统中的Bean。
● 简单Bean装配
Bean通常会有一些简单类型属性，如int和
String，通过使用<property>的子元素<value>可
以按照下面的方式设置基本类型属性，如int和
float，或java.lang.String。
例如，有一个Foo类，代码如下：
2015/7/18
School of Computer Science & Engineering
164
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
public class Foo{
String name;
…
public void setName(String name){
this.name=name;
}
…
}
可以这样配置Bean：
<bean id="foo" class="com.spring.Foo">
<property name"name">
<value>Foo McFoo</value> ←――通过
setName("Foo McFoo")方法来设置name属性
</property>
</bean>
2015/7/18
School of Computer Science & Engineering
165
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
●应用其它Bean
通过与Bean定义相同的方式，容器XML文件知道应用
程序中的其它Bean。
使用<property>元素来设置指向其它Bean的属性，
<property>的子元素<ref>实现。
public interface IWriter(){
public void save();
}
public class UsbDiskWriter implements(){
public void save(){
…
}
}
public class FloppyWriter implements(){
public void save(){
…
}
}
2015/7/18
//存至USB Disk中
//存至Floppy中
School of Computer Science & Engineering
166
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
public class Business{
IWriter writer;
public setWriter(IWriter writer){
this.writer=writer;
}
public IWriter getWriter(){
return writer;
}
public void save(){writer.save();}
}
2015/7/18
School of Computer Science & Engineering
167
2.6.4 知识点：Spring基本配置
安徽理工大学计算机科学与工程学院
对应的Bean装配：
<bean id="usbDiskWriter"
class="UsbDiskWriter"/>
<bean id="floppyWrite" class="FloppyWrite"/>
<bean id="busines" class="Businessv"/>
<property name="writer">
<ref bean="usbDiskWriter"/> ←――装配名字叫
usbDiskWriter的Bean，根据需要，也可以修改成名字
为floppyWriter的Bean.方便地实现了不同介质的存储.
</property>
</bean>
2015/7/18
School of Computer Science & Engineering
168
2.7 开发Struts 2、Spring集成程序
安徽理工大学计算机科学与工程学院
 2.7.1 概述
在此，将前面的两个框架Struts和Spring做一个
集成，开发一个简单项目。在这个项目中，用户在
登录页面输入登录名和密码，则跳转到另外一个欢
迎页面，反之，将进入失败页面。如图2-48。
图2-48 用户登录页面
2015/7/18
School of Computer Science & Engineering
169
2.7.1 概述
安徽理工大学计算机科学与工程学院
该实例最后的目录树，如图2-49所示
图2-49 项目目录树
2015/7/18
School of Computer Science & Engineering
170
2.7.1 概述
安徽理工大学计算机科学与工程学院
主要开发步骤如下：
1．完成strut2
步骤1 创建Web Project，名为
struts_spring
步骤2 添加Struts 2框架
步骤3 创建login.jsp
步骤4 创建Action
步骤5 创建login_success.jsp
步骤6 部署，测试struts2
2．集成Spring
步骤7 添加Spring框架
步骤8 添加Struts spring支持包
spring-struts-plugin-2.0.11.jar
2015/7/18
School of Computer Science & Engineering
171
2.7.1 概述
安徽理工大学计算机科学与工程学院
步骤9 修改web.xml内容
步骤10 创建struts.properties
步骤11 修改struts.xml
步骤12 修改applicationContext.xml
步骤13 部署测试
2015/7/18
School of Computer Science & Engineering
172
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤1 创建Web项目strust2_spring。
● 步骤2 添加Struts 2框架。
添加5个jar包：Struts2-core-2.0.11.jar，
xwork-2.0.1.jar和ognl-2.6.11.ar，commonlogging-1.0.4.jar，freemarker-2.3.8.jar。
配置web.xml，代码如下：
<?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>
2015/7/18
School of Computer Science & Engineering
173
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2015/7/18
School of Computer Science & Engineering
174
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤3 创建login.jsp
login.jsp代码如下：
<%@ page contentType="text/html;charset=gb2312" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<body >
<form action="login.action" method="post" >
用户名:<input type="text" name="username" /><br>
密码:<input type="password" name="password" /><br>
<input type="submit" value="登录" /><br>
</form>
</body>
</html>
2015/7/18
School of Computer Science & Engineering
175
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤4 创建Action
LoginAction.java代码如下：
package org;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport {
private String username;
private String password;
public String execute(){
return ActionSupport.SUCCESS;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
2015/7/18
School of Computer Science & Engineering
176
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
2015/7/18
School of Computer Science & Engineering
177
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 配置struts.xml文件，代码如下：
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration
2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-default.xml"/>
<package name="default" extends="struts-default">
<action name="login" class="org.LoginAction">
<result name="success">/login_success.jsp</result>
</action>
</package>
</struts>
2015/7/18
School of Computer Science & Engineering
178
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤5 创建login_success.jsp，代码如下：
<%@ page contentType="text/html;charset=gb2312" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<body >
<h2>您好! 用户<s:property value=" username"/>欢
迎您注册成功 </h2>
</body>
</html>
2015/7/18
School of Computer Science & Engineering
179
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤6 部署
部署，测试struts 2是否正常运行
http://localhost:8080/struts2_spring/login.jsp。
● 步骤7: 添加Spring框架
● 步骤8: 添加Spring支持包spring-struts2plugin.jar
● 步骤9: 修改web.xml内容
2015/7/18
School of Computer Science & Engineering
180
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
修改web.xml内容，使得程序增加对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">
<web-app>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filterclass>
</filter>
<filter-mapping>
2015/7/18
School of Computer Science & Engineering
181
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener >
<listener-class >
org.springframework.web.context.ContextLoaderListener
</listener-class >
</listener >
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/classes/applicationContext.xml
</param-value>
</context-param>
</web-app>
2015/7/18
School of Computer Science & Engineering
182
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
Listener是Servlet的监听器，它可以监听客户端的
请求，服务器的操作等。通过监听器，可以自动激发一
些操作，比如监听到在线的数量。当增加一个
HttpSession时，就激发sessionCreated方法。
监听器需要知道applictionContext.xml配置文件的
位置，通过节点<context-param>来配置。
● 步骤10 创建消息包文件struts.properties
在src目录下创建struts.properties文件，使得
Struts 2的类的生成交给Spring完成。步骤：右击项目
的“src” 目录，在弹出的菜单中选择NewFile，之后
在“Enter or select the parent folder”中填入
struts2_spring/src,在File name栏中写入
struts.properties，点确定。文件内容如下：
2015/7/18
School of Computer Science & Engineering
183
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
struts.objectFactory=spring
● 步骤11 修改struts.xml
使得struts 2的类的生成交给Spring完成。
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-default.xml"/>
<package name="default" extends="struts-default">
<action name="login" class=" org.LoginAction ">
<result name="success">/login_success.jsp</result>
</action>
</package>
</struts>
2015/7/18
School of Computer Science & Engineering
184
2.7.2 具体开发步骤
安徽理工大学计算机科学与工程学院
● 步骤12 修改applicationContext.xml
<?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/XMLSchemainstance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<beans>
<bean id="login" class="org.LoginAction">
</bean>
</beans>
● 步骤13 部署测试。
部署应用程序，启动测试。
2015/7/18
School of Computer Science & Engineering
185
2.8 开发Hibernate、 Spring集成程序
安徽理工大学计算机科学与工程学院
2.8.1 概述
本例将演示将hibernate和spring框架集成，
完成向数据库表插入一条数据，如图2-50所示。
图2-50 运行结果
2015/7/18
School of Computer Science & Engineering
186
2.8.1 概述
安徽理工大学计算机科学与工程学院
该实例最后的目录树，如图2-51所示：
图2-51 项目目录树
2015/7/18
School of Computer Science & Engineering
187
2.8.1 概述
安徽理工大学计算机科学与工程学院
主要步骤如下：
步骤1：在MySQL中创建数据库表user
步骤2：创建Java项目，名hibernate_spring
步骤3：加载用户自定义包
步骤4：加载Hibernate框架
步骤5：生成与数据库表对应的Java数据对象
和映射文件
步骤6：编写代码
步骤7：运行测试
2015/7/18
School of Computer Science & Engineering
188
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
● 步骤1 在MySQL中创建数据库表。
如果按照前面的顺序做下来，这个表已经存在，不
需要再创建。
CREATE TABLE user(
id int(10) not null auto_increment，
username varchar(10) not null，
password varchar(10) not null，
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=GBK;
● 步骤2 创建Java项目，名hibernateSpring。
● 步骤3 加载用户自定义包hibernate3
右键点击工程文件，选择MyEclipseAdd
Spring Capabilities….。
选择“User Libraries”，如图2-52所示：
2015/7/18
School of Computer Science & Engineering
189
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
添加用户自定义类库
图2-52 添加Spring Capabilities
2015/7/18
School of Computer Science & Engineering
190
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“下一步”，提示是否建立Spring配置文件，选择
默认，然后点击“Finish”。
● 步骤4 加载Hibernate框架
右键点击工程文件，选择MyEclipseAdd Hibernate
Capabilieties…，首先出现如图2-53所示对话框。
选择用户自定义类库
选中的类库JAR文件将不会被复制到项目并添加到构造路
径中
图2-53 添加Hibernate库
2015/7/18
School of Computer Science & Engineering
191
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-54所示对话框，提示
是否用hibernate的配置文件还是用Spring的配置
文件进行SessionFactory的配置，选择使用Spring
来对hibernate进行管理，这样最后生成的工程理
就不包含hibernate.cfg.xml，好处是在一个地方
就可以对hibernate进行管理了。
2015/7/18
图2-54 定义Hibernate配置
School of Computer Science & Engineering
192
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
将对Hibernate的配置放入Spring的配置文件中
图2-54 定义Hibernate配置
2015/7/18
School of Computer Science & Engineering
193
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-55所示对话框，提示是创建一个新的hibernate配
置文件还是使用已有的配置文件，由于刚才已经生成了spring配置文件，并且要
在其中进行hibernate的配置，所以选择复选框“Existing Spring configuration
file”，选择该选项后，下方的“Spring Config”后的下拉列表自动填入刚才生成的
spring配置文件路径，要求你填写SessionFactory ID，这个id就是为hibernate注
入的一个新的ID，随便起一个名字，如“sessionFactory”，点击下一步。
使用已经存在的Spring配置文件
为SessionFactory的ID起名
图2-55 定义Spring-Hibernate配置
2015/7/18
School of Computer Science & Engineering
194
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-56所示对话框，要求
选择数据库连接信息.这里需要注意一点“bean id”
处填写一个数据源的名称，如“datasource”。
为DataSource ID起名
选择数据库连接
图2-56 指定新的Spring数据源连接信息
2015/7/18
School of Computer Science & Engineering
195
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-57所示对话框，提示
是否创建“SessionFactory”类，由于本程序Spring
为注入sessionfactory，所以不用创建，选择
“finish”。
不用产生SessionFactory类
图2-57 定义SessionFactory属性
2015/7/18
School of Computer Science & Engineering
196
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Finish”。
● 步骤5 生成与数据库表对应的Java数据对象和映射
打开MyEclipse的database exploer perspective，右键选择
user表，选择Hibernate reverse engineering。选择如图2-58所
示信息。
为每一数据库表生成一个映射文件
为每一个表创建一个类
创建对类和数据库表进行操作的类
2015/7/18
图2-58
Hibernate映射文件和POJO类
School
of Computer Science & Engineering
197
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
点击下一步，在“ID generator”中选择native，
直接点击Finish。
● 步骤6 编写代码
写一个测试程序将一条记录插入到user表中。
Test.java代码如下：
import org.model.User;
import org.model.UserDAO;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationContext;
2015/7/18
School of Computer Science & Engineering
198
2.8.2 具体步骤
安徽理工大学计算机科学与工程学院
public class Test {
public static void main(String[] args) {
User user=new User();
user.setUsername("yuyan");
user.setPassword("yuyan");
ApplicationContext context=new
ClassPathXmlApplicationContext("applicationContext.xml");
UserDAO
userdao=(UserDAO)context.getBean("UserDAO");
userdao.save(user);
}
}
2015/7/18
School of Computer Science & Engineering
199
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
1．管理Hibernate资源
在一个典型的Hibernate应用中，系统读取配置
文件，并用它来创建SessionFactory。一个
SessionFactory将作用于应用的整个生命期，用
SessionFactory来获得Session对象。有了
Session对象，就能够访问数据库。在应用的整个
生命周期，只要保存一个SessionFactory实例就
可以了。所以在Spring配置文件中配置这个对象，
可以用Spring的LocalSessionFactory类。
在上例中，applicationContext.xml中有这样
一段：
2015/7/18
School of Computer Science & Engineering
200
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFa
ctoryBean">
这个SessionFactory需要知道连接到哪个数据库，所以将
DataSource放入LocalSessionFactoryBean：
<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/test"></property>
<property name="username"
value="root"></property>
<property name="password"
value="root"></property>
2015/7/18
School of Computer Science & Engineering
201
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryB
ean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>./User.hbm.xml</value></list>
</property></bean>
2015/7/18
School of Computer Science & Engineering
202
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
2． HibernateTemplate
HibernateTemplate提供持久层访问模板化，使用
HibernateTemplate不需实现特定接口，它只需要提供一
个SessionFactory的应用，就可以执行持久化操作。
SessionFactory对象通过构造参数传入，或通过设值方式
传入。
创建HibernateTemplate实例.它提供了3个构造函数:
HibernateTemplate()
HibernateTemplate(SessionFactory)
HiberanteTemplate(SessionFactory, allowCreate)
对于在Web应用，通常启动自动装载
ApplicationContext，SessionFactory和DAO对象都处在
Spring上下文管理下，因此，不需要在代码中显示设置
HibernateTemplate实例。
2015/7/18
School of Computer Science & Engineering
203
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
HibernateTemplate提供非常多的方法来完成基
本的操作，比如通常的增加、删除、修改和查询等
操作。
下面是UserDAO的代码片段，内容如下：
…
public class UserDAO extends
HibernateDaoSupport {
private static final Log log =
LogFactory.getLog(UserDAO.class);
protected void initDao() {
}
2015/7/18
School of Computer Science & Engineering
204
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
public void save(User transientInstance) {
log.debug("saving User instance");
try {
getHibernateTemplate().save(transientInstance);
log.debug("save successful");
} catch (RuntimeException re) {
log.error("save failed"， re);
throw re;
}
}
public void delete(User persistentInstance) {
log.debug("deleting User instance");
try {
getHibernateTemplate().delete(persistentInstance);
log.debug("delete successful");
} catch (RuntimeException re) {
log.error("delete failed"， re);
throw re;
}
}
…
2015/7/18
School of Computer Science & Engineering
205
2.8.3 知识点：Spring对Hibernate的支持
安徽理工大学计算机科学与工程学院
在Spring中使用Hibernate，用户可以使用
Spring提供的HibernateTemplate来实现DAO的解
决方案，用户也可以采用其它的方案，如采用
Hibernate的原生DAO的代码，如下：
public class UserDAO{
private SessionFactory sessionFctory;
public void setSessionFactory(SessionFactory
sessionFactory){
this.sessionFactory=sessionFactory;
}
Public Collection loadUserById(String Id){
return
this.sessionFactory.getCurrentSession().createQuery(“from User u
where u.id=?”).setParameter(0，id).list();
}
}
本书的实例就是用的这种方法。
2015/7/18
School of Computer Science & Engineering
206
2.9 开发Struts 2、Hibernate、Spring集成程序
安徽理工大学计算机科学与工程学院
 2.9.1 概述
在简要地了解了三种框架以后，将三种框架集
成，开发一个用户登录程序，效果图如下。如果登
录成功，进入一个欢迎页面。
图2-59 用户登录界面
2015/7/18
School of Computer Science & Engineering
207
2.9.1 概述
安徽理工大学计算机科学与工程学院
工程最后的目录树如图2-60所示
图2-60 项目目录树
2015/7/18
School of Computer Science & Engineering
208
2.9.1 概述
安徽理工大学计算机科学与工程学院
主要的开发步骤：
1环境配置
步骤1 创建数据库表
步骤2 创建Web Project
步骤3 加载用户自定义包
步骤4 加载Hibernate框架
步骤5 修改web.xml
步骤6 增加struts.properties文件
2 编写代码
步骤7 反向工程
步骤8 创建视图层
步骤9 创建Action
步骤10 配置Spring 步骤11 部署测试
2015/7/18
School of Computer Science & Engineering
209
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
● 步骤1 创建数据库如下(如果已经存在，则不
需要创建)
CREATE TABLE user(
id int(10) not null auto_increment，
username varchar(10) not null，
password varchar(10) not null，
primary key(id)
)ENGINE=InnoDB DEFAULT CHARSET=GBK;
● 步骤2 创建Web Project
在MyEclipse下建立新的Web Project，起名ssh2。
● 步骤3加载用户自定义包
工程名上右键MyEclipseAdd Spring
Capabilites，添加用户自定义包hibernate3和配置
文件applicationContext.xml。
2015/7/18
School of Computer Science & Engineering
210
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
图2-61 添加Spring库
2015/7/18
School of Computer Science & Engineering
211
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
点击Next，选择applicationContext.xml的地点，
默认情况下在WEB-INF目录下寻找。
图2-61 生成Spring配置文件
2015/7/18
School of Computer Science & Engineering
212
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
● 步骤4加载Hibernate框架
工程名上右键MyEclipseAdd Hibernate
Capabilites 添加jar包。
图2-62 添加Hibernate库
2015/7/18
School of Computer Science & Engineering
213
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
在applicationContext.xml中配置连接信息，如图2-63所示。
图2-63Hibernate配置文件
为SessionFactory起一个id，如图2-64所示。
图2-64 为SessionFactory起ID
2015/7/18
School of Computer Science & Engineering
214
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
指定Spring数据源连接的详细信息。如图2-65所示。
图2-65 指定Spring数据源连接细节
2015/7/18
School of Computer Science & Engineering
215
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
● 步骤5 修改web.xml，代码如下：
<?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>
<filterclass>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener >
<listener-class >
2015/7/18
School of Computer Science & Engineering
216
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
org.springframework.web.context.ContextLoaderListener
</listener-class >
</listener >
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/classes/applicationContext.xml
</param-value>
</context-param>
</web-app>
● 步骤6增加struts.properties文件
在src目录下，增加struts.properties文件，代码如下：
struts.objectFactory=spring
● 步骤7 反向工程
打开MyEclipse的database exploer perspective，右键选择
user表，选择Hibernate reverse engineering,生成与数据库表对
应的Java对象和映射文件，如图2-66所示。
2015/7/18
School of Computer Science & Engineering
217
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
图2-66 反向工程
2015/7/18
School of Computer Science & Engineering
218
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Next”，出现如图2-67所示界面。
选择ID的生成方式为native。
图2-67 配置细节
2015/7/18
School of Computer Science & Engineering
219
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
点击“Finish”。
● 步骤8 视图层
登录页面login.jsp，代码如下：
<%@ page language="java" pageEncoding="gb2312"%>
<html>
<head><title>登录页面</title></head>
<body>
<form action="login.action" method="post">
用户登录<br>
姓名:<input type="text" name="username"/><br>
密码:<input type="text" name="password"/><br>
<input type="submit" value="登录"/>
</form>
</body>
</html>
2015/7/18
School of Computer Science & Engineering
220
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
登录成功页面，login_success.jsp，代码如下：
<%@ page
contentType="text/html;charset=gb2312" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<body >
<h2>您好! 用户<s:property
value="username"/>欢迎您登录成功 </h2>
</body>
</html>
2015/7/18
School of Computer Science & Engineering
221
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
登录失败页面，login_error.jsp，代码如下：
<%@ page contentType="text/html;charset=gb2312"
%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<body >
<h2>登录失败</h2>
</body>
</html>
● 步骤9 创建Action
代码如下：
2015/7/18
School of Computer Science & Engineering
222
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
配置struts.xml，代码如下：
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts
Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="struts" extends="struts-default">
<action name="login" class="login">
<result name="error">/login_error.jsp</result>
<result
name="success">/login_success.jsp</result>
</action>
</package>
</struts>
2015/7/18
School of Computer Science & Engineering
223
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
● 步骤10 配置Spring
代码如下：
<?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">
<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver”/>
<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource" />
</property>
<property name="hibernateProperties">
2015/7/18
School of Computer Science & Engineering
224
2.9.2 具体步骤
安徽理工大学计算机科学与工程学院
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>./User.hbm.xml</value>
</list>
</property>
</bean>
<bean id="login" class="LoginAction">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
</beans>
● 步骤11 部署测试
2015/7/18
School of Computer Science & Engineering
225
习题
安徽理工大学计算机科学与工程学院
1. 搭建MyEclipse的开发环境。
2. 开发一个应用，在控制台显示程序运行的时
间，如“今天是2008年8月1日”。
3. 开发一个应用，通过浏览器显示程序的运行
时间，如“今天是2008年8月1日”。
4. 使用Struts 2和Hibernate完成一个用户注
册的程序。要求用户从浏览器输入用户名和密码以
后，程序将信息保存到数据库中。
5. 使用Struts 2、Hibernate、Spring完成一
个用户注册程序。要求用户从浏览器输入用户名和
密码以后，程序将信息保存到数据库中。
2015/7/18
School of Computer Science & Engineering
226