毕业设计(论文)任务书
课题名称 工业制造企业合同管理信息系统
学 院 计算机学院
专业班级
姓 名
学 号
毕业设计（论文）的主要内容:
1. 分析工业制造企业合同管理的业务需求，进行需求分析。
2. 分析、给出工业制造企业的合同管理业务模型，设计软件系统的工作流程
3. 根据需求分析和建立的业务模型完成课题的设计、编码、测试等工作。
4. 完成毕业设计说明书(毕业论文)一份。
5. 完成 5000 字的与设计内容有关的外文资料翻译。
起止时间：
2008 年 5 月 3 日至 2008 年 5 月 23 日共 3 周
指 导 教 师
签 字
系 主 任
签 字
院 长
签 字
填写说明："任务书"封面请用鼠标点中各栏目横线后将信息填入，字体设定为楷体－GB2312、
四号字；在填写毕业设计（论文）内容时字体设定为楷体－GB2312、小四号字。
摘 要
随着科技发展和社会进步，尤其是计算机大范围的普及，计算机应用逐渐由
大规模科学计算的海量数据处理转向大规模的事务处理和对工作流的管理，这就
产生了以台式计算机为核心，以数据库管理系统为开发环境的管理信息系统在大
规模的事务处理和对工作流的管理等方面的应用，特别是在各种项目处理管理之
中的应用日益收到人们的关注。 近年来我国信息产业发展迅速，手工处理数据
管理的方式已于时代不相适应，采用 IT 技术提高服务质量和管理水平势在必行。
目前，计算机已经走进家庭用户，可以说是相当的普及了，而个人理财管理还不
成熟。因此，家庭用户要提高其工作效率，改善其理财理念。这样，理财管理的
信息化是势在必行的.
此系统是为现代化企业设计的一个工业制造企业合同管理系统，随着经济的
发展，企业正向着大型化、规模化发展，而对于大中型企业，产品的多样化，所
签仃的合同也随之急剧增加，在这种情况下单靠人工来处理，计算机这些合同不
但显得力不从心，而且极容易出错。具体任务就是设计一个工业制造企业合同的
数据管理系统，由计算机机来代替人工执行一系列诸如增加新合同、删除旧合同、
修改、查询的操作。设计的指导思想是一切为了用户着想，界面要美观大方，操
作尽量简单明了，而且作为一个实用的操作系统要有良好的容错性，在用户出现
误操作时能够及时给出警告，以便用户及时地改正。计算机的资源是受到限制的，
因此要充分利用 jsp 的功能，设计出功能强大的软件，同时要尽可能地减少对系
统资源的占用。
关键字：合同管理, jsp,sturts,.
Abstract
During this information times, combining computers with enterprise usual events
management has become an emergent task that every enterprise must accomplish as
soon as possible.
The MIS (management information system) of Contracts based on Single-Layer
structure mode, which is suitable for medium and small enterprises is developed and
designed in this article. Then introduces software and hardware configuration and
implement of the system. The system adopts eclipse and myeclipse as developing
tool, MySql as DBMS(Database Management System). Then makes a concise
description of programmable environment and database technique of . Based on
feasibility analyzing and system demand analyzing, emphatically expounds
design-project、 functional model、interface designing database system designing、
security design in this paper.
The MIS of Contracts strictly follows the design principle of security, economy,
efficiency reliability, and easy operating, maintaining and expanding.
Finally, the author makes a subjective estimate of his design, and puts forward
improving methods and new plans to overcome the shortcomings of the existing
the end of this article, references are listed.
Key Words: contract manager,jsp,sturts,.
目 录
摘 要 2
目 录 4
1 绪 论 6
2 开发环境及开发工具的介绍 7
JDK，服务器，数据库的安装与配置 7
服务器安装与配置 7
Mysql 的安装与配置 8
Eclipse 和 MyEclipse 的安装与配置 9
3 开发技术介绍 11
Java 11
Java 概述 11
Java 的特点 11
Servlet 技术 12
Servlets:工作原理及概述 12
特点及应用 13
JSP 技术介绍 14
jsp 概述 14
Jsp 与 servlet 的比较 14
Jsp 的工作原理: 14
Jsp 的环境配置 15
Struts 技术 15
StrutsMVC 框架 15
基于 struts 的 web 应用的开发步骤 16
Struts 的 Token（令牌）机制 18
Hibernate 19
Hibernate 数据持久化组件 19
使用 hibernate 编程步骤 19
Hibernate 控制的事务 19
4 系统设计 20
需求分析 20
功能分析 20
角色分析: 21
数据库分析： 22
数据库设计 27
系统总体设计 28
设计思想： 28
框架设计： 29
系统界面要求 30
系统模块的划分： 30
主要系统模块的具体实现： 31
(1):职工或管理员的登录模块 31
(2):添加职工模块 34
(3):职工或管理员的修改和删除模块 38
(4):查询客户信息 41
(5):合同信息的录入 44
(6)：合同信息的签署 46
系统的测试 48
5 总结与体会 49
致 谢 50
参考文献 51
附录一：英文资料原文 52
附录二：英文资料翻译 61
1 绪 论
随着信息时代到来,电脑信息管理技术越来越受到各企业的高度重视,逐渐成
为企业在现代化发展中不可缺少的一部分.在当今 IT 技术日新月异,而企业市场
化进程加快的时刻,电脑信息管理技术几乎涉及到每一家优秀企业的整个经营活
动.对公司经营,效率甚至策略的变化都有直接而深远的影响.
《工业制造合同管理系统》是一套针对企业产品工业制造合同方面的电脑信
息管理系统,它包括了企业在产品销售合同上的各方面内容.而销售方面对一个企
业在市场化经营中是重中之重的部分.所以用电脑信息技术进行管理也是各企业
的实际需求.
随着社会经济的迅速发展和科学技术的全面进步，计算机事业的飞速发展，
以计算机与通信技术为基础的信息系统正处于蓬勃发展的时期，信息管理系统领
域正在经历一场重大的变革。计算机在企业管理中应用的普及，利用计算机实现
企业合同及文档资料的管理势在必行。随着企业间竞争的日益加强，企业对管理
系统的要求也越来越高，《工业制造企业合同管理系统》基于商业运作，依据逻
辑统筹运算思维，将销售业务的合同、销售发货、结款以及历史数据紧密衔接在
一起。本系统结合企业实际的合同文档管理制度,经过实际的需求分析，采用功
能强大的 Eclipse 作为开发工具而开发出来的企业合同管理系统。
2 开发环境及开发工具的介绍
JDK，服务器，数据库的安装与配置
服务器安装与配置
一、安装 JDK
可先到 下载 JDK 最好是 版本以上。
下载后安装到 C:\jdk 目录下，即可。
二、安装 Tomcat
可先到 下载 以上版本,然后解压并
重新命名为 Tomcat，放在 C:\根目录下。
三、设置 JDK 和 Tomcat
在 Windows 下：
a、配置 jdk
先设置 JDk 的路径(Path)：开始-设置-控制面板-系统-高级-环境变量-系统变量。
然后单击“新建”按钮。
变量名="CLASSPATH"
变量值="C:\JDK;C:\JDK\BIN;"
同理新建: PATH="C:\JDK\LIB\;C:\JDK\LIB\;"
b、配置 Tomcat
先设置 Tomcat 的路径(Path)：开始-设置-控制面板-系统-高级-环境变量-用户变
量。
然后单击“新建”按钮。
同上输入：TOMCAT_HOME=C:\TOMCAT
再在“系统变量”单击“新建”按钮。
输入：JAVA_HOME=C:\JDK;
完成以上配置就算大工告成。
测试：
进入 dos 输入 javac 如若显示可选项信息，即可。
双击 C:\Tomcat\bin\ 使虚拟服务器运行，然后打开 IE 浏览器，输入
Http://localhost:8080/ ，如若显示成功，则 Tomcat 也安装成功。
（注意：一般用户目录在：C:\tomcat\webapps\examples 下，一般用户可在其下建
一用户目录
以 便 保 存 JSP 文 件 ， 而 javaBean 一 般 放 在
C:\tomcat\webapps\examples\web-inf\classes 目录下。
另外注意：没有 IP 地址的电脑是不能运行 JVM 的。)
Mysql 的安装与配置
Mysql 的简单介绍
MySQL 作为一种开放源码数据库，以其简单易用的特点广泛被广大用户
采用，MySQL 虽然是免费的，但同 Oracle, Sybase, Informix, Db2 等商业数据
库一样，具有数据库系统的通用性：
1） 数据库管理系统。我们知道，所谓的数据库就是一些结构化的数据
的联合体，要提供对这些数据的存取、增加、修改、删除或更加复杂的数据
抽取等操作，需要有一个支撑系统，这就是数据库管理系统（DBMS），MySQL
完全具有这方面的功能。
2） 关系型数据库管理系统。在数据库的发展历程中，曾出现过多种不
同形式的数据库系统，但关系型数据库管理系统（RDBMS）以其优越性而
被广为采用，象现在几种广泛使用的数据库全为关系型数据库。同样，MySQL
也是关系型的数据库系统，支持标准的结构化查询语言（Structured Query
Language）。
3） 开放源码数据库。同商业性的数据库相比，这是 MySQL 最大的特
点。MySQL 的源码是公开的，这就意味着任何人，只要遵守 GPL 的规则都
可以对 MySQL 的源码使用、修改以符合自己特殊的需求。
4） 技术特点。MySQL 是 C/S 架构的服务器，服务器端是多线程的，
为客户端提供了不同的程序接口和链接库，如 C、C++、Java、Perl、PHP、
Tcl 等，也提供了简单的管理工具，如 mysqladmin，mysql 等。
MySQL 有如此多的特点，又由于其免费的特点，这就给许多的中小应用
提供了不错的选择。 尤其是对一些中小企业，无论是从降低成本，还是从
性能方面，采用 MySQL 作为其数据支 撑系统，都是一种可行的方案。但也
应当注意，采用 MySQL 作为应用数据库，就意味着所有的问题都需要自己
解决，要承担一定的风险。
安装与配置：
下载：从 MySql 官方网站 下载 windows 版的 mysql 安装
文件：
安装：
1． 解压 后得到 ，双击进行安装，安装过程非
常简单，最后有一项 passport 的选择页面，选择跳过即可。
2 ． 之 后 会 自 动 启 动 MySql 配 置 程 序 （ EXE 文 件 目 录 ：
$MYSQL_HOME$\bin\）。
如之前安装过会首先进入选择界面：
选择你想要配置的 mysql 服务即可，点击下一步
如果之前没有安装过任何版本的 Mysql，会直接进入下图界面：
之后是一些配置选项，按照你的用途选择就可以了，不过请注意下面这个界面：
这是选择 InnoDB Datafiles 的一步，请记住你选择的盘符和路径（原因后面再说）
最后需要设定密码，默认的用户名为 root。
安装完后它会自动编写$MYSQL_HOME$\ 并启动 Mysql 服务。
在命令行模式下输入 mysql，能够进入 mysql> 提示符说明 mysql 启动成功
Eclipse 和 MyEclipse 的安装与配置
1. 简单介绍 Eclipse 和 MyEclipse
Eclipse 是一个开放源代码的、基于 Java 的可扩展开发平台。就其本身而言，
它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse
附带了一个标准的插件集，包括 Java 开发工具（Java Development Tools，
JDT）。
这种平等和一致性并不仅限于 Java 开发工具。尽管 Eclipse 是使用 Java
语言开发的，但它的用途并不限于 Java 语言；例如，支持诸如 C/C++、COBOL
和 Eiffel 等编程语言的插件已经可用，或预计会推出。Eclipse 框架还可用来作
为与软件开发无关的其他应用程序类型的基础，比如内容管理系统。
简单而言，MyEclipse 是 Eclipse 的插件，也是一款功能强大的 J2EE 集成开
发环境，支持代码编写、配置、测试以及除错。
Genuitec 发布了 MyEclipse Enterprise Workbench ，更智能、更快捷、更简
单和更便宜的 J2EE 工具的新版本的诞生。它的价格对于个人和企业开发人员来
说都是非常有吸引力的。这是 J2EE IDE 市场一个重量级的选手。通过增加 UML
双向建模工具、WYSIWYG 的 JSP/Strutsdesigner、可视化的 Hibernate/ORM 工具、
Spring 和 Web services 支持，以及新的 Oracle 数据库开发，MyEclipse 继续为
业界提供全面的产品。
Genuitec 总裁 Maher Masri 说，"今天，MyEclipse 已经提供了意料之外的价
值。其中的每个功能在市场上单独的价格都比 MyEclipse 要高。但是，我们承诺
为顾客提供全面并且可以买得起的解决方案。按照这个传统，我们的顾客将继续
享受年度订购活动的好处，该活动提供了所有发布功能的入口以及伴随
一起的专业技术支持。"
2.安装 Eclipse 和 MyEclipse
将 直 接 解 压 到 要 安 装 的 目 录 即 可 。 然 后 安 装
MyEclipse,注意在安装的时候要正确选择 Eclipse 的安装路径。
3.运行环境的配置
指定 Eclipse+MyEclipse 的 JRE 、Tomcat 服务器和编码方式
1)一般情况下，Eclipse 可以自动找到 JRE，我们不用进行过多的设置。
2)配置 Tomcat
启动 Eclipse，菜单栏中选择“窗口(window)”－－“首选项...(preference)”
“MyEclipse”－－“Application Servers”－－“Tomcat 5”
将 Tomcat Server 设置为“Enable”，并将“Tomcat Home Directory”设置为 Tomcat
的安装目录，其他目录选项将会自动生成
3)配置默认编码
仍然是菜单栏中的“窗口(window)”－－“首选项...(preference)”
“常规(General)”－－“内容类型(Content Types)”－－“文本(text)”
然后在“缺省编码(Default encoding)”中输入“UTF-8”，点击“更新(Update)”
将“Java 类文件(Java Properties File)”及其他字符编码均“更新(Update)”为“UTF-8”
3 开发技术介绍
Java
Java 概述
1991 年,SUN MicroSystem 公司的 JameGosling、BillJoe 等人,为在电 视、控
制烤面包箱等家用消费类电子产品上进行交互式操作而开发了一个名为 Oak 的
软件(即一种橡树的名字),但当时并没有引起人们的注意 ,直到 1994 年下半
年,Internet 的迅猛发展,环球信息网 WWW 的快速增长,促进了 Java 语言研制的
进展,使得它逐渐成为 Internet 上受欢迎的开发与编程语言,一些著名的计算机 公
司纷纷购买了 Java 语言的使用权 ,如 MicroSoft、 IBM、Netscape、Novell、
Apple、DEC、SGI 等,因此,Java 语言被美国的著名杂志 PCMagazine 评为 1995
年十大优秀科技产品,(计算机类就此一项入选),随之大量出现了用 Java 编写的
软件产品,受到工业界的重视与好评,认为"Java 是八十年代以来计算机界的一件
大事",微软总裁比尔*盖茨在悄悄地观察了一段时间后,不无感慨地说:"Java 是 长
时间以来最卓越的程序设计语言",并确定微软整个软件开发的战略从 PC 单机时
代向着以网络为中心的计算时代转移,而购买 Java 则是他的重大战略决策的实施
部 署。 因此,Java 的诞生必将对整个计算机产业发生深远的影响,对传统的计算
模型 提出了新的挑战。 SUNMicroSystem 公司的总裁 ScottMcNealy 认为 Java
为 Internet 和 WWW 开 辟了一个崭新的时代。 环球信息网 WWW 的创始人
Berners-Lee 说:"计算机事业发展的下一个浪潮就 是 Java,并且将很快会发生的"。
Java 的特点
Java 是一个广泛使用的网络编程语言 ,它是一种新的计算概念 。
首先,作为一种程序设计语言,它简单、面向对象、不依赖于机器的结构、具
有可移植性、鲁棒性、安全性、并且提供了并发的机制、具有很高的性能。
其次,它最大限度地利用了网络,Java 的小应用程序(applet)可在网络上传输而
不受 CPU 和环境的限制。另外,Java 还提供了丰富的类库,使程序设计者可以很
方便地建立自己的系统。
Java 语言有面一些特点:简单、面向对象、分布式、解释执行、鲁棒、安全、
体系结构中立、可移植、高性能、多线程以及动态性。
1.简单性
Java 语言是一种面向对象的语言 ,它通过提供最基本的方法来完成指定的任
务 ,只需理 解一些基本的概念 ,就可以用它编写出适合于各种情况的应用程序。
Java 略去了运算符重 载 、 多重继承等模糊的概念 ,并且通过实现 自动垃圾收
集大大简化了程序设计者的内存 管理工作。 另外,Java 也适合于在小型机上运
行 ,它的基本解释器及类的支持只有 40KB 左右,加上标准类库和线程的支持也
只有 215KB 左右。库和线程的支持也只有 2 15KB 左右。
2.面向对象
Java 语言的设计集中于对象及其接口 ,它提供了简单的类机制以及动态的接
口模型。对象中封装了它的状态变量以及相应的方法 ,实现了模块化和信息隐藏 ;
而类则提供了一类对象的原型,并且通过继承机制,子类可以使用父类所提供的方
法 , 实现了代码的复用。
3.分布性
Java 是面向网络的语言。 通过它提供的类库可以处理 TCP/IP 协议,用户可以
通过 URL 地 址在网络上很方便地访问其它对象。
4.鲁棒性
Java 在编译和运行程序时,都要对可能出现的问题进行检查 ,以消除错误的产
生。它提供自动垃圾收集来进行内存管理,防止程序员在管理内存时容易产生的
错误。通过集成的面向对象的例外处理机制,在编译时,Java 提示出可能出现但未
被处理的例外,帮助程序员正确地进行选择以防止系统的崩溃。另外,Java 在编译
时还可捕获类型声明中的许多常见错误,防止动态运行时不匹配问题的出现。
5.安全性
用于网络、分布环境下的 Java 必须要防止病毒的入侵。Java 不支持指针,一
切对内存的访问都必须通过对象的实例变量来实现,这样就防止程序员使用"特
洛伊 "木马等欺骗手段访问对象的私有成员 ,同时也避免了指针操作中容易产生
的错误 。
Servlet 技术
Servlets:工作原理及概述
Servlets 是用 Java 语言实现的独立于协议和平台的服务器端组件，它动态扩展了
支持 Java 的服务器，它可以被插入到支持 Java 的 Web 服务器中以提供定制服务，
包括：
· 增加新的特性服务
· 页面内容的动态改变（Runtime changes）
· 页面显示的动态改变（Runtime changes）
· 对新的标准协议的支持(例如 FTP)
· 对用户定制协议的支持
如图所示，Servlets 在服务器内部工作，它们不需要图形用户接口，作为 Java 程
序组件，它们根据需要在服务器内部被部署。而使用 Servlets 的客户多种多样，
既有简单的 HTML 表单，也有复杂的 Java Applets。
Servlets 被设计在请求/应答（Request/Response）处理模式下工作，在该模式下，
客户向服务器发送请求消息，服务器则通过发送应答消息予以回复。请求消息可
以采用如下格式：
· HTTP
· URL
· FTP
· 用户定制协议
在通常情况下，请求和其相关应答可以反映请求时刻客户和服务器的状态，而客
户和服务器之间连接的状态无法在多个请求/应答之间保存，而 Servlet 所提供的
会话（Session）机制则可以在多次请求/应答之间保存会话信息。
Servlets 有效地扩展了基于请求/应答的服务器（例如 Web 服务器）的功能，下
图显示了一个最简单的应用实例，一个 Servlet 负责获取来自客户的 HTML 格式
的定单项（order-entity）数据，然后实施商业逻辑（business logic）处理，以便
最终更新用户的定单数据库。
Java Servlet API 包括若干 Java 接口（Java interfaces），全面定义了主机服务器
与 Servlets 之间的连接。Servlet API 属于标准 Java 开发包（JDK）扩展，被包含
在如下 Java 包中：
·
·
Servlets API 包括了很多有用的特性，如会话跟踪（Session tracking）、表单数据
采集（Form data parsing）、共享数据（Shared data）、国际化字符 I/O，初始化参
数、请求代理（Request delegation）等。
特点及应用
Servlets 是对 Java 环境的一个功能强大的补充，具有快速、安全、可靠和 100%
纯 Java 的优点。因为 Servlets 被插入到已经存在的服务器中运行，可以有效利用
大量现成代码和技术，所有有关网络连接、协议协商、类装载等等工作都可以由
服务器代劳，极大地减少了重复工作。
协议支持 Servlet API 提供了服务器和 Servlets 之间的紧密连接，它们允许为服
务器增加新的协议支持。Servlet API 包中已经实现了对 HTTP 的很好支持。从本
质上说，任何遵循请求/应答工作模式的协议都可以通过一个 Servlet 来实现，包
括：
· SMTP
· POP
· FTP
目前主要的 Web 服务器都实现了对 Servlets 的支持，而越来越多的其他类型的应
用程序服务器也开始实现对 Servlets 的支持。由于 HTTP 是最为常用的协议之一，
Servlets 在基于 HTTP 的系统中得到了最为广泛的应用。相对于其他服务器端技
术如 CGI、Web 服务器 API 扩展（NSAPI、ISAPI、Apache Modules）等，Servlets
有如下优势：
· 由于使用了不同的处理模型和处理机制，Servlets 在速度和效率上高于 CGI，
在功能和实现灵活性上也要强于 CGI，有取代 CGI 的趋势。
· Servlets 使用了被许多 Web 服务器产品支持的标准 API，具有较强通用性。
· Servlets 具有 Java 编程语言的所有优点，包括易于开发、平立性等。
· Servlets 可以访问基于 Java 平台和 Java 技术的大量 API，能很好地和目前主流
体系结构（如 J2EE）融合，具有高灵活性和高扩展性，适用于构造大型复杂的
应用系统。
JSP 技术介绍
jsp 概述
JavaServer Pages（JSP）是一种实现普通静态 HTML 和动态 HTML 混合编
码的技术，有关 JSP 基础概念的说明请参见《JSP 技术简介 》。
许多由 CGI 程序生成的页面大部分仍旧是静态 HTML，动态内容只在页面
中有限的几个部分出现。但是包括 Servlet 在内的大多数 CGI 技术及其变种，总
是通过程序生成整个页面。JSP 使得我们可以分别创建这两个部分
Jsp 与 servlet 的比较
1) JSP以文本为主，主要用于画界面
2) JSP可以人工扩充，而servlet是固定的
3) JSP内核是servlet,所以也是基于HTTP协议的请求响应循环
4) 由HTML（Css、xml）、java code、JSP标签组成
5) JSP有自定义标签（ASP没有）
6) CGI和Servlet以代码为主，代码中嵌文本 ；JSP中文本中嵌代码
7) JSP擅长于表现，而短于逻辑；而Servlet一般用作Contorler和diapatch(控制和
流转)；所以在JSP中写界面元素，而逻辑方面由Servlet完成。
8) JSP不需要写java文件、不需要编译和配置，它被封装到了容器内部
9) JSP代码不可重用
Jsp 的工作原理:
（1）翻译（转换）阶段：*.jsp —> *.java
（2）编译阶段：*.java —> *.class
（3）运行阶段：运行编译后生成的*.class 文件。
以上三个阶段均由 JSP 引擎来执行；JSP 引擎由 Web 服务器所提供，它实际
上就是一个 Servlet（该 Servlet 在 conf/ 中配置）
jsp 的特点
（1） JSP 里面可以嵌入 JAVA 代码
（ 2 ） 在 运 行 的 时 候 ， JSP 被 容 器 翻 译 成 为 一 个 servlet ， 放 在
--work--Catalina---localhost 目录下面
（3）不需要再在配置文件里面配置
（4）文件被修改之后，自动进行重新编译
Jsp 的环境配置
向 MyEclipse 插入 和
到 WEB 应用程序的 WEB-INF/lib 下便可使用 jsp 了。
Struts 技术
StrutsMVC 框架
web 应用的分层
交互层，表现数据，收集数据，也就是视图层，接受请求，通过处理层完成相应
的响应。（V，C）
处理层，完成数据的处理，也就是业务层（M）。
MVC 设计模式（应用观察者模式的框架模式）
M model，模型，操作数据的业务处理层。
V view，示图，采集和显示数据，为业务层提供数据，表现业务层输出的数据，
只关心数据的类型，不管新数据的来源。
C ctrl，控制器，也就是视图层和模型层桥梁，控制数据的流向，接受视图层发
出的事件，并重绘视图。
MVC 框架的实现模型
StrutsMVC 框架
Struts 是使用 MVC 的实现模式二来实现的，也就是以控制器为核心。
Struts 提供了一些组件使用 MVC 开发应用程序：
Model：Struts 没有提供 model 类。这个商业逻辑必须由 Web 应用程序的开发者
以 JavaBean 或 EJB 的形式提供
View：Struts 提供了 action form 创建 form bean, 用于在 controller 和 view 间传输
数据。此外，Struts 提供了自定义 JSP 标签库，辅助开发者用 JSP 创建交互式的
以表单为基础的应用程序，应用程序资源文件保留了一些文本常量和错误消息，
可转变为其它语言，可用于 JSP 中。
Controller：Struts 提供了一个核心的控制器 ActionServlet，通过这个核心的控制
器来调用其他用户注册了的自定义的控制器 Action，自定义 Action 需要符合
Struts 的自定义 Action 规范，还需要在 的特定配置文件中进行
配置，接收 JSP 输入字段形成 Action form，然后调用一个 Action 控制器。Action
控制器中提供了 model 的逻辑接口。
Struts 使用 Model 2 架构，它 的 ActionServlet 控制导航流，其他 Struts 类，
比如 Action, 用来访问业务逻辑类。当 ActionServlet 从容器接收到一个请求，
它使用 URI (或者路径“path”) 来决定那个 Action 将用来处理请求。一个 Action
可以校验输入，并且访问业务层以从数据库或其他数据服务中检索信息。为校验
输入或者使用输入来更新数据库， Action 需要知道什么指被提交上来。并不是
强制每个 Action 从请求中抓取这些值，而是由 ActionServlet 将输入绑定
JavaBean 中。输
入 bean 是 Struts ActionForm c 类的子类。ActionServlet 通过查找请求的路径可
以决定使用哪个 ActionForm，Action 也是通过同样的方法选取的。ActionForm
扩展 类。每个都必须以 HTTP 响应进行应答。
通常, StrutsAction 并不自行加工响应信息，而是将请求转发到其他资源，比如 JS
页面。Struts 提供一个 ActionForward 类，用来将一个页面的路径存储为逻辑名
称。当完成业务逻辑后，Action 选择并向 Servlet 返回一个 ActionForward。Servlet
然后使用存储在 ActionForward 对象中的路径来调用页面完成响应。Struts 将这
些细节都绑定在一个 ActionMapping 对象中。每个 ActionMapping 相对于一个
特定的路径。当某个路径被请求时，Servlet 就查询 ActionMapping 对象。
ActionMapping
对象告诉 servlet，哪个 Actions, ActionForms, 和 ActionForwards 将被使用。所
有这些细节，关于 Action， ActionForm， ActionForward， ActionMapping，以
及其他一些东西，都在 文件中定义。 ActionServlet 在启动时
读取这个配置文件，并创建一个配置对象数据库。在运行时，Struts 应用根据文
件创建的配置对象，而不是文件本身。
基于 struts 的 web 应用的开发步骤
1，对应用环境进行配置
2，创建 web 应用的结构，需要将 struts 应用的 jar 文件进行部署。
3，在 web 服务器部署 struts
4，配置 文件，配置 Actoin
5，写自定义 Action，实体，以及业务类
写一个基于 Struts 的 web 应用
1，创建一个符合标准的 web 应用的结构，也就是一个有 WEB-INF 文件夹的应
用文件夹，在应用中需要使用到 Struts 的一些 jar 文件，要放到 WEB-INF 的 lib
文件夹下，这些 jar 文件都在 struts 的 zip 文件中的/-bin/lib 下还有
-bin/contrib/struts-el/lib 下的 、 和 。
2，在 中配置 Struts 的核心控制器 ActionServlet，并指明 Struts 的配置文
件的所在位置 WEB-INF 下，在 struts 的文件中有一个样板的 文件，使
用这个 文件来部署应用就可以了 ，这个样板在 struts 的 zip 文件中的
文件中的 web/examples/WEB-INF/ 就是样板文件。部
署应用看 struts 是否发布成功。
<servlet>
<servlet-name>action</servlet-name>
<servlet-class></servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
3，写 jsp 页面和业务，实体，和自定义控制器类 Action，自定义 Action 是要继
承于 Action 类
ActionForm 是可以自动将表单中的数据封装成对象，当然，一个自定义
ActionForm 也是要遵守 Struts 规范的，也就是要继承于 ActionForm，并在以上
的 进行配置。
ServletController （ ActionServlet 和 自 定 义 的 Action ）， 配 置 Ctrler 需 要 配 置
，通过客户端 form 的 action 来查找调用相应的 action,自定义
action 中的 mapping 对应的是配置文件中的 forward 标签，通过 forward 的 path
属性来跳转到相应的路径。
Struts 预定义的 Action 类
注意：在使用继承 Struts 预定义的 Action 类，一定不要覆盖 execute 方法，否则
会导致无法调用自定义 Action 相应方法。
DispatchAction 类()
DispatchAction 类是 Action 类的子类，他提供了有实现的 execute 方法。
我们写的自定义 Action 类，可以继承 DispatchAction 类，但不要覆盖 execute 方
法，可以在自定义类中写反回值和参数表都与 execute 方法相同的方法，可以通
过在 中为这个 action 的配置中添加一个参数，来判断调哪一个
方法，实际上 DispatchAction 类就是通过反射机制，通过 form 中参数调用了自
定 义 Action 中 的 方 法 ， 当 然 这 些 方 法 的 定 义 要 符 合 规 范 ， 使 用 继 承
DispatchAction 类的自定义的 Action 类，也就会共享同一的 Action 路径。
注意：使用继承 DispatchAction 类的自定义的 Action，只会匹配一个 action 路径，
只能共享一个 ActionForm，如果加上校验，会产生 form 表单的参数不一致的情
况，会导致校验无法通过。
MappingDispatchAction 类()
MappingDispatchAction 类是 DispatchAction 的子类，他和 DispatchAction 不同点
就是可以去匹配多个 action 路径，这样也就是结决了共用 ActoinForm 的校验问
题了，多个 Action 的路径使用同一的自定义 Action 类，这样就不用共享同一个
ActionForm，也就不会有校验问题了。
在 JSP 页面中也不用在使用隐藏域传递参数，直接在 form 中的 action 中就可以
直接使用 匹配了。
LookupDispatchAction()
LookupDispatchAction 类也是 DispatchAction 类的子类，他所实现的功能是解决
一个表单多种提交问题的
，他是通过使用资源文件，用 submit 按钮的 value 来作为资源文件中的 key 所对
应的值，通过这个值来找到对用的 key，在使用这个 key 来获得指定 Map 中所对
应的值，这个值就是要调用的方法名。
submit 的 value----> 中的 key----->Map 中 key 对相应
的值---->action
注意：在继承 LookupDispatchAction 时，要覆盖 getKeyMethodMap()方法，并定
义 Map，向 Map 中放入指定的键值对。
自定义的 Action 类的一些规则
1，尽量不要在 Action 类中使用（静态）成员变量，如果使用要加上同步。
2，尽量使各模块间的耦合性降低，最大限度的针对接口编程。
3，可以将共代码方在覆盖父类的方法中，最后可以用 (xxx)来调用父类
的方法，使用父类的实现，并加上了自定义的功能。
Struts 的 Token（令牌）机制
Struts 使用 Token 机制，来防止恶意的破坏和重复提交问题，也就是点击后退后
在再提交，这是 Struts 无法发现的，在 form 中生成一个 token 码，在 session 中
也报村有一个同样的 token 码，当表单提交后，判断两个 token 码向等后，就会
改变 session 中的这个 token 码，当然在用回退后，form 的 token 码是不会变的，
在提交，还会判断两个 token 码是否相等，如果不等就会抛出异常，证明这是过
时的垃圾数据。
void saveToken(HttpServletRequest request)方法用于将在客户端生成的 token 码，
保存在 session 中。
void resetToken(HttpServletRequest request)方法用于重置 token 码，生成新的
token 码。
boolean isTokenValid(HttpServletRequest request,boolean reset)判断 token 码是否
相等，并且是否重置 token 码。reset 是设定是否重置 token 码，一般设为 true。
Struts 的异常处理
Struts 只处理 action 的异常，
配置 struts 的异常处理
全局的异常处理
<global-exceptions>
<exception key="error" path="xxx/xxx" type="">
</global-exceptions>
<action path="xxx/xxx" type="">
....
<exception key="xxx" path="xxx/xxx" type="">
</action>
在 exception 标签中的 key，也就是在出现异常时会封装在 ActionErrors 中，也就
是可以在页面中使用。
ActionError(String key, Object value0)，可以通过在构造 ActionError 时，指定不同
的 key 值来对异常进行分类，并且在 html:error 标签的
自己构造 ActionErrors 并使用下面的方法发送
void saveErrors(HttpServletRequest request,ActionErrors errors)这个方法用以把封
装了异常的 ActionErrors 的 key 存储到 request 中。
Hibernate
Hibernate 数据持久化组件
对象持久化，把数据保存在永久的存储介质中（数据库）
OR/M（object relation mapping）对象关系映射。
POJO 类，就是标准的 Java Bean。
Hibernate 就是一个可以自动的根据 xml 完成对象关系映射，并持久化到数据库
的开源组件。
Hibernate 的底层也是有 JDBC 实现的。
hibernate 是通过 xml 文件的配置，对数据库的底层的方言，以及数据库连接所需
的信息，以及连接数据库的驱动。hibernate 的系统配置文件的名字一般叫做
，一般是映射类名加.。一般将映射类的 xml 文件和实体
类放在一起。
中会设置数据库的连接信息，以及引用的其他文件的文件名，
和一些其他的摄制。这个文件一般放在项目的根目录下。
使用 hibernate 编程步骤
1，配置环境，加载 hibernate 的 jar 文件，以及连接数据库连接使用的 jar 文件，
并配置 CLASSPATH 环境变量。
2，写 hibernate 所需的配置文件， ，
3，写 POJO 类
4，调用 hibernate API。
1)使用 Configuration 对象的 buildSessionFactory()方法创建 SessionFactory 对
象
2)使用 SessionFactory 对象 openSession()方法创建 Session 对象。
3)使用 Session 的相应方法来操作数据库，将对象信息持久化到数据库。
Hibernate 控制的事务
事务保证原子操作的不可分，也就是操作的同时成功或同时失败。
Transaction tran=();
();
();
以上是事务对象的方法，来实现对事务的支持。
hibernate 的事务隔离级别
hibernate 的事务隔离级别和 JDBC 中大致相同。
设置时要在 配置
<property name="">4</property>
1，读未提交的数据（Read uncommitted isolation）
2，读已提交的数据（Read committed isolation）
4，可重复读级别（Repeatable read isolation）
8，可串行化级别（Serializable isolation）
hibernate 的锁（悲观锁，乐观锁）
悲观锁是由数据库本身所实现的，会对数据库中的数据进行锁定，也就是锁行。
,修改锁，在 get()方法中加上这个设置作为第三个参数。
无锁机制
读取锁
写入锁，不能在程序中直接使用
还可以使用 () () ()方法来设
置锁
4 系统设计
需求分析
功能分析
根据实际合同管理系统的行为规范，具体功能包括：
客户管理：。有客户的注册，修改和删除功能,以及客户名，地区进行查询。
合同管理：。有合同的录入，修改和删除，另外按时间，客户，客户地区，
以及按合同的进度进行查询；
职工管理：。有职工的添加，修改和删除功能，另外有查询所有的职工。
功能描述:
1) 客户管理
a) 客户基本信息的维护：
——客户信息的录入
——客户信息修改
——客户信息删除
b) 客户信息的查询：
——按地区查询
——按客户名称查询
2) 合同管理
a) 合同的基本编辑
——合同的录入
合同管理
客户管理 合同管理 职工管理
——合同的修改
b） 合同的维护
——合同录入后，交付上级管理人员、部门审核，负责
人签名
——合同变更，相关管理人员对合同内容进行变更，负
责人签名
——合同执行进度管理，对合同的执行情况进行记录
c) 合同统计查询管理
——合同订单的查询（按时间、客户、客户地区查询）
——按照合同的完成情形查询(审核,未审核)
3)职工管理
a) 职工基本信息的维护：
——职工信息的录入
——职工信息修改
——职工信息删除
b) 客户信息的查询：
---集体职工查询
角色分析:
根据实际情况，本系统分为三种角色：客户，职工，管理员。
客户：
委托职工或者管理员进行合同的办理；
职工：
受客户委托进行合同办理，合同的管理，录入，修改，查询，删除；
管理员：
受客户委托进行合同办理，合同的管理，录入，修改，查询，删除；
对职工进行管理，职工的添加，修改，查询，删除。
数据库分析：
根据功能和角色分析，可以知道实体类有三个；
管理员和职工都为一方，设计为一个类，
客户为一个类，
合同为一个类，
这样一来的话，在数据库就建成 3 张表，即：staff,customer,contract
staff 的属性信息包括：
1)：全体职工的用户名，
2)：职工的密码；
3)：职工的权限，管理员还是普通职工；
类图如下：
customer 的属性信息包括：
1)：客户姓名；
2)：客户性别；
3)：客户电话；
4)：客户住址；
5)：客户传真；
6)：客户身份证；
7)：客户邮编；
类图如下：
contract 的属性信息包括：
1):合同名称；
2):合同描述；
3):合同内容；
4):合同录入时间；
5):合同名称状态，未签署还是已签署；
类图如下：
数据实体间的关系：
职工与客户之间：
一个职工对多个客户；
客户与合同之间：
一个对应多个合同，一个合同可以被多个客户拥有,多对多关系：
数据库设计
由于合同系统功能复杂，并且要存取的数据较多，因此简单地使用文件来存
储数据库和管理显然是不合适的。所以本系统使用 MySql 数据库来存储数据。
根据系统需求分析需要创建以下的数据表来存储数据
表用来保存客户注册的一些基本信息，并且同时保存一些 staff 信
息，设计出 Customer 表如表
Customer 表
字段名称 数据类型 说明
id int 用户 Id
name varchar 用户名
phone varchar 电话号码
fox varchar 传真
postcode varchar 电子邮件
sex varchar 性别
idcNum varchar 身份证
regDate date 注册时间
address varchar 详细地址
staff_id int 职工或管理员 ID
表用来保存合同的一些基本信息，和客户的一些信息
设计出 Contract 表如下：
Contract 表
字段名称 数据类型 说明
id int 合同 Id
name varchar 合同名称
description varchar 合同描述
submitDate date 录入时间
centent varchar 合同内容
status int 状态
customer_id int 合同对应的客户 Id
表用来保存用户的一些基本信息，
设计出 Staff 表如下：
Staff 表
字段名称 数据类型 说明
id int 职工或者管理员 Id
name varchar 用户名字
passwd varchar 用户密码
flag varchar 权限
系统总体设计
设计思想：
现代化的企业越来越重视科学技术，只有把科学技术应用到企业中才能获取
更大的效益。合同是商品经济的产物，是商品交换的法律表现形式。现代企业的
经济往来，主要是通过合同形式进行的。所以，合同管理作为现代企业法律顾问
制度的重要内容之一，能否实施有效管理把好合同关，是现化企业经营管理成败
的一个重要因素。
企业往往会签订一系列的合同，并且会考虑如何去管理合同的进展，合同使
用者的信息。完善的合同管理是企业健康运作的一个重要标志。
设计原理图如下图:
框架设计：
web 开发三层结构：
交互层，表现数据，收集数据，也就是视图层，接受请求，通过处理层完成
相应的响应。（V，C）处理层，完成数据的处理，也就是业务层（M）。
管理员
职工
客户 浏览器 服 务
器
tomcat
数据库
MVC 架构模式强行的业务的表现和业务的处理分开，最大限度得减少软件
各层之间的偶合性，软件可以更好维护和扩展。当你改变业务的表现时不会影响
到业务的处理，扩展业务时不会影响到业务的表现。
StrutsMVC 框架
Struts 是使用 MVC 的实现模式二来实现的，也就是以控制器为核心。Struts
提供了一些组件使用 MVC 开发应用程序：
Model：Struts 没有提供 model 类。这个商业逻辑必须由 Web 应用程序的开
发者以 JavaBean 或 EJB 的形式提供
View：Struts 提供了 action form 创建 form bean, 用于在 controller 和 view 间
传输数据。此外，Struts 提供了自定义 JSP 标签库，辅助开发者用 JSP 创建交互
式的以表单为基础的应用程序，应用程序资源文件保留了一些文本常量和错误消
息，可转变为其它语言，可用于 JSP 中。
Controller：Struts 提供了一个核心的控制器 ActionServlet，通过这个核心的
控制器来调用其他用户注册了的自定义的控制器 Action，自定义 Action 需要符
合 Struts 的自定义 Action 规范，还需要在 的特定配置文件中进
行配置，接收 JSP 输入字段形成 Action form，然后调用一个 Action 控制器。Action
控制器中提供了 model 的逻辑接口。
MVC 结构的框架如下：
系统界面要求
系统的客户端和服务器初始界面假定用户是未登录，主页面显示登陆窗口，
通过初始界面提供的统一的用户登录接口，登录进入系统，因此系统主页面应该
能自动进行身份判别，按照访问者的身份自动进入其相应的功能权限的管理
界面设计如下：
Y
N
Y
系统模块的划分：
合同管理系统的核心内容就是方便公司内部能够有效的对客户的需求进
行管理，以得到广大新老客户的光顾，从而让企业壮大。
系统的总体用例图如下：
登陆
管理员 管理员操作界面
职工 职工操作界面
结束
本次毕业设计的合同管理系统划分为如下的功能模块：
1):职工或管理员的登录模快；
2):职工和管理员的添加模块；
3):职工或管理员的查询模块；
4):职工或管理员的信息修改模快；
5):职工或管理员的删除模快；
6):客户信息的注册模块；
7):客户信息的修改模块；
8):客户的按地区查询模块；
9):客户的按姓名查询模块；
9):客户信息的删除模块；
10):合同信息的录入模块；
11):合同的签署模块
12):按客户地区查询合同信息模块；
13):按录入时间段查询合同信息模块；
14):按合同状态查询合同信息模块；
15):按客户名查询合同信息模块；
主要系统模块的具体实现：
(1):职工或管理员的登录模块
一个 login 连接，默认为职工或管理员的登录界面，系统根据帐号和密码以
及权限设置登录到不同的页面，若职工权限进入客户管理和合同管理模块，
若管理员权限进入客户管理，合同管理以及职工管理模块；
步骤：
1．输入用户和密码，选择用户权限即 职工或管理员,点”登录“；
2．根据用户名和密码，系统进行数据库连接，若没有找到，返回错误信息：用
户名，密码或用户权限错误 返回当前登录页面；
3．若找到用户名和密码，根据权限设置，登录系统操作页面，若 a 登入管理员
页面，若 s 登入职工管理页面。
以下为登录界面：
以下为两种角色登录后的界面：
实现代码如下：
Action:
String target = "login";
StaffForm sform = (StaffForm) form;
String name = ();//通过 form 表单找到 flag,password,name;
String password = ();
String flag = ();
Staff staff = new Staff();
(name);
(password);
StaffService ss = new StaffServiceImpl();
Staff sta = (name, password);//根据数据找对象。
if (sta != null) {//如果根据用户存在一个对象。执行如下：
if ((())) {//如果 flag 传过来的是 a 进入管理员页
面。
().setAttribute("sta", sta);
} else if ((())) {//如果 flag 传过来的是 s 进入职工
页面。
().setAttribute("sta", sta);
} else {//如果不存在，抛提示信息。。
("errors", "用户名、密码或权限不对");
target="back";//返回当前登录首页；
Service:
staff=(name, password);
DAO:
return (Staff)("from Staff s where name=? and
password=?").setString(0, name).setString(1,password).uniqueResult();
(2):添加职工模块
管理员进入了管理员模块进行添加职工；
步骤：
1. 点 职工管理---→添加职工，进入添加职工页面；
2. 根据管理员的要求添加另一个管理员和职工，新创的管理员具有和该管
理员一样的权限，输入要创建的用户名和密码以及新的职工类型；
3. 点 注册 系统根据输入的帐号 访问数据库判断是否存在，如果存在，返
回错误信息，如果帐号不存在，注册成功，提示成功信息，返回添加职
工页面。管理员可以继续添加职工。
以下分别为添加职工页面，注册失败页面，注册成功页面；
实现代码如下：
Action:
String name = ();
String password = ();
String flag = ();
(flag);
Staff staff = new Staff();
(name);
(password);
(flag);
StaffService ss = new StaffServiceImpl();
try {
success = (staff);
if (success) {
("rinfo", "注册成功");
}
} catch (RuntimeException e) {
("rinfo", "注册失败");
}
Service:
Staff sta=((), ());
if(sta==null){
success=true;
(staff);
}else{
throw new RuntimeException("对不起该用户已存在。请用其他用
户名");
DAO:
(staff);
(3):职工或管理员的修改和删除模块
管理员进入管理员界面后进行职工信息的删除和修改
步骤：
1．点 所有职工 进入 职工的修改和删除页面；
2．如果点 修改 跳到 所选职工信息修改页面，对职工的信息进行修改，点
修改，系统根据数据对该职工的信息进行修改(先找到该用户，然后更
新)，返回当前页面，提示 修改成功 信息；
3．如果点 删除 删除当前所选的职工，当前所选职工信息已经不存在了 返
回到当前页面；
以下为修改，删除页面，职工信息修改界面，修改成功页面，删除后修改，
删除页面：
实现代码如下：
Action:
Staff staff = new Staff();
boolean success = false;
String name = ();
String password = ();
(name);
(password);
success = (staff);
Service:
(staff);
DAO:
(staff);
(4):查询客户信息
职工或管理员进入登录页面，对客户进行按姓名查询；
步骤：
1. 点 客户查询 -→按姓名查询,输入姓名，点 查询;
2. 系统根据所提供的姓名这个信息对数据库进行查询，若找到这个
客户所有对应的休息，跳转到另一个显示界面，显示该用户的信
息；
3. 点 客户查询 →按地区查询，输入地区名，点 查询；
4. 系统根据所提供的姓名这个信息对数据库进行查询，若找到这个
地区所有对应的信息，跳转到另一个显示界面，显示该地区的信
息表单；
以下为操作所涉及的页面：
实现代码如下：
按姓名查:
Action:
CustomerService cs=new CustomerServiceImpl();
CustomerForm cform=(CustomerForm)form;
String name=();
Customer customer=(name);
Service:
customer=(cusName);
DAO:
return (Customer)("From Customer c where
name=?").setString(0, CustomerName).uniqueResult();
按地区查:
Action:
CustomerService cs=new CustomerServiceImpl();
List<Customer> cuss=(address);
Service:
customers=(address);
DAO:
return ("From Customer c where
address=?").setString(0, address).list();
(5):合同信息的录入
职工或管理员进入合同管理页面，对合同进行管理；
步骤：
1. 点 添加合同 显示添加合同页面，录入合同页面指定的一些
信息,点提交；
2. 系统根据合同名对数据进行查询，如果有该合同名，返回当
前页面，提示录入失败；若没有，在当前提示录入成功，
以下为页面操作所涉及的页面：
实现代码如下：
Action:
ContractForm cform=(ContractForm)form;
ContractService cs=new ContractServiceImpl();
String name=();
String description=();
String content=();
int status=();
Contract c=(name);
if(c==null){
Contract con=new Contract();
(content);
(description);
(name);
(status);
(new (new
().getTime()));
(con);
("cinfo", "添加成功！");
}else{
("cinfo", "合同已存在！！");
}
Service:
(contract);
DAO:
(contract);
(6)：合同信息的签署
管理员进入合同管理页面，对合同进行签署。
步骤：
1. 到 查询合同 页面，根据姓名查询合同，若该客户不存在 提示没有
该客户，若有客户而没有合同，提示该客户没有合同，若该客户有
合同得到 按姓名查询 的合同页面，
2. 点 审核 修改合同的签署状态；
以下为所涉及到的页面：
实现代码如下：
Action:
按姓名查询合同：
ContractService cs=new ContractServiceImpl();
List<Contract> cons=new ArrayList<Contract>();
CustomerService cuss=new CustomerServiceImpl();
String name=("cname");
Customer c=(name);
if(c!=null){
Integer customerId=();
cons=(customerId);
if(cons!=null){
("cons", cons);
}else{
("cinfo", "这个客户没有合同！");
}
}else {
("cinfo", "没有该客户");
}
审核合同：
int status=();
Contract con=(name);
if(con!=null){
(content);
(description);
(name);
(status);
(new (new ().getTime()));
(con);
("cons", "修改成功");
}
系统的测试
在每个模块设计完成之后，对系统进行单元测试，确定其能否达到功能需求
所预期的目标。单元测试完成后，对系统进行各种综合测试。经过反复的测试，
工业制造企业合同管理系统基本达到功能需求的要求。
5 总结与体会
这次毕业设计的任务是利用 JSP/STRUTS 开发基于 WEB 的工业制造企业
合同管理系统，系统总体模式是 MVC，用到具体的 Struts 框架，其功能是实现
合同管理系统中客户信息的添加删除，签署合同，合同管理等。
这次毕业设计是对我大学四年所学知识的一个综合，从中我熟练掌握了软件
设计的思想及其开发的全过程。首先要进行系统的需求分析，分析系统要达到什
么功能，系统要划分为几个模块来设计，系统的具体功能应当如何去实现；分析
完之后，进行总体设计，框架设计，数据库设计，考虑其涉及到的计算机专业知
识，把问题细化，把大的问题划分为小的问题，然后逐个进行解决。毕业设计开
始阶段，由于自己初次接触 JSP/Struts 作具体的项目系统，在这方面知道的很少，
作的过程中遇到了很多 BUG 难调，通过查阅相关书籍以及在互联网上进行相关
资料的搜索，逐渐开始对所接触的事物有了一定地了解和把握。
本次系统设计，我感触很深，要想做好一个系统，不仅需要具有相关的专业
知识，还应具有相关的实践能力，要把以前所学习的各种知识综合起来并加以灵
活地运用。通过本次亲自动手设计系统，进行编码，调试通过，我更加深刻的了
解系统开发的全过程，以及在开发中遇到问题应当如何去解决，这对我今后的工
作有很大的帮助，并为我在今后工作中遇到困难、如何去克服提供了宝贵的经验。
同时感觉到软件开发的乐趣，软件开发是自我挑战，实现自我，表现自己能
力的一个途径。现在看到代码就有点莫名的冲动，有点一天不敲代码，心里痒痒
的感觉，见到代码异度兴奋。底层的代码，所体现的视觉感，总让人感到一个好
奇感。几句代码怎么就能表现出人们所想的视觉效果呢。所以在我以后的软件开
发的路途中，我会克服困难，坚决书写自己的理想。还有就是我想写一个属于个
人的专职系统，每个人都能免费的利用它来做一些生活中的小事。
由于个人能力有限以及实践经验欠缺，系统基本满足合同管理系统的功能需
求，本系统不可避免有不足之处，如一些系统功能过于简单，所以系统的功能还
算不上很完善。希望老师和同学能给予建议和指导。
致 谢
毕业设计是大学四年的最后一门课程，也是综合运用所学知识的课程。平常
上课学习的都是理论知识，然而亲自动手实践的机会很少，这次毕业设计为我提
供了一个很好的机会，可以让我将所学的理论知识运用到实践中，是检验理论知
识学习成果的最好方法,例如:在运用到 Struts 时，遇到很多 BUG，经过仔细的调
试，才能运行通过，所以说实践是实现理论的法宝。
在本次毕业设计过程中，要特别感谢我的指导老师汤亚玲老师，在整个设计
过程中对我们要求很严格，从而能顺利完成系统的设计以及论文的书写。每次和
汤老师见面时，他都会及时地提出我们设计过程中的不足，指导我们如何去解决
问题，从中我们也学到了解决问题的方法。设计过程中老师教授的知识，我们将
终身受用。
参考文献
1. 软件工程导论 张海藩 编著 清华大学出版社 1998-01-02
与系统分析设计 张龙祥 编著 人民邮电出版设
-SERVER 开发指南 清华大学出版社 2000-09-01
4.数据库系统概论 萨师煊等编著 高等教育出版社
5 数据库系统原理 李建中著 北京：电子工业出版社, 2004
面向对象开发 孙卫琴 电子工业出版社
7.精通 Java Web 整合开发[JSP+AJAX+STRUTS+HIBERNATE] ；刘斌
电子工业出版社
应用开发详解 电子工业出版社
:// 软件工程专家网
附录一：英文资料原文
Interface Collection<E>
The root interface in the collection hierarchy. A collection represents a group of
objects, known as its elements. Some collections allow duplicate elements and others
do not. Some are ordered and others unordered. The JDK does not provide any direct
implementations of this interface: it provides implementations of more specific
subinterfaces like Set and List. This interface is typically used to pass collections
around and manipulate them where maximum generality is desired.
Bags or multisets (unordered collections that may contain duplicate elements) should
implement this interface directly.
All general-purpose Collection implementation classes (which typically implement
Collection indirectly through one of its subinterfaces) should provide two "standard"
constructors: a void (no arguments) constructor, which creates an empty collection,
and a constructor with a single argument of type Collection, which creates a new
collection with the same elements as its argument. In effect, the latter constructor
allows the user to copy any collection, producing an equivalent collection of the
desired implementation type. There is no way to enforce this convention (as interfaces
cannot contain constructors) but all of the general-purpose Collection
implementations in the Java platform libraries comply.
The "destructive" methods contained in this interface, that is, the methods that modify
the collection on which they operate, are specified to throw
UnsupportedOperationException if this collection does not support the operation. If
this is the case, these methods may, but are not required to, throw an
UnsupportedOperationException if the invocation would have no effect on the
collection. For example, invoking the addAll(Collection) method on an unmodifiable
collection may, but is not required to, throw the exception if the collection to be added
is empty.
Some collection implementations have restrictions on the elements that they may
contain. For example, some implementations prohibit null elements, and some have
restrictions on the types of their elements. Attempting to add an ineligible element
throws an unchecked exception, typically NullPointerException or
ClassCastException. Attempting to query the presence of an ineligible element may
throw an exception, or it may simply return false; some implementations will exhibit
the former behavior and some will exhibit the latter. More generally, attempting an
operation on an ineligible element whose completion would not result in the insertion
of an ineligible element into the collection may throw an exception or it may succeed,
at the option of the implementation. Such exceptions are marked as "optional" in the
specification for this interface.
This interface is a member of the Java Collections Framework.
Many methods in Collections Framework interfaces are defined in terms of the equals
method. For example, the specification for the contains(Object o) method says:
"returns true if and only if this collection contains at least one element e such that
(o==null ? e==null : (e))." This specification should not be construed to imply
that invoking with a non-null argument o will cause (e) to
be invoked for any element e. Implementations are free to implement optimizations
whereby the equals invocation is avoided, for example, by first comparing the hash
codes of the two elements. (The () specification guarantees that two
objects with unequal hash codes cannot be equal.) More generally, implementations
of the various Collections Framework interfaces are free to take advantage of the
specified behavior of underlying Object methods wherever the implementor deems it
appropriate.
Since:
See Also:
Set, List, Map, SortedSet, SortedMap, HashSet, TreeSet, ArrayList, LinkedList,
Vector, Collections, Arrays, AbstractCollection
add
boolean add(E o)
Ensures that this collection contains the specified element (optional operation).
Returns true if this collection changed as a result of the call. (Returns false if this
collection does not permit duplicates and already contains the specified element.)
Collections that support this operation may place limitations on what elements may
be added to this collection. In particular, some collections will refuse to add null
elements, and others will impose restrictions on the type of elements that may be
added. Collection classes should clearly specify in their documentation any
restrictions on what elements may be added.
If a collection refuses to add a particular element for any reason other than that it
already contains the element, it must throw an exception (rather than returning false).
This preserves the invariant that a collection always contains the specified element
after this call returns.
Parameters:
o - element whose presence in this collection is to be ensured.
Returns:
true if this collection changed as a result of the call
Throws:
UnsupportedOperationException - add is not supported by this collection.
ClassCastException - class of the specified element prevents it from being added to
this collection.
NullPointerException - if the specified element is null and this collection does not
support null elements.
IllegalArgumentException - some aspect of this element prevents it from being added
to this collection.
equals
boolean equals(Object o)
Compares the specified object with this collection for equality.
While the Collection interface adds no stipulations to the general contract for the
, programmers who implement the Collection interface "directly" (in
other words, create a class that is a Collection but is not a Set or a List) must exercise
care if they choose to override the . It is not necessary to do so, and the
simplest course of action is to rely on Object's implementation, but the implementer
may wish to implement a "value comparison" in place of the default "reference
comparison." (The List and Set interfaces mandate such value comparisons.)
The general contract for the method states that equals must be
symmetric (in other words, (b) if and only if (a)). The contracts for
and state that lists are only equal to other lists, and sets to other
sets. Thus, a custom equals method for a collection class that implements neither the
List nor Set interface must return false when this collection is compared to any list or
set. (By the same logic, it is not possible to write a class that correctly implements
both the Set and List interfaces.)
Overrides:
equals in class Object
Parameters:
o - Object to be compared for equality with this collection.
Returns:
true if the specified object is equal to this collection
See Also:
(Object), (Object), (Object)
HashCode
int hashCode()
Returns the hash code value for this collection. While the Collection interface adds no
stipulations to the general contract for the method, programmers
should take note that any class that overrides the method must also
override the method in order to satisfy the general contract for the
. In particular, (c2) implies that
()==().
Overrides:
hashCode in class Object
Returns:
the hash code value for this collection
See Also:
(), (Object)
iterator
Iterator<E> iterator()
Returns an iterator over the elements in this collection. There are no guarantees
concerning the order in which the elements are returned (unless this collection is an
instance of some class that provides a guarantee).
Specified by:
iterator in interface Iterable<E>
Returns:
an Iterator over the elements in this collection
Java servlets
Sun’s Java Servlet platform directly addresses the two main drawbacks of CGI
programs.
First, servlets offer better performance and utilization of resources than conventional
CGI programs. Second, the write-once, run-anywhere nature of Java means that
servlets are portable between operating systems that have a Java Virtual
Machine (JVM).
A servlet looks and feels like a miniature web server. It receives a request and
renders a response. But, unlike conventional web servers, the servlet application
programming interface (API) is specifically designed to help Java developers create
dynamic applications.
The servlet itself is simply a Java class that has been compiled into byte code, like any
other Java object. The servlet has access to a rich API of HTTP-specific services, but
it is still just another Java object running in an application and can leverage all your
other Java assets.
To give conventional web servers access to servlets, the servlets are plugged into
containers. The servlet container is attached to the web server. Each servlet can
declare what URL patterns it would like to handle. When a request matching a
registered pattern arrives, the web server passes the request to the container, and the
container invokes the servlet. But unlike CGI programs, a new servlet is not created
for each request. Once the container instantiates the servlet, it will just create a new
thread for each request.
Java threads are much less expensive than the server processes used by CGI
programs.
Once the servlet has been created, using it for additional requests incurs very little
overhead. Servlet developers can use the init() method to hold references to expensive
resources, such as database connections or EJB Home Interfaces,
so that they can be shared between requests. Acquiring resources like these can take
several seconds—which is longer than many surfers are willing to wait.
The other edge of the sword is that, since servlets are multithreaded, servlet
developers must take special care to be sure their servlets are thread-safe. To learn
more about servlet programming, we recommend Java Servlets by Example, by Alan
R. Williamson [Williamson]. The definitive source for Servlet information is the
Java Servlet Specification [Sun, JST].
JavaServer Pages
While Java servlets are a big step up from CGI programs, they are not a panacea.
To generate the response, developers are still stuck with using println statements
to render the HTML. Code that looks like
("<P>One line of HTML.</P>");
("<P>Another line of HTML.</P>");
is all too common in servlets that generate the HTTP response. There are libraries
that can help you generate HTML, but as applications grow more complex, Java
developers end up being cast into the role of HTML page designers.
Meanwhile, given the choice, most project managers prefer to divide development
teams into specialized groups. They like HTML designers to be working on the
presentation while Java engineers sweat the business logic. Using servlets alone
encourages mixing markup with business logic, making it difficult for team members
to specialize.
To solve this problem, Sun turned to the idea of using server pages to combine
scripting and templating technologies into a single component. To build Java- Server
Pages, developers start by creating HTML pages in the same old way, using the same
old HTML syntax. To bring dynamic content into the page, the developer can also
place JSP scripting elements on the page. Scripting elements are tags that encapsulate
logic that is recognized by the JSP. You can easily pick out
scripting elements on JSP pages by looking for code that begins with <% and ends
with %>. For instance, to display the last modified date on the page, the developer
would place the following code in the page:
<B>This page was accessed at <%= new Date() %></B>
There are three different types of scripting elements: expressions, scriptlets, and
declarations, as shown in table .
Expressions Java code, bound by <%= and %>, used to evaluate Java language
statements and insert the result into the servlet’s output
Scriptlets Java code, bound by <% and %>, often used to create dynamic content
Declarations Java code, bound by <%! and %>, used to add code to the body of the
servlet class
To be seen as a JSP page, the file just needs to be saved with an extension
of . a client requests the JSP page, the container translates the page into a
source code file for a Java servlet and compiles the source into a Java class file— just
as you would do if you were writing a servlet from scratch. At runtime, the container
can also check the last modified date of the JSP file against the class file.
If the JSP file has changed since it was last compiled, the container will
retranslateand rebuild the page all over managers can now assign the
presentation layer to HTML developers, who then pass on their work to Java
developers to complete the business-logic portion. The important thing to remember is
that a JSP page is really just a servlet. Anything you can do with a servlet, you can do
with a JSP.
Scripting elements are only one of the two ways to generate dynamic JSP content.
Scriptlets are quick, easy, and powerful but require that developers mix Java code
with HTML. Experience has taught us that embedding logic into JSP pages leads to
non-maintainable applications with minimal opportunity for reuse. A popular
alternative is to use JSP tags. JSP tags are mixed in with the HTML markup and can
be used as if they were ordinary HTML tags. A single JSP tag may represent dozens
of Java statements, but all the developer
needs to know is to how to insert the tag. The programming code is hidden away in a
Java class file.
To use the same code on another page, the developer only has to insert the tag
markup again. If the code for the tag changes, all the tags will automatically use the
updated version. The JSP page using the tag does not need to be
revised. JSP tags provide much better reuse than scriptlets and can be easier for
page developers
The JavaBean design patterns provide access to the bean’s internal state through
two flavors of methods: accessors are used to read a JavaBean’s state; mutators are
used to change a JavaBean’s state.
Mutators are always prefixed with lowercase token set followed by the property
name. The first character in the property name must be uppercase. The return value is
always void—mutators only change property values; they do not retrieve them. The
mutator for a simple property takes only one parameter in its signature, which can be
of any type. Mutators are often nicknamed setters after their prefix.
The mutator method signature for a weight property of the type Double would be
public void setWeight(Double weight)
A similar design pattern is used to create the accessor method signature. Accessor
methods are always prefixed with the lowercase token get, followed by the property
name. The first character in the property name must be uppercase. The return value
will match the method parameter in the corresponding mutator.
Accessors for simple properties cannot accept parameters in their method signature.
Not surprisingly, accessors are often called getters.
The accessor method signature for our weight property is
public Double getWeight()
If the accessor returns a logical value, there is a variant pattern. Instead of using the
lowercase token get, a logical property can use the prefix is, followed by the property
name. The first character in the property name must be uppercase. The return value
will always be a logical value—either boolean or Boolean. Logical accessors cannot
accept parameters in their method signature.
The boolean accessor method signature for an on property would be
public boolean isOn()
The canonical method signatures play an important role when working with Java-
Beans. Other components are able to use the Java Reflection API to discover a
JavaBean’s properties by looking for methods prefixed by set, is, or get. If a
component finds such a signature on a JavaBean, it knows that the method can be
used to access or change the bean’s properties. Sun introduced JavaBeans to work
with GUI components, but they are now used with every aspect of Java development,
including web applications. When Sun engineers developed the JSP tag extension
classes, they designed them to the same way the Action was selected. An ActionForm
extends .
. Each HTTP request must be answered with an HTTP
response. Usually, a Struts Action does not render the response itself but forwards the
request on to another resource, such as a JSP page. Struts provides an
ActionForward class that can be used to store the path to a page under a logical name.
When it has completed the business logic, the Action selects and returns an
ActionForward to the servlet. The servlet then uses the path stored in the
ActionForward object to call the page and complete the response.
Struts bundles these details together into an ActionMapping object. Each
ActionMapping is related to a specific path. When that path is requested, the servlet
retrieves the ActionMapping object. The mapping tells the servlet which Actions,
ActionForms, and ActionForwards to use.
All of these details, the Actions, ActionForms, ActionForwards, ActionMappings, and
some other things, are declared in the file. The Action-Servlet reads
this file at startup and creates a database of configuration objects. At runtime, Struts
refers to the objects created with the configuration file, not the file itself. Figure
illustrates how these components fit together.
Believe it or not, you already know enough about Struts to assemble a simple
application. It won’t do much, but it will illustrate how Struts actually works.
附录二：英文资料翻译
Interface Collection<E>
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也
称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直
接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递
collection，并在需要最大普遍性的地方操作这些 collection。
包 (bag) 或多集合 (multiset)（可能包含重复元素的无序 collection）应该直接实
现此接口。
所有通用的 Collection 实现类（通常通过它的一个子接口间接实现 Collection）
应该提供两个"标准"构造方法：一个是 void（无参数）构造方法，用于创建空
collection；另一个是带有 Collection 类型单参数的构造方法，用于创建一个具有
与其参数相同元素新的 collection。实际上，后者允许用户复制任何 collection，
以生成所需实现类型的一个等效 collection。尽管无法强制执行此约定（因为接
口不能包含构造方法），但是 Java 平台库中所有通用的 Collection 实现都遵从
它。
此接口中包含的"破坏性"方法，是指可修改其所操作的 collection 的那些方法，
如 果 此 collection 不 支 持 该 操 作 ， 则 指 定 这 些 方 法 抛 出
UnsupportedOperationException。如果是这样，那么在调用对该 collection 无效
时，这些方法可能，但并不一定抛出 UnsupportedOperationException。例如，如
果要添加的 collection 为空且不可修改，则对该 collection 调用 addAll(Collection)
方法时，可能但并不一定抛出异常。
一些 collection 实现对它们可能包含的元素有所限制。例如，某些实现禁止 null
元素，而某些实现则对元素的类型有限制。试图添加不合格的元素将抛出一个未
经检查的异常，通常是 NullPointerException 或 ClassCastException。试图查询
是否存在不合格的元素可能抛出一个异常，或者只是简单地返回 false；某些实
现将表现出前一种行为，而某些实现则表现后一种。较为常见的是，试图对某个
不合格的元素执行操作且该操作的完成不会导致将不合格的元素插入 collection
中，将可能抛出一个异常，也可能操作成功，这取决于实现本身。这样的异常在
此接口的规范中标记为"可选"。
此接口是 Java Collections Framework 的成员。
Collections Framework 接口中的很多方法是根据 equals 方法定义的。例如，
contains(Object o) 方法的规范声明："当且仅当此 collection 包含至少一个满足
(o==null ? e==null :(e)) 的元素 e 时，才返回 true。"不 应将此规范理解
为它暗指调用具有非空参数 o 的 方法会导致为任意的 e 元
素调用 (e) 方法。可随意对各种实现执行优化，只要避免调用 equals 即
可，例如，通过首先比较两个元素的哈希码。（() 规范保证哈希
码不相等的两个对象不会相等）。较为常见的是，各种 Collections Framework 接
口的实现可随意利用基础 Object 方法的指定行为，而不管实现程序认为它是否
合适。
add
boolean add(E o)
确保此 collection 包含指定的元素（可选操作）。如果此 collection 随调用的结
果而发生改变，则返回 true。（如果此 collection 不允许有重复元素，并且已经
包含了指定的元素，则返回 false。）
支持此操作的 collection 可以限制哪些元素能添加到此 collection 中来。需要
特别指出的是，一些 collection 拒绝添加 null 元素，其他一些 collection 将对
可以添加的元素类型强加限制。Collection 类应该在其文档中清楚地指定能添加
哪些元素方面的所有限制。
如果 collection 由于某些原因（已经包含该元素的原因除外）拒绝添加特定的
元素，那么它必须 抛出一个异常（而不是返回 false）。这确保了在此调用返回
后，collection 总是包含指定的元素。
参数：
o - 确定此 collection 中是否存在的元素。
返回：
如果此 collection 随调用的结果而发生改变，则返回 true
抛出：
UnsupportedOperationException - 此 collection 不支持 add 操作。
ClassCastException - 指定元素的类不允许它添加到此 collection 中。
NullPointerException - 如果指定的元素为 null，并且此 collection 不支持 null
元素。
IllegalArgumentException - 此元素的某方面不允许它添加到此 collection 中。
equals
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
当 Collection 接口没有对 的常规协定添加任何约定时，"直接"实
现该 Collection 接口（换句话说，创建一个 Collection，但它不是 Set 或 List
的类）的程序员选择重写 方法时必须小心。没必要这样做，最简
单的方案是依靠 Object 的实现，然而实现者可能希望实现"值比较"，而不是默
认的"引用比较"。（List 和 Set 接口要求进行这样的值比较。）
方法的常规协定声称相等必须是对称的（换句话说，当且仅当存
在 (a) 时，才存在 (b)）。 和 的协定声称列
表只能与列表相等，set 只能与 set 相等。因此，对于一个既不实现 List 又不
实现 Set 接口的 collection 类，当将此 collection 与任何列表或 set 进行比较
时，常规的 equals 方法必须返回 false。（按照相同的逻辑，不可能编写一个同
时正确实现 Set 和 List 接口的类。）
覆盖：
类 Object 中的 equals
参数：
o - 要与此 collection 进行相等性比较的对象。
返回：
如果指定对象与此 collection 相等，则返回 true
另请参见：
(Object), (Object), (Object)
hashCode
int hashCode()
返回此 collection 的哈希码值。当 Collection 接口没有为 方法
的常规协定添加任何约束时，为了满足 方法的常规协定，程序
员应该注意任何重写 方法的类必须重写 方法。
需要特别指出的是，(c2) 暗示着 ()==()。
覆盖：
类 Object 中的 hashCode
返回：
此 collection 的哈希码值
另请参见：
(), (Object)
iterator
Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。关于元素返回的顺序没有任何
保证（除非此 collection 是某个能提供保证顺序的类实例）。
指定者：
接口 Iterable<E> 中的 iterator
返回：
在此 collection 的元素上进行迭代的 Iterator
Servlet
Sun 公司的 Java Servlet 平台直接解决了 CGI 程序的两个主要缺点。
首先，servlet 比常规 CGI 程序提供更好的性能和资源利用。其次，一次编写，
随处运行的 JAVA 特性意味着 servlet 在有 JVM 的操作系统间是轻便的可移动
的。
Servlet 看起来好像是一个微小的 web server。它接受请求并产生响应。但，和常
规 web server 不同，servlet API 是专门设计来帮助 Java 开发人员创建动态应用
的。
Servlet 本身是要编译成字节码的 Java 类，就像其他 Java 对象一样。Servlet 访
问 HTTP 特定服务的 API，但它仍然是一个运行于程序之中的 Java 对象，并可
以利用所有的 Java 资产。为了使常规 web servers 能访问 servlet，servlet 被安插
在一个容器之中。Servlet 容器连接到 Web 服务器。每个 servlet 都可以声明它
可以处理何种样式的 URL。当符合所注册样式的请求到达，web server 将请求传
递给容器，容器则调用响应的 servlet。
但和 CGI 程序不同，并不是针对每个请求都要创建一个新的 servlet。一旦容器
实例化了一个 servlet，它就仅为每个新的请求创建一个新的线程。Java 线程可
比使用 CGI 程序的服务器处理开销小多了。一旦 servlet 被创建，使用它处理额
外的请求仅带来很小的额外开销。Servlet 开发人员可以使用 init() 方法保持对昂
贵资源的引用，比如到数据库或者 EJB Home 接口的连接,以便它们可以在不同
的请求之间进行共享。获得这些资源要耗费数秒时间，这比大多数冲浪者愿意等
的时间要长些。
Servlet 的另一个好处是，它是多线程的， servlet 开发人员必须特别注意确保它
们的 servlet 是线程安全的
JavaServer Pages
虽然 servlets 对 CGI 程序来说前进了一大步，但它也不是万能灵药。为了产生
响应，开发人员不得不使用大量的 println 语句来生成 HTML。比如这样的代码
("<P>One line of HTML.</P>");
("<P>Another line of HTML.</P>");
在产生 HTTP 响应的 Servlet 中是很普遍的。也有一些库有助于你产生 HTML。
随着应用越来越复杂，Java 开发人员将不再扮演 HTML 页面设计的角色。
同时，大多数项目经理更喜欢将团队分成不同的小组。 它们喜欢 HTML 设计人
员处理表现层的工作，而 Java 工程师则专注于业务逻辑。单独使用 servlet 的做
法鼓励混合标记和业务逻辑，很难区分团队人员的专业工作。
为解决这个问题，Sun 提出了一个将脚本和模板技术结合到一个组件中的服务器
页面技术
（JavaServer Pages）。为创建 JSP 页面, 开发者按创建 HTML 页面类似的方式创
建页面，使用相同的 HTML 语法。为将动态内容引入页面，开发人员可以将脚
本元素置入页面之中。脚本元素是一些标记，封装了可以被 JSP 识别的逻辑。
你可以在 JSP 页面中很容易的识别出脚本元素，他们被封装在一对<% 和 %>标
记中。例如，要显示页面的最后修改日期，开发人员可以将以下
代码放入页面中：
有三种不同的脚本元素：
表达式，脚本小程序和声明
表达式 Java 代码，封装在<%= 和 %>之中，用来计算 JAVA 语句的值，
并将结果插入 Servlet 的输出之中
脚本程序 Java 代码，封装在<% 和 %>之中，常用来创建动态内容
声明 Java 代码，封装在<%！和 %>之中，常用来添加代码到 Servlet
类的 body 之中
JSP tags
为了识别 JSP 页面，文件需要保存为扩展名.jsp。当一个客户请求 JSP 页面时，
容器将页面翻译成 Java servlet 源代码文件，并将它编译成 Java 类文件--就象你
写的 servlet 文件一样。在运行时，容器也能检测 JSP 文件和相应的类的最后更
新时间。如果，JSP 文件自上次编译以来被修改了，容器将重新翻译和编译 JSP
文件。
项目经理现在可以将表现层分派给 HTML 开发人员，将业务逻辑工作分派给
JAVA 开发人员。重要的是记住， JSP 页面事实上是一个 servlet。你可以在
servlet 做的，也可以在 JSP 中做。
JavaBean
JavaBean 是一种 Java 类，它遵从一定的设计模式，使它们易于和其他开发工具
和组件一起使用。定义 JAVABEAN 是一种 JAVA 语言写成的可重用组件。要
编写
JAVABEAN，类必须是具体类和公共类，并且具有无参数的构造器（NON-ARGS
CONSTRUCTOR）。JAVABEAN 通过提供符合一致性设计模式的公共访问方法
将内部字段暴露称为属性。众所周知，属性名称也符合这种模式，其他 JAVA
类可以通过自省机制发现和操作这些 JAVABEAN 属性。
JavaBean 设计模式提供两种类型的方式来访问 bean 的内部状态：访问器
（accessor） 用来读 JavaBean 的状态，修改器（mutator ）用来改变 JavaBean
的状态。
Mutator 通常以小写的 set 前缀开始，后跟属性名。属性名的第一个字母必须大
写。返回值通常是 void，因为 mutator 仅仅改变属性的值，而不返回它们。简单
属性的 mutator 在其方法体中可能只有一个参数，该参数可以是各种类型。
Mutator 也可根据其前缀称为设置器 setters 。例如，对 Double 类型的属性 weight
的 mutator 方法体可能是：
public void setWeight(Double weight)
相似的设计模式也用于访问器方法的创建。Accessor 通常以小写的 get 为前缀，
后跟属性名。属性名的第一个字母必须大写。返回值必须匹配相应的修改器方法
的参数。简单属性的 Accessor 在其方法体中不能接受参数。同样，访问器 accessor
也经常称为获取器 getter。属性 weight 的访问器方法体可能是：
public Double getWeight()
如果访问器返回一个逻辑值，这种情况下有个变体模式。不使用小写的 get，逻
辑属性的访问器可以使用小写的 is 前缀，后跟属性名。属性名的首字母必须大
写。返回值肯定是逻辑值，不管是 boolean 还是 Boolean。逻辑访问器在其方法
体中不能接受参数。
On 属性的逻辑访问器的方法体可能是：
在使用 JavaBean 时，规范的方法体签名扮演了极为重要的角色。其他组件可以
使用 Java 的反射 API 通过查找前缀为 set, is, 或者 get 的方法来发现 JavaBean
的属性。如果一个组件在一个 JavaBean 中发现一个这样的方法，它就知道这个
方法可以用来访问或者改变 JavaBean 的属性。Sun 引入 JavaBean 是为了用于
GUI 组件，但它们已经用在 Java 开发的各个方面，包括 Web 应用。Sun 的工
程师在开发 JSP 标签的扩展类时，也被设计来可以和 JavaBean 一起工作。一个
页面的动态数据可以使用一个 JavaBean 来传递，并且 JSP 标记可以随后使用
bean 的属性来定制页面的输出。’
Model 2
Servlet/JSP 规范的 版描述了在一个应用中使用 servlet 和 JSP 的架构。在
其后的规范中，Model 2 这个叫法消失了，但它已经在 Java web 开发人员中非
常通用了。
根据 Model 2，servlet 处理数据存取和导航流， JSP 处理表现。Model 2 使 Java
工程师和 HTML 设计者分别工作于它们所擅长和负责的部分。Model 2 应用的
一部分发生改变并不强求其他部分也跟着发生改变。HTML 开发人员可以改变
程序的外观和感觉，并不需要改变后端 servlet 的工作方式。
Struts 框架是基于 Model 2 的架构。它提供一个控制器 servlet 来处理导航流和
一些特殊类来帮助数据访问。随框架也提供一个丰富的标签库，以使 Struts 易于
和 JSP 一起使用。
Struts 开始于三万英尺
抓紧你的帽子！
既然我们已经讲了一些基本知识，我们现在可以进行一个 Struts 的飞速之旅了。
在我们打开盒子吃到果子之前，我们先了解一个大概模样。
Struts 使用 Model 2 架构。Struts 的 ActionServlet 控制导航流。其他 Struts 类，
比如 Action,用来访问业务逻辑类。当 ActionServlet 从容器接收到一个请求，它
使用 URI (或者路径“path”) 来决定那个 Action 将用来处理请求。一个 Action
可以校验输入，并且访问业务层以从数据库 或其他数据服务中检索信息。
为校验输入或者使用输入来更新数据库， Action 需要知道什么值被提交上
来。它并不是强制每个 Action 都要从请求中抓取这些值，而是由 ActionServlet
将 输 入 绑 定 到 JavaBean 中 。 输 入 bean 是 Struts ActionForm 类 的 子 类 。
ActionServlet 通过查找请求的路径可以决定使用哪个 ActionForm ， Action 也
是通过同样的方法选取的。ActionForm 扩展了
类。
每个请求都必须以 HTTP 响应进行应答。 通常，Struts Action 并不自行渲
染响应信息，而是将请求转发到其他资源，比如 JSP 页面。Struts 提供一个
ActionForward 类，用来将一个页面的路径保存为逻辑名称。当完成业务逻辑后，
Action 选择并向 Servlet 返回一个 ActionForward。Servlet 然后使用保存在
ActionForward 对象中的路径来调用页面完成响应。Struts 将这些细节都绑定在
一个 ActionMapping 对象中。每个 ActionMapping 相对于一个特
定 的 路 径 。 当 某 个 路 径 被 请 求 时 ， Servlet 就 查 询 ActionMapping 对 象 。
ActionMapping 对象告诉 servlet，哪些个 Action，ActionForm，和 ActionForward
将要被本次请求使用。所有这些细节，关于 Action， ActionForm， ActionForward，
ActionMapping ， 以 及 其 它 一 些 东 西 ， 都 在 文 件 中 定 义 。
ActionServlet 在启动时读取这个配置文件，并创建一个配置对象数据库。在运行
时，Struts 应用根据文件创建的配置对象，而不是文件本身。
