安徽工业大学 毕业设计（论文）说明书
安徽工业大学
毕业设计(论文)任务书
课题名称 学 院 班 级 姓 名 学 号
毕业设计（论文）的主要内容:
医院住院管理系统
计算机学院
1、学习和掌握系统的开发和技术，按照软件工程的思想对医院住院管理系统进行设计编码和测试。
2、系统能满足实际运行需求，能实现医院住院管理的基本需求。 3、要求软件美观，使用方便。
4、完成一篇论文。篇幅为1.5到2万字左右，中外文摘要约300字，关键词3到5个。
5、完成与设计内容有关的外文资料翻译，译文约5000字。 6、提交带有注释的原程序清单。
起止时间：
年
月
日至 系 主 任 签 字
年
月
日共
周
指 导 教 师 签 字
院 长 签 字
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
摘 要
随着网络技术的发展和普及，计算机管理信息系统在企业管理中扮演着重要的角色。高效率、无差错的医院住院管理系统的开发适应了时代的需要。该系统的主要目的是告别手工操作、安全快捷的保存数据信息、节约时间、从而提高快速和准确性。
医院住院管理系统是典型的信息管理系统(MIS)，其开发主要包括后台数据库的建立和维护以及前端程序的开发两个方面。为了更好的满足医护人员用户的需求，本系统包括如下功能模块：出入院管理、病人管理、病房管理、系统用户管理模块，每个模块都有其独自的功能，以达到更好的服务于用户。 系统采用B/S结构，用当前最流行的JSP+SERVLET WEB开发技术开发，系统架构采用MVC模式，分层架构，其中持久层采用当前流行的持久层框架Hibernate来实现。数据库采用MySQL小型数据库，小巧方便使用。为了方便编码的过程，系统引入日志，使用Log4j来记录程序运行日志，以方便程序调试和查看程序运行信息。
关键词：医院住院管理系统；B/S；JAVA WEB开发技术；HIBERNATE；Log4j
共IV页 第I页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
Abstract
With the development and popularization of network technology, computer management information system in enterprise management plays an important role. Efficient, error-free hospital management system development to adapt to the needs of the times, the system's main purpose is to bid farewell to manual operation, the preservation of safe and efficient data, saving time, thereby enhancing the speed and accuracy.
Hospital Management System is a typical management information system (MIS), which mainly includes the establishment and maintenance of back-end database and front end development of the two. In order to better meet the medical needs of users, the system includes the following functional modules: the hospital management, patient management, ward management, system user management module, each module has its own features to achieve better service Users.
System uses the B / S structure, with the most popular JSP + SERVLET WEB development of technology development, system architecture using MVC model, layered architecture, which uses the popular persistence framework Hibernate to achieve persistence layer. MySQL database is a small database and compact easy to use. In order to facilitate the process of encoding, the system introduced log to record the program runs with Log4j logging to facilitate debugging and view run information.
Keywords：Hospital management system; B / S; JAVA WEB development technology;
HIBERNATE; Log4j
共IV页 第II页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
目 录
1.绪 论 ................................................................................................................................. 1
1.1系统开发的意义 ..................................................................................................... 1 1.2系统开发的目标 ..................................................................................................... 1 1.3相关研究工作 ......................................................................................................... 2 2.开发语言和开发工具简介 ............................................................................................... 3
2.1 JAVA简介 ............................................................................................................... 3
2.1.1 JAVA的概念 ................................................................................................ 3 2.1.2 JAVA的特点 ................................................................................................ 3 2.2 JAVA WEB开发技术简介 ....................................................................................... 4
2.2.1 B/S结构 ...................................................................................................... 4 2.2.2 Servlet技术 .............................................................................................. 5 2.2.3 JSP技术 ...................................................................................................... 6 2.2.4 Hibernate和Log4j简介 .......................................................................... 7 2.3 MySQL简介 ............................................................................................................. 8
2.3.1 MySQL概述 .................................................................................................. 8 2.3.2 MySQL的优点 .............................................................................................. 8 2.4 TOMCAT简介 ........................................................................................................... 9 2.5 Eclipse简介 ....................................................................................................... 10 3.可行性研究与需求分析 ................................................................................................. 11
3.1 可行性研究 .......................................................................................................... 11
3.1.1社会可行性分析 ........................................................................................ 11 3.1.2 技术可行性分析 ....................................................................................... 11 3.1.3 经济可行性 ............................................................................................... 11 3.1.4 可行性分析结论 ....................................................................................... 12 3.2 需求分析 .............................................................................................................. 12
3.2.1 系统的目的 ............................................................................................... 12 3.2.2 目标 ........................................................................................................... 13 3.3 医院住院管理系统数据流图 .............................................................................. 13 4.总体设计 ......................................................................................................................... 16
4.1 系统总体设计思想 .............................................................................................. 16 4.2 系统功能模块图 .................................................................................................. 17 4.3系统的流程图 ....................................................................................................... 18 5.详细设计 ......................................................................................................................... 19
5.1 数据库设计的E-R图 .......................................................................................... 19 5.2 数据库设计 .......................................................................................................... 20 5.3 输入输出设计 ...................................................................................................... 21
5.3.1 输入设计 ................................................................................................... 21 5.3.2 输出设计 ................................................................................................... 22 5.3.3 输入输出的界面设计 ............................................................................... 22 5.4 部分页面和代码设计、描述 .............................................................................. 22
共IV页 第III页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
5.4.1登录功能及其相关设计 ............................................................................ 22 5.4.2入院登记及其相关设计 ............................................................................ 24 5.4.3出院操作及其相关设计 ............................................................................ 25 5.4.4病房信息管理及其相关设计 .................................................................... 27 5.4.5病房信息查询及其相关设计 .................................................................... 28 5.4.6病人信息管理及其相关设计 .................................................................... 29 5.4.7病人信息查询及其相关设计 .................................................................... 30 5.4.8系统用户信息管理及其相关设计 ............................................................ 31 5.4.9系统用户信息查询及其相关设计 ............................................................ 32 5.5 DAO层代码设计与描述 ....................................................................................... 33 6.系统测试 ......................................................................................................................... 35
6.1功能测试 ............................................................................................................... 35 6.2测试结果 ............................................................................................................... 35 结 论 ................................................................................................................................... 37 致 谢 ................................................................................................................................... 38 主要参考文献 ..................................................................................................................... 39 附录一 实现本系统的部分源代码 ................................................................................... 40 附录二 外文资料翻译 ....................................................................................................... 49
外文原文 ...................................................................................................................... 49 中文译文 ...................................................................................................................... 54
共IV页 第IV页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
1.绪 论
1.1系统开发的意义
目前，我国医疗卫生制度和医疗保障制度的改革不断深化，医院也被迫向市场经济的海洋深处移动，经验主义的管理方法已明显表现出不科学、落后的弱点，如何用最快捷的方式取得医院运行的各项指标，如何对医院人，才、物进行科学的成本核算，怎样保证医院医疗、教学、科研的质量监控，怎样在医院内，甚至院外实行信息交流、网上会诊、继续教育等一系列问题都摆在医院管理者和行政人员以及每位医护人员的面前。因此，医疗卫生事业发展和管理的信息化、数字化、网络化、之间的关系，以及对医院信息化、数字化、网络化的要求，从来没有像今天这样感到迫切与巨大的压力。医院信息管理就是在这种情况下产生的一门应用科学。
一直以来医院的管理都是手工操作。手工操作手续复杂，不方便管理，不能保证数据的准确性和及时性，不仅浪费人力、物力和时间，重要的是手工操作可能造成数据录入的错误，影响工作效率。
随着计算机性能不断提高，价格不断下降，计算机已在医院医疗、教学、科研、管理等方面得到越来越广泛的应用。计算机化的医院信息系统（HIS）已成为现代化医院运营过程中必不可少的基础设施与技术支撑环境。就好像一个现代化医院的成功运行离不开功能完整、美观舒适的建筑物、及时娴熟的医护人员、性能齐全、高精尖的医疗设备一样，它也离不开计算机的医院信息系统。医疗行业是关系人类健康的重要事业，医院信息系统是医疗保险体制的信息源头，因此，医院的信息化建设不仅是今后医院发展的重要方向，也将是IT界关注的领域。一个设计合理、功能完善的检验信息系统，成为医院网络资源中的重要部分，在提高医院医疗服务和检验工作的科学管理方面具有重大意义。
1.2系统开发的目标
通过简单的需求分析，完成的医院住院管理系统，能够实现辅助医院医护人员工作，提高医院医护人员的工作效率。通过本系统，能够实现对住院部门的病人和病房两大信息的管理包括增、删、改、查，减轻医护人员的工作负担。本系统提供强大的查询功能，可以让系统用户根据各种不同的查询条件查询出相应的数据。出入院操作能够简单的实现病人的出入院操作，方便医院医护人员的操作，系统应该界面美观，操作简单，功能明确、完善。系统操作，应该有很高的效率，数据库操作方面应该提高效率，不能反应缓慢，这在系统搭建上要求合理、完善。
通过建立该医院住院管理系统，采用计算机对医院病房和病人进行管理和查询，进一步提高医院住院管理效益和现代化水平，帮助提高医院住院管理工作人员工作效率，实现医院住院管理工作流程的系统化、规范化和自动化。系统应该具有很好的扩
共58页 第1页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
展性，这就要求系统架构合理、可扩展，充分考虑到以后的需求变化。设计良好的代码允许更多的功能在必要时可以被插入到适当的位置中。这样做的好处是为了应对未来可能需要进行的修改，这就需要系统设计时能够有一个良好的软件框架。系统的安全性，也是本次系统设计的一个重要目标，设计中要考虑到用户的非法访问，通过拒绝用户的非法访问来保证用户数据的安全和系统的安全。
1.3相关研究工作
为了顺利完成基于医院住院管理系统系统的设计与实现，我在毕业设计期间所做的研究工作如下：
1.研究了相关文献中关于医院住院管理系统的内容，了解需求、制定需求 2.学习JAVA WEB开发技术，了解JSP、servlet、B/S架构 3.学习Hibernate持久层、Log4j日志的的使用 4.学习WEB项目的搭建和MVC架构模式 5.设计医院住院管理系统的体系结构 6.设计医院住院管理系统的模块及其界面
共58页 第2页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
2.开发语言和开发工具简介
2.1 JAVA简介
2.1.1 JAVA的概念
JAVA是SUN公司于1995年5月推出的JAVA面向对象程序设计语言和JAVA平台的总称。Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。使用Java编写的应用程序，既可以在一台单独的电脑上运行，也可以被分布在一个网络的服务器端和客户端运行。另外，Java还可以被用来编写容量很小的应用程序模块或者applet，做为网页的一部分使用。applet可使网页使用者和网页之间进行交互式操作。
Java也号称是能跨平台使用的语言，这主要是因为Java本身被编译之后，并不是直接产生可执行的码，而是产生一种中间码叫作 ByteCode，这种码必需在透过 Java 的直译器来解读它，才能够真正的被执行，所以只要平台上装有这种Java的直译器，就能解读ByteCode也就能执行Java编译过的程序，故与Java程序是在那种平台上被编译的，就完全没有干系了。Java写出来的程序可分为两类，分别是Java Applet与一般的Application，而Application 这一类就与一般的程序如C++的作用是比较类似的，是一个独立可执行的应用程序，像HotJava是一个浏览器，且就是使用Java程序所发展出来的。最常见的Java程序包括应用程序和applets。应用程序是单独的程序，诸如HotJava浏览器软件就是用Java语言编写的。 Applets类似于应用程序，但是它们不能单独运行， Applets可以在支持Java的浏览器中运行。Applet主要是内置于HTML网页中，在浏览时发挥作用。
Java的目标是为了满足在一个充满各式各样不同种机器，不同操作系统平台的网络环境中开发软件。利用Java程序语言，可以在网页中加入各式各样的动态效果。可以放上一段动画，加入声音，也可以建立交互式网页等。
2.1.2 JAVA的特点
1.平台无关性
平台无关性是指Java能运行于不同的平台。Java引进虚拟机原理，并运行于虚拟机，实现不同平台的Java接口之间。使用Java编写的程序能在世界范围内共享。Java的数据类型与机器无关，Java虚拟机（Java Virtual Machine）
共58页 第3页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
是建立在硬件和操作系统之上，实现Java二进制代码的解释执行功能，提供于不同平台的接口的。
2.安全性
Java的编程类似C++，学习过C++的读者将很快掌握Java的精髓。Java舍弃了C++的指针对存储器地址的直接操作，程序运行时，内存由操作系统分配，这样可以避免病毒通过指针侵入系统。Java对程序提供了安全管理器，防止程序的非法访问。
3.面向对象 Java吸取了C++面向对象的概念，将数据封装于类中，利用类的优点，实现了程序的简洁性和便于维护性。类的封装性、继承性等有关对象的特性，使程序代码只需一次编译，然后通过上述特性反复利用。程序员只需把主要精力用在类和接口的设计和应用上。Java提供了众多的一般对象的类，通过继承即可使用父类的方法。在Java中，类的继承关系是单一的非多重的，一个子类只有一个父类，子类的父类又有一个父类。Java提供的Object类及其子类的继承关系如同一棵倒立的树形，根类为Object类，Object类功能强大，经常会使用到它及其它派生的子类。
4.分布式 Java建立在扩展TCP/IP网络平台上。库函数提供了用HTTP和FTP协议传送和接受信息的方法。这使得程序员使用网络上的文件和使用本机文件一样容易。
5.健壮性
Java致力于检查程序在编译和运行时的错误。类型检查帮助检查出许多开发早期出现的错误。Java自己操纵内存减少了内存出错的可能性。Java还实现了真数组，避免了覆盖数据的可能，这些功能特征大大提高了开发Java应用程序的周期。并且Java还提供了Null指针检测、数组边界检测、异常出口、Byte code校验等功能。
2.2 JAVA WEB开发技术简介
2.2.1 B/S结构
B/S结构（Browser/Server结构）结构即浏览器和服务器结构。它是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种结构下，用户工作界面是通过WWW浏览器来实现，极少部分事务逻辑在前端（Browser）实现，但是主要事务逻辑在服务器端（Server）实现，形成所谓三层3-tier结构。这样就大大简化了客户端电脑载荷，减轻了系统维护与升级的成本和工作量，降低了用户的总体成本（TCO）。
共58页 第4页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件，只要有一台能上网的电脑就能使用，客户端零维护。系统的扩展非常容易。B/S结构的使用越来越多，特别是由需求推动了AJAX技术的发展，它的程序也能在客户端电脑上进行部分处理，从而大大的减轻了服务器的负担；并增加了交互性，能进行局部实时刷新。
B／S三层体系结构采用三层客户／服务器结构，在数据管理层(Server)和用户界面层(Client)增加了一层结构，称为中间件(Middleware)，使整个体系结构成为三层。三层结构是伴随着中间件技术的成熟而兴起的，核心概念是利用中间件将应用分为表示层、业务逻辑层和数据存储层三个不同的处理层次。三个层次的划分是从逻辑上分的，具体的物理分法可以有多种组合。中间件作为构造三层结构应用系统的基础平台，提供了以下主要功能：负责客户机与服务器、服务器与服务器间的连接和通信；实现应用与数据库的高效连接；提供一个三层结构应用的开发、运行、部署和管理的平台。这种三层结构在层与层之间相互独立，任何一层的改变不会影响其它层的功能。
在B／S体系结构系统中，用户通过浏览器向分布在网络上的许多服务器发出请求，服务器对浏览器的请求进行处理，将用户所需信息返回到浏览器。而其余如数据请求、加工、结果返回以及动态网页生成、对数据库的访问和应用程序的执行等工作全部由Web Server完成。随着Windows将浏览器技术植入操作系统内部，这种结构已成为当今应用软件的首选体系结构。显然B／S结构应用程序相对于传统的C／S结构应用程序是一个非常大的进步。
B／S结构的主要特点是分布性强、维护方便、开发简单且共享性强、总体拥有成本低。但数据安全性问题、对服务器要求过高、数据传输速度慢、软件的个性化特点明显降低，这些缺点是有目共睹的，难以实现传统模式下的特殊功能要求。例如通过浏览器进行大量的数据输入或进行报表的应答、专用性打印输出都比较困难和不便。此外，实现复杂的应用构造有较大的困难。虽然可以用ActiveX、Java等技术开发较为复杂的应用，但是相对于发展已非常成熟C／S的一系列应用工具来说，这些技术的开发复杂，并没有完全成熟的技术工具供使用。
2.2.2 Servlet技术
Servlet是一种服务器端的Java应用程序，具有独立于平台和协议的特性,可以生成动态的Web页面。它担当客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中间层。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。
Servlet是使用Java Servlet 应用程序设计接口（API）及相关类和方法的 Java 程序。除了 Java Servlet API，Servlet 还可以使用用以扩展和添加到 API 的 Java
共58页 第5页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
类软件包。Servlet 在启用 Java 的 Web 服务器上或应用服务器上运行并扩展了该服务器的能力。Java servlet对于Web服务器就好象Java applet对于Web浏览器。Servlet装入Web服务器并在Web服务器内执行，而applet装入Web浏览器并在Web浏览器内执行。Java Servlet API 定义了一个servlet 和Java使能的服务器之间的一个标准接口，这使得Servlets具有跨服务器平台的特性。
Servlet 通过创建一个框架来扩展服务器的能力，以提供在 Web 上进行请求和响应服务。当客户机发送请求至服务器时，服务器可以将请求信息发送给 Servlet，并让 Servlet 建立起服务器返回给客户机的响应。 当启动 Web 服务器或客户机第一次请求服务时，可以自动装入 Servlet。装入后， Servlet 继续运行直到其它客户机发出请求。
图2-1 Servlet运行过程
2.2.3 JSP技术
JSP（Java Server Pages）技术是由Sun公司发布的用于开发动态Web应用的一项技术。它以其简单易学、跨平台的特性，在众多动态Web应用程序设计语言中异军突起，在短短几年中已经形成了一套完整的规范，并广泛地应用于电子商务等各个领域中。在国内，JSP现在也得到了比较广泛的重视，得到了很好的发展，越来越多的动态网站开始采用JSP技术。JSP技术可以以一种简捷而快速的方法生成Web页面。使用JSP技术的Web页面可以很容易地显示动态内容。JSP技术的设计目的是使得构造基于Web的应用程序更加容易和快捷，而这些应用程序能够与各种Web服务器、应用服务器、浏览器和开发工具共同工作。
JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。网页还能通过tags和scriptlets访问存在于服务端的资源的应用逻辑。JSP将网页逻辑与网页设计和显示分离，支持可重用的基于组件的设计，使基于Web的应用程序的开发变得迅速和容易。Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序段，然后将执行结果连同JSP文件中的HTML代码一起返回给客户。插入的Java程序段可以操作数据库、重新定向网页等，以实现建立动态网页所需要的功能。JSP与Java Servlet一样，是在服务器端执行的，通常返回给客户端的就是一个HTML文本，因此客户端只要有浏览器就能浏览。
共58页 第6页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。Java Servlet 是JSP的技术基础，而且大型的Web应用程序的开发需要Java Servlet和JSP配合才能完成。JSP具备了Java技术的简单易用，完全的面向对象，具有平台无关性且安全可靠，主要面向因特网的所有特点。
2.2.4 Hibernate和Log4j简介
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate作为一种ORM技术，实现了对象模型和关系型数据库之间的映射。Hibernate将JavaBean对象和数据库的表建立了对应关系。这样程序员在操作数据库时，就不需要再使用JDBC调用SQL语句，而可以直接操作JavaBean对象，进行数据库操作。
Hibernate的核心接口一共有5个，分别为:Session、SessionFactory、
Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。
图2-2 Hibernate接口关系图
Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
共58页 第7页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
图2-3 Log4j类图
2.3 MySQL简介
2.3.1 MySQL概述
MySQL是一种开放源代码的关系型数据库管理系统（RDBMS），MySQL数据库系统使用最常用的数据库管理语言--结构化查询语言（SQL）进行数据库管理。MySQL是一个小型关系型数据库管理系统，开发者为瑞典MySQLAB公司，在2008年1月16号被Sun 公司收购。MySQL被广泛地应用在Internet上的中小型网站中。由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，许多中小型网站为了降低网站总体拥有成本而选择了MySQL作为网站数据库。如雅虎、阿尔卡特—朗讯、Google公司、诺基亚公司、百度等公司就采用了MySQL数据库。MySQL数据库可以称得上是目前运行速度最快的SQL语言数据库。除了具有许多其它数据库所不具备的功能和选择之外,MySQL数据库是一种完全免费的产品,用户可以直接从网上下载。
2.3.2 MySQL的优点
1、可移植性
使用C和C++编写，并使用了多种编译器进行测试，保证源代码的可移植性。 2、可扩展性和灵活性
MySQL可以支持UNIX、Linux和SUN OS以及Windows等多种操作系统平台。 在一个操作系统中实现的应用可以很方便地移植到其他操作系统。MySQL作为开
共58页 第8页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
源性质的 数据库服务器,可以为那些想要增加独特需求的用户提供完全定制的功能。
3、强大的数据保护功能
MySQL有一个非常灵活且安全的权限和密码系统。为确保只有获授权用户才 能进入该数据库服务器，所有的密码传输均采用加密形式，同时也提供了 SSH和SSI。支持，以实现安全和可靠的连接。MySQL强大的数据加密和解密功能，可以保证敏感数据不受未经授权的访问。
4、支持大型的数据库
虽然对于用PHP编写的网页来说，只要能够存放数百条以上的记录数据就是 够了，但MySQL可以方便地支持上千万条记录的数据库。作为一个开放源代码的数据库，MySQL可以针对不同的应用进行相应的修改。
5、超强的稳定性
MySQL拥有一个非常快速而且稳定的基于线程的内存分配系统，可以持续使 用而不必担心其稳定性。线程是轻量级的进程，它可以灵活地为用户提供服务，而不占用过多的系统资源。用多线程和C语言实现的MySQL能很容易地充分利用CPU。
6、强大的查询功能
MySQL支持查询的select和where语句的全部运算符和函数，并且可以在同一查询中混用来自不同数据库的表，从而使得查询变得快捷、方便。
2.4 TOMCAT简介
Tomcat是一个小型的轻量级应用服务器，是开发和调试JSP程序的首选。他运行时占用的系统资源小，扩展性好，支持负载平衡与邮件服务等开发应用系统常用的功能。Tomcat是一个免费的开放源代码的Servlet容器，它是Apache软件基金会（Apache Software Foundation）的一个顶级项目，由Apache、Sun和其他一些公司及个人共同开发而成。由于有了Sun的参与和支持，最新的Servlet和JSP规范总是能在Tomcat中得到体现，Tomcat 6支持最新的Servlet 2.5和JSP 2.1规范。因为Tomcat技术先进、性能稳定，而且免费，因而深受Java爱好者的喜爱，并得到了部分软件开发商的认可，成为目前比较流行的Web服务器。Tomcat和IIS、Apache等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache，我们可以将Apache和Tomcat集成在一起使用，Apache作为HTTP Web服务器，Tomcat作为Web容器。
共58页 第9页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
图2-4 Tomcat服务器接受客户请求并做出响应的过程
2.5 Eclipse简介
Eclipse 是一个开放源代码的、基于 Java 的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括 Java 开发工具（Java Development Tools，JDT）
Eclipse 是由一个很小的核心和基于这个核心之上的大量插件组成，这种插件式结构给当时开发社区带来了冲击，可以使用大量插件来进行扩展开发。Eclipse 对内存控制很好，Eclipse 对这些插件的调用是动态的，也就是说在使用这个插件的时候才会被调入内存，如果不去使用就不会占用内存，而且Eclipse 会在适当时候将长时间不使用的插件清理出内存。
Eclipse 拥有漂亮的开发界面，是基于SWT开发。标准部件库（Standard Widget Toolkit,SWT）是基于Java环境下的新类库，它提供了Java环境下的图形编程接口，SWT中的图形库和工具包取代了AWT和SWING。SWT直接调用操作系统的图形库，这使得Java程序的运行速度得到了保证，但是SWT的缺点是支持的平台太少，Eclipse 也可以开发基于SWING的程序。
Eclipse 还包括插件开发环境（Plug-in Development Environment，PDE），这个组件主要针对希望扩展 Eclipse 的软件开发人员，因为它允许他们构建与Eclipse 环境无缝集成的工具。由于 Eclipse 中的每样东西都是插件，对于给 Eclipse 提供插件，以及给用户提供一致和统一的集成开发环境而言，所有工具开发人员都具有同等的发挥场所。
共58页 第10页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
3.可行性研究与需求分析
3.1 可行性研究
可行性分析是对现行系统进行初步调查和研究之后的结论，它反映了新系统开发策略。下面分别从社会可行性、技术可行性以及经济可行性三方面进行可行性分析。
3.1.1社会可行性分析
由于医院住院病人数量众多,因而通过电脑化操作可以减少纸张的使用,同时由于数据直接通过局域网传输,可以减少信息传递时间,提高效率,同时也方便医生,病人搜查相关住院信息,提高医院工作透明度和工作效率。因此从社会可行性分析角度来说， 该系统的开发和设计是可行的。
3.1.2 技术可行性分析
本系统是一个基于B/S结构的医院住院信息管理系统，采用面向对象技术、数据库技术、各种JAVA流行框架的应用等JAVA WEB先进技术开发的应用程序，现有的开发技术已非常成熟，且被广泛应用于各行各业，利用现有技术完全可以达到功能目标。
其中软件主要使用Eclipse、TOMCAT二者都是开源免费开发组件，数据库采用MySQL。该管理系统以JAVA为主要开发语言，通过DAO方式与后台数据库MySQL相连接,建立了一个基于B/S（浏览器/服务器）的数据库应用管理系统。维护工作方便,由于MySQL的易用性,使得后台的操作十分便捷,操作人员可以在短时间内完全掌握系统的维护工作。在硬件方面，随着它的不断发展，给设计人员更大的灵活性，使研制周期变短，使复杂的设计轻而易举得以实现。
医院住院管理系统在技术可行性上完全可以胜任,由于本医院住院管理系统,采用MySQL数据库,以及JAVA语言。JAVA语言的跨平台、安全性等特性，和众多优秀开源的框架的使用，因此在技术可行性上完全能够完成。
3.1.3 经济可行性
在经济上，本系统只是对医院中的住院部进行设计，医院住院部门是医院必不可少的部分，是医院主要的收入来源，通过本系统的开发设计，使得医院住院管理更加流程化，方便，减轻医院住院部门的压力。除此之外，在可扩充性方面,系统采用生命周期法把一个复杂的系统开发工作分解成一些相对独立的部分，可以分阶段实施，
共58页 第11页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
为以后的扩充提供方便，随着医院规模的扩大，可以扩充其它的功能，而不须对系统的软硬件作大的改动，从而满足中小型医院扩建的要求。采用本系统后，医院不但可以减少医院工作人员的工作量，减少工作人员数量，还可以提高工作效率，减少病人等待时间，从而更有利于医院的发展和以后的竞争。本系统对设备要求不高，普通的服务器和几台客户机完全可以胜任本系统的运行，因此在设备费用方面将不会十分巨大。软件开发过程中，主要是针对住院管理部门过程中的开发及后台业务管理。住院管理部门是医院人流量最大，也最频繁的，一个好的信息管理系统将显著提高医院住院部门的工作效率，从而进一步提高医院的经济效益，而传统的手工操作不仅效率低下、工作人员容易犯错，而且不会提高医院的经济效益。本系统设计时从用户角度出发，界面美观，操作可视化，提供很多的提示信息，管理流程简单易懂，对医院工作人员来说容易上手。另外，系统开发时，充分考虑到，系统以后的可能扩展，因此对于二次开发，将会更加方便，也即是说，系统的适应性很强，可以长期使用。最后，对于每个住院部门,可以根据自己需要,配置性能一般的计算机做为终端,向服务器存储数据或搜索数据。
根据分析研究，使用本套住院信息管理系统对于整个住院部门来说并不是一个很大的负担，因而在经济上是可行的。
3.1.4 可行性分析结论
通过在社会、技术、经济三方面的可行性研究分析，发现系统的开发满足这三方面的要求，因此一致认为系统应该立即开发。
3.2 需求分析
3.2.1 系统的目的
利用计算机管理，使医院的日常工作简单化和规范化，缩短住院办手续的时间，同时对员工的管理工作增加了透明度，进而使医院的各项资源得到更加充分的利用。具体的目的包括：
(1)加快办理病人入院、出院的速度，实现病人的资料在住院的全过程中实现信息化管理；
(2)准确记录病人和床位的各项信息，并提供全方位的查询功能，让病人、医生、护士，能够及时准确的掌握病人和床位的各种信息，从而有效提高工作效率，缩短工作时间。
(3)系统具有一定的安全性和运行稳定性、可扩展性。系统需要医院员工输入账号和密码才能操作，可以避免其它人员的恶意操作给医院信息带来的损失。
共58页 第12页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
(4)系统能够提供一个界面友好、功能完善的信息管理系统，方面医护人员学习和操作，尽可能的简化医院操作，减少医护人员学习和掌握系统的时间。
3.2.2 目标
本系统主要实现与病人相关的各种信息的系统化、规范化和自动化，本住院管理系统主要完成的功能有：
★出入院管理模块。包括入院登记、病人出院操作。
★病房管理模块。包括对病房的增删改查（CRUD）操作，支持多种查询条件 ★病人管理模块。包括对病人信息的维护：增删改查操作。支持多种查询条件 ★系统管理模块。包括对修改用户、添加用户、删除用户、退出系统 ★系统功能模块。包括首页、前进、后退、刷新等操作和显示当前时间
3.3 医院住院管理系统数据流图
医护人员登陆系统 管理员登陆系统 医院住院管理系统 用户信息 病房信息 病人信息 病人出入院信息 图3-1 医院住院管理系统顶层
共58页 第13页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
医护人员登陆系统 对病人信息的维护、CRUD操作 入院登记出院操作对病房信息的维护、CRUD操作 出入院管理 病房信息管理 病人信息管理 病房信息 病人信息 病人出入院信息 用户信息
系统用户管理 护对、病房 信 操 息作的 维 管理员登陆系统
图3-2 医院住院管理系统第一层
CRUD 共58页 第14页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
医护人员 输入病人 详细信息 根据病人信息设置各种查询条件，查询病人信息根据病人信息设置各种对病房信息进行管理，增查询条件，查询病人信息删改操作 入院登记 出院操作 病 房信息 管理 病 房信息查询 病 人信息管理 病 人信息 查询 用 户信息管理 用 户信息 管理 病人信息表、病人-病房对应表、病房信息表 病人-病房对应表、病房信息表 病房信息表 通过设置各种查询条件，方便查询操作 病房信息表 对病人信息进行管理，增删改操作 病人信息表 通过设置各种查询条件，方便查询操作 病人信息表 管理员 对用户信息进行管理，增删改操作 用户信息表 根据病人信息设置各种通过设置各种查询条件，查询条件，查询病人信息方便查询操作 用户信息表
图3-3 医院住院管理系统第二层
共58页 第15页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
4.总体设计
4.1 系统总体设计思想
系统采用JSP + SERVLET开发，采用当前最流行的JAVA WEB开发模式MVC，采用分层的思想，从系统中分出持久层，使用Hibernate作为持久层的开发工具，MVC开发模式流程图如下所示：
方法调用
（视图） 显示模型的业务数据 接受用户请求 把用户输入数据传给控制器 业务数据查询 （模型） 包含业务数据 响应业务数据查询 处理业务逻辑 通知视图业务数据更新 选择视图 （控制器） 接受用户请求 调用模型响应用户请求 选择视图显示响应结果 业务处理 用户请求 通知业务数据更新
图4-1 MVC流程图
控制层获取持久层dao时，采用工厂模式，即先初始化dao实例放到工厂中，然后如果控制层或者视图层获取访问某个表的dao的话，即通过工厂获取该dao的实例。系统模块功能分开开发，容易扩展，每个模块功能单独、明确。为了能够实现分页显示信息，除了数据库中采用分页查询外，系统中封装分页信息类，这样，每次访问数据库中查询数据时，就必须先构造分页信息对象，如此实现查询分页显示功能。通过构造过滤器，来加强系统的安全性和适用性，本系统中通过tomcat配置了两个过滤器，一个是编码过滤器，已解决普遍存在的中文乱码问题，另一个是URL地址过滤器，为了能够防止外部用户的不合法的访问，使系统更加安全和数据更加安全。最主要的是，通过一个合理的架构设计，以使系统达到一个很好的可扩展性。
共58页 第16页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
4.2 系统功能模块图
住院管理系统 系病 统人 用管 户理 管 理 病人信息管理 修新删批 改增除量病病病删 人人人 除信信 信病 息 息息 人 信 息 按按 病科病 人室房 信名 编息称 号查 查查询 询 询 图4-2 系统功能模块图
出入院管理 用户信息管理 病房管理 入院登记 出院操作 病房信息管理 病房信息查询 新增用户信息 修改用户信息 批量删除用户信息 删除用户信息 病人信息查询 按用户姓名和性别查询 按用户名查询 新增病房信息 修改病房信息 删除病房信息 批量删除病房信息 按病房类型和病房状态查询 按病人姓名和病人性别查询 按病人编号查询 按病房编号查询 共58页 第17页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
4.3系统的流程图
N 输入用户名和密码 登陆界面 医护人员 出入病房管理 病人管理 院管理 病病 病 房出房入 人信信院院 信息操息登 息查管作 管记 询 理 理 病人信息病人-病房对应信息 病房信息 病房信息管理 系统用户信息 病房信息查询
图4-3系统流程图
输入是否正确 Y 用户类型 管理员 病人信息查询 系统用户管理 共58页 第18页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
5.详细设计
5.1 数据库设计的E-R图
1)实体及其属性
·病人：住院编号，病人姓名，病人性别，病人入院时间，病人婚姻状态，病人出生地
·病房：病房编号，病房类型，病房租金，病房状态，病房所属科室，病房负责人，病房床位数，病房医生，病房医生号码。
各个实体间有如下关系：
·一个病人只能入住一个病房，而一个病房可以住多名病人 2)E-R图：见图5-1，图中的1表示实体与实体间的对应关系是一对一，“m”“n”表示实体与实体间的关系是一对多。
出生地 ID
住院编号 病人病人 姓名 性别 病人 入院时间 婚姻状态 n 入住 病房负责病房床位数 ID 1 病房 病房医生 病房医生号码 病房编号 病房类型 病房租金 病房状态 病房所属科室
图 5-1 本系统数据库E-R图
共58页 第19页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
5.2 数据库设计
数据库设计是整个程序设计的最关键部分。数据库的设计是否合理，将对数据库的大小、代码的优化起到至关重要的作用。因此，在设计程序前必须对数据库进行设计，而在设计数据库前必须对所要完成的功能进行认真的研究分析。
根据系统的要求，需要建立存放系统使用过程中所用到的各种信息表：用户表，病人信息表，病房信息表，病人病房对应表。
1) 用户表：用来存放使用此系统的用户的信息。表具体结构如表5-1所示。
表5-1 用户信息表
编号 1 2 3 4 字段名称 数据结构 ID int USER_NAME varchar USER_REALNAMvarchar E USER_TYPE tinyint 可否为空 否 否 否 否 说明 用户名 用户姓名 用户类型，0为医护人员，1为管理员 密码 用户性别，0为男，1为女，默认为男 用户电话 用户地址 5 6 7 8 PASSWORD varchar USER_GENDER tinyint USER_TEL USER_ADDR varchar varchar 否 否 否 否 2)病人信息表：存放病人信息。表具体结构如表5-2所示
表 5-2病人信息表 编号 1 2 3 4 5 6 7 字段名称 ID HOSPITAL_NUM PATIENT_NAME PATIENT_GENDER PATIENT_BIRTHDAY PATIENT_MARRY PATIENT_BIRTHPLACE 数据结构 int varchar varchar tinyint date tinyint varchar 可否为空 否 否 否 否 可 可 可 说明 病人住院编号，由系统自动生成 病人姓名 病人性别，0为男，1为女，默认为男 病人入院时间 病人婚姻状况，0为已婚，1为未婚 病人出生地
3)病房信息表：存放病房信息。表具体结构如表5-3所示。
共58页 第20页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
表 5-3病房信息表 编号 1 2 3 字段名称 ID WARD_NUM WARD_TYPE 数据结构 int varchar tinyint 可否为空 否 否 否 4 5 6 WARD_RENT WARD_STATE double tinyint 否 否 否 WARD_DEPARTtinyint MENT 7 8 9 10 WARD_RESPNAvarchar ME WARD_BEDNUM int WARD_DOCTOR varchar WARD_DOCTORvarcher TEL 否 否 否 否 说明 病房编号 房间类型，0为单人间，1为双人间，2为四人间，3为六人间 病房租金 病房使用状态，0为可用，1为已满 病房所属科室，0为内儿科，1为妇产科，2为外科，3为骨伤科 病房负责人 病房床位数 病房管理医生 病房管理医生号码
4)病人-病房对应表：存放病人住院信息。表具体结构如表5-4所示
表 5-4病人-病房对应表
编号 1 2 3
字段名称 数据结构 ID int HOSPITAL_NUM varchar WARD_NUM varchar 可否为空 否 否 否 说明 住院编号 病房编号 5.3 输入输出设计
5.3.1 输入设计
输入数据是为了在计算机内进行加工处理而从外部接收数据，它的正确与否对于整个系统质量的好坏是起决定作用的。
1)设计原则 第一，尽量采用人机对话方式输入数据；
第二，输入格式的设计要便于填写，便于归档，尽量减少汉字输入以减轻输入设计过程，保证输入精度；
第三，输入数据的校核工作尽量由程序来保证。
共58页 第21页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
2)输入设计
输入设备为键盘。输入方式为文本输入方式。
5.3.2 输出设计
输出设计的目的是使系统能够输出满足用户需求的有用信息。 1) 设计原则
第一，表格输出要实用、方便、考虑用户已经习惯的输出格式； 第二，输出表格要考虑系统发展的需要；
第三，屏幕输出格式要清晰，重要数据要显示在突出位置上。 2) 输出设备
输出设备为显示器，输出格式举例如下：
序号 住院编号 病人姓名 入院时间 费用类型 基本操作
5.3.3 输入输出的界面设计
1)人机对话部分是人和计算机联系的主要途径，该部分主要从用户操作方便的角度出发进行考虑，主要有选项卡、数据列表框、数据组合框、文本框、按钮等形式。 2)设计的系统界面从简，避免了复杂界面给用户造成的困惑。输入界面色彩鲜艳会给操作员带来疲劳，界面灰暗又会影响用户的心情，因此，在设计输入界面时采用了柔和色彩，减轻了操作员因长时间工作而感到的劳顿。
5.4 部分页面和代码设计、描述
5.4.1登录功能及其相关设计
登录界面设计
共58页 第22页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
图5-2 登录界面
功能描述
输入URL地址，访问住院管理系统，首先映入眼帘的是一个登陆界面，如上图所示。根据提示，不同的操作员输入各自的用户号和登录口令。其中用户号会根据输入的正确与否从后台数据库“ACCOUNT”表中自动提取。输入正确，点击“确认”按钮登录系统，转到主界面；若用户不存在，则提示用户名错误；若用户密码不正确，则提示密码错误；
主要代码设计
//获取用户名和密码
String userName = req.getParameter(\"username\"); String password = req.getParameter(\"password\"); log.debug(\"用户\"+userName+\"请求登陆系统\"); AccountDAO adao = (AccountDAO)DAOFactory.getDAO(AccountDAO.class.getName()); Account account = adao.findAccountByName(userName); log.debug(\"用户\"+account); //提示错误信息，如何提示 if(account == null){
req.setAttribute(\"errorMessage\", \"用户名错误\");
req.getRequestDispatcher(\"login.jsp\").forward(req, resp); return; }
if(!password.equals(account.getPassword())){ req.setAttribute(\"errorMessage\", \"密码错误\");
共58页 第23页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
req.getRequestDispatcher(\"login.jsp\").forward(req, resp); return; }
req.getSession().setAttribute(\"isLogin\", true); req.getSession().setAttribute(\"account\", account); resp.sendRedirect(\"main.jsp\");
5.4.2入院登记及其相关设计
入院登记界面设计
图5-3 入院登记界面
功能描述
医护人员通过登记病人的详细信息，和为病人分配床位，实现病人的入院登记操作，这是病人住院的首要操作。登记时会检测病房的状态，若病房已满，则提示【住院失败，该房间已满】，若无该房间，则提示【住院失败，无该房间号！！！】，若登记成功，则会提示【登记成功！！！】，登记成功后，将病人信息存入【病人信息表中】，并将病人入院信息存入【病人-病房对应表中】，若此时房间满员，则更改房间状态为“已满”。存病人信息时，有系统自动生成住院编号，分配给该住院病人。
共58页 第24页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
入院登记主要代码设计
//获得床位信息 ① String wardNum = req.getParameter(\"wardnum\"); WardInfoDAO widao = (WardInfoDAO)DAOFactory.getDAO(WardInfoDAO.class.getName()); WardInfo wi = widao.getWardInfoByWardNum(wardNum); //如果无该房间 if(wi == null){
resp.sendRedirect(\"inHospitalRegister.jsp?result=1\"); return;
}else if(wi.getWardState() == 1){ //如果该房间状态为已满 resp.sendRedirect(\"inHospitalRegister.jsp?result=2\"); return; }
② //系统自动生成住院编号
patientInfo.setHospitalNum(pidao.getNextHospitalNum()); //包存病人信息
pidao.savePatientInfo(patientInfo); PatientWardMapDAO pwmdao = (PatientWardMapDAO)DAOFactory.getDAO(PatientWardMapDAO.class.getName());
PatientWardMap pwm = new PatientWardMap();
pwm.setHospitalNum(patientInfo.getHospitalNum()); pwm.setWardNum(req.getParameter(\"wardnum\")); //病人入院，建立关系
pwmdao.savePatientWardMap(pwm); //更改房间状态 int count = pwmdao.findPatientWardMapByWardNum(req.getParameter(\"wardnum\")).size();
log.info(\"已入住\"+count);
log.info(\"一共能入住\"+wi.getWardBednum()); if(wi.getWardBednum() == count){ wi.setWardState(1);
widao.updateWardInfo(wi); }
resp.sendRedirect(\"inHospitalRegister.jsp?success=true\");
5.4.3出院操作及其相关设计
出院操作界面设计
共58页 第25页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
图5-4出院操作界面
功能描述
医护人员通过执行此操作，进行病人出院操作。该功能模块提供三种查询病人信息的方法，分别为根据病人姓名和性别来查询、根据病房编号来查询、根据住院编号来查询，这样可以让医护人员工作更加方便、快捷的完成操作。出院时更新该病人所住房间的状态为可用，然后删除【病人-病房对应表中】相应的病人入院记录，并提示【出院操作成功！！！】，从而完成该病人的出院操作，方便、快捷、步骤简单。
出院操作主要代码设计
if(search == 0){ //查询1
PatientInfo patientInfo = new PatientInfo();
String patientName = req.getParameter(\"patientname\"); int patientGender = new Integer(req.getParameter(\"patientgender\")); patientInfo.setPatientName(patientName);
patientInfo.setPatientGender(patientGender);
patientInfos = pidao.queryListWithCondition(patientInfo); maps = pwmdao.findPatientWardMapByListPatientInfo(patientInfos); }else if(search == 1){ //查询2
PatientInfo patientInfo = new PatientInfo();
String hospitalNum = req.getParameter(\"hospitalnum\"); patientInfo.setHospitalNum(hospitalNum);
patientInfos = pidao.queryListWithCondition(patientInfo); maps = pwmdao.findPatientWardMapByListPatientInfo(patientInfos);
共58页 第26页
┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊
安徽工业大学 毕业设计（论文）说明书
}else if(search == 2){ //查询3
String wardNum = req.getParameter(\"wardnum\"); List maps = pidao.queryListWithHospitalNums(pwms); }else if(search == 3) { //出院操作 //更改房间的状态为可用 Integer id = new Integer(req.getParameter(\"id\")); String wardNum = pwmdao.getPatientWardMapById(id).getWardNum(); WardInfo wi = widao.getWardInfoByWardNum(wardNum); wi.setWardState(0); widao.updateWardInfo(wi); //删除相应的关联关系 pwmdao.deletePatientWardMapById(id); req.setAttribute(\"success\", true); resp.sendRedirect(\"outHospitalOperator.jsp?success=true\"); return; } 5.4.4病房信息管理及其相关设计 病房信息管理界面设计 图5-5 病房信息管理界面设计 功能描述 共58页 第27页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 医院相关工作人员，可以通过该功能，实现对病房信息的管理包括增删改，本模块能够实现信息的分页显示，通过设置分页信息，让信息数据分页显示，方便工作人员查看。通过该功能模块，能够实现病房信息的添加，工作人员填写相关病房信息，如租金等后单击保存即可成功添加一条病房信息，同样，病房的编号，也会由系统自动生成。也可以实现病房信息的修改，修改完需要修改的信息后，单击保存将会改变相应的病房信息。支持删除和批量删除病房信息，删除之前若用户未勾选任何一条记录，则会提示【请先选中某条记录！！！】。 病房信息管理主要代码设计 //获得分页信息 PageInfo pageInfo = (PageInfo)req.getAttribute(\"PageInfo\"); //若无分页信息，则构建第一页的分页信息 if(null == pageInfo){ pageInfo = new PageInfo(); pageInfo.setStartIndex(0); pageInfo.setEndIndex(pageInfo.getStartIndex()+pageInfo.getCurrentRecordCount()); pageInfo.setPageNum(1); } WardInfoDAO widao = (WardInfoDAO)DAOFactory.getDAO(WardInfoDAO.class.getName()); List req.setAttribute(\"PageInfo\",pageInfo); req.setAttribute(\"wardInfos\", wardInfos); req.getRequestDispatcher(\"/wardmanage/wardInfoManage.jsp\").forward(req, resp); 5.4.5病房信息查询及其相关设计 病房信息查询界面设计 共58页 第28页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 图5-6 病房信息查询界面设计 功能描述 医护人员通过执行此操作，进行病房查询操作。该功能模块提供三种查询病房信息的方法，分别为根据病房类型和病房状态来查询、根据病房编号来查询、根据科室名称来查询，这样可以让医护人员工作更加方便、快捷的完成操作。通过设定多种构建查询条件的方式，让用户能够通过各种角度获得所关心的数据。 5.4.6病人信息管理及其相关设计 病人信息管理界面设计 共58页 第29页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 图5-7 病人信息管理界面设计 功能描述 医院相关工作人员，可以通过该功能，实现对病人信息的管理包括增删改，本模块能够实现信息的分页显示，通过设置分页信息，让信息数据分页显示，方便工作人员查看。通过该功能模块，能够实现病人信息的添加，工作人员填写相关病人信息，如租金等后单击保存即可成功添加一条病人信息，同样，病人的编号，也会由系统自动生成。也可以实现病人信息的修改，修改完需要修改的信息后，单击保存将会改变相应的病人信息。支持删除和批量删除病人信息，删除之前若用户未勾选任何一条记录，则会提示【请先选中某条记录！！！】。 5.4.7病人信息查询及其相关设计 病人信息查询界面设计 共58页 第30页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 图5-8 病人信息查询界面设计 功能描述 医护人员通过执行此操作，进行病人查询操作。该功能模块提供三种查询病房信息的方法，分别为根据病人姓名和病房性别来查询、根据病人编号来查询、根据病房编号来查询，这样可以让医护人员工作更加方便、快捷的完成操作。通过设定多种构建查询条件的方式，让用户能够通过各种角度获得所关心的数据。 5.4.8系统用户信息管理及其相关设计 系统用户信息管理界面设计 共58页 第31页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 图5-9 系统用户信息管理界面设计 功能描述 系统管理人员，可以通过该功能，实现对系统用户信息的管理包括增删改，本模块能够实现信息的分页显示，通过设置分页信息，让信息数据分页显示，方便工作人员查看。通过该功能模块，能够实现系统用户信息的添加，工作人员填写相关系统用户信息，如用户名、密码和用户类型等后单击保存即可成功添加一条系统用户信息。也可以实现系统用户信息的修改，修改完需要修改的信息后，单击保存将会改变相应的系统用户信息。支持删除和批量删除系统用户信息，删除之前若用户未勾选任何一条记录，则会提示【请先选中某条记录！！！】。 5.4.9系统用户信息查询及其相关设计 系统用户信息查询界面设计 共58页 第32页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 图5-10 系统用户信息查询界面设计 功能描述 系统管理人员通过执行此操作，进行用户查询操作。该功能模块提供两种查询系统用户信息的方法，分别为根据系统用户姓名和系统用户性别来查询、根据系统用户名来查询，这样可以让系统管理人员工作更加方便、快捷的完成操作。通过设定多种构建查询条件的方式，让用户能够通过各种角度获得所关心的数据。 5.5 DAO层代码设计与描述 系统采用分层的思想架构，从中分出DAO层（持久层），并采用Hibernate实现该部分功能，以下对部分DAO代码进行描述： /** * 根据条件查询用户列表 * @param account * @return */ public List 共58页 第33页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 // if(userName != null && !\"\".equals(userName)){ //添加等于条件 criteria.add(Restrictions.eq(\"userName\", userName)); } Integer userGender = account.getUserGender(); if(userGender != null){ criteria.add(Restrictions.eq(\"userGender\", userGender)); } String userRealName = account.getUserRealName(); if(userRealName != null && !\"\".equals(userRealName)){ criteria.add(Restrictions.eq(\"userRealName\", userRealName)); } String departmentNum = patientInfo. //查询结果 List list = criteria.list(); session.close(); List return accounts; pageInfo.setPageCount((int)(Math.ceil((double)pageInfo.getTotalRecordCount()/pageInfo.getCurrentRecordCount()))); //查询根据分页信息的结果 query = session.createQuery(\"from WardInfo wardInfo order by wardInfo.id desc\"); //其实索引 query.setFirstResult(pageInfo.getStartIndex()); //每一页最大记录 query.setMaxResults(pageInfo.getCurrentRecordCount()); list = query.list(); session.close(); List } } /** * 根据分页信息查询病房信息列表 * @param pageInfo 部分分页信息 * @return */ public List 共58页 第34页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 6.系统测试 6.1功能测试 系统测试是保证质量和可靠性的关键步骤，是对系统开发过程中的系统分析、系统设计和实施的最后复查，因此为了使系统能够更好的为用户服务、发现系统潜在的问题和缺陷，系统最后进行了一轮简单的功能测试，以使系统具有更高的安全性。Functional testing (功能测试)，也称为behavioral testing（行为测试），根据产品特征、操作描述和用户方案，测试一个产品的特性和可操作行为以确定它们满足设计需求。本地化软件的功能测试，用于验证应用程序或网站对目标用户能正确工作。使用适当的平台、浏览器和测试脚本，以保证目标用户的体验将足够好，就像应用程序是专门为该市场开发的一样。功能测试也叫黑盒子测试或数据驱动测试,只需考虑各个功能，不需要考虑整个软件的内部结构及代码.一般从软件产品的界面、架构出发，按照需求编写出来的测试用例，输入数据在预期结果和实际结果之间进行评测,进而提出更加使产品达到用户使用的要求。 6.2测试结果 经过简单的功能测试，发现系统基本上满足功能需求，并在此基础上测试出一些问题，测试问题总结如下： 1、由于数据在网络传输时采用的是ISO-8859-1编码，该编码只支持英文传输，因此这就造成了网页显示及数据库存储产生乱码的问题。这个乱码问题是最让我头疼的，查了好多资料都没能彻底解决，后来自己慢慢根据前几次的经验，将所有编码都设置为utf-8，Mysql也为utf-8。同时在程序中配置了一个编码格式过滤器，通过该过滤器将网络中传输的数据格式都转换为utf-8的格式，最终解决了编码问题。 2、在页面进行数据传递时，使用 request.setAttribute(“property”,”value”)，而后使用了 response.sendRedirect(“url”)进行页面的转向，欲在另外一个页面中使用request.getAttribute(“property”)却始终无法取到相应的值。后来上网百度了之后才知道这种页面转向是无法完成页面间数据传递的。后来使用了 request.getRequestDispatcher(\"url\").forward(request, response);这种方法终于实现了页面间的转向并可以在页面间进行数据的传递。 3、在进行各种处理时经常会使用到字符串的连接操作。开始我使用的方法大致如下： String s=null; String id=\"121\"; s=s+id; 然后再对字符串s进行各种操作，但是始终都无法得到想要的结果。后来使用单 共58页 第35页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 步测试的方法才发现这种连接字符串的结果竟然是： s=”null121”; 后来我将s的初值设置为空字符串(s=””;)，然后再进行各种操作，终得到想要的结果。 4、在JSP页面中会使用到checkbox这个标签，在在线测试模块中测试试题中有单选题和多选题这两种题型，其中多选题的选项是使用一组checkbox(4个)来实现的。那么如何取得这一组checkbox的值将直接关系到后面的业务逻辑处理。 String[] str = request.getParameterValues(\"a\"); //a为表单中checkbox的名称 String str1 = \"\"; int i=0; while (i < str.length) { str1 += str[i]; i++; } 使用上述方法取得表单数据时，只要这一组checkbox中有一个被选中，那么该方法都能得到正确的表单参数。但是当这一组checkbox中没有一个标签被选中的时候，那么使用这个方法就会出现错误，不能正确的得到表单中的数据。这个问题困扰了我好几天，后来才想起来若str这个数组的值为null的话，那么其就没有length这个属性值，不能使用i < str.length这个比较条件。因此将上述部分改成下面的后，程序运行正确。 String[] str = request.getParameterValues(\"a\"); String str1 = \"\"; int i=0; if (str == null) { str1=null; } else { while (i < str.length) { str1 += str[i]; i++; } } 共58页 第36页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 结 论 本次毕业设计，我学到了很多东西，无论是在知识的掌握方面，还是在经验的积累方面，都收获颇丰。独立开发一个小型医院住院管理系统，从接受毕业设计的任务，到熟悉软件开发环境，再到集中精力开发系统，整个过程中遇到了很多问题，我学着自己解决这些问题，在解决问题的过程中，学到了很多有用的东西。过程不是一帆风顺，但却真的令我受益匪浅。 第一，关于程序设计方面，选择JAVA是因为对JAVA比较熟悉，也用JAVA开发过项目，很多开源框架，技术水平很多，容易搭建系统环境，但随着设计的逐步向前推进，发现自己欠缺的是实践经验以及对很多基本概念的深入理解。而在数据库方面，由于要用到SQL语句，就将数据库中关于SQL语句部分重新温习了一遍，但仅仅这些是不够的，还查阅了很多相关资料和帮助，对SQL语句有了更加深入全面的了解。 第二，在积累经验方面，使用的集成开发环境是Eclipse，用的是MySQL的数据库，在设计的过程中对如何使用这两个系统积累了一些很有价值的经验，尤其是对在JAVA语言下进行数据访问的相关程序设计方面，了解了很多知识，熟悉使用JAVA持久层框架Hibernate的使用。 第三，这次设计的基于B/S结构的医院住院管理信息系统，其功能基本符合用户需求，能够完成简单的医院住院工作人员的部分功能，减轻工作负担，提高工作效率。对于数据的一致性的也通过程序进行了有效的解决。但是由于毕业设计时间较短，所以该系统还有许多不尽如人意的地方，比如联机文档比较少，用户界面不够美观，出错处理不够等多方面问题。这些都有待进一步改善。 共58页 第37页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 致 谢 本设计在边琼芳老师的悉心指导和严格要求下业已完成，从课题选择、方案论证到具体设计和调试，无不凝聚着边老师的心血和汗水，在四年的本科学习和生活期间，也始终感受着导师的精心指导和无私的关怀，我受益匪浅。在此向边老师表示深深的感谢和崇高的敬意。 不积跬步何以至千里，本设计能够顺利的完成，也归功于各位任课老师的认真负责，使我能够很好的掌握和运用专业知识，并在设计中得以体现。正是有了他们的悉心帮助和支持，才使我的毕业论文工作顺利完成，在此向安徽工业大学大学，计算机科学与技术系的全体老师表示由衷的谢意。感谢他们四年来的辛勤栽培。 转眼间，大学生活即将结束，回首过去四年的大学生活，真是有苦也有乐，然而更多的则是收获，感谢母校的各位老师不但无私地传授给我们知识，也教会了我们如何做人。本设计牵涉到管理信息系统的知识，管理信息系统方面的设计与实现任务繁重，但正是在这几个月紧张而充实的设计中，我感到自己的知识得到了一次升华，我相信：我的毕业设计会给我的四年大学画上一个圆满的句号。 人们自然对未来有许多美好的愿望和设想。现代科学技术的飞速发展，改变了世界，也改变了世界的生活。作为一名合格优秀的安工大毕业大学生，应当站在世界的发展前列，掌握现代科学技术知识，调整自己的知识结构和能力结构，以适应社会发展的要求。新世纪需要具有丰富现代科学知识、能够独立解决面临任务、有创新意识的新型人才。 共58页 第38页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 主要参考文献 [1] 萨师煊,王珊.《数据库系统概论》.高等教育出版社，2000年 [2] 孙卫琴,李洪成.《Tomcat 与 Java Web 开发技术详解》.电子工业出版社,2003年 [3] BruceEckel.《thinking in java》. 机械工业出版社,2003年 [4] FLANAGAN.《Java技术手册》. 中国电力出版社,2002年 [5] 孙一林,彭波.《Java数据库编程实例》. 清华大学出版社,2002年 [6] 黄佩虹.精通Hibernate—Java数据库持久层开发核心编程.清华大学出版社, 2008年 [7] Cay S.Horstmann.JAVA2核心技术卷1：基础知识.机械工业出版社,2006年 [8] 张孝祥.深入体验Java_Web开发内幕-核心基础.电子工业出版社出版社,2006年 [9] 飞思科技产品研发中心.《JSP应用开发详解》.电子工业出版社,2003年 共58页 第39页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 附录一 实现本系统的部分源代码 URLFilter.java package filter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import org.apache.log4j.Logger; /** * 防止用户直接通过URL请求来访问页面 * * @author pxm * */ public class URLFilter implements Filter { private FilterConfig filterConfig; private static final Logger log = Logger.getLogger(URLFilter.class); @Override public void destroy() { filterConfig = null; } @Override public void doFilter(ServletRequest srequest, ServletResponse sresponse, FilterChain filterChain) throws IOException, ServletException { HttpServletRequest request = (HttpServletRequest) srequest; HttpServletResponse response = (HttpServletResponse) sresponse; HttpSession session = request.getSession(); // isLogin判断用户是否登录，登陆成功则置为true Boolean isLogin = (Boolean) session.getAttribute(\"isLogin\"); if (isLogin == null) { isLogin = false; } String path = request.getServletPath(); // 如果是做操作，但是用户未登录，且不是做登录操作，则拒绝操作 if (!isLogin && (!\"/system/login.jsp\".equals(path) && !\"/system/login.do\" 共58页 第40页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 .equals(path))) { log.debug(\"用户未登录，试图直接访问\"); response.sendRedirect(\"/his/system/login.jsp\"); return; } filterChain.doFilter(srequest, sresponse); } @Override public void init(FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; } public void setFilterConfig(final FilterConfig filterConfig) { this.filterConfig = filterConfig; } public FilterConfig getFilterConfig() { return filterConfig; } } EncodingFilter.java package filter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import org.apache.log4j.Logger; public class EncodingFilter implements Filter { private FilterConfig filterConfig; private static final Logger log = Logger.getLogger(EncodingFilter.class); private String encodingName; private String enable; public EncodingFilter() { encodingName = \"utf-8\"; enable = \"true\"; } @Override public void destroy() { 共58页 第41页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 filterConfig = null; } @Override public void doFilter(ServletRequest srequest, ServletResponse sresponse, FilterChain filterChain) throws IOException, ServletException { if (\"true\".equalsIgnoreCase(enable)) { srequest.setCharacterEncoding(this.encodingName); log.debug(\"设置编码为\"+encodingName); } filterChain.doFilter(srequest, sresponse); } @Override public void init(FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; encodingName = filterConfig.getInitParameter(\"EncodingName\"); enable = filterConfig.getInitParameter(\"Enable\"); } public void setFilterConfig(final FilterConfig filterConfig) { this.filterConfig = filterConfig; } public FilterConfig getFilterConfig() { return filterConfig; } } DAOFactory.java package controller; import java.util.HashMap; import dao.AccountDAO; import dao.PatientWardMapDAO; import dao.WardInfoDAO; import dao.IDAO; import dao.PatientInfoDAO; public class DAOFactory { private static HashMap static{ daoMap.put(AccountDAO.class.getName(), new AccountDAO()); daoMap.put(PatientInfoDAO.class.getName(), new PatientInfoDAO()); daoMap.put(WardInfoDAO.class.getName(), new WardInfoDAO()); 共58页 第42页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 daoMap.put(PatientWardMapDAO.class.getName(), new PatientWardMapDAO()); } private DAOFactory(){ } public static IDAO getDAO(String name){ return daoMap.get(name); } } AccountDAO.java package dao; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import org.apache.log4j.Logger; import org.hibernate.Criteria; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.criterion.Order; import org.hibernate.criterion.Restrictions; import controller.pageinfo.PageInfo; import dao.po.Account; /** * 针对账户表的操作，包括根据用户名查找账户 * @author pxm * */ public class AccountDAO implements IDAO{ private Session session = null; private Transaction transaction = null; private Query query = null; private Criteria criteria = null; private static Logger log = Logger.getLogger(AccountDAO.class); public Account findAccountByName(String userName){ session = MySessionFactory.getSession(); query = session.createQuery(\"from Account account where account.userName =:username\"); query.setString(\"username\", userName); List list = query.list(); 共58页 第43页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 session.close(); //用户名唯一 if(list == null || list.size() == 0){ return null; } return (Account)list.get(0); } public Account getAccountById(Integer id){ session = MySessionFactory.getSession(); query = session.createQuery(\"from Account account where account.id =?\"); query.setInteger(0, id); List list = query.list(); session.close(); //用户名唯一 if(list == null || list.size() == 0){ return null; } return (Account)list.get(0); } public List query = session.createQuery(\"select count(*) from Account\"); List list = query.list(); pageInfo.setTotalRecordCount(((Long)(list.get(0))).intValue()); pageInfo.setPageCount((int)(Math.ceil((double)pageInfo.getTotalRecordCount()/pageInfo.getCurrentRecordCount()))); query = session.createQuery(\"from Account account order by account.id desc\"); query.setFirstResult(pageInfo.getStartIndex()); query.setMaxResults(pageInfo.getCurrentRecordCount()); list = query.list(); session.close(); List Account account = (Account)list.get(i); accounts.add(account); } return accounts; } public void saveAccount(Account account){ session = MySessionFactory.getSession(); transaction = session.beginTransaction(); session.save(account); transaction.commit(); session.close(); } public void updateAccount(Account account){ session = MySessionFactory.getSession(); transaction = session.beginTransaction(); 共58页 第44页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 session.update(account); transaction.commit(); session.close(); } public void deleteAccount(int[] id){ try { session = MySessionFactory.getSession(); transaction = session.beginTransaction(); Connection con = session.connection(); String sql = \"delete from account where id in (\"; for(int i = 0 ; i < id.length; i++){ sql += id[i]; if(i != (id.length - 1)){ sql += \; } } sql += \")\"; log.info(sql); PreparedStatement ps = con.prepareStatement(sql); ps.executeUpdate(); transaction.commit(); session.close(); } catch (HibernateException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } public List criteria = session.createCriteria(Account.class); criteria.addOrder(Order.desc(\"id\")); String userName = account.getUserName(); if(userName != null && !\"\".equals(userName)){ criteria.add(Restrictions.eq(\"userName\", userName)); } Integer userGender = account.getUserGender(); if(userGender != null){ criteria.add(Restrictions.eq(\"userGender\", userGender)); } String userRealName = account.getUserRealName(); if(userRealName != null && !\"\".equals(userRealName)){ criteria.add(Restrictions.eq(\"userRealName\", userRealName)); } // String departmentNum = patientInfo. List list = criteria.list(); session.close(); List 共58页 第45页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 return accounts; } } MySessionFactory.java package dao; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class MySessionFactory { private static SessionFactory sessionFactory = null; static{ sessionFactory = Configuration().configure().buildSessionFactory(); } private MySessionFactory(){ } public static Session getSession(){ return sessionFactory.openSession(); } } PageInfo.java package controller.pageinfo; /** * 分页信息类 * @author pxm * */ public class PageInfo { //开始 private int startIndex; //结束 private int endIndex; //当前页面记录个数，初始设置为15条记录 private int currentRecordCount = 15; //总共记录个数 private int totalRecordCount; //页数 private int pageCount; //第几页 private int pageNum; public int getStartIndex() { new 共58页 第46页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 return startIndex; } public void setStartIndex(int startIndex) { this.startIndex = startIndex; } public int getEndIndex() { return endIndex; } public void setEndIndex(int endIndex) { this.endIndex = endIndex; } public int getCurrentRecordCount() { return currentRecordCount; } public void setCurrentRecordCount(int currentRecordCount) { this.currentRecordCount = currentRecordCount; } public int getTotalRecordCount() { return totalRecordCount; } public void setTotalRecordCount(int totalRecordCount) { this.totalRecordCount = totalRecordCount; } public int getPageCount() { return pageCount; } public void setPageCount(int pageCount) { this.pageCount = pageCount; } public int getPageNum() { return pageNum; } public void setPageNum(int pageNum) { this.pageNum = pageNum; } @Override public String toString() { return \"startIndex = \" + startIndex + \";endIndex = \" + endIndex + \";currentRecordCount = \" + currentRecordCount + \";totalRecordCount = \" + totalRecordCount + \";\" + \"pageCount = \" + pageCount + \";pageNum = \" + pageNum; } } hibernate.cfg.xml 共58页 第47页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 log4j.xml 共58页 第48页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 附录二 外文资料翻译 外文原文 Object creation & lifetime One critical issue when working with objects is the way they are created and destroyed. Each object requires resources, most notably memory, in order to exist. When an object is no longer needed it must be cleaned up so that these resources are released for reuse. In simple programming situations the question of how an object is cleaned up doesn’t seem too challenging: You create the object, use it for as long as it’s needed, and then it should be destroyed. However, it’s not hard to encounter situations that are more complex. Suppose, for example, you are designing a system to manage air traffic for an airport. (The same model might also work for managing crates in a warehouse, or a video rental system, or a kennel for boarding pets.) At first it seems simple: Make a container to hold airplanes, then create a new airplane and place it in the container for each airplane that enters the air-traffic-control zone. For cleanup, simply clean up the appropriate airplane object when a plane leaves the zone. But perhaps you have some other system to record data about the planes; perhaps data that doesn’t require such immediate attention as the main controller function. Maybe it’s a record of the flight plans of all the small planes that leave the airport. So you have a second container of small planes, and whenever you create a plane object you also put it in this second container if it’s a small plane. Then some background process performs operations on the objects in this container during idle moments. Now the problem is more difficult: How can you possibly know when to destroy the objects? When you’re done with the object, some other part of the system might not be. This same problem can arise in a number of other situations, and in programming systems (such as C++) in which you must explicitly delete an object when you’re done with it this can become quite complex. Where is the data for an object and how is the lifetime of the object controlled? C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For maximum runtime speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and release, and this control can be very valuable in some situations. However, you sacrifice flexibility because you must know the exact quantity, lifetime, and type of objects while you’re writing the program. If you are trying to solve a more general problem such as computer-aided design, warehouse management, or air-traffic control, this is too restrictive. The second approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don’t know until run time how many objects you need, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is running. If you need a new object, you simply make it on the heap at the point that you need it. Because the storage is managed dynamically, at run time, the amount of time required to allocate storage on the heap can be noticeably longer than the time to create storage on the stack. Creating storage on the stack is often a single assembly instruction to move the stack pointer down and another to move it back up. The time to create heap storage depends on the design of the storage mechanism. The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is 共58页 第49页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 essential to solve the general programming problem. Java uses dynamic memory allocation, exclusively.7 Every time you want to create an object, you use the new operator to build a dynamic instance of that object. There’s another issue, however, and that’s the lifetime of an object. With languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called a garbage collector that automatically discovers when an object is no longer in use and destroys it. A garbage collector is much more convenient because it reduces the number of issues that you must track and the code you must write. More importantly, the garbage collector provides a much higher level of insurance against the insidious problem of memory leaks, which has brought many a C++ project to its knees. With Java, the garbage collector is designed to take care of the problem of releasing the memory (although this doesn’t include other aspects of cleaning up an object). The garbage collector “knows” when an object is no longer in use, and it then automatically releases the memory for that object. This, combined with the fact that all objects are inherited from the single root class Object and that you can create objects only one way—on the heap—makes the process of programming in Java much simpler than programming in C++. You have far fewer decisions to make and hurdles to overcome. Exception handling: dealing with errors Ever since the beginning of programming languages, error handling has been a particularly difficult issue. Because it’s so hard to design a good error-handling scheme, many languages simply ignore the issue, passing the problem on to library designers who come up with halfway measures that work in many situations but that can easily be circumvented, generally by just ignoring them. A major problem with most error-handling schemes is that they rely on programmer vigilance in following an agreed-upon convention that is not enforced by the language. If the programmer is not vigilant—often the case if they are in a hurry—these schemes can easily be forgotten. Exception handling wires error handling directly into the programming language and sometimes even the operating system. An exception is an object that is “thrown” from the site of the error and can be “caught” by an appropriate exception handler designed to handle that particular type of error. It’s as if exception handling is a different, parallel path of execution that can be taken when things go wrong. And because it uses a separate execution path, it doesn’t need to interfere with your normally executing code. This tends to make that code simpler to write because you aren’t constantly forced to check for errors. In addition, a thrown exception is unlike an error value that’s returned from a method or a flag that’s set by a method in order to indicate an error condition—these can be ignored. An exception cannot be ignored, so it’s guaranteed to be dealt with at some point. Finally, exceptions provide a way to reliably recover from a bad situation. Instead of just exiting the program, you are often able to set things right and restore execution, which produces much more robust programs. Java’s exception handling stands out among programming languages, because in Java, exception handling was wired in from the beginning and you’re forced to use it. It is the single acceptable way to report errors. If you don’t write your code to properly handle exceptions, you’ll get a compile-time error message. This guaranteed consistency can sometimes make error handling much easier. It’s worth noting that exception handling isn’t an object-oriented feature, although in object-oriented languages the exception is normally represented by an object. Exception 共58页 第50页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 handling existed before object-oriented languages. Concurrent programming A fundamental concept in computer programming is the idea of handling more than one task at a time. Many programming problems require that the program stop what it’s doing, deal with some other problem, and then return to the main process. The solution has been approached in many ways. Initially, programmers with low-level knowledge of the machine wrote interrupt service routines, and the suspension of the main process was initiated through a hardware interrupt. Although this worked well, it was difficult and non-portable, so it made moving a program to a new type of machine slow and expensive. Sometimes, interrupts are necessary for handling time-critical tasks, but there’s a large class of problems in which you’re simply trying to partition the problem into separately running pieces (tasks) so that the whole program can be more responsive. Within a program, these separately running pieces are called threads, and the general concept is called concurrency. A common example of concurrency is the user interface. By using tasks, a user can press a button and get a quick response rather than being forced to wait until the program finishes its current task. Ordinarily, tasks are just a way to allocate the time of a single processor. But if the operating system supports multiple processors, each task can be assigned to a different processor, and they can truly run in parallel. One of the convenient features of concurrency at the language level is that the programmer doesn’t need to worry about whether there are many processors or just one. The program is logically divided into tasks, and if the machine has more than one processor, then the program runs faster, without any special adjustments. All this makes concurrency sound pretty simple. There is a catch: shared resources. If you have more than one task running that’s expecting to access the same resource, you have a problem. For example, two processes can’t simultaneously send information to a printer. To solve the problem, resources that can be shared, such as the printer, must be locked while they are being used. So a task locks a resource, completes its task, and then releases the lock so that someone else can use the resource. Java’s concurrency is built into the language, and Java SE5 has added significant additional library support. Java and the Internet If Java is, in fact, yet another computer programming language, you may question why it is so important and why it is being promoted as a revolutionary step in computer programming. The answer isn’t immediately obvious if you’re coming from a traditional programming perspective. Although Java is very useful for solving traditional standalone programming problems, it is also important because it solves programming problems for the World Wide Web. What is the Web? The Web can seem a bit of a mystery at first, with all this talk of “surfing,” “presence,” and “home pages.” It’s helpful to step back and see what it really is, but to do this you must understand client/server systems, another aspect of computing that’s full of confusing issues. Client/server computing The primary idea of a client/server system is that you have a central repository of information— some kind of data, usually in a database—that you want to distribute on 共58页 第51页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 demand to some set of people or machines. A key to the client/server concept is that the repository of information is centrally located so that it can be changed and so that those changes will propagate out to the information consumers. Taken together, the information repository, the software that distributes the information, and the machine(s) where the information and software reside are called “the server.” The software that resides on the consumer machine, communicates with the server, fetches the information, processes it, and then displays it on the consumer machine is called the client. The basic concept of client/server computing, then, is not so complicated. The problems arise because you have a single server trying to serve many clients at once. Generally, a database management system is involved, so the designer “balances” the layout of data into tables for optimal use. In addition, systems often allow a client to insert new information into a server. This means you must ensure that one client’s new data doesn’t walk over another client’s new data, or that data isn’t lost in the process of adding it to the database (this is called transaction processing). As client software changes, it must be built, debugged, and installed on the client machines, which turns out to be more complicated and expensive than you might think. It’s especially problematic to support multiple types of computers and operating systems. Finally, there’s the all-important performance issue: You might have hundreds of clients making requests of your server at any moment, so a small delay can be critical. To minimize latency, programmers work hard to offload processing tasks, often to the client machine, but sometimes to other machines at the server site, using so-called middleware. (Middleware is also used to improve maintainability.) The simple idea of distributing information has so many layers of complexity that the whole problem can seem hopelessly enigmatic. And yet it’s crucial: Client/server computing accounts for roughly half of all programming activities. It’s responsible for everything from taking orders and credit-card transactions to the distribution of any kind of data—stock market, scientific, government, you name it. What we’ve come up with in the past is individual solutions to individual problems, inventing a new solution each time. These were hard to create and hard to use, and the user had to learn a new interface for each one. The entire client/server problem needed to be solved in a big way. The Web as a giant server The Web is actually one giant client/server system. It’s a bit worse than that, since you have all the servers and clients coexisting on a single network at once. You don’t need to know that, because all you care about is connecting to and interacting with one server at a time (even though you might be hopping around the world in your search for the correct server). Initially it was a simple one-way process. You made a request of a server and it handed you a file, which your machine’s browser software (i.e., the client) would interpret by formatting onto your local machine. But in short order people began wanting to do more than just deliver pages from a server. They wanted full client/server capability so that the client could feed information back to the server, for example, to do database lookups on the server, to add new information to the server, or to place an order (which requires special security measures). These are the changes we’ve been seeing in the development of the Web. The Web browser was a big step forward: the concept that one piece of information can be displayed on any type of computer without change. However, the original browsers were still rather primitive and rapidly bogged down by the demands placed on them. They weren’t particularly interactive, and tended to clog up both the server and the Internet because whenever you needed to do something that required programming you had to send information back to the server to be processed. It could take many seconds or minutes to find out you had misspelled something in your request. Since the browser was 共58页 第52页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 just a viewer it couldn’t perform even the simplest computing tasks. (On the other hand, it was safe, because it couldn’t execute any programs on your local machine that might contain bugs or viruses.) To solve this problem, different approaches have been taken. To begin with, graphics standards have been enhanced to allow better animation and video within browsers. The remainder of the problem can be solved only by incorporating the ability to run programs on the client end, under the browser. This is called client-side programming. Client-side programming The Web’s initial server-browser design provided for interactive content, but the interactivity was completely provided by the server. The server produced static pages for the client browser, which would simply interpret and display them. Basic HyperText Markup Language (HTML) contains simple mechanisms for data gathering: text-entry boxes, check boxes, radio boxes, lists and dropdown lists, as well as a button that could only be programmed to reset the data on the form or “submit” the data on the form back to the server. This submission passes through the Common Gateway Interface (CGI) provided on all Web servers. The text within the submission tells CGI what to do with it. The most common action is to run a program located on the server in a directory that’s typically called “cgi-bin.” (If you watch the address window at the top of your browser when you push a button on a Web page, you can sometimes see “cgi-bin” within all the gobbledygook there.) These programs can be written in most languages. Perl has been a common choice because it is designed for text manipulation and is interpreted, so it can be installed on any server regardless of processor or operating system. However, Python (www.Python.org) has been making inroads because of its greater power and simplicity. Many powerful Web sites today are built strictly on CGI, and you can in fact do nearly anything with CGI. However, Web sites built on CGI programs can rapidly become overly complicated to maintain, and there is also the problem of response time. The response of a CGI program depends on how much data must be sent, as well as the load on both the server and the Internet. (On top of this, starting a CGI program tends to be slow.) The initial designers of the Web did not foresee how rapidly this bandwidth would be exhausted for the kinds of applications people developed. For example, any sort of dynamic graphing is nearly impossible to perform with consistency because a Graphics Interchange Format (GIF) file must be created and moved from the server to the client for each version of the graph. In addition, you’ve no doubt experienced the process of data validation for a Web input form. You press the submit button on a page; the data is shipped back to the server; the server starts a CGI program that discovers an error, formats an HTML page informing you of the error, and then sends the page back to you; you must then back up a page and try again. Not only is this slow, it’s inelegant. The solution is client-side programming. Most desktop computers that run Web browsers are powerful engines capable of doing vast work, and with the original static HTML approach they are sitting there, just idly waiting for the server to dish up the next page. Client-side programming means that the Web browser is harnessed to do whatever work it can, and the result for the user is a much speedier and more interactive experience at your Web site. The problem with discussions of client-side programming is that they aren’t very different from discussions of programming in general. The parameters are almost the same, but the platform is different; a Web browser is like a limited operating system. In the end, you must still program, and this accounts for the dizzying array of problems and solutions produced by client-side programming. The rest of this section provides an overview of the issues and approaches in client-side programming. Plug-ins 共58页 第53页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 One of the most significant steps forward in client-side programming is the development of the plug-in. This is a way for a programmer to add new functionality to the browser by downloading a piece of code that plugs itself into the appropriate spot in the browser. It tells the browser, “From now on you can perform this new activity.” (You need to download the plug-in only once.) Some fast and powerful behavior is added to browsers via plug-ins, but writing a plug-in is not a trivial task, and isn’t something you’d want to do as part of the process of building a particular site. The value of the plug-in for client-side programming is that it allows an expert programmer to develop extensions and add those extensions to a browser without the permission of the browser manufacturer. Thus, plug-ins provide a “back door” that allows the creation of new client-side programming languages (although not all languages are implemented as plug-ins). Scripting languages Plug-ins resulted in the development of browser scripting languages. With a scripting language, you embed the source code for your client-side program directly into the HTML page, and the plug-in that interprets that language is automatically activated while the HTML page is being displayed. Scripting languages tend to be reasonably easy to understand and, because they are simply text that is part of an HTML page, they load very quickly as part of the single server hit required to procure that page. The trade-off is that your code is exposed for everyone to see (and steal). Generally, however, you aren’t doing amazingly sophisticated things with scripting languages, so this is not too much of a hardship. One scripting language that you can expect a Web browser to support without a plug-in is JavaScript (this has only a passing resemblance to Java and you’ll have to climb an additional learning curve to use it. It was named that way just to grab some of Java’s marketing momentum). Unfortunately, most Web browsers originally implemented JavaScript in a different way from the other Web browsers, and even from other versions of themselves. The standardization of JavaScript in the form of ECMAScript has helped, but it has taken a long time for the various browsers to catch up (and it didn’t help that Microsoft was pushing its own agenda in the form of VBScript, which also had vague similarities to JavaScript). In general, you must program in a kind of least-common-denominator form of JavaScript in 中文译文 对象的创建与寿命 一个关键问题时，使用对象的，是他们创建和销毁的方式。每个对象都需要资源，最显着的记忆，为了存在。当一个对象不再需要它必须清理，使这些资源再利用释放。在简单编程的情况下，如何清除一个对象的问题似乎并没有太具有挑战性：创建对象，使用它，只要在需要它，那么它就应该被销毁。然而，这并不难遇到的局势更加复杂。 假设，例如，你正在设计一个系统来管理机场的空中交通。 （同样的模式可能也适用于仓库管理箱，或视频租赁系统，或为寄宿宠物狗。）起初它似乎很简单：一个容器持有飞机，然后创建一个新的飞机，并把它在每个飞机，进入空中交通管制区的容器。对于清理，只需适当的飞机清理对象时，飞机起飞区域。 但是，也许你有一些其他的系统来记录数据的飞机，也许并不需要的数据作为主控制器功能，如立即引起注意。也许这是一个飞行记录所有的小型飞机离开机场的计划。所以，你有一个小飞机的第二个容器，只要你创建一个对象，你也把飞机在这第二个货柜，如果它是一个小飞机。然后上执行一些后台进程在空闲时刻，在这个容器中的对象操作。 现在的问题是更加困难：你怎么可能知道什么时候销毁对象？当你的对象做一些系统的其他部分可能不是。这可能会出现同样的问题在其他一些情况，并在编程系统（如C + +）中，您必须明确地删除一个对象，当你用它这样做可能会变得非常复杂。 共58页 第54页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 哪里是一个对象的数据以及如何是受控对象的生命周期？ C + +中采用的方法是提高效率的控制是最重要的问题，所以它给了程序员的选择。为了获得最大的运行速度，存储和寿命可确定，而该程序正在被书写，通过放置在堆栈上的对象（这有时称为自动或范围的变量），或在静态存储区。这给存储分配和释放的速度一个优先事项，这种控制可以在某些情况下是非常有价值的。但是，你牺牲的灵活性，因为你必须知道确切的数量，寿命和对象，而你写程序的类型。如果你正在试图解决，如计算机辅助设计，仓库管理，或空中交通管制更一般的问题，这是过于狭窄。 第二种方法是创建一个动态的内存池对象称为堆。在这种方法中，你不知道，直到运行时你需要多少对象，他们的一生是什么，或者他们的确切类型。这些都是决定在一时冲动，而在程序运行。如果你需要一个新的对象，只是让你在这一点上，你需要它堆它。因为存储是动态管理，在运行时，所需的时间分配在堆上存储可以比时间明显更长的时间存储在堆栈上创建。在堆栈上创建的存储往往是一个汇编指令，堆栈指针向下移动，另一个是移动备份。创建堆的时间取决于存储的存储机制的设计。 动态方法，使一般的逻辑前提，对象往往是复杂的，所以寻找储存和释放，存储将不会对一个对象的创建有重要影响的额外开销。此外，更大的灵活性是必不可少的解决一般的编程问题。 Java使用动态内存分配，exclusively.7每当你要创建一个对象，可以使用new运算符创建该对象的动态实例。 还有另外一个问题，但是，这就是一个对象的生命周期。由于语言，让对象被创建在栈中，编译器确定物体持续多久，可自动销毁它。但是，如果您在堆上创建编译器不认识它的寿命。在一个像C + +语言，你必须确定编程何时销毁对象，这可能会导致内存泄漏，如果你不这样做是正确的（这是C + +程序中常见的问题）。 Java提供了一个功能叫做垃圾收集器，自动发现，当一个对象不再被使用并销毁它。垃圾收集器是一个更为方便，因为它减少了问题，您必须跟踪和代码，你必须编写数。更重要的是，垃圾收集器提供了针对内存泄漏阴险的问题，这带来了很多的C + +项目的膝盖更高层次的保险。 利用Java，垃圾收集器的设计考虑到了照顾释放内存问题（尽管这并不包括清理对象的其他方面）。垃圾收集器“知道”当一个对象不再被使用，然后它会自动释放该对象的内存。这与所有的对象都继承自一个根类Object，并且您可以创建对象其实只有一个方法相结合，在堆挣得比编程在Java编程过程非常简单的C + +。你有少得多的决定作出和障碍需要克服。 异常处理：处理错误。 自从年初的编程语言，错误处理一直是特别困难的问题。因为它是如此艰苦，设计良好的错误处理方案，许多语言根本无视这个问题，通过对问题库的设计者想出了谁中途措施，在许多情况下工作，但可以很容易地绕过，一般只要忽略他们。与大多数错误处理方案的主要问题是他们依靠程序员警惕以下商定的惯例，不是由语言执行。如果程序员没有警觉，通常情况下，如果他们是在赶时间，这些计划可以很容易地被人遗忘。 线异常处理错误处理直接排入编程语言，有时甚至操作系统。一个例外是一个被“扔”从错误的网站，可以“捕获”的设计由一个适当的异常处理该特定类型的错误处理程序对象。就好像是一个不同的异常处理，执行平行路径时可采取不如意的事情。而且因为它使用一个单独的执行路径，它不需要你的干预正常执行代码。这往往使该代码易于编写，因为你不是经常被迫检查错误。此外，抛出的异常是一个错误值，不同的方法或从一个一个的由一个方法集，以指示错误的情况，这些都可以忽略标志返回。一个例外是不容忽视的，所以它的保证是在某个时刻与处理。最后，异常提供了一种可靠地恢复一个糟糕的情况。而不是只退出程序，你往往能够拨乱反正，恢复执行，产生更加健壮的程序。 Java的异常处理中脱颖而出的编程语言，因为在Java中，异常处理是有线从一开始你不得不使用它。它是唯一可以接受的方式来报告错误。如果你不写你的代码，妥善处理异常，你会得到一个编译时错误信息。这保证一致性，有时更容易作出错误处理。 值得一提的是异常处理是不是面向对象的特征，虽然在面向对象语言的异常通常是由一个对象来表示。异常处理之前就存在的面向对象的语言。 并行编程 共58页 第55页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 在计算机编程的基本概念是在同一时间处理多个任务的想法。许多编程问题需要的程序停止它正在做什么，与其他一些问题处理，然后返回到主进程。该解决方案已在许多方面进行了接触。起初，低层次的知识，程序员写的机器中断服务程序，并中止了主要工艺是通过硬件中断启动。虽然这个运作良好，这是艰难的，不可移植，因此它使移动的一项计划，新型的机器缓慢和昂贵。 有时，中断处理时间紧迫的任务所必需的，但有一个大的问题，课堂上，你只是想单独运行分割成块（任务），这样，整个程序可以更加适应的问题。在一个程序中，这些作品分别被称为线程运行，和一般概念称为并发性。一个常见的例子是并发的用户界面。通过使用任务，用户可以按下一个按钮，并获得而不是被迫等待，直到程序完成当前任务的快速反应。 通常，任务只是一种方式来分配一个单一的处理器时间。但是，如果操作系统支持多个处理器，每个任务可以被分配到一个不同的处理器，他们可以真正并行运行。对在语言级别的并发方便的特点之一是，程序员不必担心是否有很多处理器或只有一个。该方案在逻辑上分为任务，如果机器有多个处理器，那么在程序运行速度更快，不需要任何特殊的调整。 这一切使得并发听起来很简单。有一个问题：共享资源。如果你有多个任务运行的的期待访问相同的资源，你有问题。例如，两个进程不能同时将信息发送到打印机。为了解决这个问题，可以共享资源，如打印机，必须被锁定，而他们正在使用。因此，一个任务锁定资源，完成其任务，然后释放该锁，让别人可以使用的资源。Java的并发性是建立在语言，而Java SE5增加了大量额外的库支持。 Java和因特网 如果Java是，事实上，但另一台计算机编程语言，你可能会质疑，为什么它是如此重要，为什么它被作为一个计算机编程革命性的一步推广。答案是不会立即明显，如果你从传统的角度来规划。虽然Java是非常传统的独立编程解决问题有用的，也是重要的，因为它解决了万维网规划问题。 什么是Web？ 网页时可能会一开始看起来是一个谜，这一切的“冲浪”，“存在”和“主页说话。”是有帮助的退后一步，看看它到底是什么，而是要做到这一点你必须明白客户机/服务器系统，另一个方面是计算的混淆问题的完整。 客户机/服务器计算 一个客户机/服务器系统的基本思想是，你有一个中央资料库的一些类型的数据，通常在一个数据库，您要分发的需求，一些人或机器设置。一个客户机/服务器概念的关键是，信息库是位于市中心，以便它可以被更改，以便这些更改将传播出来的信息消费者。两者合计，信息库，该软件分发的资料，和机器（s）凡居住信息和软件被称为“服务器。”软件上的消费机所在，与服务器通信，获取的信息，对其进行处理，然后显示的是被称为客户端的消费机了。 客户机/服务器计算的基本概念，那么，是不是太复杂。出现的问题，因为你有一台服务器一次尝试，为众多客户。一般来说，一个数据库管理系统有关，所以设计师“平衡”转化为优化使用表中的数据的布局。此外，系统通常允许一个到服务器的客户端插入新的信息。这意味着你必须确保一个客户端的新数据不走了另一个客户端的新数据，或数据是不是在将它添加到数据库过程中丢失（这就是所谓的事务处理）。由于客户端软件的变化，它必须建立，调试，并在客户端机器，原来是更加复杂和昂贵的比你想象的安装。它的特别问题，以支持计算机和操作系统的多个类型。最后，还有所有重要的性能问题：你可能使你的服务器在任何时候要求数百家客户，所以小延迟是至关重要的。为了尽量减少等待时间，程序员辛苦工作来分担处理任务，经常到客户机，但有时其他机器在服务器的网站，利用所谓的中间件。 （中间件也可以用来提高可维护性）。 而分发信息的简单的想法有这么多层次的复杂性，整个问题似乎无望高深莫测。然而它的关键：客户机/服务器计算占大约一半的所有方案编制活动。这是从接受订单和信用卡交易的任何数据股 共58页 第56页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 市，科学，政府实物分配的一切负责，你的名字。我们已经为你想的是，在过去个别问题个别解决，发明了一种新的解决方案每次。这些都难以建立和难于使用，用户必须学会为每个新的接口。整个客户机/服务器的问题需要加以解决的一大途径。 作为一个巨大的服务器上的Web 该网站实际上是一个巨大的客户机/服务器系统。这是一个比这个更糟糕，因为你把所有的服务器和客户端在一个网络共存的一次。你不需要知道，因为所有你所关心的是一个连接和一次（即使你可能是世界各地的跳跃在你的正确的服务器搜索）服务器交互。 最初，它是一个简单的单向过程。你犯了一个服务器的请求，并递给你一个文件，你的机器的浏览器软件（即客户端）将被解释到本地机器的格式。但在短期内开始人们想要做的不仅仅是提供从一个服务器的页面。他们希望充分的客户机/服务器功能，以便客户端可以养活信息返回到服务器，例如，做服务器上的数据库查询，添加新的信息到服务器，或下订单（这需要特别的保安措施） 。这些都是变化，我们已经在Web开发看。 在Web浏览器是一个很大的进步的东西：一条信息可以在任何类型的计算机，而无需改变显示的概念。不过，原来的浏览器仍相当原始的，并迅速陷入了对他们提出的要求了。他们不是特别互动，往往阻塞服务器和你需要的，因为只要做一些事情，需要编程，你必须将信息发送回服务器进行处理互联网。它可以采取许多秒钟或几分钟，看看你有拼写错误的东西在您的要求。因为浏览器只是一个观众可以不执行甚至最简单的计算任务。 （另一方面，它是安全的，因为它不能在本地计算机上执行任何程序可能包含错误或病毒。） 为了解决这个问题，已采取不同的做法。首先，图形标准已得到增强，以便更好地在浏览器中的动画和视频。问题的其余部分可以解决只有通过整合的能力，在客户端上运行方案下的浏览器。这就是所谓的客户端编程。 客户端编程 Web的初始服务器浏览器的设计提供互动内容，但互动性被完全由服务器提供的。该服务器为客户端产生的浏览器，它会简单地解释并显示它们的静态页面。基本超文本标记语言（HTML）包含了一些简单的数据收集机制：文本输入框，复选框，单选按钮，列表和下拉列表，以及一个，只能进行编程，以重置窗体上的数据或“提交按钮“表单上的数据返回给服务器。这次提交的通用网关接口，通过及格（CGI）功能提供了所有的Web服务器。内提交文字告诉的CGI用它做什么。最常见的动作是在服务器上运行位于这通常被称为“cgi - bin目录。”目录中的程序（如果你看在浏览器顶部的地址窗口，当你推一个网页上的按钮，就可以有时看到“cgi - bin目录”内的所有官样文章那里。）这些程序可以在大多数语言编写的。 Perl已经是一个普遍的选择，因为它是专为文本操作和解释，所以它可以在任何服务器上安装，无论处理器或操作系统。然而，Python（www.Python.org）一直因为其更大的权力和简洁中取得进展。 许多强大的网站今天是建立严格的CGI，事实上，你可以做任何事情几乎与CGI。但是，在CGI程序建立的Web站点可以迅速变得过于复杂的维护，也有响应时间问题。一个CGI程序的响应取决于多少数据必须在服务器上发送和互联网，以及负载。 （在此之上，开始了CGI程序往往是缓慢的。）初始 在Web设计者并没有预见到这一带宽如何迅速将有关申请的人开发的各种用尽。例如，任何动态图形的排序几乎是不可能的，因为一个具有一致性进行图形交换格式（GIF）文件必须创建并从服务器移到每个版本的图形客户端。此外，你无疑经历了一个网络的数据输入表单验证程序。您按页面上提交按钮，将数据运回服务器，服务器启动一个CGI程序，发现了一个错误，一个HTML格式的网页，告知你的错误，然后发送回您的网页，你必须然后回到了一个网页，然后再试一次。这不仅是缓慢的，它是不好的。 该解决方案是客户端编程。大多数Web浏览器运行的台式电脑的强大引擎，能够做大量工作，并与原有的静态HTML的做法他们坐在那里，只是悠闲地等待服务器炮制了下一页。客户端的编程意味着Web浏览器是做什么工作的驾驭它，并为用户的结果是在你的网站更快捷和更具 共58页 第57页 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 装 ┊ ┊ ┊ ┊ ┊ 订 ┊ ┊ ┊ ┊ ┊ 线 ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ ┊ 安徽工业大学 毕业设计（论文）说明书 交互性的体验。 与客户端编程讨论的问题是，它们都与一般不同的编程讨论。该参数几乎相同，但该平台是不同的，一个Web浏览器像一个有限的操作系统。最后，您还必须计划，为的问题和客户端的编程解决方案产生的令人眼花缭乱的原因。本节的其余部分提供了有关问题，以及在客户端的编程方法进行了综述。 插件 最重要的步骤，客户端的编程前锋之一，是发展的插件。这是一种让程序员可以通过下载添加一段代码插入到浏览器中的适当位置本身新功能的浏览器。它告诉浏览器，“从现在开始，您可以执行这个新的活动。”（你需要下载插件只有一次。）一些快速而强大的行为将被添加到通过插件的浏览器，但是写一个插件不是一个简单的任务，是不是你想做的事，作为一个特定的网站建设过程的一部分。对价值的插件用于客户端编程的是，它允许程序员开发的专家扩展和添加未经批准的浏览器制造商扩展到浏览器。因此，插件提供了一个“后门”，允许新的客户端编程语言创作（虽然不是所有的语言都作为插件实现的）。 脚本语言 插件导致了浏览器脚本语言的发展。用脚本语言，你直接嵌入到HTML页面对您的客户端程序的源代码和插件，解释，语言是自动激活，而被显示的HTML页面。脚本语言往往是相当容易理解，而且因为它们是简单的文本，它是一个HTML页面的一部分，它们加载非常快的单服务器的一部分命中需要促使页。权衡是你的代码是公开给大家看（偷）。但是，总的来说，你是不是令人惊讶的脚本语言做复杂的事情，因此这不是太艰苦了。 一种脚本语言，你可以指望一个Web浏览器，支持无插件是JavaScript（这只是一笔带过相似的Java，你就得爬一个额外的学习曲线，使用它。它被命名这种方式只是为了抓住Java的营销势头一些）。不幸的是，大多数Web浏览器中的JavaScript最初实施不同的方式从其他Web浏览器，甚至从他们自己的其他版本。的JavaScript形式的ECMAScript规范有所帮助，但是它采取了很长时间的各种浏览器赶上（并没有帮助，微软推VBScript的形式，这也有它自己的议程含糊到JavaScript相似）。在一般情况下，你必须在一个程序最小公分母实物形式的JavaScript 共58页 第58页 因篇幅问题不能全部显示，请点此查看更多更全内容