获取项目源文件，联系Q:1225467431,可指导毕设，课设
摘 要
随着学校规模的不断扩大，学生数量急剧增加，有关学生的各种信息也成倍增长。面对如此庞大的信息量，开发学生信息管理系统来提高学生管理工作的效率就成为必然。通过该系统，可以做到信息的规范管理、科学统计和快速查询，从而减少管理方面的工作量。
本文主要介绍了学生信息管理系统的主要任务，阐述了开发该系统用到的关键技术，如采用B/S结构，使用JSP编程、利用SQLServer2000建立数据库、采用HTML，JavaScript等编程技术。
本系统是采用B/S模式进行开发的，系统的用户权限有两种：学生和系统管理员，不同权限用户登入到不同的操作界面。该系统主要由学籍维护、选课管理、成绩查询等功能模块组成，本文具体介绍了各功能模块所包含的小模块的功能，学籍维护模块主要是对学生的基本信息进行添加、查询、修改、删除；选课管理模块主要是对选修的课程进行添加、删除、统计选修人数，以及学生进行选课和更改选课；成绩查询模块主要是对必修课进行添加、删除、录入成绩，以及学生进行查询成绩等功能。
关键字：学生信息管理，B/S，JSP，Script，SQLServer2000。
Based on JSP student information management system
Abstract
Along with the school scale unceasing expansion, the student quantity sharp growth, concerned students each kind of information also becomes doubles the growth. Facing the so huge information content develops the student information management system to enhance the student supervisory work the efficiency to become inevitably. Through this system, may achieve the information the standard management, the science statistics and the fast inquiry, thus reduced management aspect work load.
This article mainly introduced the student information management system primary mission, elaborated develops essential technology which this system uses, like uses the B/S structure, uses the JSP programming, using the SQLServer2000 establishment database, uses HTML and JavaScript, and so on programming technology.
This system uses the B/S pattern to carry on the development; the system user jurisdiction has two kinds: The student and the system manager, the different jurisdiction user records to the different operation contact surface. This system mainly by the school register maintenance, chooses function module and so on class management, result inquiry to be composed, this article specifically introduced various functions module contains the small module function, the school register maintenance module mainly is carries on the increase, the inquiry, the revision, and the deletion to students basic information; Chooses the class administration module mainly is to the curriculum which takes as an elective carries on the increase, the deletion, the statistics takes as an elective the population, as well as the student carries on chooses the class and re-elects the class; The result inquiry module mainly carries on the increase, the deletion, the input result to the required course, as well as the student carries on function and inquiry result and so on.
目 录
TOC 1-3 摘 要 I
Abstract II
引 言 1
第一章 绪论 2
1.1 选题的背景和意义 2
1.2 国内外研究现状及发展趋势 2
1.3 本课题研究内容 2
1.4 本课题研究的目标及主要特色 3
第二章 系统设计使用技术介绍 4
2.1 JSP（Java Server Pages）和Java Bean技术介绍 4
2.1.1 JSP概述 4
2.1.2 JSP工作原理 4
2.1.3 JavaBean技术介绍 4
2.2 B/S体系结构介绍 5
2.3 JavaScrit技术介绍 6
2.4 SQL Server 2000 数据库 6
2.4.1 数据库介绍 6
2.4.2 ODBC数据访问接口 7
2.4.3 JDBC数据访问接口 7
第三章 系统设计 9
3.1 需求分析 9
3.1.1 运行环境 9
3.2 系统总体设计 9
3.2.1 系统目标设计 9
3.2.2 系统设计思想 9
3.2.3 系统功能描述 10
3.2.4 系统用例图 12
3.2.5 系统UML活动图 13
第四章 数据库设计 14
4.1 总体表设计 14
4.2 数据库表的结构 14
4.3 实体及ER图 16
4.3.1 实体介绍 16
4.3.2 实体的ER图以及各实体之间联系的ER图 16
4.4 数据库表的关系图 19
4.5 数据库表的视图 20
4.6 数据库连接 20
第五章 系统具体实现 23
5.1 登入界面 23
5.2 学生界面 25
5.3 学生界面功能实现 26
5.3.1 查看公告页面 26
5.3.2 学生修改密码页面 26
5.3.3 学生学籍维护页面 28
5.3.4 成绩查询 30
5.3.5 查看学修课表并进行选修 30
5.4 管理员界面 32
5.5 管理员界面功能实现 33
5.5.1 查看学生基本信息 33
5.5.2 添加新学生和选修课 35
5.5.3 查看学修课表和必修课表 36
5.5.4 查看学生选课情况和学生成绩 37
5.5.5 添加必修课表和学生成绩 40
第六章 全文总结 44
致 谢 45
参考文献 46
引 言
学生信息管理系统(SMIS)是大学信息管理系统建设的重要组成部分，是提高教学管理的质量和效益乃至建设知名高水平大学的关键环节。学生信息处理的电脑化、网络化，也是实现学校管理现代化和信息化的重要内容。
学生信息管理系统的内容对于学校的决策者和管理者来说都至关重要, 所以学生信息管理系统应该能够为用户提供充足的信息和快捷的查询手段。但一直以来人们使用传统人工的方式管理文件档案，这种管理方式存在着许多缺点,如:效率低、保密性差,另外时间一长,将产生大量的文件和数据,这对于查找、更新和维护都带来了不少的困难。
随着科学技术的不断提高,计算机科学日渐成熟,其强大的功能已为人们深刻认识,它已进入人类社会的各个领域并发挥着越来越重要的作用。
作为计算机应用的一部分,使用计算机对学生信息进行管理,具有手工管理所无法比拟的优点。例如:检索迅速、查找方便、可靠性高、存储量大、保密性好、寿命长、成本低等。这些优点能够极大地提高学生档案管理的效率,也是进行科学化、正规化管理，与世界接轨的重要条件。
随着进入二十一世纪，计算机技术迅速向着网络化、集成化方向发展。传统的单机版应用软件正在逐渐退出舞台，取而代之的是支持网络、支持多种数据信息（多媒体）的新一代网络版应用软件，而目前网络版软件中似乎存在着两种不同的趋势，一种是称为客户端——服务器的C/S结构应用系统，另一种是称为浏览器——服务器的B/S结构应用系统。而后者的特点是在客户端直接采用了功能强大的浏览器软件作为界面，其优点在于软件开发效率高，客户端不受操作平台的限制、也不受地域的限制，网络传输量少，即适用于局域网，更适用于Internet，而且投资小、见效快，用户可以不必进行服务器方面的投资，而是去租用，甚至是免费使用ISP的服务器资源，因而受到越来越多中小型单位的青睐。
因此，开发一套采用B/S结构的学生信息管理系统就成为必要的事情。本系统正是采用B/S结构开发的，该系统主要由学籍维护、选课管理、成绩查询等功能模块组成，实现学生基本信息管理、学生选修课程管理以及学生成绩查询管理等。本文将在后面一一加以详细阐述。
第一章 绪论
1.1 选题的背景和意义
随着我国教育产业化的飞速发展，社会对教育水平和教学管理软硬件的要求日益提高，尤其是对一个学校能够具有一整套完善的教学管理软件提出了更多的要求。为了适应这种形式，教育系统尤其是大学不仅首先要有坚实的硬件基础，还要有一整套完善的教学管理软件管理系统。而要实现这一功能，就要求学校管理者配备一套高效的教育管理网络系统，以便在学校内实施良好的一整套完善的管理且以最快地速度响应教师和学生的需求，及时为他们提供服务，为他们提供一个高效、便捷的环境。学生信息管理系统是校园网络中一个重要的应用系统，它大大改善了学校教学、科研与管理的基础环境，在一定程度上反映出学校管理现代化的水平。
随着国家对于教育的重视逐渐加大，学校正向着大型化、规模化发展，而对于大中型学校，跟学生信息管理有关的信息随之急剧增加。在这种情况下单靠人工来处理员工的工资不但显得力不从心，而且极容易出错。该系统就是设计一个学生信息数据库管理系统，由计算机代替人工执行一系列诸如增加新学生，删除旧学生，学生信息修改，查询，维护及打印等操作。这样就使学生部门管理人员可以轻松快捷地完成学生信息管理的任务。
1.2 国内外研究现状及发展趋势
管理信息系统(MIS)是进行信息的采集、存储、加工、维护和使用的系统。它是随着管理科学和技术科学的发展而形成的。MIS的发展与计算机网络技术的发展是紧密相关的，随着Internet/Intranet技术的广泛应用，MIS的体系结构也发生很大的变化，从以往基于C/S结构的数据访问及安全体系发展到当前的基于B/S结构体系。学生信息管理系统是典型的管理信息系统（MIS），其系统开发主要包括数据库的规划设计与维护和客户端应用程序的开发两个方面。对于前者要求建立起的数据库具有完整性和一致性，且具有一定的数据安全性，而对于后者则要求程序界面友好、功能完备，容易使用，具有流行软件的操作习惯等特点。
随着学校的规模不断扩大，学生数量急剧增加，有关学生的各种信息也成倍增长。面对庞大的信息量，有必要开发学生信息管理系统来提高学生管理工作的效率。通过这样的系统，可以做到信息的规范管理、科学统计和快速查询，从而减少管理方面的工作量。
鉴于上述管理信息系统的日趋成熟和收集信息的情况，该学生信息管理系统充分运用MIS的总体思想，综合应用了B/S模式、SQL Server、JSP等技术，并具有学生对自己所需信息的操作和管理员对系统进行管理等功能，很好的将教学质量提升了，真正完好地达到服务于教学计划。
1.3 本课题研究内容
本课题研究内容为学生信息管理系统，信息管理系统提供了强大的学生档案管理管理功能，方便管理员对学生信息的添加、修改、删除、查询等操作。本系统开发的总体任务是实现学生信息管理的系统化、规范化、自动化、达到提高学生信息管理效率的目的。
主要内容包过：
（1） 学籍维护模块：
1. 管理员可以对学生进行添加（包过基本信息）、删除、查看、修改信息。
2. 学生可以查看自己的基本信息，添加、修改详细个人信息。
（2） 选课管理模块：
1. 管理员可以对选修课程进行添加、删除、统计每门课程选修的人数以及查找
单个学生所选的课程。
2. 学生可以查看所有选修课程并进行选修以及查看自己所选课程并进行修改。
（3） 成绩管理模块：
1. 管理员可以进行添加、删除、修改基本课程，录入、修改学生基本课程成绩，
查找单个学生的所有成绩以及查找单门基础课程所有学生的成绩。
2. 学生可以查询自己的基础课程成绩。
学生信息管理系统主要提供方便高效的管理功能以及网上的信息查阅平台，学生可以通过该系统查阅相关信息、选课及修改相关信息，管理员可以管理所有信息。该系统使用JSP编程语言，Microsoft SQL2000数据库以及Apache Tomcat作为开发平台，运用软件工程思想方法，对系统进行快速有效开发, 系统分为以下几个方向：
（1）用户管理。实现对不同用户分配不同的权限。
（2）数据库连接。使程序能访问数据库，并能对其中的数据进行操作。
（3）数据录入。通过程序能实现往数据库中增加记录。
（4）数据查询。通过各种查询组合实现对数据的精确选取。
（5）数据维护。包括对数据的修改及删除操作。
系统依据Apache Tomcat构架的运行平台,利用Dreamweaver 进行整体框架的设计,连接数据库,最后进行全面的系统调试而完成。
1.4 本课题研究的目标及主要特色
一、研究目标：建立一个B/S层结构的学生信息管理系统，实现管理员对学生信息的获取、统计等各环节的计算机管理。
二、主要特点：
1、实现学生信息管理的基本要求，对学生学习进行完善管理。
2、界面友好，简单易用。
3、系统操作简单，功能强大，易于维护。
第二章 系统设计使用技术介绍
2.1 JSP（Java Server Pages）和Java Bean技术介绍
2.1.1 JSP概述
JSP(Java Server Pages)是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术，它是在传统的网页HTML文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP标记(tag)，从而形成JSP文件(*.jsp)。
2.1.2 JSP工作原理
JSP文件第一次被请求时，JSP引擎把该JSP文件转换成为一个servlet。而这个引擎本身也是一个servlet，在JSWDK(java服务器网络开发包)中，它就是JspServlet。JSP引擎先把该JSP文件转换成一个Java源文件，在转换时如果发现jsp文件有任何语法错误，转换过程将中断，并向服务端和客户端输出出错信息；如果转换成功， JSP引擎用javac把该Java源文件编译成相应的class文件。然后创建一个该SERVLET的实例，该SERVLET 中的jspInit()方法被执行，jspInit()方法在servlet的生命周期中只被执行一次。然后jspService()方法被调用来处理客户端的请求。对每一个请求，JSP引擎创建一个新的线程来处理该请求。如果有多个客户端同时请求该JSP文件，则JSP引擎会创建多个线程。每个客户端请求对应一个线程。以多线程方式执行可大大降低对系统的资源需求,提高系统的并发量及响应时间.但应该注意多线程的编程限制，由于该servlet始终驻于内存，所以响应是非常快的。 如果.jsp文件被修改了，服务器将根据设置决定是否对该文件重新编译，如果需要重新编译，则将编译结果取代内存中的servlet，并继续上述处理过程。 虽然JSP效率很高，但在第一次调用时由于需要转换和编译而有一些轻微的延迟。 此外，如果在任何时候如果由于系统资源不足的原因，JSP引擎将以某种不确定的方式将servlet从内存中移去。当这种情况发生时jspDestroy()方法首先被调用, 然后servlet实例便被标记加入垃圾收集处理。 jspInit()及jspDestory()格式如下：可在jspInit()中进行一些初始化工作,如建立与数据库的连接，或建立网络连接，从配置文件中取一些参数等，在jspDestory()中释放相应的资源。
2.1.3 JavaBean技术介绍
JavaBean是一种软件组件模型，它与其他软件对象相互作用，决定如何建立和重用软件组件，这些可重用软件组件被称为Bean。Bean使用现有的Bean帮助开发新的计划，进而建立它们之间的关系。
JavaBean是基于Sun公司的JavaBean规范的，可在编程工具中被可视化处理的可复用的软件组件。因此JavaBean具有4个基本特性：
（1） 独立性；
（2） 可重用性；
（3） 在可视化开发工具中使用
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。这样JavaBean就变成了一个组件了，达到代码的重用性和隔离性，在调用JavaBean的时候，不用关心JavaBean的实现过程，只要知道方法的功能、输入参数和输出参数就可以了。
2.2 B/S体系结构介绍
在B/S体系结构系统中，用户通过浏览器向分布在网络上的许多服务器发出请求，服务器对浏览器的请求进行处理，将用户所需信息返回到浏览器。B/S结构简化了客户机的工作，客户机上只需配置少量的客户端软件。服务器将担负更多的工作，对数据库的访问和应用程序的执行将在服务器上完成。浏览器发出请求，而其余如数据请求、加工、结果返回以及动态网页生成等工作全部由Web Server完成。实际上B/S体系结构是把二层C/S结构的事务处理逻辑模块从客户机的任务中分离出来，由Web服务器单独组成一层来负担其任务，这样客户机的压力减轻了，把负荷分配给了Web服务器。这种三层体系结构如图1所示。
图2..1
采用该结构软件的优势在于：
(1)无须开发客户端软件，维护和升级方便；
(2)可跨平台操作，任何一台机器只要装有WWW浏览器软件，均可作为客户机来访问系统；
(3)具有良好的开放性和可扩充性；
(4)可采用防火墙技术来保证系统的安全性，有效地适应了当前用户对管理信息系统的新需求。
这种三层结构层与层之间相互独立，任何一层的改变不影响其他层的功能。
三层B/S结构将应用的三个部分明确的分开：表示部分、应用逻辑部分、数据访问部分。这三个部分在逻辑上独立的分开，分别加以实现，称之为：客户端、应用服务器、数据库服务器。而在客户端和应用服务器之间加入一个WEB服务器，就形成了一种特殊的B/S结构：Browser/Server，只在客户端安装浏览器软件即可。客户端使用Internet Explore时，就可以让Internet Explore变成为能够处理数据的应用系统。
由于这种模式是提供一个跨平台的、简单一致的应用环境，实现了开发系统与应用系统的分离，因此避免了为多重不同的操作系统开发同一应用系统的重复操作，便于用户群的扩展、变化以及应用系统的管理。
因此该结构在管理信息系统开发领域中获得飞速发展，成为应用软件开发中一种流行的体系结构.所以在开发本系统时采用这种模式。
2.3 JavaScrit技术介绍
JavaScript是一种基于对象(object)和事件驱动(event driven)并具有安全性能的脚本语言。它的目的是与html超文本标记语言、java 脚本语言（java小程序）一起实现在一个web页面中链接多个对象，与web客户交互作用。它被嵌入 HTML 的文件之中。通过 JavaScript 可以做到响应用户的需求事件（如表单的输入），这样当一位使用者输入一项信息时，它不需要通过网络传送到服务器端进行处理再传回来的过程，而可以直接在客户端进行事件的处理。它的出现弥补了html语言的缺陷。
JavaScript是一种脚本语言，它采用小程序段的方式实现编程。像其它脚本语言一样,JavaScript同样已是一种解释性语言,它提供了一个易的开发过程。
它的基本结构形式与C、C++、VB、Delphi十分类似。但它不像这些语言一样，需要先编译，而是在程序运行过程中被逐行地解释。它与HTML标识结合在一起，从而方便用户的使用操作。
2.4 SQL Server 2000 数据库
2.4.1 数据库介绍
SQL Server 2000具有较好的可伸缩性和可靠性，提供了以Web标准为基础的扩展数据库编程功能，可以满足电子商务和企业应用程序的要求。SQL Server 2000支持XML和Internet标准，具有基于Web的分析能力，允许使用内置的存储过程以XML格式存储、更新、删除、检索数据。
SQL Server 2000能提供超大型系统所需的数据库服务。大型服务器可能有成千上万的用户同时连接到SQL Server 2000的情况，SQL Server 2000为这些环境提供了全面的保护，具有防止问题发生的安全措施，例如，可以防止多个用户试图同时更新相同的数据。SQL Server 2000还在多个用户之间有效地分配可用资源，比如内存、网络带宽和磁盘I/O等。
SQL Server 2000不仅能作为一个功能强大的数据库服务器有效地工作，而且数据库引擎也用在需要在客户端本地存储独立数据库的应用程序中。SQL Server 2000可以动态地将自身配置成能有效地使用客户端桌面或膝上型电脑中的可用资源，而不需要为每个客户端专设一个数据库管理员。应用程序供应商还可以将SQL Server 2000作为应用程序的数据存储组件嵌入到应用程序中。SQL Server在网络组件的顶部添加了服务器特有的中介组件，诸如开放式数据库连接(ODBC)后能使不同客户机进行相互连接,它可处理基于Internet的应用程序,帮助用户把SQL Server数据库信息集成到Web页面。
SQL语句介绍：
SQL(Structured Query Language，结构查询语言)是一个功能非常强大的数据库语言，可以用在一些大型数据库的建立。SQL语句通常用于完成一些数据库的操作任务，比如在数据库中插入数据、更新数据、删除数据，或者从数据库中检索数据。使用SQL的常见关系数据库管理系统有：Oracle、 Sybase、 DB2、My SQL 、 Microsoft SQL Server、 Access等。绝大多数SQL结构化查询语言都可以在数据库之间通用，虽然不同的数据库在SQL语言上有些差异。但是，标准的SQL命令如Select、 Insert、 Update、 Delete、 Create和 Drop用于完成绝大多数数据库的操作，在不同数据库之间几乎没有差异。
SQL功能强大，但是概括起来，它可以分成以下几部分：DML（Data Manipulation Language数据操作语言）用于检索或者修改数据； DDL（Data Definition Language数据定义语言） 用于定义数据的结构，如创建、修改、删除等命令；DCL（Data Control Language数据控制语言）用于赋予或取消用户的权限。
2.4.2 ODBC数据访问接口
开放数据库互连（Open DataBase Connectivity,ODBC）是Microsoft公司开发的一套开发数据库系统应用程序接口规范，它支持应用程序以标准的ODBC函数和SQL语句操作各种不同的数据库。在这一实现过程中，ODBC驱动程序起了关键作用，简单地说，ODBC驱动程序相当于一个转换开关，它负责将应用程序发送来的标准SQL语句传递给各种数据库驱动程序处理，再将处理结构送回使用程序。于是，应用程序开发者只须面对统一的ODBC数据源，而不必针对各种数据库进行不同的设置，这样的程序具备更好的适用性和可移植性，甚至可以访问多种不同的数据库，如图2所示
图2.2 ODBC工作原理
2.4.3 JDBC数据访问接口
为支持Java程序的数据库操作功能，Java语言采用了专门的Java数据库编程接口（Java DataBase Connecivity,JDBC），用于在Java程序中实现数据库操作功能并简化操作过程。JDBC支持基本SQL语句，提供多样化的数据库连接方式，为各种不同的数据库提供统一的操作界面。
JDBC工作原理如图3所示。
图2.3 JDBC工作原理
第三章 系统设计
3.1 需求分析
本系统主要是针对各个学校的学生信息进行管理，本系统满足以下几点要求：
系统安全性。由于该系统的使用对象多,要求有较好的权限管理。不同权限进入不同的界面，为了防止数据的并发现象的出现，数据的编辑必须由合法用户来操作，并对每个学生的信息进行良好的保密。
系统内容的全面性。学生信息管理系统不仅是对学生的基本信息进行管理，还包过学生选课管理，成绩管理等，因此，本系统能够很好的满足学校对学生的信息进行完善、统一的管理。
系统灵活性。要求有良好的人机界面，操作简单（数据的添加、删除、修改、查询等方 便快捷）。
可扩展性。站点的数据承载量、功能模块的单个或整体调整都可以满足变化的需要，这种适应性称为可扩展性。固定资产管理系统的可扩展性，体现在不同用户群需要处理不同类型的数据、数据与用户之间进行交互、数据要符合个用户的使用需求、多表查询系统化、避免性能下降等方面。
易维护性。本系统采用B/S结构，系统的升级只需要在服务器端完成，更新软件系统的数据库、文件也只需要更新服务器端即可。在进行系统的维护时，只需要远程登录服务器系统，减少了维护系统的成本和周期。
3.1.1 运行环境
操作系统：Windows 2000 (Advanced) Server/2003 Server/XP Professional
数据库：SQL Server 2000；
JSP服务器：Tomcat；
开发工具：JBuilder X。
3.2 系统总体设计
3.2.1 系统目标设计
系统开发的总体任务是实现学校学生信息管理系统化、规范化和自动化，从而达到学生信息管理高效率的目的。使得教务处人员能够方便快捷地管理学生信息以及学生能够方便快捷的查看修改个人信息，从而提高工作效率和经济效益。计算机的资源是受到限制的，因此要充分利用JSP的功能，设计出功能强大的软件，同时要尽可能减少对系统资源的占用，同时对本系统要求有良好的灵活性和完善性。
3.2.2 系统设计思想
学生信息管理系统主要是对学生的学籍，选课，成绩等的管理。学生信息管理首先就应该有学生，所以系统应该有对学生的添加和删除以及学生信息的修改；选课，固然要有课程让学生选，就应该有添加、删除选修课程的功能，要让学生选就应该有学生查看、添加、修改选修课程；成绩管理就是学生能够在网上平台上快速查询自己的分数，这个功能的实现首先应该有添加、删除基础课程的功能，学生登入界面后能够查询功能。根据所需功能以及数据库、JSP所能提供的功能来设计该系统。
3.2.3 系统功能描述
本系统功能主要包过三大块：学籍维护（管理员添加、删除学生基本信息；学生查看、修改个人附加信息）；选课管理（添加、删除选修课表，查看单个学生选课情况以及单门课程被学生选修情况；学生查看、选修课程并可对所选课程进行修改）；成绩查询（管理员添加、删除成绩课表，添加学生分数以及查询单人或单课分数情况；学生查看自己所学基础课成绩）。
由于该系统权限有2个，学生和管理员，故这两个权限范围内的都应该具有上述功能，即将上述三大功能模块划分给这2 个权限去具体实现。
权限管理模块图
学生页面应具有的功能模块如下：
学生功能模块
1. 修改密码：学生进入页面后可以修改自己的密码，以达到保密性；
2. 学籍维护：学生可以查看自己的基本信息（基本信息由管理员录入不能修改），并填写修改自己的学籍情况；
3. 选修课程：该功能主要是让学生查看已有的选修课程并进行选修，可以查看自己已选的课程如不满意可以删除重选，每个学生至多能选3门；
4. 查看成绩：学生可以查看自己的必修课成绩。
管理员页面应具有的功能，总括为：
管理员功能模块
1. 学生管理：该模块主要添加新学生基本信息；查看已有学生基本信息及可对其修改，删除多余或出错学生信息。
2. 选课管理：可以添加新选修课程；查看已有选修课程并对起进行删除修改；查看学生选课情况，可以根据输入学号查看个人选课情况，还可以输入课程号查看该课被选情况；统计每门课程选修的人数以便打印出给任课老师。
3. 成绩管理：可以添加学生所学的基本课程并修改；添加学生成绩；查看学生成绩（根据输入学号和课程号来查看不同的成绩情况）；可以对学生成绩进行修改。
下图是学生信息管理系统的总功能模块图：
图3.1 系统功能图
3.2.4 系统用例图
图3.2 学生用例图
图3.3 管理员用例图
3.2.5 系统UML活动图
第四章 数据库设计
在本系统中使用的是SQL Server2000数据库管理系统。本系统使用的数据库名为yuqingpeng，下面具体讲解数据库中各数据表的创建和逻辑结构.
4.1 总体表设计
本系统中共用到了6个数据表，如下：
1. admin表：记录管理员信息；
1. student表：记录学生学籍信息；
2. kechengbiao表：记录选修课信息；
3. chegnji表：记录学生基础课信息；
4. 成绩关联表：记录学生基础课成绩信息；
6. 选课关联表：记录学生选课信息。
4.2 数据库表的结构
表1：
admin表的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
admin_id 管理员ID 是 varchar 20 Not null 唯一标识
password 密码 否 varchar 20 Not null
表2：
Student表的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
name 学生姓名 否 varchar 20 Not null
stu_id 学号 是 varchar 20 Not null 唯一标识
password 密码 否 varchar 20 Not null
sex 性别 否 varchar 20 Not null
zy 专业 否 varchar 20 Not null
mz 民族 否 char 10 Not null
zzmm 政治面貌 否 varchan 20 Not null
cym 曾用名 否 varchar 20
sfz 身份证 否 varchar 20
csrq 出生日期 否 varchar 20
jg 籍贯 否 varchar 20
jkzk 健康状况 否 varchar 20
rxnf 入学年份 否 varchar 20
jtdz 家庭地址 否 varchar 50
jtdh 家庭电话 否 varchar 20
yzbm 邮政编码 否 varchar 10
brlxfs 联系方式 否 varchar 20
email 邮件 否 varchar 20
qtlxfs 其他联系 否 varchar 20
bz 备注 否 varchar 20
表3：
Chengji表的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
学期号 学期号 否 varchar 20
课程号 课程号 是 varchar 20 Not null 唯一标识
课程名 课程名 否 varchar 20 Not null
学分 学分 否 varchar 20
主讲教师 主讲教师 否 varchar 20
表4：
Kechengbiao表的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
课程号 课程号 是 varchar 20 Not null 唯一标识
课程名 课程名 否 varchar 20 Not null
任课教师 任课教师 否 varchar 20
星期几 星期几 否 varchar 20
时间 时间 否 varchar 20
上课教室 上课教室 否 varchar 20
表5：
成绩关联表的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
id 自动标识 是 int 4 Not null 唯一标识
stu_id 学号 否 varchar 20 Not null
课程号 课程号 否 varchar 20 Not null
成绩 成绩 否 varchar 20 Not null
重修成绩 重修成绩 否 varchar 20 Not null
表6：
选课关联的定义：
字段名 字段描述 是否主键 数据类型 长度 约束 说明
id 自动标识 是 int 4 Not null 唯一标识
stu_id 学号 否 varchar 20 Not null
课程号 课程号 否 varchar 20 Not null
4.3 实体及ER图
4.3.1 实体介绍
本系统中的实体共有4 个，分别为：
实体1: 学生(姓名name，学号stu_id，密码password，性别sex，专业zy，民族mz，政治面貌，曾用名cym，身份证sfz，出身日期csrq，籍贯jg，健康状况jkzk，入学年份rxnf，家庭地址jtdz，家庭电话jtdh，邮政编码yzbm，联系方式lxfs，Email email，备注bz)； 关键字为：学号
实体2：选修课（课程号，课程名，任课教师，星期几，时间，上课教室）； 关键字为：课程号
实体3：基础课（学期号，课程号，课程名，学分，主讲教师） 关键字为：课程号
实体4：成绩（id，学号，课程号，成绩，重修成绩）；
4.3.2 实体的ER图以及各实体之间联系的ER图
实体1的ER图：
图4.1 实体1
实体2的ER图
图4.2 实体2
实体3的ER图
图4.3 实体3
实体4的ER图：
图4.4 实体4
实体1与实体2之间的联系：选修（学号，课程号）
图4.5 实体1与实体2（m：n）关系
实体1与实体3之间的关系：学习（学号，课程号，成绩）
图4.6 实体1与实体3（m：n）关系
4.4 数据库表的关系图
在本系统中共有6个表，其中有些表之间存在着联系，并建立起了关系：
4.5 数据库表的视图
4.6 数据库连接
JDBC是Java数据库连接(Java Data Base Connectivity)技术的简称，是为各种常用
的数据库提供无缝连接的技术。JDBC定义了Java语言同各种SQL数据之间的应用程序设计
接口（API），提高了软件的通用性。
JDBC的关键技术是数据库连接驱动程序，针对这点大量的数据库厂商和第三方开发商
支持Java的JDBC的标准，并开发了不同的数据库JDBC驱动程序。这些驱动程序可以分成四种：JDBC-ODBC Bridge驱动程序、JDBC Native Bridge驱动程序、JDBC-Network Bridge驱动程序、Pure Java JDBC Driver。
本系统正是利用JDBC-ODBC Bridge驱动程序来连接数据库的，连接数据库时用到了
JavaBean技术，起代码为：
package yu;
import java.io.*;
import java.sql.*;
public class dbconn {
String Sd=sun.jdbc.odbc.JdbcOdbcDriver; //建立一个联接机
String Sc=jdbc:odbc:yqp; //建立一个Odbc源
Connection con=null; //Connection对象
ResultSet rs=null; //建立一个记录集
PreparedStatement prepstmt = null;
String userName = sa;
String password = ;
public dbconn(){
try{
Class.forName(Sd); //用classforname方法加载驱动程序类
}catch(java.lang.ClassNotFoundException e){ //当没有发现这个加载这个类的时候抛出的异常
System.err.println(e); //执行系统的错误打印
}
}
public ResultSet executeQuery(String sql){ //可以执行添加删等操作
try{ con=DriverManager.getConnection(Sc,userName,password);
Statement stmt = con.createStatement(
ResultSet.TYPE_SCROLL_SENSITIVE,
ResultSet.CONCUR_READ_ONLY);
rs=stmt.executeQuery(sql);
}catch(SQLException er){
System.err.println(er.getMessage());
}
return rs;
}
public int executeUpdate(String sql){ //数据库的更新操作
int result=0;
try{ con=DriverManager.getConnection(Sc,userName,password);
Statement stmt=con.createStatement();
result=stmt.executeUpdate(sql);
}catch(SQLException ex){
System.err.println(ex.getMessage());
}
return result;
}
public void close(){
try{ if(con!=null)
con.close();
}catch(Exception e){
System.out.print(e);
}try{
if(rs!=null)
rs.close();
}catch(Exception e){
System.out.println(e);
} }
public PreparedStatement preparedstatements(String sql) {
try{
con=DriverManager.getConnection(Sc,userName,password);
prepstmt = con.prepareStatement(sql);
}catch(SQLException ex){
System.err.println(ex.getMessage());
}
return prepstmt; }
}
在JSP程序中调用这个JavaBean时只需加一条语句：class=yu.dbconn/> 就与数据库连接上了，可以进行数据调用、修改。
第五章 系统具体实现
按照上面所说的学生信息管理系统应具有的具体功能来具体实现该系统，尽量完善系
统的每一个要求，做到精益求精。
5.1 登入界面
由于系统设置了2个不同的权限，所以登入时首先应该对权限进行判断，然后对所属
权限范围内的用户进行用户名和密码验证，验证成功才进入相应的页面。
登入系统界面如下：
当用户输入ID和密码后会根据选择的权限对ID和密码进行验证验证成功时进入下一
页面，判断用户权限及密码正确与否的代码如下：
Login.jsp页面代码：
<%@ page contentType=text/html; charset=GB2312 %>
<%@ page import=java.sql.* %>
<%@ page language=java %>
<%@ page import=java.util.* %>
<%@ page import=yu.* %>
<% request.setCharacterEncoding(GBK);
if(sel.equals(student)){
sql = SELECT * FROM student where stu_id=+user+ and password=+pwd+;
URL=student.jsp;
ResultSet rs = stmt.executeQuery(sql);
if(rs.next()){
String a=rs.getString(name);
request.getSession(true);
session.setAttribute(name,a);
session.setAttribute(id,user);
response.sendRedirect(URL) ;}
else
response.sendRedirect(error.jsp) ;
}
else if(sel.equals(admin)){
sql = SELECT * FROM admin where admin_id=+user+ and password=+pwd+;
URL=admin.jsp;
ResultSet rs = stmt.executeQuery(sql);
if(rs.next()){
request.getSession(true);
session.setAttribute(id,user);
response.sendRedirect(URL) ;}
else
response.sendRedirect(error.jsp) ;
}//使用executeQuery执行SQL查询语句
%>
5.2 学生界面
当验证用户名和密码正确后进入学生界面：
学生主页面主要就是显示学生的一些功能，在右边设置了一个frame框来显示学生选择功能后进入的页面。
5.3 学生界面功能实现
在学生主页面中有学生所需要的一些功能，如查看公告，修改自己的登入密码，查看学籍并进行修改，查看选修课表并进行选修，查看已选课程并可修改。
5.3.1 查看公告页面
5.3.2 学生修改密码页面
修改密码代码：
Change.Jsp页面：
<% request.setCharacterEncoding(GBK);
String pwd=;
String number=(String)session.getAttribute(id);
String sql=;
sql=SELECT * FROM student where stu_id=+number+;
ResultSet rs = a.executeQuery(sql);
if(rs.next()){
pwd=rs.getString(password);
}
%>
以输入一个密码修改框的table已删，下面是修改后把新密码导入数据库：
Change_pwd.jsp 页面代码：
<% request.setCharacterEncoding(GBK);
String sql=;
String password=request.getParameter(pwd2);
String number=(String)session.getAttribute(id);
sql=update student set password =+password+ where stu_id =+number+;
a.executeUpdate(sql);
response.sendRedirect(welcome.jsp) ;
%>
5.3.3 学生学籍维护页面
学生可以查看自己的信息以及修改自己的学籍信息。
学籍维护页面代码主要有两个页面来实现：
Xueji.jsp页面：用来显示已有信息，并能让学生进行修改提交；change_xueji.jsp页面用来把学生新提交信息保存到数据库中：
Change_xueji.jsp页面代码：
<% request.setCharacterEncoding(GBK);
String sql=;
String xuehao=(String)session.getAttribute(id);
String cym=request.getParameter(cym);
String sfz=request.getParameter(sfz);
String csrq=request.getParameter(csrq);
String jg=request.getParameter(jg);
String jkzk=request.getParameter(jkzk);
String rxnf=request.getParameter(rxnf);
String jtdz=request.getParameter(jtdz);
String jtdh=request.getParameter(jtdh);
String yzbm=request.getParameter(yzbm);
String brlxfs=request.getParameter(brlxfs);
String email=request.getParameter(email);
String qtlxfs=request.getParameter(qtlxfs);
String bz=request.getParameter(bz);
sql=update student set cym=+cym+,sfz=+sfz+, csrq=+csrq+,jg=+jg+,jkzk=+jkzk+,rxnf=+rxnf+,jtdz=+jtdz+,jtdh=+jtdh+,yzbm=+yzbm+,brlxfs=+brlxfs+,email=+email+,qtlxfs=+qtlxfs+,bz=+bz+ where stu_id=+xuehao+ ;
a.executeUpdate(sql);
response.sendRedirect(xueji.jsp) ;
%>
5.3.4 成绩查询
学生可以查看自己以前学期所学课程的成绩，省了寄成绩单的麻烦。该功能主要是跟数据连接，管理员录入的信息给掉出来，显示在页面上，没什么特别之处。
5.3.5 查看学修课表并进行选修
学生可以在该页面进行查看已有的学修课程，并进行选修。每个学生只能选修3门课程。
查看已选课程并修改：
这2个功能页面由kecheng1.jsp,kecheng2.jsp,kecheng3.jsp,kecheng4.jsp来具体实现。
Kecheng3.jsp页面部分代码： 该页面是主要是实现从数据库中掉课程表及选课保存到选课关联表中去，并限制每人至多能选3门课程。
<% request.setCharacterEncoding(GBK);
String kechenghao=request.getParameter(id2);
String xuehao=(String)session.getAttribute(id);
String sql=;
String sql2=;
String sql3=;
int totalrecord = 0;
sql3= SELECT count(*) as recordcount FROM 选课关联 where stu_id=+xuehao+;
ResultSet rs = a.executeQuery(sql3);
if (rs.next()) totalrecord = rs.getInt(recordcount);
if(totalrecord<3)
{ sql=SELECT * FROM 选课关联 where stu_id=+xuehao+ and 课程号=+kechenghao+;
ResultSet rs1=a.executeQuery(sql);
if(rs1.next()) {%>
<%}
else
{ sql2= INSERT INTO 选课关联(stu_id,课程号) values(+xuehao+,+kechenghao+);
a.executeUpdate(sql2);
%>
<% }
} else
{%>
<%}%>
5.4 管理员界面
该界面是管理员通过验证后进入的页面，管理员可以今选择进行自己所需要的操作。
5.5 管理员界面功能实现
进入管理员界面后，后台工作人员可以选择不同功能进行操作，主要功能有：查看学生基本信息并进行修改、删除；添加新学生信息；查看选修课表并进行修改；查看学生选课情况；添加新选修课；查看必修课表并进行修改；查看学生成绩；添加必修课程；添加学生成绩。
5.5.1 查看学生基本信息
该页面可以对学生进行删除，以及对学生基本信息进行修改。
修改学生基本信息页面：
该功能主要有xuesheng.jsp;xuesheng1.jsp;xuesheng2.jsp;xuesheng3.jsp页面来完成。
<% String id2=request.getParameter(id);
String sql=select * from student where stu_id=+id2+;
ResultSet rs = a.executeQuery(sql);
while(rs.next()) { %>
=center>
<% } rs.close();%>
| 修改学生信息 | 姓名： | > | |
| 学号： | > | ||
性别： |
> | ||
专业： |
> | ||
民族： |
> | ||
政治面貌： |
> | ||
以上是修改页面xuesheng2.jsp的代码。
5.5.2 添加新学生和选修课
该页面主要是用来添加新的学生及其基本信息。代码主要有add1.jsp和add1_stu.jsp完成。
Add1_stu.jsp部分代码如下：
<% request.setCharacterEncoding(GBK);
String name=request.getParameter(name);
String stu_id=request.getParameter(stu_id);
String password=request.getParameter(password);
String sex=request.getParameter(sex);
String zy=request.getParameter(zy);
String mz=request.getParameter(mz);
String zzmm=request.getParameter(zzmm);
String sql=;
String sql2=;
sql=SELECT * FROM student where stu_id=+stu_id+;
ResultSet rs=a.executeQuery(sql);
if(rs.next())
{%> <% }
else {
sql2=INSERT INTO student(name,stu_id,password,sex,zy,mz,zzmm) values(+name+,+stu_id+,+password+,+sex+,+zy+,+mz+,+zzmm+);
a.executeUpdate(sql2); %>
<% } %>
添加新选修课
该页面有add2.jsp和add2_xkb.jsp来完成。
5.5.3 查看学修课表和必修课表
该功能是让管理员能够查看所有选修课程并删除多余的课程，该页面还添加了一个统计每门课程选修人数的功能，让教师能够清楚了解该课选修情况。由kebiao.jsp页面完成。查看必修课表功能就是查看学生的基础课表，可以对其进行删除，方便添加学生成绩。该功能是由bixiu.jsp和bixiu1.jsp来完成。
统计人数功能实现为一个简单的数据库数据查询语句，如下：
<%
String sql2=””;
sql2 = SELECT count(*) as recordcount FROM 选课关联 where 课程号=+kechenghao+;
ResultSet bs = a.executeQuery(sql2);
if (bs.next()) totalrecord2 = bs.getInt(recordcount);%>
5.5.4 查看学生选课情况和学生成绩
查看选课该功能分为2个：输入学号查看单个学生的选课情况；输入课程号查看选修该课的学生信息。该功能的实现主要由：xuanke.jsp,xuanke1.jsp和xuanke2.jsp来实现。
根据选择进入不同的界面：
Xuanke.jsp页面部分代码2个功能函数，2个form表如下：
function a(){ if(form6.stu_id.value==)
{alert(请输入学号在查看);return false;}
}
function b(){ if(form7.kechenghao.value==)
{alert(请输入课程号在查看);return false;}
}
输入学号查看个人选课情况
输入课程号查看选修该课学生：
查看成绩该功能分为2个：输入学号查看单个学生的成绩情况；输入课程号查看选修该课的所有学生的成绩。该功能的实现主要由：chakan1.jsp,chakan1_1.jsp,chakan1_1_1.jsp
chakan1_1_10.jsp和chakan1_2.jsp来实现完成。
输入学号查看个人成绩：
输入课程号查看所学该课所有人成绩：
5.5.5 添加必修课表和学生成绩
该功能是添加必修课程，由add3.jsp 和add3_1.jsp完成
Add3.jsp页面代码如下：
请输入新基础课信息：
| 学期号： | 课程号： | ||
| 课程名： | 学分： | ||
| 主讲教师： |
该功能是添加学学生成绩，以便学生能方便快捷地知道自己的成绩。由add4.jsp和 add4_1.jsp来实现。
Add4_1.jsp页面代码如下：
<% request.setCharacterEncoding(GBK);
String stu_id=request.getParameter(stu_id);
String number=request.getParameter(number);
String sql3=;
sql3=SELECT * FROM student where stu_id=+stu_id+;
ResultSet as=a.executeQuery(sql3);
String sql4=;
sql4=SELECT * FROM chengji where 课程号=+number+;
ResultSet bs=a.executeQuery(sql4);
if(as.next()&&bs.next()) {
String cj=request.getParameter(cj);
String cj2=request.getParameter(cj2);
String sql=;
String sql2=;
sql=SELECT * FROM 成绩关联 where stu_id=+stu_id+ and 课程号=+number+ ;
ResultSet rs=a.executeQuery(sql);
if(rs.next()) {%>
<% }
else { sql2=INSERT INTO 成绩关联 values(+stu_id+,+number+,+cj+,+cj2+);
a.executeUpdate(sql2);
%>
<% }
}
else
{%>
<%} %>
通过以上功能的实现，该系统也就差不多完成了。以上部分代码已省略，详细代码请查看毕业设计作品。
第六章 全文总结
经过测试，系统能够很好的运行实现管理功能，功能模块也能够达到老师所指定的要求。系统可以实现学生信息的集中管理、分散操作、检索迅速、查找方便、可靠性高、存储量大、保密性好、寿命长、成本低等。这些优点能够极大地提高学生信息管理的效率,也是高校的科学化、正规化管理,与世界接轨的重要条件。
通过系统的设计，本人感触最深的是加深了对软件开发过程的理解，熟悉了利用JSP实现各种实用的数据库型软件的开发，以及了解了教务管理的一些流程，也更加深入理解了MIS设计中常见问题和其设计的意义。本文在详细分析了学生信息管理的各功能模块基础上，设计并实现了学生信息管理系统的简易版本。论文的主要工作包括以下几个方面：
1． 详细地分析和总结了学生信息管理的需求，并确定了学生信息管理系统实现的初步方案。
2．分析了系统实现的关键技术原理，和具体描述了各个功能模块，并用图示表示出了系统功能结构图，使得更容易了解本系统。
3．设计并实现了信息管理系统的逻辑模型，并基于SQL Server2000数据库实现了学生信息管理系统数据的物理模型。
4．采用JSP实现了学生信息管理系统的初步版本。
经过两个多月的设计和开发，学生信息管理系统基本开发完毕，但是由于毕业设计时间较短，所以该系统还有许多不尽如人意的地方，比如班级管理，系统出错处理等一些问题。在我的进一步工作中，我将对这些问题进行完善。
致 谢
这篇论文写到这里就即将结束了，在论文结束之前，我要向那些曾经给予我无数关心与帮助的老师、同学和朋友们致以诚挚的谢意。
参考文献
[1] 薛华成 管理信息系统（第四版[M]. 清华大学出版社 2003.12
[2] 石志国 薛为民 董洁JSP应用教程[M]. 清华大学出版社 2004.10
[3] 丁宝康 董健全 施伯乐 数据库实用教程[M]. 清华大学出版社 2001.9
[4] 李香敏 SQL Server2000编程员指南[M]. 北京希望电子出版社 2000.12
[5] 杨易编著 JSP网络编程技术与实例[M]. 人民邮电出版社 2005.10
[6] 朱俊炎 软件工程实训套件教学特色系列教材Web开发技术[M]. 2006.6
英文原文：
Using XML and JSP together
Im going to assume that, like most Java programmers, you know what JavaServer Pages (JSP) and Extensible Markup Language (XML) are, but you may be a little unclear on how you can use them. JSP use is pretty easy to defend. It allows you to design a Website built from files that look and act a lot like HTML. The only difference is that JSPs also act dynamically -- for example, they can process forms or read databases -- using Java as a server-side scripting language. XML use is more difficult to justify. While it seems as if every new product supports it, each one seems to be using XML for a different purpose.
In this article, you will learn to design a system using XML in a fairly modest way. Many Websites have vast collections of data that are displayed in a more or less standard way. I will design a system that uses XML files to store data on a Web server and JSP files to display that data.
XML versus relational databases
But wait, you may ask, youre using XML to store data? Why not use a database? Good question. The answer is that for many purposes, a database is overkill. To use a database, you have to install and support a separate server process, which often also requires installing and supporting a database administrator. You must learn SQL, and write SQL queries that convert data from a relational to an object structure and back again. If you store your data as XML files, you lose the overhead of an extra server. You also gain an easy way to edit your data: just use a text editor, rather than a complicated database tool. XML files are also easier to back up, to share with your friends, or to download to your clients. You can also easily upload new data to your site, using FTP.
A more abstract advantage of XML is that, being a hierarchical rather than a relational format, it can be used in a much more straightforward manner to design data structures that fit your needs. You dont need to use an entity relationship editor nor normalize your schema. If you have one element that contains another element, you can represent that directly in the format, rather than using a join table.
Note that for many applications, a filesystem will not suffice. If you have a high volume of updates, a filesystem may get confused or corrupted by simultaneous writes; databases usually support transactions, which allow concurrency without corruption. Further, a database is an excellent tool if you need to make complicated queries, especially if they will vary from time to time. Databases build indexes, and are optimized for keeping the indexes up to date with a constantly changing data set. Relational databases also have many other advantages, including a rich query language, mature authoring and schema design tools, proven scalability, fine-grained access control, and so on.
(Note: You can use simple file locking to provide a poor mans transaction server. And you can also implement an XML index-and-search tool in Java, but thats a topic for another article.)
In this case, as in most low-to-medium volume, publishing-based Websites, you can assume the following: most of the data access is reads, not writes; the data, though potentially large, is relatively unchanging; you wont need to do complicated searches, but if you do, youll use a separate search engine. The advantages of using a mature RDBMS fade, while the advantage of using an object-oriented data model come to the fore.
Finally, its entirely possible to provide a wrapper for your database that makes SQL queries and translates them into XML streams, so you could have it both ways. XML becomes a more robust, programmer-friendly frontend to a mature database for storing and searching. (Oracles XSQL servlet is one example of this technique.)
The application: An online photo album
Everybody loves photos! People love showing pictures of themselves, their friends, their pets, and their vacations. The Web is the ultimate medium for self-indulgent shutterbugs -- they can annoy their relatives from thousands of miles away. While a full-fledged photo album site would require a complicated object model, Ill focus on defining a single Picture object. (The source code for this application is available in Resources.) The object representing a picture needs fields representing its title, the date it was taken, an optional caption, and, obviously, a pointer to the image source.
An image, in turn, needs a few fields of its own: the location of the source file (a GIF or JPEG) and the height and width in pixels (to assist you in building tags). Here there is one neat advantage to using the filesystem as your database: you can store the image files in the same directory as the data files.
Finally, lets extend the picture record with an element defining a set of thumbnail images for use in the table of contents or elsewhere. Here I use the same concept of image I defined earlier.
The XML representation of a picture could look something like this:
1999-08-08
Trying in vain to get a tan
alex-beach.jpg
340
200
alex-beach-sm.jpg
72
72
alex-beach-med.jpg
150
99
Note that by using XML, you put all the information about a single picture into a single file, rather than scattering it among three or four separate tables. Lets call this a .pix file -- so your filesystem might look like this:
summer99/alex-beach.pix
summer99/alex-beach.jpg
summer99/alex-beach-sm.jpg
summer99/alex-beach-med.jpg
summer99/alex-snorkeling.pix
etc.
Techniques
Theres more than one way to skin a cat, and theres more than one way to bring XML data on to your JSP page. Here is a list of some of those ways. (This list is not exhaustive; many other products and frameworks would serve equally well.)
DOM: You can use classes implementing the DOM interface to parse and inspect the XML file
XMLEntryList: You can use my code to load the XML into a java.util.List of name-value pairs
XPath: You can use an XPath processor (like Resin) to locate elements in the XML file by path name
XSL: You can use an XSL processor to transform the XML into HTML
Cocoon: You can use the open source Cocoon framework
Roll your own bean: You can write a wrapper class that uses one of the other techniques to load the data into a custom JavaBean
Note that these techniques could be applied equally well to an XML stream you receive from another source, such as a client or an application server.
JavaServer Pages
The JSP spec has had many incarnations, and different JSP products implement different, incompatible versions of the spec. I will use Tomcat, for the following reasons:
It supports the most up-to-date versions of the JSP and servlet specs
Its endorsed by Sun and Apache
You can run it standalone without configuring a separate Web server
Its open source
(For more information on Tomcat, see Resources.)
You are welcome to use any JSP engine you like, but configuring it is up to you! Be sure that the engine supports at least the JSP 1.0 spec; there were many changes between 0.91 and 1.0. The JSWDK (Java Server Web Development Kit) will work just fine.
The JSP structure
When building a JSP-driven Website (also known as a Webapp), I prefer to put common functions, imports, constants, and variable declarations in a separate file called init.jsp, located in the source code for this article.
I then load that file into each JSP file using <%@include file=init.jsp%>. The <%@include%> directive acts like the C languages #include, pulling in the text of the included file (here, init.jsp) and compiling it as if it were part of the including file (here, picture.jsp). By contrast, the tag compiles the file as a separate JSP file and embeds a call to it in the compiled JSP.
Finding the file
When the JSP starts, the first thing it needs to do after initialization is find the XML file you want. How does it know which of the many files you need? The answer is from a CGI parameter. The user will invoke the JSP with the URL picture.jsp?file=summer99/alex-beach.pix (or by passing a file parameter through an HTML form).
However, when the JSP receives the parameter, youre still only halfway there. You still need to know where on the filesystem the root directory lies. For example, on a Unix system, the actual file may be in the directory /home/alex/public_html/pictures/summer99/alex-beach.pix. JSPs do not have a concept of a current directory while executing, so you need to provide an absolute pathname to the java.io package.
The Servlet API provides a method to turn a URL path, relative to the current JSP or Servlet, into an absolute filesystem path. The method ServletContext.getRealPath(String) does the trick. Every JSP has a ServletContext object called application, so the code would be:
String picturefile =
application.getRealPath(/ + request.getParameter(file));
or
String picturefile =
getServletContext().getRealPath(/ + request.getParameter(file));
which also works inside a servlet. (You must append a / because the method expects to be passed the results of request.getPathInfo().)
One important note: whenever you access local resources, be very careful to validate the incoming data. A hacker, or a careless user, can send bogus data to hack your site. For instance, consider what would happen if the value file=../../../../etc/passwd were entered. The user could in this way read your servers password file.
The Document Object Model
DOM stands for the Document Object Model. It is a standard API for browsing XML documents, developed by the World Wide Web Consortium (W3C). The interfaces are in package org.w3c.dom and are documented at the W3C site (see Resources).
There are many DOM parser implementations available. I have chosen IBMs XML4J, but you can use any DOM parser. This is because the DOM is a set of interfaces, not classes -- and all DOM parsers must return objects that faithfully implement those interfaces.
Unfortunately, though standard, the DOM has two major flaws:
The API, though object-oriented, is fairly cumbersome.
There is no standard API for a DOM parser, so, while each parser returns a org.w3c.dom.Document object, the means of initializing the parser and loading the file itself is always parser specific.
The simple picture file described above is represented in the DOM by several objects in a tree structure.
Document Node
--> Element Node picture
--> Text Node (whitespace)
--> Element Node title
--> Text Node Alex On The Beach
--> Element Node date
--> ... etc.
To acquire the value Alex On The Beach you would have to make several method calls, walking the DOM tree. Further, the parser may choose to intersperse any number of whitespace text nodes, through which you would have to loop and either ignore or concatenate (you can correct this by calling the normalize() method). The parser may also include separate nodes for XML entities (like &), CDATA nodes, or other element nodes (for instance, the big bear would turn into at least three nodes, one of which is a b element, containing a text node, containing the text big). There is no method in the DOM to simply say get me the text value of the title element. In short, walking the DOM is a bit cumbersome. (See the XPath section of this article for an alternative to DOM.)
From a higher perspective, the problem with DOM is that the XML objects are not available directly as Java objects, but they must be accessed piecemeal via the DOM API. See my conclusion for a discussion of Java-XML Data Binding technology, which uses this straight-to-Java approach for accessing XML data.
I have written a small utility class, called DOMUtils, that contains static methods for performing common DOM tasks. For instance, to acquire the text content of the title child element of the root (picture) element, you would write the following code:
Document doc = DOMUtils.xml4jParse(picturefile);
Element nodeRoot = doc.getDocumentElement();
Node nodeTitle = DOMUtils.getChild(nodeRoot, title);
String title = (nodeTitle == null) ? null : DOMUtils.getTextValue(nodeTitle);
中文翻译：
XML与JSP联手
我们在此假设你已经了解javaserver pages(jsp)和extensible markup language (xml)。但也许你对该如何综合使用它们仍然有些迷惑。jsp的应用很容易，你可以用它设计网页，使之看起来似乎和html一样。唯一的不同是jsp是动态执行的。例如，它们可以处理表单form和读写数据库。xml的应用的说明则比较困难。似乎所有的产品都支持它，每个人也好象都以各种不同目的在使用它。
在本文中，你可以看到如何使用一种相当先进的方式用xml来设计一个系统。许多站点有巨量数据收集并以一种很标准或很不标准的方式来显示它们。我将设计一个系统，它使用xml文件在web服务器上进行存储，并用jsp来显示数据。
xml vs 关系型数据库
等一下！你可能问,你用xml文件存储数据吗?为什么不使用数据库？
这个问题问的很好。我的回答是，对很多目的用途来说，用数据库太过浪费了。.要使用一个数据库，你必须安装和支持一个分离的服务器处理进程（a separate server process）,它常要求有安装和支持它的administrator。你必须学习sql, 并用sql写查询，然后转换数据，再返回。而如果你用xml文件存储数据，将可减少额外的服务器的负荷。还有，你还找到了一个编辑数据的简单方法。你只要使用文本编辑器,而不必使用复杂的数据库工具。xml文件很容易备份，和朋友共享，或下载到你的客户端。同样的，你可以方便地通过ftp上载新的数据到你的站点。
xml还有一个更抽象的优点，即作为层次型的格式比关系型的更好。 它可以用一种很直接的方式来设计数据结构来符合你的需要。你不需要使用一个实体-关系编辑器，也不需要使你的图表（schema）标准化。 如果你有一个元素（element）包含了另一个元素，你可以直接在格式中表示它，而不需要使用表的关联。
注意，在很多应用中，依靠文件系统是不够充分的。如果更新很多，文件系统会因为同时写入而受到破坏。数据库则通常支持事务处理，可以应付所发生的请求而不至于损坏。对于复杂的查询统计要有反复、及时的更新，此时数据库表现都很优秀。当然，关系型数据库还有很多优点，包括丰富的查询语言，图表化工具，可伸缩性，存取控制等等。
(注意：你可以使用简单的文件锁定来提供一个事务处理服务器，你还可以在java中执行一种 xml index-and-search工具，不过这已经是另外一篇文章的主题了。)
在下面这样的案例中，正如大多数中小规模的、基于发布信息的站点一样，你可能涉及的大多数数据存取都是读，而不是写，数据虽然可能很大，但相对来说并没有经常的更新变化，你也不需要做很复杂的查询，即使你需要做，也将用一个独立的查询工具，那么成熟的rdbms的优点消失了，而面向对象型的数据模型的优点则可以得到体现。
最后，为你的数据库提供一个查询器外壳来进行sql查询并将他们转化进入xml stream也是完全有可能的。
所以你可以选择这二种方式之一。xml正变成一种非常健壮的，便于编程的工具，作为某个成熟的数据库的前端工具来进行存储和查询。(oracle的xsql servlet即是这种技术的一个很好的例子。)
所有人都喜欢照相！他们喜欢展示自己的，亲人的，朋友的，度假时的照片，而 web 是他们展示的好地方。-- 即使千里之外的亲戚都可以看到。我将着重于定义一个单独的picture对象。(这一应用的源代码在resources中可以取得) 。该对象描述了表示一张照片所需要的字段：title,date,一个可选的标题，以及对图片来源的一个指向。
一个图象，需要它自己的一些字段：源文件( gif/jpeg)的定位，宽度和高度像素(以协助建立 标记。 这里可以看到一个很简单的优点，即使用文件系统来代替数据库的时候，你可以将图形文件存放在与数据文件相同的目录中。
最后，让我们来用一个元素扩展图片记录，该元素定义了一套缩略图（thumbnail）来用于内容表或其它地方。这里我用了和先前同样定义的图片内容。
一张图片的xml表示可以是这样的：
1999-08-08
trying in vain to get a tan
alex-beach.jpg
340
200
alex-beach-sm.jpg
72
72
alex-beach-med.jpg
150
99
注意，通过使用xml, 你将一张单独图片的全部信息放到了一个单独的文件中，而不是将它分散放入3-4个表中。
我们将这称为 .pix file
-- 于是你的文件系统会是这样的:
summer99/alex-beach.pix
summer99/alex-beach.jpg
summer99/alex-beach-sm.jpg
summer99/alex-beach-med.jpg
summer99/alex-snorkeling.pix
etc.
技术篇
俗话说，要剥下猫的皮的方法何止一种。同样，将xml数据放到jsp中也不止一种办法。这里列举了其中一些方法，（其实，很多其它工具也可以做得同样出色。）
dom: 你可以使用类（classes）来调用dom接口（interface）对xml文件进行分析检查。
xmlentrylist: 你可以使用我的代码来将xml加载到name-value pairs 的java.util.list中。
xpath: 你可以使用一个 xpath处理器（如resin）通过路径名在xml文件中定位元素。
xsl:你可以使用某种xsl处理器将xml转换成为html。
cocoon: 你可以使用开放源码的cocoon framework 。
运行你自己的bean: 你可以写一个外壳类（wrapper class），使用某种其它技术来将数据加载到字定义的javabean中。
请注意这些技术将和一个你从另外来源取得的xml stream执行得同样出色，例如一个客户端或者一个应用服务器。
javaserver pages
jsp规范有很多替身，不同的jsp产品表现也不尽相同，不同版本之间也有差别。我选择了tomcat,这基于以下原因：
它支持大多数最新的jsp/servlet规范
它受到 sun和apache认同
你可以独立运行它而不需要另外配置一个web服务器。
它是开放源码的
你可以选择任何你喜欢的jsp引擎，但要自己配置它，它必须至少支持jsp 1.0规范。0.91和1.0之间有了许多区别。而jswdk (java server web development kit) 可能刚刚好地适合要求
jsp结构
当创建一个jsp网站 (webapp), 我喜欢将公用的函数、导入、常量、变量声明都放入到一个单独的文件init.jsp中。 然后用 <%@include file=init.jsp%>加载到每一个文件中去。 <%@include%> 就象c语言的 #include, include在编译时使其中的文本作为一个部分被加入并一起进行编译，相对地， 标记则是使其中的文件被独立地进行编译，然后在文件中嵌入一个对它的调用。
查找文件
当jsp启动时，初始化后第一件事情就是查找你要的xml文件。它是怎么知道在众多文件中你要找的是哪一个? 它来自与一个参数，使用者会在调用jsp的url中加入参数： picture.jsp?file=summer99/alex-beach.pix (或者通过html表单来传递文件参数)。
但是，当jsp接受此参数以后，你仍然只完成了一半工作，因为还要知道文件系统的根目录在哪里。例如，在unix系统中，实际文件可能在这样的路径：
/home/alex/public_html/pictures/summer99/alex-beach.pix。
jsp文件在执行状态时没有当前路径概念。所以你为java.io包要给出一个绝对路径。
servlet api可以提供一个方法来将一个url路径，从相对于当前jsp或servlet的路径转化成为一个绝对的文件系统路径。方法是：
servletcontext.getrealpath(string)。
每一个jsp有一个叫做application的 servletcontext对象。所以代码可以是：
string picturefile =
application.getrealpath(/ + request.getparameter(file));
或者
string picturefile =
getservletcontext().getrealpath(/ + request.getparameter(file));
它也可以在servlet中工作。(你必须加上 / 因为此方法需要传递request.getpathinfo()的结果。)
这里有一个重要的提示：每当你存取本地的资源，要非常小心地检查输入数据的合法性。黑客或者粗心的用户，可能发送伪造的或错误的数据来破坏你的站点。例如，请想一下以下的表达会发生什么结果：
如果输入了file=../../../../etc/passwd。这样用户回读到你的服务器的password文件！
dom (document object model）
dom 代表文档对象模型document object model。它是浏览xml文档的一种标准api，由world wide web consortium (w3c)发展。 接口在org.w3c.dom包中，文档参见w3c站点。
有许多可用的dom分析器工具。我选择了 ibm的xml4j。但你可以使用任何其它的dom分析器。这是因为dom是一套接口，而不是类 --所有的dom分析器（parser）必须返回同样地处理这些接口的对象。
遗憾的是，虽然很标准，dom还是有两大缺陷：
1 api虽然也是面向对象的，还是相当笨重。
dom parser并没有标准的api，所以， 当每一个分析器返回一个org.w3c.dom对象，文档对象--分析器初始化和文件自身加载的方式，对应于不同分析器通常总是特定的。
这个简单的上面已描述的图片文件在dom中可以在一个树结构中通过一些对象表示如下：
document node
--> element node picture
--> text node (whitespace)
--> element node title
--> text node alex on the beach
--> element node date
--> ... etc.
为了取得alex on the beach”，你要做一些方法调用，游历dom树，而且，分析器可能选择分散whitespace”文本nodes的一些数据，你不得不使用循环和串联等 （你可以通过调用normalize()来纠正这个问题。）分析器可能还包含了分离的xml实体(如 &), cdata nodes或者其它实体nodes (如big会被变成至少三个node。也没有办法在dom中简单表示get me the text value of the title element. 总之，在dom中游历有一点笨重。（参见本文用xpath取代dom章节。）
2 从更高处看，dom的问题是xml对象无法象java对象一样可以直接得到，它们需要通过 dom api一个一个地得到。
你可以参考我的为java-xml data binding技术讨论做的一些归纳，那里也用了这种直接使用java的方法来存取xml数据。
我写了一个小的工具类，叫做domutils,包含了静态方法来执行公用的dom任务。例如，要获得根（图片）元素的title子元素的文本内容，你可以编写如下代码：
document doc = domutils.xml4jparse(picturefile);
element noderoot = doc.getdocumentelement();
node nodetitle = domutils.getchild(noderoot, title);
string title = (nodetitle == null) ? null : domutils.gettextvalue(nodetitle);
数据库
Browse
Web服
务器
应
用
程
序
ODBC
驱动程序
Oracle驱动程序
SQLserver驱动程序
Access驱动程序
其他数据库驱动
Orcale
SQLserver
Access
…….....
应
用
程
序
J
DBC
驱动程序管理器
JDBC驱动程序 for Oracle
SQLserver驱动程序 for DB2
JDBC-ODBC桥驱动程序
JDBC网络驱动程序
Orcale
DB2
…….....
ODBC连接的数据库
学生
管理员
信息管理系统
学生
修改密码
学籍维护
选修课程
查看成绩
管理员
学生管理
选课管理
成绩管理
学生信息管理系统
学籍维护
选课管理
成绩管理
管理员
学生
修改密码
查看信息
修改学籍
添加学生
删除学生
修改信息
添加课程
删除课程
修改课程
选课情况
查看选课
选修课程
修改选课
添加课程
删除课程
查看成绩
添加分数
查看成绩
管理员
学生
管理员
学生
修改密码
查看学籍信息
查看选修课表
修改学籍信息
选修课程
成绩查询
修改选修课
退出系统
查看学生信息
添加新学生
删除学生
查看选修课
删除选修课
添加选修课
查看选课情况
查看必修课
查看成绩
添加成绩
添加必修课
退出系统
系统主页
选定登入模块
管理员操作
学生操作
查看成绩
选修课程
学籍维护
修改密码
成绩管理
选课管理
学生管理
学生
姓名
学号
密码
性别
专业
民族
政治面貌
曾用名
身份证
出生日期
健康状况
籍贯
入学年份
家庭地址
联系方式
选修课
课程号
任课教师
星期几
时间
上课教室
课程名
必修课
课程号
课程名
主讲教师
学分
学期号
成绩
学号
课程号
成绩
重修成绩
ID
学生
选修
选修课
学习
必修课
学生
输入用户名和密码
系统验证通过
选择权限
当用户或密码错误
判断用户名和密码
判断权限
学生界面
管理员界面
PAGE
8
获取项目源文件，联系Q:1225467431,可指导其它毕设,课设