获取项目源文件，学习交流联系Q:1415736481,可指导毕设，课设

【摘要】计算机信息技术应用于医院的日常管理，可以为医院的发展提供巨大的动力。本系统采SQL server2000为后台数据库，以MyEclipse 6.5为前端开发工具，以TomCat 6.0为服务器，采用MVC三层开发框架。系统实现了挂号管理、处方管理、收费管理、药品管理等必需的功能，其操作简单、功能完善、运行比较稳定，适用于小型医院的门诊信息管理工作。

【关键词】门诊；管理信息系统；SQL server2000；Jsp

The Development of Hospital Management Information System

Abstract: Computer information technology in the daily hospital management, hospitals can provide a tremendous impetus to the development. The system adopted for the background SQL server2000 database to MyEclipse 6.5 as the front-end development tools to TomCat 6.0 as the server, three-tier development using MVC framework. System to achieve the registration management, prescription management, charge management, drug management, the necessary functions. Its operation is simple、perfect function 、stable operation、for small hospital outpatient information management.

Key words: diagnosis ;management information system;SQL server2000;Jsp

引言... 1

1概述... 2

1.1开发背景. 2

1.2开发意义. 2

1.3系统目标. 2

2 系统设计原理... 3

2.1系统设计的基本思想. 3

2.2 SQL servser数据库简介. 3

2.3 MyEclipse开发工具描述. 4

2.3.1 MyEclipse简介... 4

2.3.2MyEclipse的开发环境... 4

2.3.3 MyEclipse的数据库的访问方法... 4

3 系统分析... 6

3.1可行性分析. 6

3.2需求分析. 6

3.2.1功能需求... 6

3.2.2数据需求... 6

3.2.3系统数据流图... 7

3.2.4数据字典... 9

4 系统设计... 11

4.1总体设计. 11

4.2数据库设计. 12

4.2.1概念结构设计... 12

4.2.2逻辑结构设计... 13

4.2.3物理结构设计... 13

5 系统实现... 16

5.1数据库的建立. 16

5.2数据库的连接. 17

5.3主界面的实现. 18

5.4挂号管理模块的实现. 19

5.5处方管理模块的实现. 22

5.6收费管理模块的实现. 26

5.7药品管理模块的实现. 28

5.8后台管理模块的实现. 32

6 系统测试... 35

6.1测试环境. 35

6.2功能测试. 35

6.3性能测试. 35

6.4界面测试. 36

6.5调试问题. 36

6.6测试结果. 36

总结... 38

致谢... 39

参考文献... 40

科技外文文献... 41

附录A：源程序代码... 46

附录B：系统使用说明书... 64

引言

随着计算机技术的飞速发展，计算机在医院管理中应用的普及，利用计算机实现医院门诊信息

的管理势在必行，当前的医院门诊管理系统正在由C/S结构向B/S结构转移，但是由于安全性等方面的因素，C/S结构的信息系统仍然占据医院管理信息系统的主流。

逐渐地随着计算机在社会各个领域的广泛应用，大量繁杂的工作得以快递、高效的完成，使人们从繁重的劳动中解脱出来，提高了工作效率和工作质量。在计算机应用的众多领域中，管理信息系统占据着十分重要的地位，它使用系统的观点，以计算机科学和现代通信技术为基础，对某一组织或机构中有关管理的数据进行收集、处理，并输出有用信息，使大量的手工劳动自动完成，避免了因人工操作带来的各种错误。

医院门诊管理系统是现代医院管理不可缺少的一部分，是适应现代医院要求，推动医院的门诊信息管理走向科学化、规范化、高效化的必要条件。现代医院需要高效的完成医院门诊信息管理的日常业务，包括病人挂号管理，处方管理，收费，取药，药品管理等操作。并达到操作过程中的直观、方便、使用、安全等要求。此外，医院门诊信息管理系统还需要后台用户的管理功能，以及用户需求进行数据的添加、删除、修改等操作。为了方便医院门诊信息管理需要，我们设计制作了医院门诊信息管理系统提供。

该医院门诊信息管理系统可以应用在一个医院的局域网中，系统地、全面的进行门诊信息管理。支持病人的挂号管理，处方管理，收费管理，药品管理以及在各个模块中信息的增加、删除、修改、查询等，系统以其系统性、全面性、使用的安全性和稳定性以及应用的广泛性为特点，极大地减轻了医院工作人员的工作强度，提高了医院门诊信息管理工作的水平，下面章节将详细介绍本系统的设计过程。

1概述

1.1开发背景

近年来，信息产业发展迅猛，信息技术的发展形成了一系列的热点。这些热点既为医院信息化建设带来了许多的发展机遇，同时又提出了新的挑战。医院担负着保障人民生命健康，治病救人的艰巨任务，是我国医疗卫生事业的主要支柱。信息科学和计算机应用的发展，将极大的加快医院信息化建设的发展。

门诊部是医院的一个重要部门，是直接向广大患者提供医疗服务的主要窗口之一，门诊部的信息化建设工作，直接关系到整个医院的信息化建设工作。因此，作好门诊部信息化建设工作，对于规范门诊部的管理，建立更加方便患者就医的门诊工作流程，从而促进整个医院的信息化建设都具有极其重要的意义。我们认为门诊部信息化建设应达到的总体目标是：以医院信息化建设工程为依托，充分发挥现代计算机网络信息共享的优势，从而达到方便患者就诊，减轻医护人员工作强度，推动医院门诊管理水平提高的目的。

1.2开发意义

当今时代是飞速发展的信息时代。在各行各业中离不开信息处理，这正是计算机被广泛应用于信息管理系统的原因。计算机的最大好处在于利用它能够进行信息管理。使用计算机进行信息控制，不仅提高了工作效率，而且大大的提高了其安全性。尤其对于复杂的信息管理，计算机能够充分发挥它的优越性。计算机进行信息管理与信息管理系统的开发密切相关，系统的开发是系统管理的前提。本系统就是为了更好管理门诊信息而设计的。当前，医院作为病人就诊的地方，有许多信息需要处理和管理。现今，有很多门诊信息系统都是初步开始使用，甚至尚未使用计算机进行信息处理。根据调查得知，他们以前对信息管理的主要方式是基于文本、表格等纸介质的手工处理，对于处方等很多信息都是用人工计算、手抄进行。数据信息处理工作量大，容易出错；由于数据繁多，容易丢失，且不易查找。总的来说，缺乏系统，规范的信息管理手段。数据处理手工操作，工作量大，出错率高，出错后不易更改。基于这此问题，我认为有必要建立一个门诊信息管理系统，使门诊信息管理工作规范化，系统化，程序化，避免管理的随意性，提高信息处理的速度和准确性，能够及时、准确、有效的查询和修改情况。

1.3系统目标

医院门诊信息管理系统是用于管理医院门诊信息的重要工具，一个完善的医院门诊信息管理系统的功能主要包括以下几项：

挂号管理：包括挂号、挂号单处理。

处方管理：包括开处方、处方查询、处方管理。

收费查询：包括处方查询、收费单处理。

药品管理：包括收费单查询、录入药品信息、药品管理。

后台管理：主要用于添加各个板块的用户。

2 系统设计原理

2.1系统设计的基本思想

医院门诊信息管理系统主要是针对医院门诊的信息自动化管理而开发的，作为一个典型的信息管理系统，其系统开发任务主要包括数据库的设计与维护、客户端应用程序的开发两方面。对于前者要求建立起的数据库具有完整性和一致性，且具有一定的数据安全性，对于系统要求程序界面友好、功能完备等特点。经过详细的分析，选用MyEclipse 6.5作为前端开发工具，TomCat6.0为WEB服务器，以及SQL server2000为后台数据库来达到实现这个系统的目的。

2.2 SQL servser数据库简介

SQL Server 2000是一个关系数据库管理系统，它最初是由Microsoft Sybase 和Ashton-Tate三家公司共同开发的，于1988 年推出了第一个OS/2 版本。在Windows NT 推出后，Microsoft与Sybase 在SQL Server 的开发上就分道扬镳了。Microsoft 将SQL Server 移植到Windows NT系统上，专注于开发推广SQL Server 的Windows NT 版本；Sybase 则较专注于SQL Server在UNIX 操作系统上的应用。在本书中介绍的是Microsoft SQL Server 以后简称为SQL Server或MS SQL Server。

SQL Server 2000 是Microsoft 公司推出的SQL Server 数据库管理系统的最新版本。该版本继承了SQL Server 7.0 版本的优点同时又比它增加了许多更先进的功能，具有使用方便,可伸缩性好与相关软件集成程度高等优点，可跨越从运行Microsoft Windows 98 的膝上型电脑到运行Microsoft Windows 2000 的大型多处理器的服务器等多种平台使用。

SQL Server 2000 的特性包括：

1）Internet 集成。SQL Server 2000 数据库引擎提供完整的XML 支持。它还具有构成最大的Web 站点的数据存储组件所需的可伸缩性、可用性和安全功能。SQL Server 2000 程序设计模型与 Windows DNA 构架集成，用以开发 Web 应用程序，并且SQL Server 2000 支持 English Query 和 Microsoft 搜索服务等功能，在Web 应用程序中包含了用户友好的查询和强大的搜索功能。

2）可伸缩性和可用性。同一个数据库引擎可以在不同的平台上使用，从运行Microsoft Windows 2000 数据中心版的大型多处理器服务器。SQL Server 2000 企业版支持联合服务器、索引视图和大型内存支持等功能，使其得以升级到最大 Web 站点所需的性能级别。

3）企业级数据库功能。SQL Server 2000 关系数据库引擎支持当今苛刻的数据处理环境所需的功能。数据库引擎充分保护数据完整性，同时将管理上千个并发修改数据库的用户的开销减到最小。SQL Server 2000 分布式查询使您得以引用来自不同数据源的数据，就好象这些数据是 SQL Server 2000 数据库的一部分，同时分布式事务支持充分保护任何分布式数据更新的完整性。复制同样使您得以维护多个数据复本，同时确保单独的数据复本保持同步。可将一组数据复制到多个移动的脱接用户，使这些用户自主地工作，然后将他们所做的修改合并回发布服务器。

4）易于安装、部署和使用。 SQL Server 2000 中包括一系列管理和开发工具，这些工具可改进在多个站点上安装、部署、管理和使用 SQL Server 的过程。SQL Server 2000 还支持基于标准的、与 Windows DNA 集成的程序设计模型，使 SQL Server 数据库和数据仓库的使用成为生成强大的可伸缩系统的无缝部分。这些功能使您得以快速交付 SQL Server 应用程序，使客户只需最少的安装和管理开销即可实现这些应用程序。

数据仓库。 SQL Server 2000 中包括析取和分析汇总数据以进行联机分析处理 (OLAP) 的工具。SQL Server 中还包括一些工具，可用来直观地设计数据库并通过 English Query 来分析数据。

SQL Server 2000共有4个版本，分别是个人版，标准版，企业版和开发版

SQL server 2008是微软出的SQL系列最新版本。

其主要特点如下：

(1)高性能设计，可充分利用WindowsNT的优势。

(2)系统管理先进，支持Windows图形化管理工具，支持本地和远程的系统管理和配置。

(3)强壮的事务处理功能，采用各种方法保证数据的完整性。

(4)支持对称多处理器结构、存储过程、ODBC，并具有自主的SQL语言。 SQLServer以其内置的数据复制功能、强大的管理工具、与Internet的紧密集成和开放的系统结构为广大的用户、开发人员和系统集成商提供了一个出众的数据库平台。

2.3 MyEclipse开发工具描述

3 系统分析

3.1可行性分析

(1)经济可行性分析

开发需求较低,加上成熟的软硬件环境、目标系统并不是十分复杂和开发周期较短,人员经济支出有限。开发完成运行后，为使用者带来便利，为系统的进一步推广创造了条件，经济收益将远超过投资。从经济角度考虑,此系统开发可行。

(2)法律可行性分析

由于整个系统是自行开发,自行使用，所以系统本身不存在版权争议，符合国家各种政策法规。

(3)技术可行性分析

采用SQL server 2000作为数据库MyEclipse6.5作为开发工具TomCat 6.0作为服务器，采用MVC三层框架来进行开发。现在的MVC开发模式发展的已经很成熟，资料也很丰富，即使遇到问题也有很多资料，所以说从在技术上是可行的。

3.2需求分析

3.2.1功能需求

医院门诊管理系统是管理医院门诊信息的重要工具，医院门诊信息管理涉及挂号信息、处方信息、收费信息、药品信息等多种数据管理。从信息管理角度出发可将分为五类：挂号管理、处方管理、收费管理、药品管理和后台用户管理。

一个完善的医院门诊信息管理系统的任务主要包括以下几项：

挂号管理：包括病人挂号、挂号单处理。

处方管理：包括开处方、处方查询、处方管理。

收费管理：包括处方查询、收费单管理。

药品查询：包括收费单查询、录入药品信息、药品管理。

后台管理：主要是对各个模块的用户进行添加和删除。

安全退出：主要是删除系统中的用户登录记录。

3.2.2数据需求

　输出数据：查询关键字确定的数据库记录的子集；

　　　　　　　挂号单、收费单、处方单、药品信息表等操作结果；

3.2.3系统数据流图

数据流图（DFD）是一种图形化技术，它描绘信息流和数据从输入移动到输出的过程中所经受的变换。在数据流图中没有任何具体的物理元素，它只是描绘信息在软件中流动和被处理的情况。因为数据流图是系统逻辑功能的图形表示，即使不是专业的计算机人员也容易理解它，所以它是分析员和用户之间极好的通信工具。

如图3.1所示，数据流图的四种基本符号和具体描述如下:

数据的源点/终点

变换数据的处理

数据存储

数据流

图3.1 数据流图的基本符号

医院门诊管理系统的顶层数据流图3.2所示：

图3.2 顶层数据流图

医院门诊管理系统的一层数据流图如图3.3所示：

图3.3 一层数据流图

3.2.4数据字典

编号：D1

数据存储名称：病人挂号信息

简述：病人在医院门诊时挂号所产生的信息

组成：病人挂号信息=自增项id+挂号单编号+病人姓名+病人性别+病人年龄+所挂可是类别+所挂科室名+所要办理的业务

来源：挂号信息录入

去向：医生

编号：D2

数据存储名称：处方信息

简述：医生对病人进行开处方时所产生的信息

组成：处方信息=自增项id+处方单编号+病人姓名+病人性别+病人年龄+是否交费

来源：处方添加

去向：医院收费人员、药房管理人员

编号：D3

数据存储名称：收费信息

简述：病人在医院交费处交费所产生的信息

组成：收费信息=自增项id+收费单编号+收费日期+病人名+开处方的当事人+处方价钱+备注

来源：挂号信息录入

去向：医院收费人员、药房管理人员

编号：D4

数据存储名称：药品信息

简述：药房管理人员处理药品信息时所产生的信息

组成：药品信息=自增项id+药品单编号+药品名+药品类型+药品规格+生产企业+包装量+包装单位+单位价格+现有数量

来源：药品信息录入

去向：药房管理人员

编号：D5

数据存储名称：用户信息

简述：管理员添加用户信息时所产生的信息

组成：用户信息=自增项id+用户名+用户密码

来源：用户信息录入

去向：后台管理员

通过对数据字典的定义，我们就可以开始的程序和数据库，进行系统的设计了。

4 系统设计

首先根据系统功能分析设计出数据库，包括各个数据表和数据表关系图的详细结构。

实现功能模块时，采用先模块化，后集成的方式。即对系统各个功能模块分别独立设计和调式，在创建系统主窗体时再将各个功能模块通过主窗体的菜单系统集成到一起，最后进行系统整体设计调式。

在访问数据库时，采用功用数据模块存放数据库需要的对象。该模块在各个功能模块中被直接调用，避免对数据库的反复连接，并可减少代码编写，从而提高系统开发效率。

4.1总体设计

在设计医院门诊信息系统时：根据实际情况，进行模块化设计；由上可得出，医院门诊信息管理系统需要实现的功能模块有：

（1）详细模块设计

医院门诊信息管理系统

挂号管理

处方管理

收费管理

药品管理

挂号

挂号信息处理

开处方

处方信息查询

处方信息管理

处方查询及收费

收费单信息处理

收费查询及开药

录入药品信息

药品信息管理

后台管理

图4.1 “医院门诊信息管理系统”功能模块

4.2数据库设计

4.2.1概念结构设计

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

系统中所涉及的实体属性图如图4.2 图4.3 图4.4 图4.5 图4.6所示。

4.2.2逻辑结构设计

数据库逻辑结构设计是把概念模型(E-R图)转换为符合数据库管理系统的数据模型，就是把概念模型(E-R图)转换为关系模型。把系统的概念模型(E-R图)转换为关系模型可得如下的关系模式。

挂号表（自增项，挂号单编号，病人姓名，病人性别，病人年龄，所挂科室类别，所挂科室名，所要办理的业务），挂号单编号为此关系的码。

处方表（自增项，处方单编号，日期，病人姓名，病人性别，病人年龄，备注），处方单编号为此关系的码。

处方内容表（自增项，处方单编号，药品1编号，药品1数量，…），处方单编号为此关系的码。

收费表（自增项，收费单编号，日期，病人名，收费的当事人，处方价钱，备注），收费单编号为此表的码。

药品管理表（自增项，取药单编号，取药时间，取药人姓名，开药人姓名，备注），取药单标号为此表的码。

药品信息表（自增项，药品单编号，药品名，药品类型，药品规格，生产企业，包装量，包装单位，单位价格，现有数量），药品单编号为此表的码。

4.2.3物理结构设计

在医院门诊管理系统中数据库的名称设置为hospital　数据库中的表名称和字符标识，如下所示：

表4.1挂号表（guahao）

序号	字段名	描述	数据类型	数据长度	主键	可否为空
1	G_id	自增项	int			n
2	G_number	编号	archar	30	√	n
3	G_name	姓名	varchar	20		Y
4	G_age	年龄	varchar	4		Y
5	G_sex	性别	Varchar	4		Y
6	G_kenei	科室类别	Varchar	40		Y
7	G_ke	科室名	varchar	40		Y
8	G_nei	办理事务	Varchar	40		Y

.表4.2处方表（chufang）

序号	字段	描述	数据类型	数据长度	主键	可否为空
1	C_id	自增项	int			n
2	C_number	编号	varchar	20	√	n
3	C_time	日期	varchar	20		Y
4	C_name	病人名	varchar	20		Y
5	C_sex	病人性别	varchar	10		Y
6	C_age	病人年龄	varchar	10		Y
7	C_cost	是否交费	varchar	10		Y

表4.3处方内容表（C_drug）

序号	字段	描述	类型	数据长度	主键	可否为空
1	D_id	自增项	int			N
2	D_number	处方单编号	Varchar	20	√	N
4	DY_name1	药品1名称	Varchar	20		y
5	DY_number1	药品1数量	Float			y
6	DY_name2	药品2名称	Varchar	20		y
7	DY_number2	药品2数量	Float			Y

表4.4收费表：（shoufei）

序号	字段	描述	数据类型	长度	主键	可否为空
1	S_id	自增项	Int			N
2	S_number	收费单编号	varchar	20	√	N
3	S_time	收费日期	Varchar	20		y
4	S_name	病人名	Varchar	20		y
5	S_names	收款人姓名	Varchar	20		y
6	S_money	处方价钱	Float			y
7	S_nei	备注	Varchar	20		y

表4.5药品管理表（drug）

序号	字段	描述	数据类型	数长度	主键	可否为空
1	X_id	自增项	Int			N
2	X_number	取药单编号	Varchar	20	√	N
3	X_time	取药时间	Varchar	20		Y
4	X_name	病人姓名	Varchar	20		Y
	X_names	开药人姓名	Varchar	20		Y
	X_beizhu	备注	Varchar	40		Y

表4.6药品信息表（M_drug）

序号	字段	描述	据类型	数据长度	主键	可否为空
1	M_number	药品编号	Varchar	20	√	N
2	M_name	药品名	Varchar	20		N
3	M_nei	药品类型	Varchar	20		Y
4	M_gui	药品规格	Varchar	20		Y
5	M_corporation	生产企业	Varchar	40		Y
6	M_liang	包装量	Varchar	10		Y
7	M_danwei	包装单位	Varchar	10		Y
8	M_money	单位价格	Varchar	10		Y
9	M_you	现有数量	Varchar	10		Y

5 系统实现

5.1数据库的建立

本次采用SQL server 2000作为数据库，整个操作将通过SQL语句在查询分析器中进行，本系统的数据库名为Hospital，本系统采用的SQL server登陆验证是SQL server验证，用户名为“sa”，密码为“sa”。

1）打开SQL server服务器，然后打开查询分析器，在SQL server的验证方式下，输入用户名和密码，然后在工作区中输入如下语句，运行即可：

create database hospital //建立名为hospital德数据库

use hospital //切换hospital为当前数据库

2）在输入各个表的SQL语句，建立各个子表：

建立挂号表guahao

create table guahao(

G_id int identity not null, --自增项

G_number varchar(30) primary key, --挂号单编号

G_name varchar(20), --病人姓名

G_sex varchar(4), --病人性别

G_age varchar(20), --病人年龄

G_kenei varchar(40), --所挂科室类别

G_ke varchar(40), --所挂科室名

G_nei varchar(40) --所要办理的业务

)

建立用户处方表

create table chufang(

C_id int identity not null,

C_number varchar(20) primary key, --处方单编号

C_time varchar(20), --开处方的日期

C_name varchar(20), --病人姓名

C_sex varchar(10), --病人性别

C_age varchar(10), --病人年龄

C_cost varchar(10) --用户是否缴费

)

建立处方药品单

create table C_drug(

D_id int identity not null,

D_number varchar(20) primary key, --处方单编号

DY_name1 varchar(20), --药品1名字

DY_number1 float, --药品1数量

DY_name2 varchar(20), --药品2名字

DY_number2 float, --药品2数量

DY_name3 varchar(20), --药品3名字

DY_number3 float, --药品3数量

DY_name4 varchar(20), --药品4名字

DY_number4 float, --药品4数量

DY_name5 varchar(20), --药品5名字

DY_number5 float, --药品5数量

DY_name6 varchar(20), --药品6名字

DY_number6 float, --药品6数量

DY_name7 varchar(20), --药品7名字

DY_number7 float, --药品7数量

DY_name8 varchar(20), --药品8名字

DY_number8 float, --药品8数量

DY_name9 varchar(20), --药品9名字

DY_number9 float, --药品9数量

DY_name10 varchar(20), --药品10名字

DY_number10 float, --药品10数量

DY_name11 varchar(20), --药品11名字

DY_number11 float, --药品11数量

DY_name12 varchar(20), --药品12名字

DY_number12 float --药品12数量

)

建立收费表

create table shoufei(S_id int identity, --自增项

S_number varchar(20) primary key, --收费单编号

S_time varchar(20), --收费日期

S_name varchar(20), --病人名

S_names varchar(20), --开处方的当事人

S_money float, --处方价钱

S_nei varchar(20) --备注

)

建立药品管理表

create table drug(X_id int identity not null, --自增项

X_number varchar(20) primary key, --取药单编号

X_time varchar(20), --取药时间

X_name varchar(20), --取药人姓名

X_names varchar(20), --开药人姓名

X_beizhu varchar(40) --备注

)

建立药品信息单

create table M_drug(

M_number int identity not null, --药品编号

M_name varchar(20) primary key, --药品名

M_nei varchar(20), --药品类型

M_gui varchar(20), --药品规格

M_corporation varchar(40), --生产企业

M_liang varchar(10), --包装量

M_danwei varchar(10), --包装单位

M_money varchar(10), --单位价钱

M_you varchar(10) --现有数量)

5.2数据库的连接

1）先要将SQL server 2000的jar包导入到项目中，SQL server 2000有三个jar包，将其放在lib包下。

2）在写连接数据库类，写入如下代码：

package com.fit.dao;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

public class LoginDao

{

public void login(String sql)

{

String db="com.microsoft.jdbc.sqlserver.SQLServerDriver"; Stringurl="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=Hospital;user=sa;password=sa";

try{

Class.forName(db);

Connection conn=DriverManager.getConnection(url);

Statement stmt=conn.createStatement();

stmt.executeUpdate(sql);

public ResultSet Ku(String sql)

{

String db="com.microsoft.jdbc.sqlserver.SQLServerDriver";

String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=Hospital;user=sa;password=sa";

ResultSet rs=null;

try{

Class.forName(db);

Connection conn=DriverManager.getConnection(url);

Statement stmt=conn.createStatement();

rs=stmt.executeQuery(sql);

5.3主界面的实现

主界面主要是起到将各个模块整合在一起的作用，如图5.1所示：

图5.1主页界面图

5.4挂号管理模块的实现

1）挂号处理

在挂号管理中，进行病人的挂号信息的录入工作，如图5.2所示：

图5.2挂号处理界面图

挂号处理的核心代码：

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.GuaHao;;

public class GuaHaoService

{

public void guahao(String number,String name,String sex,String age,String kebie,String kename,String keshi)

{

String sql="insert into guahao values('"+number+"','"+name+"','"+sex+"','"+age+"','"+kebie+"','"+kename+"','"+keshi+"')";

LoginDao login=new LoginDao();

}

public List showguahao(String number) throws SQLException

{

String sql="select *from guahao where G_number='"+number+"'";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

GuaHao cu=new GuaHao();

cu.setNumber(rs.getString(2));

cu.setName(rs.getString(3));

cu.setSex(rs.getString(4));

cu.setAge(rs.getString(5));

cu.setKebie(rs.getString(6));

cu.setKename(rs.getString(7));

cu.setKeshi(rs.getString(8));

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String sex=request.getParameter("sex");

String age=request.getParameter("age");

String kebie=request.getParameter("kebie");

String kename=request.getParameter("kename");

String keshi=request.getParameter("keshi");

GuaHaoService guahao=new GuaHaoService();

guahao.guahao(number, name, sex, age, kebie, kename, keshi);

try {

List list=guahao.showguahao(number);

request.setAttribute("action", list);

request.getRequestDispatcher("index/GuaHaok.jsp").forward(request, response);

} catch (SQLException e) {

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.GuaHao;

public class GuaHaoUpdateService

{

public List showupdate(String number) throws SQLException

{

String sql="select *from guahao where G_number='"+number+"'";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

GuaHao cu=new GuaHao();

cu.setNumber(rs.getString(2));

cu.setName(rs.getString(3));

cu.setSex(rs.getString(4));

cu.setAge(rs.getString(5));

cu.setKebie(rs.getString(6));

cu.setKename(rs.getString(7));

cu.setKeshi(rs.getString(8));

package com.fit.service;

import com.fit.dao.LoginDao;

public class GuaHaoDelectService

{

public void delect(String number)

{

String sql="delete guahao where G_number='"+number+"'";

LoginDao login=new LoginDao();

}

5.5处方管理模块的实现

1）开处方，如图5.4所示：

图5.4 开处方界面

核心代码的核心代码为：

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.CuFang;;

public class CuSelectService

{

public List cuselect() throws SQLException

{

String sql="select *from chufang";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

CuFang cu=new CuFang();

cu.setC_number(rs.getString(2));

cu.setC_time(rs.getString(3));

cu.setC_name(rs.getString(4));

cu.setC_sex(rs.getString(5));

cu.setC_age(rs.getString(6));

cu.setC_cost(rs.getString(7));

public List cuselect1(String number) throws SQLException

{

String sql="select *from chufang,C_drug where C_drug.D_number=chufang.c_number and C_number='"+number+"'";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

CuFang cu=new CuFang();

cu.setC_number(rs.getString(2));

cu.setC_time(rs.getString(3));

cu.setC_name(rs.getString(4));

cu.setC_sex(rs.getString(5));

cu.setC_age(rs.getString(6));

cu.setC_cost(rs.getString(7));

cu.setDY_name1(rs.getString(10));

cu.setDY_number1(rs.getFloat(11));

cu.setDY_name2(rs.getString(12));

cu.setDY_number2(rs.getFloat(13));

cu.setDY_name3(rs.getString(14));

cu.setDY_number3(rs.getFloat(15));

cu.setDY_name4(rs.getString(16));

cu.setDY_number4(rs.getFloat(17));

cu.setDY_name5(rs.getString(18));

cu.setDY_number5(rs.getFloat(19));

cu.setDY_name6(rs.getString(20));

cu.setDY_number6(rs.getFloat(21));

cu.setDY_name7(rs.getString(22));

cu.setDY_number7(rs.getFloat(23));

cu.setDY_name8(rs.getString(24));

cu.setDY_number8(rs.getFloat(25));

cu.setDY_name9(rs.getString(26));

cu.setDY_number9(rs.getFloat(27));

cu.setDY_name10(rs.getString(28));

cu.setDY_number10(rs.getFloat(29));

cu.setDY_name11(rs.getString(30));

cu.setDY_number11(rs.getFloat(31));

cu.setDY_name12(rs.getString(32));

cu.setDY_number12(rs.getFloat(33));

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.CuFang;

public class CuSelectOneService

{

public List cuselect(String number,String name,String time) throws SQLException

{

String sql="select *from chufang where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and C_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and C_name='"+name+"'";

}

if(time!=null&&!time.equalsIgnoreCase(""))

{

sql1=sql+" and C_time='"+time+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

CuFang cu=new CuFang();

cu.setC_number(rs.getString(2));

cu.setC_time(rs.getString(3));

cu.setC_name(rs.getString(4));

cu.setC_sex(rs.getString(5));

cu.setC_age(rs.getString(6));

cu.setC_cost(rs.getString(7));

package com.fit.service;

import com.fit.dao.LoginDao;

public class CuUpdateService

{

public void updatecu(String number ,String yao1,float numberz1,String yao2,float numberz2,

String yao3,float numberz3,String yao4,float numberz4,String yao5,float numberz5,

String yao6,float numberz6,String yao7,float numberz7,String yao8,float numberz8,

String yao9,float numberz9,String yao10,float numberz10,String yao11,float numberz11,

String yao12,float numberz12)

{

String sql="update C_drug set DY_name1='"+yao1+"',DY_number1="+numberz1+",DY_name2='"+yao2+"',DY_number2=1"+numberz2+",DY_name3='"+yao3+"',DY_number3="+numberz3+",DY_name4='"+yao4+"',DY_number4="+numberz4+"," + "DY_name5='"+yao5+"',DY_number5="+numberz5+",DY_name6='"+yao6+"',DY_number6="+numberz6+",DY_name7='"+yao7+"',DY_number7="+numberz7+",DY_name8='"+yao8+"',DY_number8="+numberz8+",DY_name9='"+yao9+"'," +"DY_number9="+numberz9+",DY_name10='"+yao10+"',DY_number10="+numberz10+",DY_name11='"+yao11+"',DY_number11="+numberz11+",DY_name12='"+yao12+"',DY_number12="+numberz12+" where D_number='"+number+"'";

LoginDao dao=new LoginDao();

dao.login(sql);

}

5.6收费管理模块的实现

1）处方查询界面，如图5.7所示：

图5.7处方查询界面

处方查询的核心代码：

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

public class SHMoney

{

public void shoufei(String numberA, String number,String time,String name,String beizhu,String shou,float money)

{

String sql="insert shoufei values('"+number+"','"+time+"','"+name+"','"+shou+"',"+money+",'"+beizhu+"')";

String sql1="update chufang set C_cost='已交费' where C_number='"+numberA+"'";

LoginDao dao=new LoginDao();

dao.login(sql);

dao.login(sql1);

}

public List shoufei1() throws SQLException

{

String sql="select *from shoufei";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ShouFei cu=new ShouFei();

cu.setS_number(rs.getString(2));

cu.setS_time(rs.getString(3));

cu.setS_name(rs.getString(4));

cu.setS_names(rs.getString(5));

cu.setS_money(rs.getFloat(6));

cu.setS_nei(rs.getString(7));

public void delect(String number)

{

String sql="delete shoufei where S_number='"+number+"'";

LoginDao dao=new LoginDao();

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

public class SHSelectService

{

public List cuselect(String number,String name,String time) throws SQLException

{

String sql="select *from shoufei where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and s_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and s_name='"+name+"'";

}

if(time!=null&&!time.equalsIgnoreCase(""))

{

sql1=sql+" and s_time='"+time+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

ShouFei cu=new ShouFei();

cu.setS_number(rs.getString(2));

cu.setS_time(rs.getString(3));

cu.setS_name(rs.getString(4));

cu.setS_names(rs.getString(5));

cu.setS_money(rs.getFloat(6));

cu.setS_nei(rs.getString(7));

5.7药品管理模块的实现

1) 收费单查询，如图5.9所示：

图5.9 收费单查询界面

收费单查询核心代码

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

import com.fit.javabean.YaoPin;

public class XYYaoInsertService

{

public void yao(String name,String nei,String gui,String corporation,String liang,String danwei,String money, String you )

{

String sql="insert into M_drug values('"+name+"','"+nei+"','"+gui+"','"+corporation+"','"+liang+"','"+danwei+"','"+money+"','"+you+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public List yaopin() throws SQLException

{

String sql="select *from M_drug";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

public List yaopin1(int number1) throws SQLException

{

String sql="select *from M_drug where M_number="+number1+"";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

public List xyselect(String number,String name,String nei,int number1) throws SQLException

{

String sql="select *from M_drug where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and M_number="+number1;

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and M_name='"+name+"'";

}

if(nei!=null&&!nei.equalsIgnoreCase(""))

{

sql1=sql+" and M_nei='"+nei+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

package com.fit.service;

import com.fit.dao.LoginDao;

public class XYinsertService

{

public void xyinsert(String number,String time,String name,String shou,String beizhu)

{

String sql="insert into drug values('"+number+"','"+time+"','"+name+"','"+shou+"','"+beizhu+"')";

String sql1="update shoufei set S_nei='"+beizhu+"' where S_number='"+number+"'";

LoginDao dao=new LoginDao();

package com.fit.service;

import com.fit.dao.LoginDao;

public class XYDeleteService

{

public void delectyao(int number1)

{

String sql="delete M_drug where M_number="+number1+" ";

LoginDao hao=new LoginDao();

hao.login(sql);

}

public void updateyao(String name,String nei,String gui,String corporation,String liang,

String danwei,String money, String you, int number1)

{

String sql="update M_drug set M_name='"+name+"',M_nei='"+nei+

"',M_gui='"+gui+"',M_corporation='"+corporation+"',M_liang='"+liang+"',M_danwei='"+danwei+

"',M_money='"+money+"',M_you='"+you+"' where M_number="+number1+"";

LoginDao dao=new LoginDao();

dao.login(sql);

}

5.8后台管理模块的实现

后台管理界面，如图5.12所示：

图5.12后台管理界面如图

后台管理的核心代码：

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ZGuan;

public class ZMangeService

{

public List guahao() throws SQLException

{

String sql="select *from user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setUsername(rs.getString(2));

cu.setPassword(rs.getString(3));

public List chufang() throws SQLException

{

String sql="select *from C_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setC_username(rs.getString(2));

cu.setC_password(rs.getString(3));

public List shoufie() throws SQLException

{

String sql="select *from S_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setS_username(rs.getString(2));

cu.setS_password(rs.getString(3));

public List yaopin() throws SQLException

{

String sql="select *from Y_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setY_username(rs.getString(2));

cu.setY_password(rs.getString(3));

6 系统测试

在完成了一个应用程序的开发之后，便进入了系统测试阶段，系统测试将检查应用程序是否完成了用户的需求，软件在操作的过程中是否存在漏洞。

6.1测试环境

本医院门诊信息管理系统开发与测试运行环境如下：

开发环境：Windows XP、TomCat

开发工具：MyEclipse6.5、TomCat

运行环境：Windows 98/ME/2000/XP

6.2功能测试

按挂号单编号、病人名、所挂科室名进行查询挂号单基本信息；

按处方单编号、病人名、开处方日期查询处方单基本信息；

按交费单编号、病人名、交费日期查询交费单基本信息；

按药品编号、药品名、药品种类查询药品基本信息；

6.3性能测试

对性能进行了测试，主要有以下两点：

(1)数据精确度

查询时应保证查全率，所有在相应域中包含查询关键字的记录都应能查到，同时保证查准率。

(2)时间特性

一般操作的响应时间应在1－2秒内。

6.4界面测试

软件拥有图形用户界面。测试重点是正确性、易用性和视觉效果。在评价易用性和视觉效果时，主观性非常强，应当考虑多个人的观点。

6.5调试问题

在测试软件的时候，我遇到了转码的问题，中文不能存入数据库中，在查询中也不能输入中文进行查询。经过最后的分析，我通过加入过滤器进行了转码，最终解决了乱码的问题，过滤器代码如下：

package com.fit.Encoding;

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;

public class Encoding implements Filter {

public void destroy() {

// TODO Auto-generated method stub

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain filterChain) throws IOException, ServletException {

request.setCharacterEncoding("GBK");

filterChain.doFilter(request, response);

}

public void init(FilterConfig arg0) throws ServletException {

// TODO Auto-generated method stub

}

将过滤器在xml文件中进行如下配置：

<filter-name>Encoding</filter-name>

<filter-class>com.fit.Encoding.Encoding</filter-class>

</filter>

<filter-mapping>

<filter-name>Encoding</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

6.6测试结果

经过全面的测试，该系统所要求的功能基本能实现，系统性能稳定，安全性好。界面友好且朴实无华。基本达到预期效果。

总结

毕业设计的过程是艰辛的，但是我的收获却是很大的。我的毕业设计主要是应用以前学习的Java知识数据库的知识和在校外学习的jsp技术，综合起来完成了这个医院门诊信息管理的软件，软件虽然不大，但是付出却是十分艰辛的。

首先，通过做毕业设计，我把以前学习到的知识得到了巩固和进一步的提高。再次，我在课程设计中碰到了大量的问题，我通过查阅相关书籍、资料、网络，通过自己钻研，特别是得到了我的指导老师杨刚老师的帮助，使得我在做整个毕业设计的过程中感觉非常的顺利，同时我思路开阔也变得开阔，对软件编程也有了新的认识。

我这次毕业设计的任务是建立一个医院门诊信息管理系统，它用到的开发工具是MyEclipse6.5、SQL server 2000以及TomCat6.0服务器。医院门诊信息管理系统的基本功能：挂号管理、处方管理、收费管理、药品管理和后台管理。在老师同学的帮助下，以及自己的努力下，终于完成这个系统的开发。

当然，通过这次课程设计，我也发现了自身的很多不足之处，在以后的学习中，我会不断的完善自我，不断进取，能使自己在编程这方面有一个大的发展。总之，通过几个月的毕业设计，让我感受了软件开发的整个过程的艰辛。毕业设计不仅是对我在大学所学知识的一个综合运用，也是一次增长知识和经验的好机会，同时也使我学会了许多处理、解决问题的方法，大大提高了自己的动手能力，为即将走上工作岗位打下了良好的基础

致谢

毕业设计与论文即将完成之际，回想起开始做毕业设计时的不知所措，以及调研、调试过程中的多次遇阻，真是说不出的艰辛。幸好，有许多老师、同学的帮助，我才得以调试成功，一次次的改进自己的程序，实现各种功能。正是在这些朋友的帮助下，我才及时纠正了自己的语法错误、逻辑错误、攻克了不少难点。

感谢我的指导师杨刚老师。是他在毕业设计之初帮助我分析题目，讲解整个软件的思路，为良好的开端奠定了基础。尤其是在实际设计阶段，老师给了很多的资料，这些资料给了我我相当大的帮助。在杨老师和同学的帮助下，我的毕业设计才能如此迅速的顺利的完成。所以，非常感谢杨刚老师的指导。

不积跬步何以至千里.这次做论文的经历也会使我终身受益，我感受到做论文是要真真正正用心去做的一件事情，是真正的自己学习的过程和研究的过程，没有学习就不可能有研究的能力，没有自己的研究，就不会有所突破，本设计能够顺利的完成，也归功于各位任课老师的认真负责，和同学的热心帮助，使我能够很好的掌握和运用专业知识，并在设计中得以体现。正是有了他们的悉心帮助和支持，才使我的毕业论文工作顺利完成。

在此向陕西理工学院，计算机系的全体老师表示由衷的谢意。感谢他们多年来的辛勤栽培。

参考文献

[1] 朱道元等编著,《数据库精选》，北京：海洋出版社，2000。

[2] 周义仓，赫孝良编著，《数据库实验》西安：西安交通大学出版社，1999。

[3] 陈理荣主编，《数据库导论》，北京：北京邮电大学出版社，1999。

[4] 萨师煊，王珊，《数据库系统概论》，北京：高等教育出版社，1990。

[5] 李建义主编, 《数据库原理及应用》, 出版社: 北京交通大学出版社, 2006

[6]Management Information System , Mcleod , Printice Hall , 1998

[7]薛华成主编，《管理信息系统》[M] .北京：清华大学出版社，1999，

[8] Thomas R. Peltier.Information Security Risk Analysis.Rothstein Associates Inc,2001

科技外文文献

JSP Introduction

JSP (JavaServer Pages) by Sun Microsystems, advocacy, many companies involved in the establishment of a dynamic website with technical standards, the site at http://www.javasoft.com/products/jsp. The technology for creating display dynamically generated content Web page provides a simple and fast way. JSP technology is designed to make Web-based application constructed more easily and quickly, but these applications to work with a variety of Web servers, application server, browser and development tools to work together. JSP specification is the Web server, application server, transaction systems and development tools supplier broad cooperation between the results. In a traditional web page HTML file (* htm, *. html) to add Java program fragment (Scriptlet) and JSP tags (tag), constitutes JSP pages (*. jsp). Web server in the event of a request to access JSP page, the first implementation of the program fragment, and then implement the results in HTML format back to the customer. Program fragments can operate the database, redirect pages and send email, etc., which is needed to create dynamic web site functionality. All program operations are executed on the server, network upload client is only given to the results obtained, the client browser requests a minimum, can be achieved without Plugin, no ActiveX, no Java Applet, even without Frame.

Brief history of the World Wide Web, World Wide Web has grown from a majority of the network shows the evolution of static information to carry out stock transactions and a textbook operation of infrastructure. In various applications, may be used for Web-based client, look no restrictions.

Browser-based client-based applications than traditional client / server applications have several advantages. These benefits include the almost unlimited client access and an extremely simplified application deployment and management (to update an application, managers only need to change a server-based programs, rather than the tens of thousands of installed applications on the client ). In this way, the software industry is quickly to build browser-based client applications into the multi-layered.

The rapid growth of sophisticated Web-based application requires development of technical improvements. Static HTML content for displaying relatively static is a good choice; new challenge is to create a Web-based interaction of applications, in these proceedings, the page's content is based on the user's request or the state of the system, not pre-defined text .

For this problem an early solution is to use CGI-BIN interfaces. Developers to write interfaces associated with the separate procedures, and Web-based applications, the latter through the Web server to call the former. The program has a serious scalability issues - each new CGI request to add a process server. If multiple users concurrent access to the program, the process will consume all of the Web server's available resources and system performance will be reduced to extremely low proportions.

Some of the Web server vendors have tried through their servers, "plug" and the API to simplify Web application development. These solutions are associated with a specific Web server, and can not solve the cross-vendor solution for multiple problems. For example, Microsoft's Active Server Pages (ASP) technology makes Web pages easier to create dynamic content, but can only work in Microsoft's IIS and Personal Web Server on.

There are other solutions, but do not make a normal page designers can easily grasp. For example, technologies such as Java Servlet using the Java language can make interactive applications in the server-side code easier. Developers to write such a Servlet, to receive from the Web browser's HTTP request to dynamically generate the response (which may have to query the database to complete the request) and send HTML or XML document that contains the response to the browser.

JSP technology in various aspects of accelerated development of dynamic Web pages:

1. Content generation and display separation

Use JSP technology, Web page developers can use HTML or XML logo to design and format the final page. Use the logo or feet have been generated JSP pages of dynamic content (content is based on a request to change, for example, account information or request a specific price for a bottle of wine). Generates the logic is encapsulated in the logo and JavaBeans components and tied in small script, all the scripts run in the server. If the core logic is encapsulated in the identification and Beans, then others, such as managers and Web page designers, can edit and use the JSP page without affecting the content generated. On the server side, JSP JSP engine identification and a small script to explain to generate the requested content (for example, by accessing JavaBeans components, using JDBCTM technology to access the database, or include file), and the results to HTML (or XML) page of the form sent back to the browser. This helps to protect their code on, but ensure that any HTML-based Web browser, full availability.

2. Emphasize reusable components

Most JSP pages rely on reusable, cross-platform components (JavaBeans or Enterprise JavaBeansTM components) to implement the requirements of the application more complex treatment. Developers to share and exchange components to perform common operations, or making more of these components is used by the user or customer groups. Component-based approach to accelerate the overall development process, and makes all kinds of organizations optimize their existing skills and the results of development efforts in equilibrium.

3. Simplify page development with identity

Web page developers are familiar with the scripting language will not be programmers. JavaServer Page technology encapsulates many features that are easy to use, XML and JSP-related identity of the dynamic content generation needs. JSP standard logo can access and instantiate JavaBeans component, set or retrieve the component properties, download Applet, as well as implementation of the code more difficult by other means, and time consuming functions.

Identity through the development of customized database, JSP technology is extensible. In the future, third-party developers and other personnel functions for commonly used libraries to create their own identity. This allows Web page developers can use familiar tools and the same as the identification of components that perform specific functions to work.

JSP technology is easily integrated into a variety of applications architecture to take advantage of existing tools and techniques, and extended to support enterprise-class distributed applications. As part of the family using Java technology, and Java 2 (Enterprise Architecture) is an integral part of, JSP technology can support the highly complex Web-based applications.

Since the built-in scripting language, JSP pages are based on Java programming language, and all JSP pages are compiled into Java Servlet, JSP page to have all the benefits of Java technology, including robust storage management and security. As part of the Java platform, JSP Java programming language has a "write once, run everywhere" feature. As more providers will add JSP support to their products, you can use your own choice of server and tools, change tools, or the server does not affect the current application. As with the Java 2 Platform, Enterprise Edition (J2EE) and Enterprise JavaBean technology integration time, JSP page will provide enterprise-class scalability and performance, which is for deployment in a virtual enterprise Web-based applications is required.

4. Technical Analysis

ASP technology is Microsoft's Active Server Page technology. From the form of JSP and ASP are very similar, ASP programmers will recognize a <%%> and <% =%,>. But go further explore the differences will find that many of them, most notably the following three points:

(1）JSP higher efficiency and security

ASP stored in source form, to explain the run, each call ASP pages need to be interpreted on the source, the efficiency is not high. In addition, IIS vulnerability has led many major exposure source site, including the author previously developed sites using ASP, ASP program all be downloaded to. Before the first in the implementation of JSP is compiled into byte code (byte code), byte code by a Java Virtual Machine (Java Virtual Machine) to explain the implementation, interpretation and efficient than the source; server also bytecode Cache mechanism will byte code to improve access efficiency. The first call JSP page may slightly slower, because it is compiled into Cache, after the faster too. Meanwhile, JSP source code is unlikely to be downloaded, especially JavaBean procedures can not put the external directory.

(2）JSP component (Component) method is more convenient

ASP via COM to expand the complex functions such as file upload, send email, and the business process or complex calculations separated into independent reusable modules. JSP JavaBean achieved through the expansion of the same features. In development, COM development complex and cumbersome than the JavaBean, ASP is not difficult to learn, but learn to develop COM to be. The JavaBean much easier, from the previously mentioned examples can be seen easily JavaBean development. In maintenance, COM must be registered on the server, if the revised COM program, you must re-register, and even to shut down and restart. JavaBean do not need to register on the CLASSPATH includes the directory on the line. If the JavaBean was modified, then the Tomcat JSWDK and now need to close and re-run (but not off), but the developers have promised to do in later versions do not need to shut down the server. Another JavaBean is complete OOP, can function for different business processes to establish a set of easily reusable object library, such as user access control, email auto-reply, etc..

(3） JSP wider adaptation platform

ASP is only available for NT and IIS. Although plug-ins ChiliSoft under Unix to support ASP, but their function is limited ASP, ASP + COM must be through a combination of expansion, Unix COM under very difficult to achieve.

中文译文

JSP简介

JSP(JavaServer Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准，其网址为http://www.javasoft.com/products/jsp。该技术为创建显示动态生成内容的Web页面提供了一个简捷而快速的方法。JSP技术的设计目的是使得构造基于Web的应用程序更加容易和快捷，而这些应用程序能够与各种Web服务器，应用服务器，浏览器和开发工具共同工作。 JSP规范是Web服务器、应用服务器、交易系统、以及开发工具供应商间广泛合作的结果。在传统的网页HTML文件(*htm,*.html)中加入Java程序片段(Scriptlet)和JSP标记(tag)，就构成了JSP网页(*.jsp)。Web服务器在遇到访问JSP网页的请求时，首先执行其中的程序片段，然后将执行结果以HTML格式返回给客户。程序片段可以操作数据库、重新定向网页以及发送 email 等等，这就是建立动态网站所需要的功能。所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，对客户浏览器的要求最低，可以实现无Plugin，无ActiveX，无Java Applet，甚至无Frame。

在万维网短暂的历史中，万维网已经从一个大部分显示静态信息的网络演化到对股票进行交易和进行购书操作的一个基础设施。在各种各样的应用程序中，对于可能使用的基于Web的客户端，看上去没有任何限制。

基于浏览器客户端的应用程序比传统的基于客户机/服务器的应用程序有几个好处。这些好处包括几乎没有限制的客户端访问和极其简化的应用程序部署和管理（要更新一个应用程序，管理人员只需要更改一个基于服务器的程序，而不是成千上万的安装在客户端的应用程序）。这样，软件工业正迅速地向建造基于浏览器客户端的多层次应用程序迈进。

这些快速增长的精巧的基于Web的应用程序要求开发技术上的改进。静态HTML对于显示相对静态的内容是不错的选择；新的挑战在于创建交互的基于Web的应用程序，在这些程序中，页面的内容是基于用户的请求或者系统的状态，而不是预先定义的文字。

对于这个问题的一个早期解决方案是使用CGI-BIN接口。开发人员编写与接口相关的单独的程序，以及基于Web的应用程序，后者通过Web服务器来调用前者。这个方案有着严重的扩展性问题——每个新的CGI要求在服务器上新增一个进程。如果多个用户并发地访问该程序，这些进程将消耗该Web服务器所有的可用资源，并且系统性能会降低到极其低下的地步。

某些Web服务器供应商已经尝试通过为他们的服务器提供“插件”和API来简化Web应用程序的开发。这些解决方案是与特定的Web服务器相关的，不能解决跨多个供应商的解决方案的问题。例如，微软的Active Server Pages（ASP）技术使得在Web页面上创建动态内容更加容易，但也只能工作在微软的IIS和Personal Web Server上。

还存在其他的解决方案，但都不能使一个普通的页面设计者能够轻易地掌握。例如，像Java Servlet这样的技术就可以使得用Java语言编写交互的应用程序的服务器端的代码变得容易。开发人员能够编写出这样的Servlet，以接收来自Web浏览器的HTTP请求，动态地生成响应（可能要查询数据库来完成这项请求），然后发送包含HTML或XML文档的响应到浏览器。

JSP技术在多个方面加速了动态Web页面的开发：

1．将内容的生成和显示进行分离

使用JSP技术，Web页面开发人员可以使用HTML或者XML标识来设计和格式化最终页面。使用JSP标识或者小脚本来生成页面上的动态内容（内容是根据请求来变化的，例如请求帐户信息或者特定的一瓶酒的价格）。生成内容的逻辑被封装在标识和JavaBeans组件中，并且捆绑在小脚本中，所有的脚本在服务器端运行。如果核心逻辑被封装在标识和Beans中，那么其他人，如Web管理人员和页面设计者，能够编辑和使用JSP页面，而不影响内容的生成。在服务器端，JSP引擎解释JSP标识和小脚本，生成所请求的内容（例如，通过访问JavaBeans组件，使用JDBCTM技术访问数据库，或者包含文件），并且将结果以HTML（或者XML）页面的形式发送回浏览器。这有助于作者保护自己的代码，而又保证任何基于HTML的Web浏览器的完全可用性。

2．强调可重用的组件

绝大多数JSP页面依赖于可重用的，跨平台的组件（JavaBeans或者Enterprise JavaBeansTM组件）来执行应用程序所要求的更为复杂的处理。开发人员能够共享和交换执行普通操作的组件，或者使得这些组件为更多的使用者或者客户团体所使用。基于组件的方法加速了总体开发过程，并且使得各种组织在他们现有的技能和优化结果的开发努力中得到平衡。

3．采用标识简化页面开发

Web页面开发人员不会都是熟悉脚本语言的编程人员。JavaServer Page技术封装了许多功能，这些功能是在易用的、与JSP相关的XML标识中进行动态内容生成所需要的。标准的JSP标识能够访问和实例化JavaBeans组件，设置或者检索组件属性，下载Applet，以及执行用其他方法更难于编码和耗时的功能。

通过开发定制化标识库，JSP技术是可以扩展的。今后，第三方开发人员和其他人员可以为常用功能创建自己的标识库。这使得Web页面开发人员能够使用熟悉的工具和如同标识一样的执行特定功能的构件来工作。

JSP技术很容易整合到多种应用体系结构中，以利用现存的工具和技巧，并且扩展到能够支持企业级的分布式应用。作为采用Java技术家族的一部分，以及Java 2（企业版体系结构）的一个组成部分，JSP技术能够支持高度复杂的基于Web的应用。

由于JSP页面的内置脚本语言是基于Java编程语言的，而且所有的JSP页面都被编译成为Java Servlet，JSP页面就具有Java技术的所有好处，包括健壮的存储管理和安全性。作为Java平台的一部分，JSP拥有Java编程语言“一次编写，各处运行”的特点。随着越来越多的供应商将JSP支持添加到他们的产品中，您可以使用自己所选择的服务器和工具，更改工具或服务器并不影响当前的应用。当与Java 2平台，企业版(J2EE)和Enterprise JavaBean技术整合时，JSP页面将提供企业级的扩展性和性能，这对于在虚拟企业中部署基于Web的应用是必需的。

4．技术分析

Microsoft 公司的 ASP 技术也是动态网页开发技术。JSP和ASP从形式上非常相似，ASP程序员一眼就能认出<% %>以及<%= %>。但是深入探究下去会发现它们很多的差别，其中最主要的有以下三点：

(1） JSP的效率和安全性更高

ASP以源码形式存放，以解释方式运行，每次ASP网页调用都需要对源码进行解释，运行效率不高。另外，IIS的漏洞曾使得许多网站源程序大曝光，包括笔者以前用ASP开发的网站，ASP程序全部被人下载了去。JSP在执行以前先被编译成字节码 (byte code)，字节码由Java虚拟机(Java Virtual Machine)解释执行，比源码解释的效率高；服务器上还有字节码的Cache机制，能提高字节码的访问效率。第一次调用JSP网页可能稍慢，因为它被编译成Cache，以后就快得多了。同时，JSP源程序不大可能被下载，特别是JavaBean程序完全可以放到不对外的目录中。

(2） JSP的组件 (Component) 方式更方便

ASP通过COM来扩充复杂的功能，如文件上载、发送email以及将业务处理或者复杂计算分离出来成为独立可重复利用的模块。JSP通过JavaBean实现了同样的功能扩充。在开发方面，COM的开发远比JavaBean复杂和繁琐，学会ASP不难，但学会开发COM可不简单。而JavaBean就简单多了，从本文上述示例中可以看出开发JavaBean很方便。在维护方面，COM必须在服务器上注册，如果修改了COM程序，就必须重新注册，甚至必须关机和重新启动。JavaBean则不需要注册，放在CLASSPATH包含的目录中就行了。如果JavaBean进行了修改，则JSWDK和Tomcat现在还需要关闭和重新运行（但不是关机），但开发者已经许诺将在以后的版本中做到不需要关闭服务器。另外JavaBean是完全的OOP，可以针对不同的业务处理功能方便地建立一整套可重复利用的对象库，例如用户权限控制、email自动回复等等。

(3） JSP的适应平台更广

ASP目前仅适用于NT和IIS。虽然Unix下有ChiliSoft的插件来支持ASP，但是ASP本身的功能有限，必须通过ASP+COM的组合来扩充，Unix下的COM实现起来非常困难。

附录A：源程序代码

挂号管理模块的部分代码:

package com.fit.service;

import com.fit.dao.LoginDao;

public class GuaHaoDelectService

{

public void delect(String number)

{

String sql="delete guahao where G_number='"+number+"'";

LoginDao login=new LoginDao();

}

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.GuaHao;;

public class GuaHaoSelectService

{

public List select() throws SQLException

{

String sql="select *from guahao";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

GuaHao cu=new GuaHao();

cu.setNumber(rs.getString(2));

cu.setName(rs.getString(3));

cu.setSex(rs.getString(4));

cu.setAge(rs.getString(5));

cu.setKebie(rs.getString(6));

cu.setKename(rs.getString(7));

cu.setKeshi(rs.getString(8));

public List select1(String number,String name,String sex) throws SQLException

{

String sql="select *from guahao where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and G_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and G_name='"+name+"'";

}

if(sex!=null&&!sex.equalsIgnoreCase(""))

{

sql1=sql+" and G_sex='"+sex+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

GuaHao cu=new GuaHao();

cu.setNumber(rs.getString(2));

cu.setName(rs.getString(3));

cu.setSex(rs.getString(4));

cu.setAge(rs.getString(5));

cu.setKebie(rs.getString(6));

cu.setKename(rs.getString(7));

cu.setKeshi(rs.getString(8));

public List select2(String number,String name,String keshi) throws SQLException

{

String sql="select *from guahao where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and G_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and G_name='"+name+"'";

}

if(keshi!=null&&!keshi.equalsIgnoreCase(""))

{

sql1=sql+" and G_ke='"+keshi+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

GuaHao cu=new GuaHao();

cu.setNumber(rs.getString(2));

cu.setName(rs.getString(3));

cu.setSex(rs.getString(4));

cu.setAge(rs.getString(5));

cu.setKebie(rs.getString(6));

cu.setKename(rs.getString(7));

cu.setKeshi(rs.getString(8));

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

GuaHaoDelectService gua=new GuaHaoDelectService();

gua.delect(number);

response.sendRedirect("GuaHaoXianServlet");

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String sex=request.getParameter("sex");

GuaHaoSelectService hao=new GuaHaoSelectService();

try {

if(number==""&&name==""&&sex=="")

{

List list=hao.select();

request.setAttribute("action", list);

request.getRequestDispatcher("index/GuaHaoSelect.jsp").forward(request, response);

}

else

{

List list1=hao.select1(number, name, sex);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/GuaHaoSelect.jsp").forward(request, response);

}

} catch (SQLException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String sex=request.getParameter("sex");

String age=request.getParameter("age");

String kebie=request.getParameter("kebie");

String kename=request.getParameter("kename");

String keshi=request.getParameter("keshi");

GuaHaoService guahao=new GuaHaoService();

guahao.guahao(number, name, sex, age, kebie, kename, keshi);

try {

List list=guahao.showguahao(number);

request.setAttribute("action", list);

request.getRequestDispatcher("index/GuaHaok.jsp").forward(request, response);

} catch (SQLException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

GuaHaoUpdateService show=new GuaHaoUpdateService();

try {

List list=show.showupdate(number);

request.setAttribute("action", list);

request.getRequestDispatcher("index/GuaHaoUpdate.jsp").forward(request, response);

} catch (SQLException e) {

e.printStackTrace();

}

处方模块部分代码

package com.fit.service;

import com.fit.dao.LoginDao;

public class CuDelectService

{

public void delectcu(String number)

{

String sql1="delete chufang where C_number='"+number+"'";

String sql2="delete C_drug where D_number='"+number+"'";

LoginDao dao=new LoginDao();

dao.login(sql1);

dao.login(sql2);

}

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.CuFang;

public class CuSelectOneService

{

public List cuselect(String number,String name,String time) throws SQLException

{

String sql="select *from chufang where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and C_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and C_name='"+name+"'";

}

if(time!=null&&!time.equalsIgnoreCase(""))

{

sql1=sql+" and C_time='"+time+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

CuFang cu=new CuFang();

cu.setC_number(rs.getString(2));

cu.setC_time(rs.getString(3));

cu.setC_name(rs.getString(4));

cu.setC_sex(rs.getString(5));

cu.setC_age(rs.getString(6));

cu.setC_cost(rs.getString(7));

package com.fit.service;

import com.fit.dao.LoginDao;

public class CuXianService

{

public void CuInsert(String C_name, String C_number,String C_time,String C_cost,

String C_sex,String C_age,String yao1,float numberz1,String yao2,float numberz2,

String yao3,float numberz3,String yao4,float numberz4,String yao5,float numberz5,

String yao6,float numberz6,String yao7,float numberz7,String yao8,float numberz8,

String yao9,float numberz9,String yao10,float numberz10,String yao11,float numberz11,

String yao12,float numberz12)

{

String sql1="insert into chufang values" +

"('"+C_number+"','"+C_time+"','"+C_name+"','"+C_sex+"','"+C_age+"','"+C_cost+"')";

String sql2="insert into C_drug values" + "('"+C_number+"','"+yao1+"',"+numberz1+",'"+yao2+"',"+numberz2+",'"+yao3+"',"+numberz3+",'"+yao4+"',"+numberz4+",'"+yao5+"',"+numberz5+",'"+yao6+"',"+numberz6+"," + "'"+yao7+"',"+numberz7+",'"+yao8+"',"+numberz8+",'"+yao9+"',"+numberz9+",'"+yao10+"',"+numberz10+",'"+yao11+"',"+numberz11+",'"+yao12+"',"+numberz12+")";

LoginDao dao=new LoginDao();

dao.login(sql1);

dao.login(sql2);

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

CuSelectService hao=new CuSelectService();

try {

List list=hao.cuselect();

request.setAttribute("action", list);

request.getRequestDispatcher("index/CuDelect.jsp").forward(request, response);

} catch (SQLException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String C_number=request.getParameter("C_number");

String C_time=request.getParameter("C_time");

//String number=request.getParameter("number");

String C_name=request.getParameter("name");

String C_sex=request.getParameter("sex");

String C_age=request.getParameter("age");

String yao1=request.getParameter("yao1");

String number1=request.getParameter("number1");

String yao2=request.getParameter("yao2");

String number2=request.getParameter("number2");

String yao3=request.getParameter("yao3");

String number3=request.getParameter("number3");

String yao4=request.getParameter("yao4");

String number4=request.getParameter("number4");

String yao5=request.getParameter("yao5");

String number5=request.getParameter("number5");

String yao6=request.getParameter("yao6");

String number6=request.getParameter("number6");

String yao7=request.getParameter("yao7");

String number7=request.getParameter("number7");

String yao8=request.getParameter("yao8");

String number8=request.getParameter("number8");

String yao9=request.getParameter("yao9");

String number9=request.getParameter("number9");

String yao10=request.getParameter("yao10");

String number10=request.getParameter("number10");

String yao11=request.getParameter("yao11");

String number11=request.getParameter("number11");

String yao12=request.getParameter("yao12");

String number12=request.getParameter("number12");

float numberz1=Float.valueOf(number1).floatValue();

float numberz2=Float.valueOf(number2).floatValue();

float numberz3=Float.valueOf(number3).floatValue();

float numberz4=Float.valueOf(number4).floatValue();

float numberz5=Float.valueOf(number5).floatValue();

float numberz6=Float.valueOf(number6).floatValue();

float numberz7=Float.valueOf(number7).floatValue();

float numberz8=Float.valueOf(number8).floatValue();

float numberz9=Float.valueOf(number9).floatValue();

float numberz10=Float.valueOf(number10).floatValue();

float numberz11=Float.valueOf(number11).floatValue();

float numberz12=Float.valueOf(number12).floatValue();

String C_cost="未交费";

CuXianService cu=new CuXianService();

cu.CuInsert(C_name, C_number, C_time, C_cost, C_sex, C_age, yao1,

numberz1, yao2, numberz2, yao3, numberz3, yao4, numberz4, yao5, numberz5, yao6, numberz6, yao7, numberz7, yao8, numberz8, yao9, numberz9, yao10, numberz10, yao11, numberz11, yao12, numberz12);

response.sendRedirect("CuXianServlet");}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String keshi=request.getParameter("keshi");

GuaHaoSelectService hao=new GuaHaoSelectService();

try {

if(number==""&&name==""&&keshi=="")

{

List list=hao.select();

request.setAttribute("action", list);

request.getRequestDispatcher("index/CuXian.jsp").forward(request, response);

}

else

{

List list1=hao.select1(number, name, keshi);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/CuXian.jsp").forward(request, response);

}

} catch (SQLException e) {

e.printStackTrace();

}

收费管理模块的部分代码

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

public class SHMoney

{

public void shoufei(String numberA, String number,String time,String name,String beizhu,String shou,float money)

{

String sql="insert shoufei values('"+number+"','"+time+"','"+name+"','"+shou+"',"+money+",'"+beizhu+"')";

String sql1="update chufang set C_cost='已交费' where C_number='"+numberA+"'";

LoginDao dao=new LoginDao();

dao.login(sql);

dao.login(sql1);

}

public List shoufei1() throws SQLException

{

String sql="select *from shoufei";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ShouFei cu=new ShouFei();

cu.setS_number(rs.getString(2));

cu.setS_time(rs.getString(3));

cu.setS_name(rs.getString(4));

cu.setS_names(rs.getString(5));

cu.setS_money(rs.getFloat(6));

cu.setS_nei(rs.getString(7));

public void delect(String number)

{

String sql="delete shoufei where S_number='"+number+"'";

LoginDao dao=new LoginDao();

dao.login(sql);

}

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

public class SHSelectService

{

public List cuselect(String number,String name,String time) throws SQLException

{

String sql="select *from shoufei where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and s_number='"+number+"'";

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and s_name='"+name+"'";

}

if(time!=null&&!time.equalsIgnoreCase(""))

{

sql1=sql+" and s_time='"+time+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

ShouFei cu=new ShouFei();

cu.setS_number(rs.getString(2));

cu.setS_time(rs.getString(3));

cu.setS_name(rs.getString(4));

cu.setS_names(rs.getString(5));

cu.setS_money(rs.getFloat(6));

cu.setS_nei(rs.getString(7));

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String time=request.getParameter("time");

CuSelectOneService hao=new CuSelectOneService();

CuSelectService hao1=new CuSelectService();

try {

if(number==""&&name==""&&time=="")

{

List list=hao1.cuselect();

request.setAttribute("action", list);

request.getRequestDispatcher("index/SHSelect.jsp").forward(request, response);

}

else

{

List list1=hao.cuselect(number, name, time);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/SHSelect.jsp").forward(request, response);

}

} catch (SQLException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

CuSelectService hao=new CuSelectService();

try {

List list=hao.cuselect();

request.setAttribute("action", list);

request.getRequestDispatcher("index/SHSelect.jsp").forward(request, response);

} catch (SQLException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String time=request.getParameter("time");

SHSelectService hao=new SHSelectService();

SHMoney hao1=new SHMoney();

try {

if(number==""&&name==""&&time=="")

{

List list=hao1.shoufei1();

System.out.print("*****************"+list.size());

request.setAttribute("action", list);

request.getRequestDispatcher("index/SHSelectOne.jsp").forward(request, response);

}

else

{

List list1=hao.cuselect(number, name, time);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/SHSelectOne.jsp").forward(request, response);

}

} catch (SQLException e) {

e.printStackTrace();

}

药品管理模块的部分代码

package com.fit.service;

import com.fit.dao.LoginDao;

public class XYDeleteService

{

public void delectyao(int number1)

{

String sql="delete M_drug where M_number="+number1+" ";

LoginDao hao=new LoginDao();

hao.login(sql);

}

public void updateyao(String name,String nei,String gui,String corporation,String liang,

String danwei,String money, String you, int number1)

{

String sql="update M_drug set M_name='"+name+"',M_nei='"+nei+

"',M_gui='"+gui+"',M_corporation='"+corporation+"',M_liang='"+liang+"',M_danwei='"+danwei+

"',M_money='"+money+"',M_you='"+you+"' where M_number="+number1+"";

LoginDao dao=new LoginDao();

dao.login(sql);

}

package com.fit.service;

import com.fit.dao.LoginDao;

public class XYinsertService

{

public void xyinsert(String number,String time,String name,String shou,String beizhu)

{

String sql="insert into drug values('"+number+"','"+time+"','"+name+"','"+shou+"','"+beizhu+"')";

String sql1="update shoufei set S_nei='"+beizhu+"' where S_number='"+number+"'";

LoginDao dao=new LoginDao();

dao.login(sql);

dao.login(sql1);

}

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ShouFei;

import com.fit.javabean.YaoPin;

public class XYYaoInsertService

{

public void yao(String name,String nei,String gui,String corporation,String liang,String danwei,String money, String you )

{

String sql="insert into M_drug values('"+name+"','"+nei+"','"+gui+"','"+corporation+"','"+liang+"','"+danwei+"','"+money+"','"+you+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public List yaopin() throws SQLException

{

String sql="select *from M_drug";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

public List yaopin1(int number1) throws SQLException

{

String sql="select *from M_drug where M_number="+number1+"";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

public List xyselect(String number,String name,String nei,int number1) throws SQLException

{

String sql="select *from M_drug where 1=1";

String sql1 = null;

if(number!=null&&!number.equalsIgnoreCase(""))

{

sql1=sql+" and M_number="+number1;

}

if(name!=null&&!name.equalsIgnoreCase(""))

{

sql1=sql+" and M_name='"+name+"'";

}

if(nei!=null&&!nei.equalsIgnoreCase(""))

{

sql1=sql+" and M_nei='"+nei+"'";

}

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql1);

while(rs.next())

{

YaoPin cu=new YaoPin();

cu.setNumber(rs.getInt(1));

cu.setName(rs.getString(2));

cu.setNei(rs.getString(3));

cu.setGui(rs.getString(4));

cu.setCorporation(rs.getString(5));

cu.setLiang(rs.getString(6));

cu.setDanwei(rs.getString(7));

cu.setMoney(rs.getString(8));

cu.setYou(rs.getString(9));

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String number=request.getParameter("number");

String name=request.getParameter("name");

String nei=request.getParameter("nei");

XYYaoInsertService hao=new XYYaoInsertService();

try {

if(number==""&&name==""&&nei=="")

{

List list=hao.yaopin();

System.out.print("*****************"+list.size());

request.setAttribute("action", list);

request.getRequestDispatcher("index/XYYaoXian.jsp").forward(request, response);

List list1=hao.xyselect(number, name, nei, number1);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/XYYaoXian.jsp").forward(request, response);

}

else{

int number1=Integer.parseInt(number);

List list1=hao.xyselect(number, name, nei, number1);

request.setAttribute("action", list1);

request.getRequestDispatcher("index/XYYaoXian.jsp").forward(request, response);

}

} catch (SQLException e) {

e.printStackTrace();

}

后台用户管理部分代码

package com.fit.service;

import com.fit.dao.LoginDao;

public class ZDelectService

{

public void delect(String number)

{

String sql="delete from user1 where username1='"+number+"' ";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void delect1(String number1)

{

String sql="delete from C_user1 where username1='"+number1+"' ";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void delect2(String number2)

{

String sql="delete from S_user1 where username1='"+number2+"' ";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void delect3(String number3)

{

String sql="delete from Y_user1 where username1='"+number3+"' ";

LoginDao dao=new LoginDao();

dao.login(sql);

}

package com.fit.service;

import com.fit.dao.LoginDao;

public class ZInsertService

{

public void insert(String username,String password)

{

String sql="insert into user1 values('"+username+"','"+password+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void insert1(String username,String password)

{

String sql="insert into C_user1 values('"+username+"','"+password+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void insert2(String username,String password)

{

String sql="insert into S_user1 values('"+username+"','"+password+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

public void insert3(String username,String password)

{

String sql="insert into Y_user1 values('"+username+"','"+password+"')";

LoginDao dao=new LoginDao();

dao.login(sql);

}

package com.fit.service;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import com.fit.dao.LoginDao;

import com.fit.javabean.ZGuan;

public class ZMangeService

{

public List guahao() throws SQLException

{

String sql="select *from user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setUsername(rs.getString(2));

cu.setPassword(rs.getString(3));

public List chufang() throws SQLException

{

String sql="select *from C_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setC_username(rs.getString(2));

cu.setC_password(rs.getString(3));

public List shoufie() throws SQLException

{

String sql="select *from S_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setS_username(rs.getString(2));

cu.setS_password(rs.getString(3));

public List yaopin() throws SQLException

{

String sql="select *from Y_user1";

List list=new ArrayList();

ResultSet rs=null;

LoginDao login=new LoginDao();

rs=login.Ku(sql);

while(rs.next())

{

ZGuan cu=new ZGuan();

cu.setY_username(rs.getString(2));

cu.setY_password(rs.getString(3));

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

ZMangeService hao=new ZMangeService();

try {

List list=hao.guahao();

List list1=hao.chufang();

List list2=hao.shoufie();

List list3=hao.yaopin();

request.setAttribute("action", list);

request.setAttribute("action1", list1);

request.setAttribute("action2", list2);

request.setAttribute("action3", list3);

request.getRequestDispatcher("index/ZGuan.jsp").forward(request, response);

} catch (SQLException e) {

e.printStackTrace();

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String zhong=request.getParameter("zhong");

String username=request.getParameter("username");

String password=request.getParameter("password");

ZInsertService hao=new ZInsertService();

if(zhong.equalsIgnoreCase("1"))

{hao.insert(username, password);

}

if(zhong.equalsIgnoreCase("2"))

{hao.insert1(username, password);

}

if(zhong.equalsIgnoreCase("3"))

{hao.insert2(username, password);

}

if(zhong.equalsIgnoreCase("4"))

{hao.insert3(username, password);

}

response.sendRedirect("ZGuanServlet");

}

附录B：系统使用说明书

软件名称：医院门诊信息管理系统

开发时间：2010年3月—2010年6月

开发环境：Windows XP 、SQL server 2000

开发工具：MyEclipse6.5、TomCat6.0

运行环境：Windows 98/ME/2000/XP

(1)软件介绍：

医院门诊管理系统是为了实现医院门诊信息之间的自动化管理为目的而设计的，它把挂号、处方管理、收费管理以及药品管理有机的联系起来，使医院门诊的信息管理告别纸制时代。本系统分为挂号管理、处方管理、收费管理、药品管理和后台管理五个模块。

(2)功能介绍：

本医院门诊信息管理系统涉及挂号信息、处方信息、收费信息、药品信息等多种数据管理。在本系统主要涉及到的是各种信息的查询以及对其进行的信息的增加、删除、修改等操作。医院门诊信息管理系统是医院门诊信息的重要工具，一个完善的医院门诊信息管理系统的任务主要包括以下几项：

挂号管理：包括挂号管理、挂号单管理。

处方管理：包括挂号单查询、处方单查询、处方单管理、开处方。

收费管理：包括处方单查询、收费、收费单管理。

药品管理：包括处方单查询、取药、录入药品信息、药品管理。

后台管理：主要是对各个模块的用户进行管理。

(3)使用方法：

1)配置运行环境，首先先要在服务器上安装MyElisple6.5、TomCat6.0和SQL server2000数据库（记住一定要在你的服务器上安装JDK6.0）。下来将项目文件导入到MyElisple6.5,启动SQL server2000将数据库文件导入，建立本项目的数据库，最后将该项目部署到TomCat6.0服务器上。

2)启动IE浏览器，在地址栏中输入“http://localhost:8080/Hospital”，进入主界面。

3)点击挂号管理，输入该模块的密码（lihaijin,123456），进入界面后对挂号信息进行录入，

点击挂号单管理对挂号单信息进行管理。

4)点击处方管理，输入该模块的密码（lihaijin,123456），进入界面后点击挂号单查询查询所

要处理的病人并对其进行开处方操作，点击处方单查询即可查询你要找的处方以及详情查看。

4)点击挂号管理，可以进行处方查询、交费、处方单查询。

5)点击药品查询，可以进行取药操作、药品基本信息录入、药品信息管理。

(4)系统维护：

系统维护与系统的建立的过程一样重要。日常维护可以保持系统的良好运行。为此特制定维护计划：

1)定期备份系统，以免磁盘发生错误。

2)定期检查内部和外部连接，以保证他们正确连接。

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

struts2 05 action通配符
实现动态访问还可以通过通配符 eg: <action name="user*" class="pack.manager" method="{1}"> <result >/success_{1}.jsp</result> </action> 当访问时如果输入 http://localhost:8080/Demo/userAdd 就会匹配到这…...
2024/4/27 8:27:04
systemd实现python的守护进程
守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。（摘自百度百科）之前有转过一遍python实现守护进程方法的博客，这次我们看看用systemd是如何实现的。有关systemd的介绍和使用推荐阮一峰老师的以下两篇…...
2024/4/27 18:09:45
递归下降语法分析程序的设计与实现
一、实验目的：加深对语法分析器工作过程的理解；加强对递归下降法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己编写的分析程序对简单的程序段进行语法翻译。二、实验内容：在实验1的基础上，用递归下降分析法编制语法分析程序，语法…...
2024/4/27 16:53:29
python教程中文版，官方版的翻译，非常好的资源
终于找到了python2官方文档的中文版，最好的python教程。在线文档地址：点击进入。...
2024/4/20 6:16:59
Struts——通配符、常量
1.Struts2的action的开发的几种方式。方式1：继承ActionSupport（如果使用struts的数据校验的功能，必须继承此类）方式2：实现Action接口方式3：不继承任何类，不实现任何接口2.通配符：在struts中的配置信息中，可以用*与{1}优化配置 < action name="login" cl…...
2024/3/28 19:48:53
Python爬取QQ空间日志及说说
17年始，想着开始学习Python，学习一段时间后，试着用Python爬取QQ空间的日志，期间碰到好多坑，有些东西也是边学边弄，代码质量都是菜鸟级别的。需要安装selenium，PhantomJS，requests。算是可见成效的第一段代码，登陆部分是从网上找的，忘记出处了，如有侵犯还请留言，我…...
2024/4/27 18:33:25
struts2 —— 通配符
struts2 通过通配符的使用可以大大简化其配置文件。其在配置文件中的使用形式如下：[b]一、调用相同Action中的不同方法：[/b]<action name="*Action" class="Test.LoginRegistAction" method="{1}" > <result name="input"…...
2024/4/16 18:50:42
语法分析：算术表达式递归下降分析程序设计
1、实验目的：（1）掌握自上而下语法分析的要求与特点。（2）掌握递归下降语法分析的基本原理和方法。（3）掌握相应数据结构的设计方法。 2、实验内容：编程实现给定算术表达式的递归下降分析器。算术表达式文法如下： E-->E+T|T T-->T*F|F F-->(E)|i 3、设计说…...
2024/4/3 16:26:49
Python 2.7 创建二维数组
前言：从java到cobol，一直没有把数组的坑填过。至少现在把python的二维数组的坑填上~~ 只要开始，都不算晚二维数组的创建beginning~ Python中的list、tuple默认都是一维的。方式一：lst2 = [1, 2, [3, 4]]等同于：lst = [1, 2] lst.append([3, 4]) print lst # 输出结果 […...
2024/4/20 17:51:56
老男孩Python 第7期老男孩Python培训视频教程
老男孩Python 第7期老男孩Python培训视频教程高清全套Python教程，如需更多Python或者老男孩的培训课程，请直接在论坛搜索关键字老男孩课程目录就不多截图了，文件夹从L01-oldboy-python-video-day1到L17-oldboy-python-video-day17_lastday每个文件夹里面包含多节视频教程，…...
2024/4/27 14:33:55
Python学习网站（简明python教程，The Python Tutorial，Python学习笔记，啄木鸟社区）
简明python教程(W3CSCHOOL)：http://www.w3cschool.cc/python/python-tutorial.htmlThe Python Tutorial(英文）: https://docs.python.org/3/tutorial/index.html，中文版：http://python.usyiyi.cn/python_341/tutorial/index.html Python学习笔记：http://www.iteedu.com/pl…...
2024/4/27 17:27:35
struts2.5.2 通配符问题_亲测有用
学了一段时间struts2，跟着教程做，但发现struts2的版本不同，很多东西的使用是有差异的。例如之前遇到的创建sessionFactory的方式就跟之前版本有着明显的差异。今天又遇到一个问题，那就是通配符的使用。问题：若不使用通配符，可以找到相对应的action，而使用通配符就会报错…...
2024/4/27 16:04:38
这可能是史上最全的 Python 算法集！| 技术头条
本文是一些机器人算法（特别是自动导航算法）的Python代码合集。其主要特点有以下三点：选择了在实践中广泛应用的算法；依赖最少；容易阅读，容易理解每个算法的基本思想。希望阅读本文后能对你有所帮助。前排友情提示，文章较长，建议收藏后再看。目录环境需求怎样使用本地化…...
2024/4/20 0:35:09
递归下降分析-实验报告
实验四：语法分析实验一、实验目的编制一个递归下降分析程序。 E→TE E→(+T|-T)E|ε T→FT T→(*F|/F)T|ε F→(E)|i 二、实验内容和要求输入：算术表达式；判断：每遇到一个终结符，则判断当前读入的单词符号是否与该终结符相匹配，若匹配，则继续读取下一个单词符…...
2024/4/27 13:36:19
【编译原理与技术】递归下降语法分析器（C++实现）
目录内容：示例：具体实现：C++代码：运行结果：内容：实现以下语法的递归下降分析：示例：对于以下代码给出其递归下降语法分析过程： {i=2;while(i<=100){sum=sum+i;i=i+2;} }具体实现：首先对上下文无关文法进行检查，消除左递归和左公共因子，从逻辑上检测避免死循环…...
2024/4/27 14:57:25
使用struts2完成用户注册主要是通配符的映射这个点
我们在做用户注册的功能点时，肯定会涉及到两个action,emp-input.action, emp-save.action. <action name="emp-*" //其中*号代表通配符 class="com.atguigu.app.Employee" method="{1}">//这个1是指第一个通配符。 …...
2024/4/27 17:27:03
【教程】【PDF】Python2.7教程
百度搜索一下python，廖雪峰python教程排行前三，进入看下还不错，但是手机上看起来不方便，所以将其教程从网页上采集起来转为pdf，有需要的朋友可以看看。python2.7教程pdf链接：http://download.csdn.net/detail/qq752923276/8796269 廖雪峰网站教程链接：http://www.liaox…...
2024/4/17 12:47:48
【强化学习篇】--强化学习案例详解一
一、前述本文通过一个案例来讲解Q-Learning 二、具体 1、案例假设我们需要走到5房间。转变为如下图：先构造奖励，达到5，即能够走得5的action则说明奖励比较高设置成100，没有达到5说明奖励比较低，设置成0。Q-learning实现步骤：2、案例详解：第一步的Q(1,5)：最开始的Q矩阵…...
2024/4/16 18:50:42
递归下降法的语法分析器-3-编译原理
递归下降法的语法分析器一、实验目的掌握语法分析器的构造原理，掌握递归下降法的编程方法。二、实验内容用递归下降法编写一个语法分析程序，使之与词法分析器结合，能够根据语言的上下文无关文法，识别输入的单词序列是否文法的句子。（注意，需要改写文法，消除左递归等）…...
2024/4/20 4:46:13
Struts2配置文件通配符的使用
Struts2配置文件中使用通配符收藏形式一：调用相同Action中的不同方法 <action name="*Action" method="{1}" class="com.system.web.action.LoginAction"><result name="input">/login.jsp</result><result na…...
2024/4/16 18:50:30

基于java医院门诊管理系统设计

相关文章

最新文章