文章发布系统的设计与实现（论文+PPT+源码）

摘　要

随着计算机技术的迅速发展，网络正以一种前所未有的冲击力影响着人类的生产和生活。网络的快速发展，颠覆了传统的信息传播方式，冲破了传统的时间，空间的局限性，继而引发了人类阅读方式的变革。现如今，网络阅读已成为一种新的时尚，在这种趋势下，文章发布系统应运而生，该系统能以更快速有效的方式分享世界各种信息资源。

本文设计的文章发布系统是一个基于B/S模式，前台界面采用JSP语言编写，后台采用SSH框架来搭建，开发环境使用MyEclipes的系统。该系统充当了一个网络文章发布媒介的功能，实现了系统化、自动化的管理，使人们在任何地方都能获得需要的信息。该系统实现了以下几个功能：用户管理功能，文章管理功能，文章搜索功能，文章评论功能。

关键词: java；MVC；文章发布

The Design And Implementation Of The Article Publishing System

Abstract

With the rapid development of computer technology，the network is an unprecedented impact on the impact of human production and life. The rapid development of the network, to subvert the traditional means of information dissemination, breaking the traditional time, space limitations, and then triggered a change in human reading. Now, read the network has become a new fashion trend in this article publishing system came into being, the system can share the world a variety of information resources in a more rapid and efficient manner.
This article design article publishing system is based on the B / S mode, the front interface using JSP language, the background using SSH framework to build, the development environment using MyEclipes system. The system serves as a network article to publish media functions, to achieve a systematic, automated management, so that people can get the information in any place. The system implements the following functions: user management functions, article management functions, article search function, article comment function.

Key words: java; MVC;article published

目 录

摘要1

Abstract2

1 绪论3

1.1 课题背景3

1.2 研究现状及发展趋势3

1.3 课题意义与目的3

1.4 研究内容4

1.5 论文组织4

2 开发工具和技术介绍5

2.1 开发工具5

2.1.1 Myeclipse简介5

2.1.2 MySQL简介5

2.1.3 Tomcat简介5

2.2 开发技术5

2.2.1 JSP技术简介5

2.2.2 Servlet技术简介6

2.2.3 SSH框架整合技术简介6

2.2.4 B/S模式简介7

3 系统分析8

3.1 可行性分析8

3.1.1 技术可行性8

3.1.2 经济可行性8

3.1.3 操作可行性8

3.1.4 法律可行性 8

3.2 系统需求分析8

3.2.1 功能模块8

3.2.2 类图10

3.2.3 用例图10

3.3 系统详细设计12

3.3.1 用户注册模块12

3.3.2 用户登录模块12

3.3.3 文章搜索模块13

3.3.4 用户留言模块13

3.3.5 用户评论模块13

3.3.6 用户信息管理模块14

3.3.7 用户管理模块14

3.3.8 公告管理模块15

3.3.9 文章管理模块15

3.3.10 评论管理模块16

3.3.11 留言管理模块16

3.3.12 管理员管理模块17

3.4 数据库需求分析18

3.4.1 系统数据库18

3.4.2 实体E-R图18

3.4.3 数据库表结构21

4 系统实现23

4.1 功能模块的实现23

4.1.1 用户管理23

4.1.2 公告管理24

4.1.3 文章管理25

4.1.4 文章评论管理27

4.1.5 留言管理28

4.1.6 管理员信息管理28

4.2 界面设计30

4.2.1 系统首页30

4.2.2 用户注册31

4.2.3 用户登录31

4.2.4 文章搜索32

4.2.5 用户留言33

4.2.6 用户评论34

5 系统测试36

5.1 系统测试测试策略说明36

5.2 测试环境36

5.2.1 系统测试硬件环境36

5.2.2 系统测试软件环境37

5.3 测试时间37

5.4 测试报告37

总结41

致谢42

参考文献43

1 绪论

1.1 课题背景

在科学技术不断地发展与进步的同时，网络也从各个方面慢慢改变着人们的生活，在当今的时代，我们的生活与网络密不可分，网络已然成为我们生活中不能缺乏的部分。比如：通过网上学习、网上购物等。而文章作为传播信息的一种途径，也需要与网络结合起来，提供网上文章浏览、发布系统供人们使用，人们在任何时间、地点只要上网即可浏览信息。在减少纸质书籍的印刷的同时也节省了资源。

传统的网络开发是基于页面、服务器端数据传输的模式，把网络表示层建立于html页面。随着信息技术的不断发展，这样的页面已经不能满足网络用户的需求了，现在，用户希望有更好的体验，同时，管理员也希望有更方便、快捷的管理。为了能够达到用户、管理员所期待的效果，我们使用jsp动态网页来实现发布系统，带给用户、管理员更好的体验。

1.2 研究现状及发展趋势

从国内外发展经验来看，信息系统可以不仅仅局限于文本、数值，使用图像、视频、声音等多种媒体可以丰富信息系统。使信息系统具有更好的效果、更好的交互性、更大的使用范围。信息的传播是指信息从发送到接收的过程。有三个要素在这个过程中：发送者、接收者和传播渠道。一般来说，传播渠道有两种：单向、双向，单向传播是指发送者传递、发送信息，不关心接收者的反馈；双向传播是指发送者接收接收者的反馈，接受者和发送者会有互动。本系统作为信息发布系统，需要与用户有交互的作用，故使用的传播渠道应该是双向的。

随着信息管理系统发展的普及，功能也越来越完善，所以要引进先进的技术来让它具有更大的优势，本文使用了JQuery、JS、CSS等前端语言来优化用户页面，使用MVC的架构、SSH的框架完整后台代码。系统采用了B/S的架构模式，将浏览器作为客户端，用户只需浏览器即可使用该系统，不需要额外下载客户端。

目前该系统有了好的发展趋势，随着信息技术的不断发展，我相信文章发布系统有更好的前景，能给人们带来更多的便利。

1.3 课题意义与目的

文章发布系统的实现减轻了管理员更新维护文章的工作量，通过该系统，将管理员的工作简化了，现在管理员只需录入文字和上传图片，就可以发布文章，缩短了文章的更新时间，方便了管理员管理维护。

文章发布系统是一个集文章发布、评论、留言于一体的管理系统，游客可以搜索相关文章，游客注册后可以登录网站属于文章进行评论以及对网站进行留言，管理员可以登录进入管理员中心对网站信息进行管理，对文章进行发布以及管理、对用户评论进行管理，对用户留言进行回复，和用户进行互动。极大的方便的网民，是广大网民点开浏览器，输入网址，即可浏览相关信息。

1.4 研究内容

本文设计系统，首先从技术、经济、操作、法律进行可行性分析。在确定系统可行的情况下，对系统用进行需求分析，确定系统的功能模块，然后设计数据库，编写代码实现详细系统功能模块，最后对完成的系统进行测试。在该系统中，前台使用CSS、JQuery等技术使界面更美观，交互性更好，而后台则是使用了SSH框架，方便代码的管理与维护。

人们普遍认为一个软件功能多就好，往往忽略了在系统功能增多的同时，也会给系统的用户带来很多麻烦。在大部分情况下，系统用户都是非专业人员，如果将系统设计的过于复杂，就需要花时间进行对这些使用者进行培训，无形中增加了系统成本。同时系统中的一些功能使用次数较少，这些功能性价比低，可以适当的进行删减，减少系统成本。因此，在功能确定、选择上，更看重的应该是合适，不要盲目追求系统的功能，系统做到简洁、实用即可。

1.5 论文组织

本文有五个章节组成：

1. ：绪论。介绍课题背景、当前研究现状及发展趋势、开设此课题意义与目的以及本文主要研究的内容。
2. ：开发环境和工具介绍。介绍了开发工具MySql，Myeclipes的使用、SSH框架的原理、MVC模型的构成以及B/S模型等的实现原理。
3. ：系统分析。从可行性分析开始到需求分析，然后进行各个模块详细分析与设计以及数据库的设计。
4. ：系统实现。根据各模块功能，编写代码完成具体实现。
5. ：系统测试。系统完成后，对系统进行完整测试。

最后对本次毕业设计进行工作总结，分析论文完成情况并对系统做出总体评价。

2 开发工具和技术介绍

2.1 开发工具

2.1.1 Myeclipse简介

​​MyEclipse，是一个十分优秀的用于开发Java​​[1]。它的功能强大，支持广泛，支持多种开源产品。它的工作平台是企业级，它扩展了EclipseIDE。利用MyEclipes可以方便数据库以及应用程序的组合，提高我们的效率。此外，它还具有模块化的结构，让我们可以单独的对某一模块进行扩展和升级。

总而言之，MyEclipes拥有功能强大的开发环境，良好的兼容性。

2.1.2 MySQL简介

MySQL通常运用于小型企业以及小型数据系统。MySQL数据库因为具有体积小、总体拥有成本低、速度快、源码开放等优势受到了热捧。

MySQL是关系数据库管理系统，它没有将数据全都放入一个仓库中，而是将数据分别写入不同表中，使数据更灵活，从而也提高了数据库的查询速度。

MySQL数据库有以下优点：

1. 支持多种数据库；
2. 支持多线程，充分利用CPU资源；
3. 优化SQL的算法，提高查询的速度；
4. 提供JDBC等多种数据库连接途径；
5. 提供用于管理、检查、优化数据库操作的管理工具；
6. 支持比较大型的数据库，对于几万条记录的数据库可进行同时处理；
7. 使用了标准的SQL数据语言形势；

2.1.3 Tomcat简介

Tomcat是由Apache、Sun 等公司及部分个人共同开发出来的。因其技术的先进、性能的稳定、免费的使用受到了Java使用者的喜爱，同时得到了一些软件开发商的支持与鼓励。Tomcat是当前比较流行的WEB服务器。

Tomcat 服务器属于轻量级的应用服务器，在一些中小型系统中被普遍使用，它是开发和调试JSP 程序的首选。实际上Tomcat是独立运行的，当运行tomcat 时，它是作为一个单独的进程来运行的。

2.2 开发技术

2.2.1 JSP技术简介

JSP把网页设计显示与逻辑分离，它支持基于组件设计的重用，极大地方便了Web应用程序的开发。

在遇到请求访问JSP网页时，Web服务器对其中的程序首先执行，返回给客户执行的结果以及JSP文件中的HTML代码。操作数据库以及网页重新定向可以由其中插入的Java代码来实现，从而达到实现动态网页需求的功能。

JSP通常执行在服务器端，返回HTML文本到客户端，使用户在浏览器上就可浏览相关信息。

2.2.2 Servlet技术简介

Servlet是应用于服务器端的Java程序，独立于协议和平台。它担当服务器响应与客户请求的中间层。 它与启动Java应用程序通过命令行的方式不同，加载是由Web服务器进行。

Servlet生命周期：Servlet加载、实例化、服务、销毁

init()：Servlet生命周期中，init()方法只执行一次，在装入Servlet是，init()方法就开始执行。

service()：对客户的请求进行响应，一般使用doGet()和doPost()方法来处理请求。

destroy()：destroy()方法执行一次，在服务器端卸载或者停止时就执行此方法。

2.2.3 SSH框架整合技术简介

SSH 即 Struts +Spring + Hibernate三种技术组合而成的框架。

SSH框架的优势：

1. 体现了MVC三层架构的思想，极大的减轻了软件开发技术人员为解决问题所付出的精力和所承担的负担，减少了开发时间，同时也有助于新需求的开发。图2-1为MVC模型图：

图2-1 MVC模型图

2.具有可扩展性，SSH有强大的支持，在框架扩展性方面比较优秀，对于一些特殊的应用可以进行插播，解决了部分由于技术问题而实现不完整的功能。

3.具有可维护性，新需求在系统中总是经常出现，三层构架合理的分离，有效的降低了修改需求的风险。伴随着新老系统的更新，一些系统需要进行重构，ssh构架因为其兼容性较好使得重构成功率高了许多。

4.具有解耦性，软件产品的需求总是在不断的改变。客户的需求，在开发过程中慢慢深入中，变得更加清晰，准确。因此，经常在软件开发进行一段时间后，由于需求的变更，软件的开发过程也不得不进行调整。而ssh框架，因其具有良好的解耦性，使用了大量的接口编程，在软件需求变更、软件开发需要调整的时候，软件开发中部分发生改变但是其它部分依然不会发生改变，可以减轻程序员的工作量，有利于代码的维护与重写。

2.2.4 B/S模式简介

B/S（Browser/Server）结构即浏览器和服务器结构。B/S有开发简单、方便维护、分布性强的特点。B/S是对C/S架构的改进，在这种架构下，浏览器是作为客户端出现的，这种方式减轻了电脑的压力，只需装一个浏览器应用程序即可访问多种后台页面，这样减少了后期对客户端进行的维护，极大地方便了用户。

3 系统分析

3.1 可行性分析

文章发布系统，在国内外的研究已经成熟，应用已经广泛。国内外有大量的网站，他们每时每刻都要进行大量的信息维护，来保持信息的及时更新，这个时候就需要建设一个管理系统来对信息进行增、删、改、查，动态的实现操作内容。

随着网络的发展，静态网站的维护变得复杂，工作量加大。信息的不断增加，使得维护人员经常修改页面，以达到信息及时更新的效果。现在html已经不能满足用户的需要，使用动态的、交互的页面才是用户所喜欢的。所以我们要创建一个友好的、易维护的系统来吸引用户。

3.1.1 技术可行性

该系统是个小型文章发布系统，开发难度较低。经过对众多开发工具的分析，选择了Tomcat作为系统服务器、MySQL作为数据库开发工具、MyEclipes作为前后台开发工具。在技术上采用了JSP为主的页面开发语言，以及java为主的后台开发语言。在模式上采用B/S（浏览器/服务器）模式，而这些技术现在都相对成熟，完全可以满足系统的开发，所以在技术上是可行的。

3.1.2 经济可行性

文章发布系统打破了传统静态的网页，突破了传统无法交互的局限。它建立一种动态的、可交互的系统。开发本系统，一些基本的硬件和免费的软件就可以保证本系统的开发与调试，不需要再去购买设备和软件，所以在经济上是可行的。

3.1.3 操作可行性

文章发布系统开发的目的就是使用户获取信息更方便，使管理员管理信息方便。本系统通过一些调查，了解了大部分网民的需求。设计出来的系统基本满足用户的需求，而且操作十分简单，保证了使用者就算不了解系统也能使用。所以在操作上是可行的。

3.1.4 法律可行性

文章发布系统作为毕业设计，不用于商业，不侵犯专利，符合国家法律规定。所以在法律上是可行的。

通过上述可行性的分析，我可以确定本系统是可行的。

3.2 系统需求分析

在开发系统时，要对系统进行需求分析。需求分析要对系统的功能和性能进行描述，对使用的数据库进行设计。

抽象出系统的逻辑模型。了解系统要“怎么做”，在这基础上，再从系统的物理模型当中抽象逻辑模型。一般来说，物理模型中通常有许多物理因素，一些物理因素非系统所必要，这些因素就成为系统的负担，所以要分析物理模型，区分必要、非必要因素，然后在模型中去掉非必要的因素素最后获得反映系统本质的逻辑模型。

为了完整系统的描述，通常需要补充系统的逻辑模型。采用图形的方式来对网页的界面进行表达，有助于系统后续开发。

3.2.1 功能模块

根据需求分析的结果，文章发布系统主要划分两个子模块后台管理模块，前台门户模块，各模块又包含子模块。

分为以下几个模块：

界面设计模块：

用户注册模块

用户登录模块

文章搜索模块

用户留言模块

用户评论模块

用户信息管理模块

功能管理部分

用户管理模块

公告管理模块

文章管理模块

评论管理模块

留言管理模块

管理员管理模块

图3-1为文章发布系统的层次图：

图3-1 系统层次图

性能需求:

该系统在性能功能上应达到如下需求：

操作简单、界面友好：简化文章的添加功能，对于文章分类、来源等内容只需在相应的框内写入相关信息即可完成；其次在删除等功能上对用户加以提示，防止出现错删等情况的出现。

即时可布，即时见效：对文章的处理后（添加、修改、删除、查询）将及时在主页上对应的显示块内显示出来；

1.系统运行时应该高效、稳定、快速；

2.有良好的扩展性在结构上。

3.2.2 类图

模块中类的关系通常是由类图来描述的，这些描述中包括类与类之间的继承、类与接口之间的继承，类与类之间的依赖关系、聚合关系等。同时类图还要描述每一个类的详细信息，然后根据；类图进行详细的设计。

在本系统中共有六个类：

用户类包括用户的基本信息与行为：

属性包括：用户名、密码、姓名、性别、电话、地址等

动作包括：注册、登录、评论、评论、修改个人信息等

留言类包括包括留言的基本信息与行为：

属性包括：内容、留言用户、留言日期、回复等

管理员类包括包括管理员的基本信息与行为：

属性包括：用户名、密码、姓名、性别、电话、地址等

动作包括：登录、管理用户、管理文章、管理评论、管理留言、修改个人信息等

评论类包括包括评论的基本信息与行为：

属性包括：对应文章编号、内容、评论用户、评论日期等

文章类包括包括文章的基本信息与行为：

属性包括：标题、内容、发布日期等

公告类包括包括公告的基本信息与行为：

属性包括：标题、内容、发布日期等

图3-2为文章发布系统的类图：

图3-2 类图

3.2.3 用例图

用例图呈现了参与者和用例，以及它们之间的关系，是一中UML模型图。图3-3，图3-4，图3-5分别描述了游客、用户以及管理员与其功能之间的关系：

图3-3 游客用例图

图3-4 用户用例图

图3-5 管理员用例图

3.3 系统详细设计

3.3.1 用户注册模块

游客进行注册，注册成功后可对网站进行留言，文章进行评论。

用户点击注册，进入注册页面，填写个人相关信息，点击提交进行格式验证，若格式正确，到数据库中查询用户名是否存在，若存在则提示用户名已被占用，若不重复则将该条数据插入到数据库中，用户注册成功。图3-6为用户注册模块流程图：

图3-6 用户注册模块流程图

3.3.2 用户登录模块

已注册的用户进行登录，登录后可对网站进行留言，对文章进行评论。

用户点击登录，进入登录页面，填写用户名、密码，点击登录，到数据库中验证用户名、密码是否正确，若不正确回到当前页面，若正确登录成功跳转到主页面。图3-7为用户登录模块流程图：

图3-7 用户登录模块流程图

3.3.3 文章搜索模块

游客、用户、管理员都可进行文章搜索，输入关键词后，可搜索具有相关关键词的文章。

用户在搜索文章一栏中填入想要搜索的关键词，点击搜索，在数据库中检索到相关关键词的文章，在页面上显示出来。图3-8为文章搜索模块的流程图：

图3-8 文章搜索模块流程图

3.3.4 用户留言模块

用户登录后，可以使用留言的方式提出对网站的建议、对网站的评价。

用户点击留言板，在输入框内输入留言内容，点击提交，将留言信息插入到数据库中，用户留言成功，重新加载页面，该条留言更新在页面上。图3-9为用户留言模块的流程图：

图3-9 用户留言模块流程图

3.3.5 用户评论模块

用户登录后，可以使用文章评论的方式，表达自己对这篇文章的看法。

用户进入到文章详细页面后，在输入框内输入评论内容，点击提交，将评论内容插入到数据库中，用户评论成功，重新加载页面，该条评论更新到页面上。图3-10为用户评论模块的流程图：

图3-10 用户评论模块流程图

3.3.6 用户信息管理模块

用户登录后，可以对个人信息进行修改。

用户进入到主页面后，点击修改个人信息，跳转到用户个人信息修改页面，在文本框内输入修改后的内容，点击提交，在数据库中更新个人信息，用户信息修改成功，返回主页面，图3-11为用户评论模块的流程图：

图3-10 用户评论模块流程图

3.3.7 用户管理模块

管理员登录后，可以对注册用户信息进行管理，可以查询、修改、删除。

管理员登录后，进入到管理员中心用户管理页面，在输入框内输入用户名，点击查询，在数据库中查找该用户名，若用户名存在，将查询结果显示在页面上，若用户名不存在，无查询结果；点击修改，跳转到修改页面，对用户信息进行修改，填写完成点击提交，在数据库中更新，用户信息修改完成；点击删除，弹出是否删除对话框，点击确定，该用户删除成功，点击取消，取消删除返回到用户管理页面。图3-11为用户管理模块流程图：

图3-11 用户管理模块流程图

3.3.8 公告管理模块

管理员登录后，在网站公告有变动的时候，修改公告，让用户及时看到最新公告。

管理员登录后，进入到管理员中心公告管理页面，直接在文本框内输入最新公告，点击提交，在数据库中更新，公告修改成功，返回主页公告已更新。图3-12为公告管理模块流程图：

图3-12 用户管理模块流程图

3.3.9 文章管理模块

管理员登录后，可对网站文章进行管理，可以查询、添加、修改、删除。

管理员登录后，进入管理员中心文章管理页面，在输入框内输入文章关键词，点击查询，在数据库中查找该关键词对应的文章，若文章存在，将查询结果显示在页面上，若用文章不存在，无查询结果；点击添加，跳转到文章添加页面，输入要添加文章信息，插入到数据库中，添加成功；点击修改，跳转到修改页面，对文章信息进行修改，填写完成点击提交，在数据库中更新，文章信息修改完成；点击删除，弹出是否删除对话框，点击确定，该文章删除成功，点击取消，取消删除返回到文章管理页面。图3-13为文章管理模块流程图：

图3-13 文章管理模块流程图

3.3.10 评论管理模块

管理员登录后，可对网站文章评论进行管理，可以进行删除操作。

管理员登录后，进入管理员中心评论管理页面，点击删除，弹出是否删除对话框，点击确定，该评论删除成功，点击取消，取消删除返回到评论管理页面。图3-14为评论管理模块流程图：

图3-14 评论管理模块流程图

3.3.11 留言管理模块

管理员登录后，可对网站留言进行管理，可以进行删除操作。

管理员登录后，进入管理员中心留言管理页面，点击回复，进入管理员回复页面，输入回复信息，点击提交，插入到数据库中，管理员回复成功，返回到留言管理页面。点击删除，弹出是否删除对话框，点击确定，该留言删除成功，点击取消，取消删除返回到留言管理页面。图3-15为留言管理模块的流程图：

图3-15 留言管理模块流程图

3.3.12 管理员管理模块

管理员登录后，可对管理员信息进行管理，可以进行修改、删除操作。

管理员登录后，进入管理员中心管理员管理页面，点击修改，进入管理员信息修改页面，修改相关信息，点击提交，在数据库中更新，信息修改成功，返回到管理员信息管理页面。点击删除，弹出是否删除对话框，点击确定，该管理员删除成功，点击取消，取消删除返回到管理员信息管理页面。图3-16为管理员管理模块的流程图：

图3-16 管理员管理模块流程图

3.4 数据库需求分析

在系统开发需求的过程中，数据库的设计是非常重要。良好的数据库设计减少了数据冗余、提高了查询效率，降低了应用程序的编写难度。

3.4.1 系统数据库

根据系统确定的需求，本系统共需要建立5个表，其数据表的说明如表3-1所示：

3.4.2 实体E-R图

E-R图是一种信息模型图，体现了系统实体与实体之间的关系。通过对系统进行需求分析，了解数据流程，根据数据流图确定实体的属性和实体之间的关系。然后根据这些实体与实体之间的关系，可以得到系统E-R。

图3-17为系统E-R图：

图3-17 系统E-R图

图3-18为用户的实体属性图：

图3-18 用户实体属性图

图3-19为留言的实体属性图：

图3-19 留言实体属性图

图3-20为文章的实体属性图：

图3-20 文章实体属性图

图3-21为文章评论的实体属性图：

图3-21 文章评论属性图

图3-22为文章类别的实体属性图：

图3-22 文章类别实体属性图

3.4.3 数据库表结构

表3-2为用户、管理员信息表：

表3-3为留言表：

表3-4为文章表：

表3-5为文章类别表：

表3-6为文章评论表：

4 系统实现

4.1 功能模块的实现

管理员点击登录，输入用户名、密码后跳转到后台管理员管理中心主页面，如图4-1所示：

图4-1 文章发布系统管理员管理中心页面

4.1.1 用户管理

管理员可对用户信息进行查询、修改、删除，页面如图4-2所示：

图4-2 管理员管理用户页面

用户查询功能，输入用户名或者姓名，点击查询信息按钮，即可对查找对应用户，图4-3为输入用户“003”的查询结果：

图4-3 管理员查询用户结果

用户删除功能，点击用户列表右侧删除可对用户进行删除。点击删除后跳出如图4-4对话框，点击确定，用户删除成功。

图4-4 管理员删除用户对话框

用户修改功能，点击用户列表右侧修改可对用户进行修改。点击修改后出现如图4-5显示页面，填入所需信息，点击提交信息按钮，即可保存修改后的用户信息。

图4-5 管理员修改用户页面

4.1.2 公告管理

管理员可对公告进行修改，页面如图4-6所示：

图4-6 管理员管理公告信息

点击提交信息，即可在首页上可以看到如图4-7所示的网站公告。

图4-7 主页上所显示的网站公告

4.1.3 文章管理

管理员可对文章进行查询、添加、删除、修改，页面如图4-8所示：

图4-8 管理员管理文章页面

文章查询功能，在标题一栏中输入文章关键词，点击查询按钮即可查询相关文章。图4-9为关键词为“人生”的查询结果：

图4-9 管理员查询文章结果

文章添加功能，点击添加按钮，输入文章信息即可添加文章，如图4-10所示：

图4-10 管理员添加文章页面

输入相关文章信息，点击提交信息按钮，弹出如图4-11所示的对话框，点击确定，添加成功。

图4-11 文章信息提交对话框

返回所有文章主页面，显示如图4-12所示，文章已添加：

图4-12 文章添加完成页面

文章删除功能，点击文章列表右侧删除，即可对文章进行删除。弹出如图4-13所示的对话框，点击确定，该篇文章删除。

图4-13 管理员删除文章对话框

文章修改功能，点击右侧修改，修改标题，如图4-14所示：

图4-14 管理员修改文章页面

点击提交信息后，返回所有文章页面，文章列表所显示文章标题已更改，如图4-15所示：

图4-15 文章修改完成页面

4.1.4 文章评论管理

管理员可对文章评论进行删除，图4-16是文章评论管理主页面：

图4-16 管理员管理文章评论页面

文章评论删除功能，对于不法评论、攻打性评论，可点击右侧删除对评论进行删除。图4-17为删除第一条评论后页面显示的结果：

图4-17 文章评论删除结果

4.1.5 留言管理

管理员可对用户留言进行回复、删除，页面如图4-18所示：

图4-18 管理员管理留言页面

留言回复功能，点击右侧回复可对用户留言进行回复。点击回复后，弹出如图4-19所示对话框：

图4-19 留言回复信息页面

在输入框内输入所回复留言，点击提交信息按钮，得到如图4-20所示结果：

图4-20 留言回复完成结果

留言删除功能，点击留言列表右侧删除后，即可删除对应留言。删除第二条留言，得到如图4-21所示结果：

图4-21 留言删除完成结果

4.1.6 管理员信息管理

管理员可对管理员信息进行修改、删除，页面如图4-22所示：

图4-22 管理员信息管理页面

管理员信息修改功能，点击管理员列表右侧修改，可对管理员信息进行修改。图4-23为点击修改后的页面。

4-23 管理员信息修改页面

修改信息后，点击提交信息后，管理员信息结果如图4-24所示：

4-24 管理员修改完成结果

管理员信息删除功能，点击管理员右侧删除，可对管理员信息进行删除。图4-25为点击删除姓名为“小花”的管理员后的结果：

4-25 管理员删除完成结果

4.2 界面设计

4.2.1 系统首页

用户输入网址，出现文章发布系统的主页面，系统的主页面主要包括：导航栏、登录注册、文章搜索、留言板、公告等。系统首页如图4-26所示：

图4-26 文章发布系统主界面

点击导航栏中的“网站介绍”，出现如图4-27所示的页面：

图4-27 文章发布系统网站介绍

点击导航栏中的“联系我们”，出现如图4-28所示的页面：

图4-28 文章发布系统联系我们

4.2.2 用户注册

游客可进行注册，注册完成后，即可对文章进行评论。图4-29为点击注册后的用户注册页面：

图4-29 用户注册界面

输入个人信息，点击提交按钮，用户注册成功，则出现如图4-30所示页面：

图4-30 用户注册成功对话框

4.2.3 用户登录

用户可进行登录，登录后可对文章进行评论。图4-31为用户登录页面：

图4-31 用户登录界面

用户名、密码输入正确，点击登录按钮，登录成功后，右上角显示如图4-32所示信息：

图4-32 用户登录成功界面

点击“修改个人信息”，即可进入个人信息修改页面，对个人信息进行修改，图4-33为个人信息修改页面：

图4-33 用户个人信息修改页面

输入需要修改的信息，点击提交信息按钮提交个人信息，个人信息修改成功。

若点击重新填写，即可清空文本框内的所有内容，用户可以对信息重新进行填写。

4.2.4 文章搜索

游客、用户、管理员可对文章进行搜索，输入关键字，即可对相关文章进行搜索。图4-34为文章搜索页面：

图4-34 文章搜索页面

输入关键词“人生”，点击查找文章按钮查询得到关键词为“人生”的文章，图4-35为搜索结果：

图4-35 文章搜索结果

4.2.5 用户留言

用户可对网站进行留言，提出自己的想法和观点，图4-36为网站留言板页面：

图4-36 留言板页面

用户在输入框内输入留言内容，即可对网站进行留言。图4-37为输入的留言内容：

图4-37 留言板留言页面

输入留言内容后，即可点击提交留言按钮后，在页面刷新后，留言出现在留言板页面上，如图4-38所示：

图4-38 用户留言提交结果

4.2.6 用户评论

用户可对文章进行评论，表达自己的想法。点开文章详细页面，如图4-39、图4-40所示：

图4-39 文章详细页面

图4-40 文章评论页面

在评论框内输入如图4-41所示文字

图4-41 文章评论内容

点击提交评论按钮，评论内容显示在文章底部，如图4-42所示：

图4-42 文章评论提交结果

5 系统测试

测试的重要性

在软件的生命周期中，软件测试起着重要的作用。对于软件来说，软件完成过程中总会有一些错误，现在，普遍的一种观点是在软件开发过程中的每一个阶段都进行软件的测试，这样可以保证软件返工率达到最低，有效的保证了程序员的效率，减少了项目的开发时间，降低了项目的开发成本，然后我们还需要在软件交付前对软件进行总体测试，将所有模块集成起来做最后的测试，通过测试检查出问题所在，然后解决问题，以此来保证软件的质量，提高客户的满意度。

测试的目的

① 软件测试重执行程序是为了发现错误;

② 测试是为了证明程序有错;

③ 一个好的测试用例是在于它能发现至今未发现的错误;

④ 一个成功的测试是发现了至今未发现的错误的测试。

测试并不仅仅是为了要找出错误。通过对产生错误原因和错误分布特征进行分析，可以帮助我们发现当前已开发软件中的缺陷，有助于我们进一步的改进。同时，这种测试目的的明确性能够让我们知道测试的目的，让我们对测试重视起来，从而起到增加软件开发有效性的作用。

然后，不管有没有发现错误，软件测试都是有价值的。

5.1 系统测试测试策略说明

对测试质量进行保证，则需要将测试过程分成四个阶段，下面为几个阶段的详细介绍：

单元测试

单元测试检测软件设计过程中具有最小单位的模块，通过测试可以发现该模块的需求中所要达到的效果与实际效果是否相符。若不相符，对代码进行修改，力求达到实际效果与所期望效果相符的结果。

集成测试

集成测试是对按照需求组装起来的模块进行测试，通过测试发现与模块集成过程中与接口相关的问题。如果模块之间存在有害的影响或者是组合起来的功能达不到预期的结果，都要认真修改源代码，对各模块进行排除，找到问题接口，解决该接口中的错误。

确认测试

确认测试是验证系统是否符合客户的需求。经过集成测试后，已经排除了接口的错误，同时各模块也已经组装成完整的系统，然后我们就需要验证系统是否有效，这也就是确认测试的内容。如果满足客户的需求那么确认测试完成。

系统测试

在确认测试完成后，还要对系统进行恢复测试、强度测试、安全测试和性能测试等。

5.2 测试环境

5.2.1 系统测试硬件环境

本系统在普通电脑即可运行，需要一台PC机。

PC机配置最低配置：CPU 2GHz，内存256M，硬盘40G。

5.2.2 系统测试软件环境

客户端：

PC机上安装并配置java运行环境——JDK，本人用的JDK是jdk1.8。

PC机上安装web服务器，本人用的web服务器是tomcat网络服务器。

服务器端：

PC机上需要安装浏览器。

5.3 测试时间

本系统的测试分为一下几个阶段进行：

第一阶段：根据需求分析确定软件测试的内容；

第二阶段：分模块对系统中要测试的功能和性能的范围，对需求分析中各模块的功能呢个和性能及用户的特殊需求进行测试，记录各个模块的问题，及时解决；

第三阶段：在模块测试的基础上将各个模块拼接起来进行整体功能和性能的测试；

第四阶段：综合测试。

5.4 测试报告

表5-1为用户注册测试表：

表5-2为用户登录测试表：

表5-3为文章搜索测试表：

表5-4为用户留言测试表：

表5-5为用户评论测试表：

表5-6为用户信息管理测试表：

表5-7为用户管理测试表：

表5-8为文章管理测试表：

表5-9为公告管理测试表：

表5-10为评论管理测试表：

表5-11为留言管理测试表：

表5-12为管理员管理测试表：

总 结

本文通过文章发布系统的设计与实现，完成的工作如下：

（1）网站开发的前期工作。完成了文章发布系统的可行性分析，需求分析以及数据库需求分析；

（2）网站的功能实现。完成了网站的主体页面设计，实现了网站的功能模块。

1. 网站的测试。完成了各个模块的测试以及集成后的测试。

通过这次的系统设计，我熟悉了JSP的编写以及MYSQL数据库的使用，在系统实现的过程中，不仅巩固了我的理论知识、丰富了我的实践经验，也提高了我独立处理问题的能力。刚开始面对这个系统我不知道从哪开始写起，但后来通过不断地从网上找资料，查阅书籍，询问老师，渐渐明确自己要怎么去完成这个系统以及如何去实现系统的功能。在做系统时，面对不断的报错等系统问题，我也曾手忙脚乱，也曾不知所措，但是经过近三个月的锻炼，对于频繁出现的错误已经基本上掌握了它的解决思路以及解决办法，对于我们不太熟悉的知识，总是需要我们花费很大的力气，做大量的工作，花大量的时间来解决，但是在这个学习的过程中却也积累了工作经验，让我们懂得了如何将理论知识与实践经验联系起来，既可以将理论应用与实际，又可以在实际中遇到问题时，学会用理论知识来解决，以后遇到这种情况的时候会更加得心应手。

在这次的毕业设计中，我设计的系统也有许多不足的地方，在一些细节上处理不是很到位，界面的设计也不够美观，存在代码冗余等等一些问题，在今后的时间里，我要认真学习专业知识，提高自己的能力，独立的去思考解决问题，努力编写出高质量的代码。

致　　谢

本次毕业设计历时三个多月，在这段时间里，我的老师和同学都给了我很大的帮助。这是我第一次正式地写论文，很多格式规范都不是很清楚，谢谢老师能够及时指出我论文的不足，及时对我提出的问题进行回复。如果没有老师的教导和帮助，我无法如此顺利地完成此次毕设。在此，谢谢我的指导老师，谢谢老师用那一丝不苟的工作态度，精益求精的求知精神来感染我，使我丝毫不敢松懈，而这将对我以后的学习、工作和生活产生巨大的影响。

再次感谢为此毕业设计提供意见的老师们，感谢提供帮助的文献的作者们，感谢网络上答疑解惑的网友们。

参 考 文 献

1袁健美. 基于JSP的B/S动态网站开发及数据库连接[J]. 计算机技术与发展，2007，（6）：29-35.

2杨国军. 基于http://ASP.NET​的文章发布系统设计与实现[J]. 电脑知识与技术，2003，（14）：3295-3297.

2施汝军. 网站JSP后代解决方案[M]. 北京：人民邮电出版社，2001：4-14.

4朱兆霞. 基于JSP技术的网站新闻管理系统的设计与实现[J]. 计算机与网络，2007，（12）：55-58.

5萨师煊. 数据库系统概论[M]. 北京：高等教育出版社，2002：3-460.

6杨昭兵. 基于JSP WEB动态网页技术中中文乱码问题及解决方案[J]. 甘肃科技纵横，2010，6（40）40-41.

7黄理，洪亮等. JSP高级编程[M]. 北京：北京希望电子出版社，2000.

8Horstmann C S. Cornell G. Core Java2[M]. 北京：机械工业出版社，2002.

9Joseph J.Bambana，Pual R.Allen. J2EE技术内幕[M]. 北京：机械工业出版社，2002.

10Scot Johnson. Active Server Pages详解[M]. 北京：电子工业出版社，2009.

外文原文

1. Introduction

Software tools and packages for the nonlinear analysis of complex spatial dynamic systems increasingly use Web-based networking platforms for the implementation of their user interface, scientific analysis, distribution of simulation results, and information exchange among scientists. The real-time Web-based access to nonlinear analysis simulation software becomes a critical part of many applied systems. The intensive technological change in networking hardware and software [1] provides more freedom of choices than in the past [2]. Therefore, the rational selection and development of the Web platform is of increasing importance for the whole area of nonlinear analysis and its numerous applications. The current stage of Web development is characterized by the emergence of a significant number of open source frameworks. Frameworks shift the focus of Web development to a higher level, allowing the reuse of basic functionality and thus increasing the productivity of development.

In some cases, open source frameworks do not provide a solution to common problems. For this reason, developers build their own development framework on top of an open source framework. The aim of this paper is to describe a developed Java-based framework that leverages open source frameworks and assists in developing Web-based applications. By analyzing some existing open source frameworks, this paper presents a new architecture, infrastructure and associated techniques for enhancing and leveraging some other frameworks. The proposed architecture defines its own development methodology, which is designed to assist in custom development projects and integration projects.

There are common application design concerns which are often used across projects. Even across unique functional requirements, there are commonly occurring patterns of use cases, which lend themselves to design and development reuse. This paper describes a ``customized'' framework, which had been developed in an effort to identify such common application concerns and identify design patterns that can be used by the developers. This framework, which we will refer to as the developed XYZ framework, provides a set of patterns and tools that were built on industry best practices, tailored to common application concerns. It provides an application development stack, from presentation to integration layers.

This paper articulates these application concerns and the patterns, tools and industry best practices. The developed XYZ framework can be customized to various projects' needs. It was developed and configured based on various frameworks and tools such as Struts, Spring, Hibernate and JUnit.

2. Major technologies of the developed framework

2.1. Layers and separation of code and configuration

Web applications have various design concerns such as presentation, business logic, data access and security. A separation of design concerns into distinct code layers has several advantages such as: ease of maintenance, the ability to implement good design patterns, and the ability to select specialized tools and techniques for specific concerns. Separating a project into layers can result in dependencies between those layers. For example, a single-use case involving simple data entry and inquiry usually must integrate presentation, business logic and data access together to deliver required functionality [3]. Therefore, there must be a well defined strategy to manage the dependency relationships. The developed XYZ framework combines design patterns, reusable code and configuration files to make this as easy as possible. This framework uses

Spring's Inversion of Control to manage dependencies. The Spring Framework [4] provides a way to tie together the objects that make up an application. It accomplishes this goal with the Spring Application Context, which is a strategy for managing dependencies between objects. Spring uses dependency injection and method interception techniques described below.

The code that we write is dependent on the objects it uses. It is responsible for creating these objects. This may result in tight coupling, but we would prefer that our code be loosely coupled. Dependency injection is a technique which helps us to accomplish this. Dependency injection is a form of Inversion of Control (IoC) [5]. When applications use dependency injection, the code becomes much cleaner and easier to follow. It is also loosely coupled, allowing for easier configuration and testing. The XYZ framework uses several Spring application context files to define dependencies between the layers. Method interception is a concept of Aspect Oriented Programming (AOP) [6]. Spring AOP implements method interception through JDK dynamic proxies. The XYZ framework uses Spring AOP to manage concerns such as transaction management and performance monitoring.

The developed XYZ framework consists of two distinct parts: code and configuration. Code resides in a particular application layer and focuses on a particular piece of the application solution. This could be interacting with a database, or presenting data to the screen. Configuration glues the various layers of the application together. Separating configuration from code allows us to manage configuration independently, giving us the flexibility of applying different configurations to the same code base. For example, a Data Access Objects (DAO) implementation knows that it is using JDBC to connect to a database through a data source, but it does not know anything about the implementation of that data source. It may come from a Java Naming and Directory Interface (JNDI) context or be derived from a driver manager. It may point to the remote database or a local database. Regardless of where the data source comes from, the DAO implementation will operate on the data source in the same manner. Likewise, a Service object may depend on a DAO, but it does not know whether the DAO is implemented via Hibernate, straight JDBC, or a Web service. The service object interacts with the DAO in the same manner, regardless of the DAO's implementation.

Spring gives us a way to manage our application's entire configuration through a Spring application context, defined by a set of XML files. We could define the application context in one file. However, by defining it in groups of smaller files, we can simplify configuration management. A logical set of such application context files which forms a complete application configuration is called a configuration set.

During the development of Java-based enterprise applications the standard configuration is where a framework's configuration set uses external resources such as data sources and JNDI resources. This type of configuration sometimes can create problems with:

1. An incomplete database that has not yet been loaded. Developers may want to test the display of certain types of data, but if the underlying database has not yet been completed, they will not be able to do this.
2. Services or DAOs that may not have been developed yet. Integrating with unfinished services or DAOs may halt development.

These issues decrease productivity. The developed XYZ framework has separated its configuration from its code, we can use an alternate configuration set targeted specifically towards development. This relieves us from worrying about the availability of external systems, which are irrelevant to solving immediate development needs.

The developed XYZ framework defines two configuration sets: default and standalone. We can also customize our application by adding additional configuration sets based on our project needs. The default configuration set connects to the development database using the DataSource defined in JNDI. It uses fully developed application services and DAOs. The standalone configuration set is the most flexible environment for development. This configuration set:

1. connects to either a locally installed database or the development database using a DriverManagerDataSource;
2. uses Spring's DataSourceTransactionManager for local transaction management;
3. uses fully developed application Services and DAOs;
4. fully wired Spring application contexts can be run and tested entirely outside of the application server.

The developed XYZ framework is configured by its application context. The application context may be defined in one or more XML files. A configuration set is a set of XML files that define one application context. The configuration set consists of two parts: service and Web. The service part defines services, DAOs, and resources for the service and integration layers. The Web part defines components for the presentation layer. A configuration set cannot be complete without both of these parts.

The developed XYZ framework configuration sets are grouped together by what Spring calls a bean reference context defined in the files beanRefContext.xml and applicationContextMapping.properties. The beanRefContext.xml file defines the service part of all configuration sets. This file is located in the src/config directory of the service project.

Application context files shared between configuration sets are also located in this directory. In addition, each configuration set has its own subdirectory, which contains files specific to it. Services and DAOs, for instance, are shared between configuration sets, while supporting services (like data sources) belong in the subdirectories. XML files define the Spring beans in this application by using the hbeani tag. A Spring bean is a Java object created and initialized by the application context.

2.2. Classes and dependencies

Using the developed XYZ framework, the following code and configuration artifacts will be typically required to develop a user interface screen:

1. Action, ActionForm classes and validation.xml entries;
2. service interface and implementation class;
3. DAO interface and implementation class;
4. dependency management between all of the above.

When starting development for a use case, we must be aware of the need of all these classes and their dependencies upfront.

2.3. Testing technology

Testing should be an integral part of the development process. For applications built using the developed XYZ framework, unit testing means testing methods of a single class in the service or integration layer. Presentation layer artifacts (Action classes) are not taken up for unit testing. The purpose of this test is to ensure that the behavior encapsulated by the class works as expected when testing integration with other components. Unit tests in applications, developed using the developed XYZ framework, are based on the JUnit framework [7]. Unlike unit tests, integration tests do require code dependencies to be available. The purpose of this test is to ensure that the integration between different classes (developed by different developers) works as expected. During the Functional Testing process, the focus is on testing functionality of the application by using data to depict different scenarios. Functional testing typically involves testing classes in the Service layer with different data. It can also be performed by testing the user interface layer and by using real dependencies.

In order to perform different types of testing, the application being developed must be testable. Let us list some of the basic characteristics of a testable application.

1. Ease of developing unit and integration tests. We should be able to unit test without necessarily using data sources, or queues. Also, we should be able to mock dependencies of code under test.
2. Ease of simulating various test scenarios for functional testing.
3. Ease of re-running all tests repeatedly over the life cycle of the application.
4. Clean separation of testing code from application code.

A well structured application that separates design concerns such as presentation, services and data access is important for designing testable applications. Application coding starts with getters, setters, variables etc., which are then integrated to provide the required solution. Unit tests are a fundamental building block for any testing approach. The developed XYZ framework's design facilitates development of testable applications by: providing testing template classes that help to create unit tests; and also by enabling easy configuration of application to adapt to testing needs. Unit tests can be run like any JUnit test. The specially developed default ``build script'' provides a task to run unit tests. This task can be called when generating an EAR file for deployment or can be run separately.

2.4. Web presentation design

The developed XYZ framework uses the Struts framework concepts and JavaScript to implement presentation concerns and provides additional features that can be extended for use in projects. When using the Struts framework for development, at first we set up the Action Servlet in web.xml; then we set up configuration, action mappings, form beans and local forwards in the struts-config.xml; and finally we set up validation rules in validation.xml.

This approach has been changed in applications that were built using the developed XYZ framework, such that developers must not directly edit the struts-config.xml or validation.xml. Instead we specify this information as XDoclet annotations in the Action and ActionForm classes directly. This information is then transferred into the struts-config.xml and validation.xml by running the Ant script.

There are two types of validations that are required: data format validation and business logic validation. Data format validations are best done in the presentation layer, while business logic validations are best done in the services layer. Business logic validation errors, which occur in the service layer, should be handled by throwing custom exceptions.

The following are design goals for the presentation layer: (1) There is only one Action class ascending one ActionForm per JSP. A single Web page must all be handled in a single Action class. (2) Dependencies and validation rules are specified using XDoclet annotations. (3) Developers should avoid or minimize the use of session objects, because it hinders scalability.

The XYZ framework provides a default template Action class that contains a solution to the above mentioned design goals for this layer. The following are typical code artifacts required for developing a Web page:

1. Create a new JSP with a default hidden field called ``actionType'' for use in handling user actions that are expected to occur on the page.
2. Create a new Action class that extends this template Action class. We must specify dependencies on ActionForm specific methods that handle user actions represented by values in hidden field ``actionType''. After that we can declare permissions that are required in order to access this Action class. This is done in the Spring configuration files.
3. Create a new ActionForm class and specify validation rules as required using XDoclet annotations.

Once the JSP, Action and ActionForm are created, it is necessary to run the Ant script to regenerate the ``struts-config.xml'' file.

中文翻译

介绍

用于复杂空间动态系统非线性分析的软件工具和软件包越来越多地使用基于Web的网络平台来实现用户界面，科学分析，分布仿真结果以及科学家之间的信息交换。对非线性分析仿真软件的实时基于Web的访问成为许多应用系统的关键部分。网络硬件和软件的密集技术变革[1]提供了比过去更多的选择自由[2]。因此，Web平台的合理选择和发展对于非线性分析的整个领域及其众多应用越来越重要。 Web开发的当前阶段的特征是出现了大量的开源框架。框架将Web开发的重点转移到更高层次，允许重用基本功能，从而提高开发的生产力。

在某些情况下，开源框架不能解决常见的问题。因此，开发人员在开源框架之上构建自己的开发框架。本文的目的是描述一个开发的基于Java的框架，利用开源框架并协助开发基于Web的应用程序。通过分析一些现有的开源框架，本文提出了一种新的架构，基础架构和相关技术来增强和利用其他一些框架。建议的架构定义了自己的开发方法，旨在协助定制开发项目和集成项目。

通常在项目中使用常见的应用程序设计问题。即使是独特的功能需求，通常也会出现一些使用案例，这些使用案例有助于设计和开发重用。本文介绍了一个“定制”框架，该框架是为了确定这些常见的应用程序问题而开发的，并确定了开发人员可以使用的设计模式。这个框架，我们将被称为开发的XYZ框架，提供了一套基于业界最佳实践的模式和工具，针对常见的应用问题。它提供了从演示到集成层的应用程序开发栈。

本文阐述了这些应用问题以及模式，工具和行业最佳实践。开发的XYZ框架可以根据各种项目的需求进行定制。它是基于各种框架和工具（如Struts，Spring，Hibernate和JUnit）开发和配置的。

2.开发框架的主要技术

2.1层次和分离代码和配置

Web应用程序具有各种设计问题，如演示，业务逻辑，数据访问和安全性。将设计问题分离为不同的代码层具有以下优点，例如：易于维护，实现良好设计模式的能力，以及为特定问题选择专门的工具和技术的能力。将项目分成多个层可能会导致这些层之间的依赖关系。例如，涉及简单数据输入和查询的单用例通常必须将演示，业务逻辑和数据访问集成在一起，以提供所需的功能[3]。因此，必须有一个明确的策略来管理依赖关系。开发的XYZ框架结合了设计模式，可重用代码和配置文件，使其尽可能简单。这个框架使用

Spring的控制反转来管理依赖关系。 Spring Framework [4]提供了组合应用程序的对象的方法。它通过Spring应用程序上下文来实现这一目标，该应用程序上下文是管理对象之间依赖关系的策略。 Spring使用下面描述的依赖注入和方法拦截技术。

我们编写的代码取决于它使用的对象。它负责创建这些对象。这可能导致紧耦合，但是我们希望我们的代码松散耦合。依赖注入是一种帮助我们实现这一点的技术。依赖注入是反转控制（IoC）的一种形式[5]。当应用程序使用依赖注入时，代码变得更干净，更容易遵循。它也松散耦合，允许更容易的配置和测试。 XYZ框架使用几个Spring应用程序上下文文件来定义层之间的依赖关系。方法截取是面向方面编程（AOP）的概念[6]。 Spring AOP通过JDK动态代理实现方法拦截。 XYZ框架使用Spring AOP来管理事务管理和性能监视等问题。

开发的XYZ框架由两个不同的部分组成：代码和配置。代码驻留在特定的应用程序层中，并专注于特定的应用程序解决方案。这可能是与数据库进行交互，或者将数据呈现给屏幕。配置将应用程序的各个层粘合在一起。将配置与代码分离允许我们独立地管理配置，使我们灵活地将不同的配置应用于相同的代码库。例如，数据访问对象（DAO）实现知道它正在使用JDBC通过数据源连接到数据库，但它并不知道该数据源的实现。它可能来自Java命名和目录接口（JNDI）上下文或从驱动程序管理器派生。它可能指向远程数据库或本地数据库。不管数据来源何处，DAO实现将以相同的方式对数据源进行操作。同样，一个服务对象可能依赖于DAO，但是它不知道DAO是通过Hibernate，直接JDBC还是Web服务实现的。不管DAO的实现如何，服务对象以相同的方式与DAO进行交互。 Spring为我们提供了一种通过由一组XML文件定义的Spring应用程序上下文来管理我们的应用程序整个配置的方法。我们可以在一个文件中定义应用程序上下文。但是，通过将其定义成较小的文件，我们可以简化配置管理。构成完整应用程序配置的这种应用程序上下文文件的逻辑集称为配置集。在开发基于Java的企业应用程序期间，标准配置是框架的配置集合使用外部资源（如数据源和JNDI资源）的位置。这种类型的配置有时可能会产生以下问题：

1. 尚未加载的不完整的数据库。开发人员可能想要测试某些类型的数据的显示，但是如果底层数据库尚未完成，则他们将无法进行此操作。
2. 可能尚未开发的服务或DAO。与未完成的服务或DAO集成可能会阻止开发。

这些问题降低了生产率。开发的XYZ框架将其配置与其代码分离，我们可以使用专门针对开发的替代配置集。这使我们不必担心外部系统的可用性，这与解决即时发展需求无关。开发的XYZ框架定义了两个配置集：默认和独立。我们还可以根据我们的项目需求添加额外的配置集来定制我们的应用程序。默认配置集使用JNDI中定义的DataSource连接到开发数据库。它使用完全开发的应用服务和DAO。独立配置集是开发最灵活的环境。此配置集：

1. 使用DriverManagerDataSource连接到本地安装的数据库或开发数据库;
2. 使用Spring的DataSourceTransactionManager进行本地事务管理;
3. 使用完全开发的应用服务和DAO;
4. 完全有线的Spring应用程序上下文可以在应用程序服务器之外完全运行和测试。

开发的XYZ框架由其应用程序上下文配置。应用程序上下文可以在一个或多个XML文件中定义。配置集是定义一个应用程序上下文的一组XML文件。配置集由服务和Web两部分组成。服务部分为服务和集成层定义服务，DAO和资源。 Web部件定义了表示层的组件。如果没有这两个部分，配置集将无法完成。开发的XYZ框架配置集由Spring调用beanRefContext.xml和applicationContextMapping.properties中定义的bean引用上下文组合在一起。 beanRefContext.xml文件定义了所有配置集的服务部分。该文件位于服务项目的src / config目录中。配置集之间共享的应用程序上下文文件也位于此目录中。另外，每个配置集都有自己的子目录，它包含特定于它的文件。例如，服务和DAO在配置集之间共享，而支持服务（如数据源）属于子目录。 XML文件通过使用hbeani标签在此应用程序中定义了Spring bean。 Spring bean是由应用程序上下文创建和初始化的Java对象。类和依赖使用开发的XYZ框架，通常需要以下代码和配置工件来开发用户界面屏幕：

（a）Action，ActionForm类和validation.xml条目;

（b）服务接口和实现类;

（c）DAO接口和实施类;

（d）所有上述之间的依赖关系管理。

在开发用例时，我们必须先了解所有这些类及其依赖关系的需要。测试技术测试应该是开发过程的一个组成部分。对于使用开发的XYZ框架构建的应用程序，单元测试意味着服务或集成层中单个类的测试方法。演示层工件（Action类）不用于单元测试。此测试的目的是确保在测试与其他组件的集成时，该类封装的行为如预期的那样工作。使用开发的XYZ框架开发的应用程序中的单元测试基于JUnit框架[7]。与单元测试不同，集成测试确实需要代码依赖性才能使用。此测试的目的是确保不同类（由不同开发人员开发）之间的集成工作正常。在功能测试过程中，重点是通过使用数据来描述不同的场景来测试应用程序的功能。功能测试通常涉及使用不同的数据测试服务层中的类。也可以通过测试用户界面层和使用真正的依赖来执行。为了执行不同类型的测试，正在开发的应用程序必须是可测试的。我们列出一个可测试应用程序的一些基本特征。

1. 易于开发单元和集成测试。我们应该能够进行单元测试，而不必使用数据源或队列。此外，我们应该能够模拟被测代码的依赖关系。
2. 轻松模拟功能测试的各种测试场景。
3. 在应用程序的生命周期内轻松重新运行所有测试。
4. 清除测试代码与应用程序代码的分离。

分离设计问题（如演示，服务和数据访问）的结构良好的应用程序对于设计可测试应用程序很重要。应用程序编码从getter，setter，变量等开始，然后将其集成以提供所需的解决方案。单元测试是任何测试方法的基本构建块。开发的XYZ框架的设计通过以下方式促进可测试应用程序的开发：提供有助于创建单元测试的测试模板类;并且还可以轻松配置应用程序以适应测试需求。单元测试可以像任何JUnit测试一样运行。专门开发的默认“构建脚本”提供了运行单元测试的任务。在生成用于部署的EAR文件或可以单独运行时，可以调用此任务。 Web演示设计开发的XYZ框架使用Struts框架概念和JavaScript来实现演示问题，并提供可扩展用于项目的其他功能。当使用Struts框架进行开发时，我们首先在web.xml中设置Action Servlet;然后我们在struts-config.xml中设置配置，操作映射，表单bean和本地转发;最后我们在validation.xml中设置验证规则。在使用开发的XYZ框架构建的应用程序中，这种方法已经改变，因此开发人员不能直接编辑struts-config.xml或validation.xml。相反，我们直接在Action和ActionForm类中将此信息指定为XDoclet注释。然后通过运行Ant脚本将此信息传输到struts-config.xml和validation.xml。有两种类型的验证是必需的：数据格式验证和业务逻辑验证。数据格式验证最好在表示层中完成，而业务逻辑验证最好在服务层中完成。服务层中出现的业务逻辑验证错误应通过抛出自定义异常来处理。

以下是表示层的设计目标：

1. 每个JSP只有一个Action类上升一个ActionForm。单个Web页面都必须在单个Action类中处理。
2. 依赖关系和验证规则使用XDoclet注释指定。
3. 开发人员应避免或尽量减少会话对象的使用，因为它阻碍了可扩展性。 XYZ框架提供了一个默认模板Action类，其中包含了该层对上述设计目标的解决方案。

以下是开发Web页面所需的典型代码工件：

1. 创建一个带有默认隐藏字段（称为“actionType”）的新JSP，用于处理预期在页面上发生的用户操作。
2. 创建一个扩展此模板Action类的新Action类。我们必须指定依赖于ActionForm的具体方法，处理由隐藏字段“actionType”“中的值表示的用户操作。之后，我们可以声明为了访问此Action类而需要的权限。这完成了Spring配置文件。
3. 创建一个新的ActionForm类，并根据需要使用XDoclet注释指定验证规则。 一旦创建了JSP，Action和ActionForm，就需要运行Ant脚本来重新生成“struts-config.xml”文件。