网络考试系统的设计与实现（论文+PPT+源码）

毕业设计（论文）任务书

第1页

第2页

第3页

毕业设计（论文）任务书

第1页

第2页

第3页

毕业设计（论文）

毕业设计（论文）任务书

第1页

第2页

第3页

网络考试系统的设计与实现

摘 要

科技在进步，人们生活和工作的方式正发生着改变，不仅体现在人们的衣食住行，也体现在与时俱进的考试形式上。以前的考试需要组织者投入大量的时间和精力，需要对考试的试题进行筛选，对后期的考卷进行批阅，这么多的步骤影响了整个考试执行的效率。因此，本文提出了一种网络考试系统，用于解决上述的一些问题。

本文描述的网络考试系统主要是利用浏览器作为界面，利用B/S模式，即用户可利用浏览器直接访问本站点。主要用到的技术是采用JavaWeb技术和MySql数据库等设计出了各种功能。该系统主要有用户管理、功能管理、角色权限管理、学生网络考试、试题管理、错题管理、自动组卷等功能。

本文提供了一些该系统的部分代码跟截图帮助介绍该系统，对系统的总体设计、详细设计以及测试都给出了一些介绍，还对运行截图以及代码作出了相应的解释。该网络考试系统基本上可以满足一些简单的考试，运行良好，基本可以满足设计要求。

关键词： 考试；JavaWeb；网络

The design and implementation of the network examination system

Abstract

Science and technology in progress, people living and working the way is changing, not only reflected in people's basic necessities, but also reflected in the form of examination with the times. The previous exams require the organizers to devote a lot of time and effort to the examination of the examination questions, the late examination of the examination papers, so many steps affect the efficiency of the entire examination. Therefore, this paper presents a network test system, used to solve some of the above problems.

This article describes the network test system is mainly using the browser as an interface, the use of B / S mode, that users can use the browser to directly access the site. The main use of the technology is the use of JavaWeb technology and MySql database design a variety of functions. The system mainly has user management, function management, role rights management, student network examination, test questions management, wrong title management, automatic test paper and other functions.

This article provides some of the system code and screenshots to help introduce the system, the overall design of the system, detailed design and testing are given some introduction, but also on the operation of the screenshot and the code to make a corresponding explanation. The network test system is basically able to meet some simple exams, running well, the basic can meet the design requirements.

Keywords：Examination; JavaWeb; Network

目 录

摘 要ii

Abstractiiii

第1章 绪论11

1.1 研究的目的及意义11

1.2 研究开发现状分析11

1.3 研究的内容11

第2章 系统相关技术33

2.1 JAVA简介33

2.2 J2EE33

2.3 MySQL44

2.4 MyEclipse55

2.5 JavaScript66

2.6 JQuery66

2.7 CSS377

2.8 JSP77

2.9 Tomcat服务器88

第3章 可行性与需求分析99

3.1 可行性分析99

3.2 需求分析99

第4章 系统总体设计1111

4.1. 系统概要功能图1111

4.2 系统基本功能1111

4.2.1 登录功能1111

4.2.2 系统答题1111

4.2.3 答题得分1212

4.2.4 错题解析1212

4.2.5 系统功能管理1212

4.2.6 用户管理1212

4.2.7 角色管理1212

4.2.8 题目管理1313

4.2.9 试卷管理1313

4.3 数据库设计1313

第5章 系统详细设计1818

5.1 学生用户端1818

5.1.1 学生用户登录1818

5.1.2 主界面1919

5.1.3 系统答题2020

5.1.4 答题得分2121

5.1.5 错题解析2424

5.2 管理员端2424

5.2.1 管理员登录2424

5.2.2 管理员主界面2525

5.2.3 系统功能管理2525

5.2.4 用户管理2727

5.2.5 角色管理2929

5.2.6 题目管理3030

5.2.7 试卷管理3232

5.3 数据管理3333

第6章 系统测试3737

6.1 功能测试3737

6.2 兼容性测试4242

6.3 测试的方法4242

第7章 结束语4343

致谢4444

参考文献4545

外文翻译4646

第1章 绪论

1.1 研究的目的及意义

在我们以往的考试经历中，我们可以看到，每次考试都需要经过出试卷、印试卷、发卷、做卷、收卷、阅卷、统计等过程，这几个过程有着很强的先后次序，不能顺序颠倒。这些过程中，又以出卷、阅卷和统计最为复杂，当一次考试涉及的人数众多时，老师需要批阅非常多的卷子，重复的批阅卷子浪费了大量的时间，此外，不仅效率底下，同时大量的阅卷工作也让老师疲于应付，最后导致阅卷的准确率下降。即便阅卷完成之后，工作还没结束，还需要对这些卷子进行分数登记、成绩统计以及对各个题目进行错误率统计，这些工作消耗时间非常多，因此效率也是非常低的。此外，从学生角度出发，每次做卷都要准备笔和草稿纸，麻烦且不符合环保的要求，从老师的角度出发，如果能够减少出卷、阅卷和统计的时间，那么可以腾出更多的时间用在其他的地方。因此本文基于JavaWeb技术希望开发一套网络考试系统来解决出卷、阅卷、统计花费时间过多的问题，同时为学校教务信息化作出一份贡献。

本文开发的网络考试系统具有一定的现实意义，主要是解决教师在出卷、阅卷和统计上花费时间过多的问题。开发一个系统需要考虑很多方面的问题，比如说时效性和高效性这是两个最最常见的因素，因为时效性关系到你的系统在投入使用时是不是真的能够解决当前所存在的这些问题，网络考试系统在国内虽然已经初具规模，一些学校也在使用这种方式考试，但我觉得目前的考试系统还存在着一些未解决的问题，还需进一步完善。同时高效性也是一个非常重要的因素,如果你的系统用了以后还不如不用那么你的系统必定是一个不成功的产品这也是我们开发需要考虑的一个重要问题。本系统目前只可以实现对一门科目的客观题的考试，基本上还不是特别成熟的一个系统，我还需要考虑如何进行多科目的主客观题型的考试是我以后研究的方向。因此是本系统的开发具有很重要的实际意义，能在当前的发展状态下为学生和教师提供适当的帮助的同时也为今后此类软件的发展提供一定的基础。

1.2 研究开发现状分析

国内考试系统的信息化发展比较缓慢，在广泛化应用的过程中，开发者一方面不断投资购建各种硬件、系统软件和网络，另一方面也不断开发实施了各类教学软件、数据统计、信息记录等应用系统，形成了一定规模的信息化建设体系。可是，由于目前国内的系统还不是很完善，比如一门考试就需要一个系统去支持，这样成本太高，而且我国集体信息化水平有些落后，资金短缺等因素。我国的网络考试系统还没有很好地完全自如的融入到我们的学习生活中，比其他国家有一定的差距。国外的管理与国内完全不同，不但在线考试化建设早，而且他们有坚强的技术团队来提供技术基础。

1.3 研究的内容

本系统的研究目的在于实现网络考试系统，实现该系统要完成的工作包括如下几个方面：

（1）了解全球的网络考试系统的发展历程和现状。深入解析其工作流程。

（2）根据该系统的工作流程设计其总体结构，绘制其结构图。

（3）设计系统的功能模块，如：后台系统运行维护模块。包括试题的录入、筛选、删除，随机生成，提交，打分等功能。前台考试模块，包括题的分发、时间的记录等功能。教师组题模块，具有考题的生成、选择、分数评判的等能力。设计并实现教师考前出题的组题功能模块。包括题类型，数量，每个题考分的设定等。

（4）熟练地运用和掌握JavaWeb技术和MySql数据库编程，进行考试系统的程序代码编写、调试运行以及功能测试。

（5）了解电脑服务器的运行问题以及原理；大数据库的储存；以及大数据库与程序的互相交流问题。

本网络考试系统运用了很多的开发工具以及以java为基础的开发语言，在后台的代码编写中主要运用了Java、J2EE；前台的设计中运用了JavaScript、JQuery、css等一些开发语言；通过eclipse来编写这些程序；用mysql进行数据库的设计与分析；另外该网络考试系统的部署容器为tomcat，当需要进行考试时，只需要配置tomcat服务器，便可进行考试。

2.1 JAVA简介

Java作为一种计算机编程语言，其在企业网络和Internet环境的应用更是十分广泛，现在已成为Internet中最受欢迎、最有影响的编程语言之一。其最大的特点就是面向对象，这种面向对象的程序设计更接近我们的思维方式，相对于面向过程的程序设计，它最大的优点就是可扩展性和可维护性，这也使我们的代码更健壮。

我们都知道面向对象主要有四大特性：封装、抽象、继承和多态。

封装：在面向对象语言中，封装特性最为直接的体现在类中，类即现实生活中的实体的抽象，我们将其所拥有的属性和方法封装到类中，对外部我们提供相应的接口，通过实例化的对象可以调用类中封装好的属性和方法，并且在使用这些方法时并不用知晓其内部的具体实现，这是面向对象的封装特性；

抽象：抽象就是将一类实体的所共同拥有的特性抽象出来，封装在一个抽象类中，抽象在面向对象语言中是由抽象类来体现的。抽象类描述的是一类事物共有的东西，而并非特指某种事物，所以在Java编程语言中体现为抽象类不能实例化；

继承：继承就是指子类可以继承父类或者接口，从而可以实现代码重用，其实继承体现的是单继承关系，父类和子类本质上还是一类实体。

多态：Java中的多态具有多重含义。首先多态最为直白的体现就是父类对象引用不同的子类对象实例，调用不同的子类重写的方法从而表现出不同的行为。多态能够提高代码重用，还可为程序提供更好的可扩展性。

2.2 J2EE

J2EE是一项目架构标准主要用于网页的开发通过这个标准可以制定出一些应用于企业的网站。严格地来说，J2EE并不属于一种产品而是一种约束或者是标准。有的人把它称开发的规范，因此，不管是哪一家公司他们只要在这个架构下进行开发都可以开发出一款比较实用的高级应用程序。J2EE从开发到设计，再到最后的综合管理可以构成一套完整的开发体系，J2EE是由oracle软件公司跟其他多数享誉盛名的科技公司共同努力发明并且应用起来的。J2EE是软件开发的一项标准。J2EE并非是一种生产产品,它既可以说一种开发标准,也能够说是一种开发规范。无论是哪家公司都能够在这种现有统一的标准下开发出一套属于自己企业的高级应用系统的。J2EE是一个公司级平台。它用来给那些在公司经营项目中遇到的研发、设计、系统管控有关难题进行简化。

J2EE可以说这一项技术是根据JAVA标准升级而成而不是凭空独创的，J2EE不断的更新和发展最终形成了现在的约束和规范。J2EE技术首先要不违背它所继承的技术和规范标准，比如说对数据库的访问以及良好的跨平台性质，以及分布式的应用。同时，还要适用于各种各样的使用人群。除此之外必须还要为其他的网页开发或者企业开发提供大量的预留接口，体现其强大的可扩展性。其他的开发人员可以通过这些预留的接口对该规范和准则进行更加标准和一致性高的开发，从而体现出J2EE标准的强大的伸缩性。那么最终的一个目的就是要使得程序开发人员在开发过程中尽量少使用市场上的一些现有的框架，从而规范一个正确的开发体系。那么，他是利用一种开发模型，此模型呈现分布式。以此来完成对所有应用的开发。在开发过程中主要根据系统的各个功能进行划分，也可将这些功能划分为不同的组件。不同的组件会存放在不同的服务器上，并通过不同的用户接口进行管理。那么使用这一标准可以明确的规范开发的流程，并且可以通过MVC来解决系统层次和架构的问题，使得开发人员更加轻松的开发代码，并且让维护人员或者后期的修改人员能更加方便地查看系统的代码和结构。

2.3 MySQL

MySQL是一款开源的数据库。它具有非常实用的价值。他属于中型数据库。MySQL提供了许多的技术支持其中包括了多操作系统的支持也包括了多线程的支持，同时也提供多种资源的支持，除此之外，还可以提供多种的数据库连接方法解决数据库并发和大量数据操作的问题 。使用MySQL的人都会认为这个数据库特别实用。由于它是完全开源和免费的，在使用成本上也不会有太大的损失，因此是目前中小型公司主要使用的数据库之一。从数据库关系来看他是一款关系型数据库具有很多优点比如说用的内存空间较小用户界面简单操作起来十分便捷并且不需要太多繁琐的安装步骤。MySQL是由MySQL公司开发而成，那么这个公司是一个什么公司呢？从历史数据来看它是一个非常有商业眼光的公司，也是非常成功的一个公司，它所开发的产品都受到了人们的青睐。MySQL本身的特性也非常的突出，他能够兼容多种操作系统，同时也能兼容多种的编程语言，比如说Linux环境下使用，也同时能够支持多种编程语言并为这些编程语言提供他们所要使用的用户接口。在性能方面具有处理大数据高并发的处理能力，并且不会占用太多的主机内存，这一点相对其他的数据库要好很多。MySQL的架构应用图如2-1所示：

图2-1 Mysql架构服务图

MySQL使用了好几种软件进行测试，保证这个可用性；它支持好多种操作系统；支持多线程，提供了很多资源；也提种了很多数据库连接方法；它还可以处理很多比较大的数据库。大部分使用这个软件的人就会有很大的帮助了，而且还因为其他开放源码软件，也还大大降低总体拥有成本了。

MySQL数据库是最流行的关系型数据库管理系统，在WEB应用方面MySQL数据库是最好的RDBMS(Relational Database Management System：关系型数据库管理系统)应用软件之一。关系型数据库有较强的灵活性，它将数据保存到不同的表中，这样将数据进一步细分，读取速度和灵活性就会提高。MySQL数据库是真正做到了多线程、多用户的SQL数据库[9]。它使用最常用标准化语言去访问数据库。MySQL数据库以其成本低、体积小、速度快和源码开发的优点，开发中小型的网站都选用MySQL数据库作为数据库。

在大学期间，MySQL做为我们最先接触和理解的数据库其基础应用相对广泛，此次毕业设计我也选用MySQL做为后台数据库。

MySQL数据库的实现是以一个客户机/服务器结构[13]的形式，它是很多不同的客户程序和库和一个服务器守护程序组合而成的。

MySQL数据库主要是快度速、比较健壮和易于使用。我们需要这样一个SQL服务器，它能基于不昂贵的基础上，处理数据速度快，加之可视化插件、软件的使用可以使其数据操作更加方便。

可以总结出MySQL具有以下几个特性：

1. 支持AIX、FreeBSD、HP-UX、Linux、Mac OS、NovellNetware、OpenBSD、OS/2 Wrap、Solaris、Windows等多种操作系统；
2. 为多种编程语言提供了API；
3. 支持多线程，充分利用CPU资源；
4. 通过优化的SQL语句算法，有效地增进了查询速度；
5. 能够作为单独的应用程序为客户端服务器网络环境提供数据支持，也能够作为库而嵌入到其他的软件，完成相关的数据存储作用；
6. 提供多种语言支持，数据表名和数据列名都可以使用多种编码方式如中文的GB 2312、BIG5，日文的Shift_JIS等；
7. 提供多种用于管理数据库操作的管理工具；

使用MySql数据库用作集群服务器管理系统的数据库。可以让服务器大量的相关数据得以快捷地查询处理。

2.4 MyEclipse

MyEclipse是一种有集成效果的开发工具。在Eclipse的基础上进行插件的集成，最终形成功能强大的开发软件。目前主要用于JAVA，JAVAEE的开发，也可以用于移动应用的开发，其主要特点是功能强大，应用广泛，并且支持很多开源的产品，应用前景非常广发。

MyEclipse是由Eclipse通过对插件的集成而来，是对IDE的拓展，可以用来开发网页等应用，可以实现程序的开发，调试，发布等，能极大的提高开发效率，能完美支持HTML、STRUTS等，可以说集成后的MyEclipse包含了当前所有主流的开源产品。MyEclpise也经历了很多代的产品，从最开始的到后来的2014版本，2015版本等都说明了它在发展历程中的变化。

MyEclipse的配置使用也非常智能，不需要使用者懂太多的知识，只需要在自己使用的功能中进行了解即可，在完成项目开发之后，也可以直接通过MyEclipse进行项目部署，可以将网页项目进行选中，直接运行在Tomcat中，也可以将项目打包通过导出功能将项目全部导出，然后将项目发布到tomcat中，通过对配置文件的设置，完成布置，布置完项目以后可以在浏览器中进行查看。可以说，有了MyEclipse之后，基本就能支持所有的web开发，就能使用快捷的编译工具进行快速的开发，也能在各种各样的服务器上进行代码测试。在其他方面，MyEclispe也有很多的开发前景，比如在云开发领域，在移动端开发领域，在企业级开发领域等等，因此，MyEclipse的应用场景非常的广泛。

2.5 JavaScript

JavaScript看样子和Java很像，但是，实际上它们之间并没有直接联系，只是大家都以Java开头而已。目前互联网上最重要的语言是什么？不是Java，不是.Net，也不是PHP，而是JavaScript，它是互联网上最重要的语言。它不仅能跨平台、跨浏览器，它还能跨后端语言。在WEB2.0时代，JavaScript语言像桥一样，将前端页面和后端服务器连接了起来，这样前端页面不用知道服务器那里是用什么语言编写的，也不用知道是如何编写的，而服务器那头也不用知道前端是用什么语言写的，只需要知道前端会传过来一些固定格式的数据信息。JavaScript编写的程序是在浏览器中运行的，它不会在服务器那头运行，一定程度上减少了服务器那头的压力。JavaScript语言在网页完全加载完毕后，可以与网页产生互动来完成一些操作，利用这个特性，我们经常将JavaScript运用在验证表单、修改HTML元素和存储用户数据等方面上。这些功能，Flash和Silverlight都能完成，但是Flash和Silverlight都要单独的安装插件，使用门槛比较高，而且针对不同的浏览器，插件也不一样，在一堆插件中，用户很难选择正确的插件进行安装。而JavaScript不同，它不需要额外的安装什么东西，只要是个浏览器，就能支持。JavaScript的语法与C的语法类似，语句通过在最后加上“;”符号来表示结束，同样的大小写敏感，注释也是“//”开始。因此学习过C语言的人能够很快的上手JavaScript的开发工作。

2.6 JQuery

如果把开发人员扔回石器时代，那么JavaScript就是一堆绳子、木头和石头，通过用这些工具，人类就可以在石器时代活下来，同样的，开发人员也能用JavaScript做任何事。但是，如果说我们把绳子、木头和石头组装起来，做成榔头，做成弓箭，那么无论是打猎还是耕作，效率都会有很大的提升。jQuery就是这里的榔头和弓箭。jQuery是由JavaScript写的，它封装了一些我们在创作网页时候常用的操作，比如对DOM的修改、AJAX等操作，这些操作如果让开发人员自己用JavaScript编写，那么可能要花几十行代码，复杂的甚至要上百行，同时考虑到这些操作比较频繁，那么一个页面上你会看到很多很多的JavaScript代码，开发成本和维护成本都会很高，代码也不容易读。在jQuery，这些操作只需要少数几行代码甚至一行代码就能完成，减少了开发人员的负担，也让后期维护更加简单。绳子、木头和石头可以组装成榔头、弓箭等，同样的，JavaScript也能组装成许多和jQuery类似的工具，但是我们为什么选择jQuery，而不选择其他的呢？一方面是因为jQuery功能强大且容易学习，另一方面，jQuery从发行到现在，经历了许多版本的迭代，不仅稳定，而且网上相关的资料也更齐全，遇到问题也能更容易的解决。此外，在jQuery的支持下，还诞生一大批基于jQuery的插件，比如UI插件、弹窗、选项卡、导航菜单、在线客服、瀑布流、3D、时间轴等等的插件，这些插件不仅简化了开发，还使网页更加美观，用户交互体验更加好。基于上述原因，才在众多工具中，采用了jQuery。

2.7 CSS3

Cascading Style Sheets(CSS)，中文叫层叠样式表。现在来说我们已经进入了WEB2.0的时代，WEB2.0下的网站不仅需要好看的外观，同时还要用户体验良好的界面。CSS2标准，从现在的大环境下去看，显然已经不能满足日益增长的用户需求和开发需求。因此CSS3标准应运而生。CSS的作用是控制页面的布局，除了控制布局外，它还能够对页面上的字体颜色、大小、字体、背景和你能在网页上看到的一切进行控制。日前很多浏览器都能很好的支持CSS3标准。

CSS3引入许多新特性，以字体为例，在以前的CSS版本中，如果我们将网页的字体设置成“宋体”，那么大多数的电脑都能正常显示，可是我们都知道，MacOS系统里的字体要比Windows下的字体好看，但是如果我们将网页的字体设置为MacOS系统里的字体，那么Windows系统用户就没办法正常访问。这在老版本的CSS中是没办法解决的，但是在CSS3中，通过@Font-face特性，可以允许浏览器从服务器上加载字体文件，换句话说，即便你的电脑上没有这种字体，你也能正常的访问用了这个字体的页面。可见CSS3赋予了更大的灵活性。除了@Font-face特性外，CSS3还引入了包括Word-wrap & Text-overflow样式、文字渲染、多列布局、渐变、阴影、反射、盒子模型、Transforms 和 Animation Transitions等等新特性，这些新特点的引进，降低了创造者的开发难度，也提高了体验。

2.8 JSP

JSP（Java Script Pages）是由Sun公司建立的一种动态网页技术，它是建立在HTML文件基础上的。在传统的网页HTML文件（*.htm，*.html）中加入Java程序。

首先JSP是跨平台的，因为Java就是可移植跨平台的，而JSP技术是建立在Java平台之上，所以使用JSP开发的Web应用也是跨平台的。

JSP页面不仅可以使用普通网页一样使用标准标记语言的元素（如HTML标记）以外，还可以使用其独有的JSP标记。JSP可以直接向数据库中获取或写入数据，所以通过JSP，我们可以在网页中加入更多动态内容。

JSP有如下优点：

（1）一次编写，到处运行。除了系统之外，代码不用做任何更改。

（2）JSP具有多平台支持。可以在任意平台上的任意环境中开发，在任意环境中进行系统的部署和扩展。相比JSP的多平台支持相比ASP/.net的局限性是显而易见的。

（3）具有可伸缩性。不论是只有一个小的Jar文件就可以运行的Servlet/JSP，还是由多台服务器进行集群和负载均衡，亦或者由多台Application来事务处理，Java显示了其广阔的应用范围和巨大的生命力。

（4）功能强大的多样化的开发工具支持。Java已经有了许多非常优秀的开发工具，其中大部分可以免费得到，并且其中大多都能运行在多平台下。

选取JSP的原因

JSP通过其独有的标签库，使静态HTML网页技术向动态网页技术完善。通过其在网络编程中的使用，可以利用嵌入Java代码使其充分利用Java语言的上手容易，跨平台，运行效率高等优点。具备一定程序设计的基本知识，学习JSP也十分容易。

首先JSP是一种动态网页编程语言，再加上JSP具有跨平台、运行效率高、易学易用等特点和优势，做简单界面比较容易，故选用JSP来实现网络考试系统。

2.9 Tomcat服务器

Tomcat 服务器是Apache组织的一个开源子项目。具备基本的web服务的功能，是中小型系统首选的服务器，更是开发和调试JSP 程序的首选。因为Tomcat 技术不仅免费而且性能稳定，我们在本科阶段的很多web项目中也多为使用Tomcat作为服务器，其也成为目前比较流行使用的Web 应用服务器。

如果配置正确，Tomcat 服务器实际上在运行JSP 页面和Servlet容器。此外，Tomcat和其他Web服务器一样，都具有基于处理HTML页面的功能，另外它还是一个Servlet和JSP容器。独立的Servlet容器是Tomcat服务器的默认模式。目前Tomcat服务器最新版本为8.0.0，本次毕设我使用的也是Tomcat8。

此外，Tomcat 服务器运行时占用的系统资源较小，可扩展性良好，支持邮件服务和负载平衡等开发应用系统常用的功能。因此利用Tomcat服务器作为网络考试系统的Web应用服务器。

3.1 可行性分析

可行性分析是用最小的代价在最短的时间内确定问题是否能够解决。我首先需要进一步对上一章节目前考试系统现状的分析。之后初步的确定项目的规模跟目标，确定项目的约束跟限制，必须分析几种可能解法的利弊，从而判定原定系统的目标和规模是否能够实现，系统完成后带来的效益是否能够达到最大值。总之，只有认真的进行了可行性分析，才会避免或者减轻项目开发后期可能出现的困境。

1. 经济可行性

经济可行性的重要方面是研究成本,其中包含毕业设计所需的开发成本，对开发成本是不是会大于开发项目前期预计利润进行预算。在结合上述所有情况的分析下，我觉得自己的毕设课题是经济可行性好的。首先开发此次毕设软件不要前期的投入资金，其次是自己设计的，最多是自己去图书馆找书，在实验室做项目，通过老师教导，同学帮助，这些都是免费的，再有就是需要一台电脑，这些都是能接受的，成本很小的同时我也可能够提升我在编码方面的实现能力。

2. 技术可行性

本课题使用的是Java技术，开发平台选用Eclipse，Eclipse有着完整配备的功能，便于初学者使用还有代码提示，让我使用更加得心应手。在决定了编程框架后，再说用Java语言编码的优点：快，精简，可用性高等。同时，使用的数据库是MySQL，开源的MySQL增添了可视化和稳定化的优点，而且安全方面也做得很好，更别说它的强大的保存数据功能以及查询数据功能。

1. 操作可行性

该网络考试系统部署容器为tomcat，当需要进行考试时，只需要配置tomcat服务器，便可进行考试。本系统采用jsp技术，利用网络就能够进行访问和操作，且界面简单易操作，用户只要有电脑，都能进行访问和操作。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的。因此本系统可以进行开发。

3.2 需求分析

一.功能需求分析

网络考试系统主要用于实现高校在线考试，基本功能包括：自动组卷、试卷发布、试卷批阅、试卷成绩统计等。本系统结构如下：

（1）学生端：

登录模块：登录功能；

网络考试模块：可参加考试，并查看考试结果，提交试卷后老师允许的情况下查看错题；

（2）超级管理员端：

登录模块：实现管理员登录功能；

用户管理模块：实现用户信息的增加、修改、查看功能；

角色权限管理模块：实现角色的增加、修改、查看功能；

试卷管理模块：实现试卷信息的增加、修改、查看功能；

试题管理模块：实现试题信息的增加、修改、查看功能；

1. 试题管理员端（老师）：

试卷管理模块：实现试卷信息的增加、修改、查看功能；

试题管理模块：实现试题信息的增加、修改、查看功能；

二.非功能需求分析

1、整个系统的设计中，系统必须满足以下要求：

（1）数据安全性

存储有关隐私权的网络考试等问题的系统数据，需要确保数据的安全性，在网站设计时必须要采取安全防范措施，以解决潜在的安全问题，比如如何防止学生上网查答案。

（2）易用性

在用户权限范围内，可在一个统一风格的界面内即可完成相关的所有业务流程操作或者获取所有相关信息，大大提高操作员的工作效率和易用性，灵活应用本系统。

（3）柔软性

由于这个网络考试系统涉及到范围广泛的业务，设计出的系统必须能够处理接受变化的能力。

（4）扩展性

随着互联网管理业务管理需求的不断变化，老师管理系统必然涉及到业务更新及扩展，这就要求在设计之初就应该考虑良好的可扩展性方案。

第4章 系统总体设计

4.1. 系统概要功能图

本系统所开发的网络考试系统主要分成了三个模块的主要功能，系统功能、考试功能和学生功能，每个功能都包含了几个子功能，子功能主要包括：对于系统功能方面的管理、角色的管理、用户方面的管理、对于试题管理、对于的试卷管理、学生答题、总结出错题库与得分。系统的概要功能图如图4-1所示：

图4-1 系统概要功能图

4.2 系统基本功能

系统功能的划分方式可以分成很多种类，前面是按照功能模块进行划分，将系统分成三个模块，本章节依据网络考试系统的系统角色不同，可以分成用户端和管理员端。用户端包括：登录功能、学生答题、答题得分以及考完试之后的错题解析。管理员端包括：登录功能、系统功能管理、用户管理、角色管理、题目管理、试卷管理。下面本节主要对各个基本的功能进行一个简介。(此处没有对试题管理员进行详细介绍，因为管理员的题目管理跟试卷管理的功能就是他的功能)

4.2.1 登录功能

登录功能是一个系统的重要组成部分，也是一个系统重要的门户功能，登录功能主要实现了使用者对系统的登录，在本文所设计的体系中，登录主要分成了两种身份：学生用户和管理员。两种身份登陆，能细分系统的功能模块，实现更加方便的操作和管理。

4.2.2 系统答题

系统答题模块是本系统的一个重要功能，可以实现让用户的答题操作。系统答题功能主要是学生用户登录以后操作的，学生用户在输入正确的用户名和密码以后能开始系统答题，系统答题的题目均来自数据库。

4.2.3 答题得分

答题得分功能实现了学生用户在答题结束以后对自己得分情况的查看，该功能就实现了登录系统的学生用户在完成自己的试卷以后，点击体提交就能看到自己的得分，因此该功能是一个展示性质的功辅助能。

4.2.4 错题解析

错题解析功能是系统答题功能的一个辅助或者说优化的功能，只有学生用户在登录系统完成答题以后在老师允许的情况下才能进行该功能的操作，学生答题可能存在一定的错误，对错误题目的查看成为考试系统的子功能。因此本文所设计的错题解析功能，能让学生迅速发现正确或者错误题目，以及解析过程。这样方便自学和改进。学生功能结构图,如图4-2所示：

图4-2学生系统结构图

4.2.5 系统功能管理

系统功能管理主要实现了对系统的其他功能进行管理，主要包括对新功能的添加和编辑，对现有功能的添加和修改，同时能对现有的功能进行子功能的编辑和修改，修改后的功能可以在系统中被查看。

4.2.6 用户管理

用户管理是一个系统的重要功能之一，对用户的管理可以实现对系统使用者的了解和查看，能让使用者更加方便的使用本系统，用户的种类分为多种，本文主要体现在学生用户和管理者两种用户上面，可以对用户的信息进行添加修改等。

4.2.7 角色管理

角色管理主要是针对用户来设计的，不同的用户拥有不同的权力。换句话说就是操作的权限是不同的。学生账号只能进行答题等行为，而不能进行后台的管理员操作。管理员账号也拥有不一样的权利。这些权力体现在对账号的操作，试卷和题目的管理上，因此对权限的管理能很好的控制系统用户的行为，有利于系统更加稳定的运行。

4.2.8 题目管理

题目管理主要是针对管理员的功能，该功能面向系统中试卷所使用的题目库，在本系统中，管理员能通过对题目的添加和修改对题目进行管理，可以查看现有的题目，同时也能对新的题目进行添加，为试卷的生成提供更多题目的选择。

4.2.9 试卷管理

试卷管理是本系统的核心功能，主要实现的是对学生用户考试答题的试卷进行管理，通过系统随机抽取的题目自动生成试卷并且能将试卷存入数据库，供学生考试时进行选择。管理员功能结构图,如图4-3所示：

图4-3 管理员功能结构图

4.3 数据库设计

数据库的设计十分重要，下面将对本文所使用的数据表进行逐一的介绍。

1. 用户表及ER图

表4.1用户表

用户表ER图，如图4-4所示：

图4-4 用户表ER图

用户id：每一个登陆的用户都有一个特有的编号；

角色id：学生、超级管理员、试题管理员，三个角色分别对应一个编号；

账号：登录时需要用到的；

密码：密码对应相应的账号；

姓名：用户的真实姓名；

状态：1为正常，0为禁用。

2. 角色表

表4.2角色表

角色id：学生、超级管理员、试题管理员，三个角色分别对应一个编号；

角色名：学生、超级管理员、试题管理员；

角色状态：1为正常，0为禁用。

3. 功能表ER图

表4.3功能表

功能表ER图，如图4-5所示：

图4-5 功能表ER图

功能id：每个功能对应的编号；

功能名：分别有系统功能管理、角色管理、用户管理、题目管理、试卷管理等；

功能地址：每个功能对应一个地址，用于管理；

顶层功能id：系统功能包括系统功能管理、角色管理、用户管理，试题管理包括题目管理、试卷管理；

状态：1为正常，0为禁用。

4. 权限表ER图

表4.4权限表

权限表ER图，如图4-6所示：

图4-6 权限表ER图

角色权限id：每个角色所拥有的权限对应的编号；

功能id：每个功能对应的编号；

5. 试题表ER图

表4.5试题表

试题表ER图，如图4-7所示：

图4-7 试题表ER图

试题id：每道题对应的编号；

题干：题目的内容；

6. 试卷表ER图

表4.6试卷表

试卷表ER图，如图4-8所示：

图4-8 试卷表ER图

试卷ID：每套试卷对应的编号；

试卷名：试卷对应的名字；

试题id：每道题对应的编号；

7. 学生试卷表ER图

表4.7学生试卷表

学生试卷表ER图，如图4-9所示：

图4-9 学生试卷表ER图

试卷ID：每套试卷对应的编号；

用户id：每一个登陆的用户都有一个特有的编号；

角色id：学生、超级管理员、试题管理员，三个角色分别对应一个编号；

学生答案：学生做试卷后的结果；

试题答案：每道题的正确答案；

本章主要介绍网络考试系统的详细设计，分别从用户端和管理员端介绍各个功能模块的实现情况和运行截图。下面首先介绍用户端，然后介绍管理员端。

5.1 学生用户端

在这个系统中使用者主要是分为管理员和学生，我在这里先介绍学生用户系统的运行情况。以下是学生用户从登陆到错题解析的整个运行流程情况将在下面的论文中进行展示。

5.1.1 学生用户登录

学生用户登陆，先到这个界面。 如图5-1所示：

图5-1用户登录运行界面

在进入登录界面以后选择学生登录，再输入正确的用户名和正确的密码，就可以登录。如图5-2所示：

图5-2用户登录输入界面

用户正确完成登录输入以后，系统会根据用户所输入的信息，通过功能代码实现与数据库中存储数据的对比，从而判别该登录用户是否合法，如果不合法将提示输入正确的登录信息，输入正确则登录系统，进入系统的主界面。

5.1.2 主界面

学生用户正确登录系统之后会跳转到学生用户端的界面，主界面如图5-3所示：

图5-3学生用户主界面

学生用户的主界面主要包含了试卷列表和查看错题两个功能，试卷列表中罗列了所有考试的试卷，学生可以根据老师的要求选择对应的的试卷进行考试，考试结束以后还可以进行错题查看功能。

5.1.3 系统答题

学生用户登录系统以后选择试卷列表中的试卷进行考试答题，答题界面如图5-4所示：

图5-4学生用户答题界面

学生要在一定的时间内，完成试卷上的所有题目，然后进行提交，答题的进度和时间的限制可以系统会给出提示，运行界面如图5-5所示：

图5-5学生用户答题进度界面

5.1.4 答题得分

学生在规定的时间内完成答题，完成以后提交系统，提交系统，系统会根据题库对比得到考试成绩，成绩界面如图5-6所示：

图5-6学生用户答题成绩界面

计时器（到时自动交卷）功能，交卷时判断试卷是否有未答题、计算得分等功能都在paper.jsp中用javascript来实现

// 交卷功能

判断是否有未答题目

function unAnswer(){

if(unanswer != 0){

layer.open({

title:'警告',

content: "还有"+unanswer+"道题目未做！",

icon:2,

end:function(){

postAnswer();

}

});

}else{

postAnswer();

}

}

计算得分

function getScore(){

//var spid = n

$.post({

url: basePath + 'user/studentPaper?cmd=score&userid='+'${userid}'+'&spid='+ now.getTime(),

contentType: false,

processData: false,

success: function(res) {

console.log(res)

layer.open({

title:'得分',

content: res,

icon:1,

end:function(){

location.href = basePath+'user/studentPaper?cmd=stupaper';

}

})

},

error: function(res) {

console.log('error');

}

})

}

倒计时功能

//小于10的数字前面补0

function p(n){

return n<10?'0'+n:n;

}

//获取当前时间

var now=new Date();

//获取结束时间

var endDate=new Date();

//设置考试时间（单位分钟）

endDate.setMinutes(now.getMinutes()+20)

function getTime(){

var startDate=new Date();

var countDown=(endDate.getTime()-startDate.getTime())/1000;

var h=parseInt(countDown/(60*60)%24);

var m=parseInt(countDown/60%60);

var s=parseInt(countDown%60);

$('.time').html(p(h)+'时'+p(m)+'分'+p(s)+'秒');

if(countDown<=0){

document.getElementById('time').innerHTML='考试结束';

layer.open({

title:'警告',

content: '考试时间到，试卷已经提交！',

icon:5,

end:function(){

unAnswer();

}

})

}else{

setTimeout('getTime()',500);

}

}

getTime()

学生得到成绩以后可以对自己的本次成绩进行查看，也能对自己的其他考试试卷的成绩进行查看，查看界面如图5-7所示：

图5-7学生答题情况成绩结果界面

5.1.5 错题解析

学生用户能对自己的答题试卷中错误的题进行查看，并且能看到错题的解析，但是此功能只是一个辅助优化功能，必须是在交卷之后老师同意的情况下，才能查看。错题的解析界面如图5-8所示

图5-8学生用户错题解析界面

学生能根据数据库中给出的正常答案，对比自己的错误选项进行研究和学习，达到考试提升能力的效果。

5.2 管理员端

管理员端的功能主要为了更好的管理系统，让学生用户能顺利考试，因此管理员功能在实现的时候需要考虑的因素和功能会比较多，下面对管理员如何在这个系统中操作进行演示。试卷管理员（老师）的功能包括在其中。

5.2.1 管理员登录

管理员登录和学生用户登录使用的是同一个登录界面，区别在于登录时选取的身份是管理员身份，登录界面如图5-9所示：

图5-9管理员登录界面

5.2.2 管理员主界面

管理员正确输入信息后会跳转到管理员的主界面，主界面如图5-10所示：

图5-10管理员主界面

在管理员主界面上，我们可以看到管理员端主要分成了两个部分的功能，第一个是系统功能，第二个是试卷管理功能，下面将对这两个功能下的子功能进行逐一介绍。

5.2.3 系统功能管理

系统功能管理实现了所有的父功能和子功能之间的联系，能让管理员更方便得查看各个功能的实现情况。系统功能管理的界面如图5-11所示：

图5-11系统功能管理界面

功能之间存在着主次关系，可以通过新建实现新的功能，也可以通过编辑来实现功能间的联系，新建功能如图5-12所示：

图5-12系统新建功能界面

编辑系统子功能如图5-13所示：

图5-13系统功能管理编辑子功能界面

5.2.4 用户管理

实现用户的管理解决的是学生的使用系统有关的问题，用户管理界面如图5-14所示：

图5-14用户管理界面

用户管理可以对用户进行新增、修改和查询，用户新增界面如图5-15所示：

图5-15用户新增界面

用户修改界面如图5-16所示：

图5-16用户修改界面

用户查询界面如图5-17所示：

图5-17用户查询界面

5.2.5 角色管理

角色管理主要把各个角色之间的权限管理实现了，方便最高权限的人对其他管理员的管理。角色管理界面如图5-18所示：

图5-18角色管理界面

对角色的管理主要体现在对角色的权限控制上，权限设置界面如图5-19所示：

图5-19角色设置界面

角色可以通过添加完成。添加角色界面如图5-20所示：

图5-20角色新增界面

5.2.6 题目管理

题目的管理主要实现对所有考试题目得新增和编辑。题目管理界面如图5-21所示：

图5-21题目管理界面

实现对现有题目的编辑如图5-22所示：

图5-22题目编辑界面

除了对现有题目的修改，还能实现对新题目的添加，新增新题目的界面如图5-23所示：

图5-23题目新增界面

5.2.7 试卷管理

试卷的管理是学生考试的关键功能，试卷管理界面如图5-24所示：

图5-24试卷管理界面

试卷的种类分为很多种，要想从试卷中找到相关的试卷可以启动搜索功能，搜索界面如图5-25所示：

图5-25试卷搜索界面

可以随机抽取题目生成试卷。生成试卷的界面如图5-26所示：

图5-26试卷新增界面

在DAO层，利用随机函数，（设置试卷题目和插入题目数量）实现自动组卷

public Integer addpaper(Paper paper) {

// TODO Auto-generated method stub

String sql = "INSERT INTO paper(pname,sid) SELECT ?,sid FROM " +

"subject where sstate = 1 ORDER BY rand() LIMIT ?";

Integer rtn =DBUnitHelper.executeUpdate(sql,paper.getPname(),paper.getScount());

return rtn;

5.3 数据管理

数据管理对代码与数据库之间的连接和交互起作用，数据库交互实现的代码为：

Connection conn = null;

try {

DbUtils.loadDriver("com.mysql.jdbc.Driver");

conn = DriverManager.getConnection(

"jdbc:mysql://localhost:3306/exam", "root", "zhs2668281");

} catch (SQLException e) {

e.printStackTrace();

}

return conn;

}

完成数据库的连接，进行一些简单的数据库操作，包括增删改查等，主要代码为：

public static Integer executeUpdate(String sql,Object ...objects){

Connection conn = getConn();

QueryRunner qr = new QueryRunner();

Integer rtn = 0;

try {

if(objects == null){

rtn = qr.update(conn, sql);

}else{

rtn = qr.update(conn, sql, objects);

}

} catch (Exception e) {

e.printStackTrace();

}finally{

try {

DbUtils.close(conn);

} catch (Exception e) {

e.printStackTrace();

}

}

return rtn;

}

public static Integer executeUpdate(String sql){

return executeUpdate(sql, null);

}

public static <T> List<T> executeQuery(String sql,Class<T> cls,Object ...objects){

Connection conn = getConn();

List<T> list = null;

try{

QueryRunner rq = new QueryRunner();

if(objects == null){

list = rq.query(conn, sql,new BeanListHandler<T>(cls));

}else{

list = rq.query(conn, sql,new BeanListHandler<T>(cls),objects);

}

}catch(Exception e){

e.printStackTrace();

}finally{

try {

DbUtils.close(conn);

} catch (SQLException e) {

e.printStackTrace();

}

}

return list;

}

其中分页查找的代码为：

/**

* 带分页的查询

* @param sql SQL语句

* @param map SQL参数

* @param pc 分页控制对象，需要传递参数：当前第几页（currentindex）,每页显示多少行：(pagesize)

* 分页控件显示多少也：showpcount

* @return

*/

public static <T> Pager<T> execlist(String sql,PageControl pc,Class cls,String pk,Object...object){

//获取总记录数sql

String sqlcount = "select count(*) as count from ("+sql+") a";

//获取具体数据的SQL语句

Integer min = (pc.getCurrentindex()-1)*pc.getPagesize();

Integer max = pc.getPagesize();

String sqllist = "select * from ("+sql+") a where a."+pk+" limit "+min+","+max;

Connection conn = getConn();

Pager<T> pager = new Pager<T>();

try {

QueryRunner rq = new QueryRunner();

Object count = rq.query(conn, sqlcount, new ScalarHandler<Object>("count"), object);

List<T> list = executeQuery(sqllist,cls,object);

//设置总记录数

Integer c = 0;

if(count!=null){

c=Integer.parseInt(count.toString());

}

pc.setRscount(c);

pager.setList(list);

pc = dealpage(pc);

pager.setPagectrl(pc);

DbUtils.close(conn);

} catch (Exception e) {

e.printStackTrace();

}

return pager;

}

第6章 系统测试

系统测试一个很主要的任务便是检查系统中所存在的一些不足和需要改进的方面，以此来提高整个系统的可靠性。而系统建设的一个更主要的目的是检测整个系统的“执行如何”。这其中可以把它分为三大步，分别是对于模块测试、组装测试以及对于验证的测试。而模块测试即是要测试整个程序的正确与否，装测试便是测试程序的接口正确与否，最后的验证测试是使用者是否满足整个系统软件的功能和性能的关键。一旦经过系统检测测试出所存在的一系列问题的时候就需要经过不断的调试，从而找出具体的错误所存在的位置在哪里，以便更好的改正。黑盒测试要根据系统整体需求说明书,应该全面覆盖到系统联合部件。系统检测是对整个系统进行一系列检测，进一步看看它是否符合需求规格的定义。在与需求规格定义不吻合或者是产生矛盾的地方要做进一步的修改。我们进行的软件测试主要是包括功能测试和兼容性测试。

6.1 功能测试

为了确保程序的正常运行为了保证每个功能都能实现既定的任务，在程序开发结束时应该对整个系统进行功能测试。就像我们所知道的功能测试就是对我们所开发的产品的各个功能进行逐一验证确保只能够完成我们所设计的功能。在功能测试的过程中我们需要用到一些测试用例对每一项功能足以测试从而可以检查我们所设计的系统能不能达到我们当时所期望的所有功能。功能测试从另一个方面来讲也可以叫做黑盒测试或者数据驱动测试，因为在黑盒测试和数据驱动测试系功能测试中我们只需要考虑的是每一个独立功能而不需要考虑整个代码的功能。一般来讲我们可以从系统的每一个小功能开始测试，比如说在本文中体现的就是登陆功能和发表评论功能，通过对这两个小功能的测试我们可以得出结论我们的系统是否满足我们所期望的功能需求的。

我们所接触的功能测试一般也叫黑盒测试，我们部队底层代码或者其他因素进行测试，我们只对各个功能进行测试。我们首先会对整个界面的各个功能进行测试，然后逐步深入，对每一个子功能进行测试，这个就是我们预期的目标。我们需要对所有功能进行测试以确保我们的设计和我们的实现是一致的，这样我们的功能说明说才是真实有效的。

我们进行程序的功能测试主要是对功能完整性进行测试，但是不是做完这些就可以了，我们还要对其他的部分进行测试，这就好比:判断条件的测试，输入的测试等。功能测试如表5.1所示。

表6.1 功能测试表

部分测试用例如表6.2、6.3所示：

表6.2 软件测试用例表

错误等级如表6.3所示：

表6.3 错误等级描述表

功能测试会存在一定的等级误差也可以理解成我们所开发的功能是否能满足我们所期望的设计的一个范围因此我们可以将错误的等级划分成几个不同的种类。

表6.4用户管理模块功能测试用例

表6.5角色管理模块功能测试用例

表6.6系统功能管理模块功能测试用例

表6.7题目管理模块功功能测试用例

表6.8试卷管理模块功能测试用例

6.2 兼容性测试

兼容性测试是一个系统是否能在各种情况下正常运行的关键，测试的环境主要在各个操作系统和各个浏览器上展开，软件测试中的兼容性测试很重要，如果说一个B/S系统与大多数的主浏览器都不是很兼容，那么这个系统将不能在市场上稳定的运行。在本设计中，我们所提出的系统虽然不用考虑过多的商业因素但是也必须将兼容性测试后考虑在其中，这样能让系统在以后的使用中更加稳定的运行。因此对系统进行一次兼容性测试是很有用的一个检测方式。

6.3 测试的方法

软件测试的常用方法基本有两种：静态测试和动态测试。

1.静态测试主要是指在不运行程序的前提下，通过人工评审程序源代码和程序有关的说明文档以及其他各类资料，来发现软件中存在的逻辑错误和代码错误，但是该类方法有一定的局限性；

2.动态测试顾名思义就是要运行测试程序，检查运行结果和预期结果的差异，并分析运行效率和健壮性等属性，动态测试的关键就是测试用例的构建。目前，大部分公司的测试方式主要是动态测试，动态测试中设计测试用例的方法是白盒法与黑盒法；

白盒测试：也称之为结构测试，是将软件看成了一个透明的白盒子，并按照程序的内部结构与处理逻辑来选定测试用例，对软件的逻辑路径及过程进行测试，检查它与设计是否相符。白盒测试：是通过程序的源代码进行测试而不使用用户界面。这种类型的测试需要从代码句法发现内部代码在算法，溢出，路径，条件等等中的缺点或者错误，进而加以修正。

黑盒测试：也称功能测试，数据驱动测试或基于规格说明的测试，是通过使用整个软件或某种软件功能来严格地测试, 而并没有通过检查程序的源代码或者很清楚地了解该软件的源代码程序具体是怎样设计的。测试人员通过输入他们的数据然后看输出的结果从而了解软件怎样工作。将软件看作黑盒子，在完全不考虑程序的内部结构和特性的情况下，测试软件的外部特性。根据软件的需求规格说明书设计测试用例，从程序的输入和输出特性上测试是否满足设定的功能。

这篇论文主要讲述了一个网络考试系统，在实现网络考试系统的时候，我重点完成了以下几点内容：（1）认识国内外网络考试系统的发展情况，深入思考该系统的工作流程；（2）按照该考试系统的工作流程设计该系统的总体结构，绘制结构图；（3）设计系统的功能模块，如：后台系统维护模块，其中包含试题的录入、整理、删除等功能；前台考试模块，其中包括考试题的抽取、考试时间的倒计时等一些功能；教师组题模块，包括考试题的生成、题目形式的选择、每道题分值的设置等功能；设计并完成老师在考试前把题目整理出来功能模块，包括考题类型、数量、每个题分数的设置等；（4）熟练地运用和掌握JavaWeb技术和MySql数据库编程，进行考试系统的程序代码编写、调试运行以及功能测试；（5）了解服务器的部署问题，数据库的存储问题，以及数据库与程序的交互问题。本文总结了当前网络考试系统的应用领域和发展趋势，分析了现今一些考试系统存在的问题，结合我们所使用的考试系统和使用环境，提出了本文设计网络考试系统的必要性。同时，根据系统需求与可行性分析完成了系统架构的方案设计和管理员、学生用户的功能分析以及各个功能的详细实现。课题在具体内容上首先详细介绍了系统所使用的关键技术，并对这些技术的相关知识进行了详细的介绍，紧接着对我的这个系统的结构和还有模块进行了一些详细的解释，最后对这个系统的实现进行分析和演示。

至此，本文所设计的网络考试系统基本完成，但是本文所提出的仅仅是一个的毕业设计，它所涉及的内容和形式都非常有限，在许多功能的实现和完成方式上存在着诸多的不足，这将在今后的学习中得到改进。

致谢

在这紧张而又对社会带着新奇的大四下半学年，每天基本都与毕业设计和论文度过，我的每一天的进步都跟我的毕设负责老师的耐心指导有着很大的关系，我的一点一点的进步凝集着老师的责任心以及对学术研究的执着。

在这里我想感谢帮助过我的所有老师，正是有了他们的耐心教导和积极的负责的工作态度，我的论文才能够完成的稍微顺利的完成。从我的论文选择题目开始到大概完成论文的定稿都集聚着指导老师大量的智慧和心血。老师在修改我论文的过程中非常严谨、对待我论文中的问题让我一句一句的修改、老师的学术功底也深深的影响着我，对我今后的学习有很大的帮助。在此向老师至以最衷心的感谢。

从大学刚来那一天，到现在马上离开大学的校园，感触颇深，有很多美好的记忆，也有很多的遗憾，毕业论文是最后的一段记忆，这四年中正是因为每位专业课老师的指导帮助，我现在的毕业论文才能完成的游刃有余，感谢每一位我遇到的老师。

最后还要对我的同学和朋友们说一声谢谢，感谢他们在我对论文有问题时及时伸出的援助之手，给我讲解一些程序的代码，解决了一些比较重要的问题。在这里我要对那些帮助我的人说一声谢谢。

[1] 李英杰. 基于JAVA技术的网络考试管理系统的研究与开发[D]. 上海： 同济大学，2007， (23)：页码.

[2] 王添财. 基于Java EE的在线考试系统的设计与实现[D]. 广东：华南理工大学，2014.

[3] 刘毅. 人工智能在自动组卷建模中应用研究[J]. 计算机仿真，2011.

[4] 郭琳. Java Web中错误异常的处理方法分析[J]. 电子技术与软件工程，2015.

[5] 关海伟. Java Web的云存储技术研究[D]. 西安：西安电子科技大学，2014，(23)：页码.

[6] Renuka Kumar. Detection of Obfuscation in Java Malware[J]. 爱思唯尔期刊，2016.

[7] 郑保平，郭荣宁. 数据库技术研究综述[J]. 军事通信系统，2003，(18): 页码.

[8] Ronald P .Anjard. The Basics of Database Management Systems[J]. Emerald期刊，1994.

[9] Sepideh Naghdi. Preventing database schema extraction by error message handing[J]. 爱思唯尔期刊， 2015.

[10] 朱少民. 软件测试方法和技术[D]. 北京：清华大学出版社，2010.

[11] 柳纯录. 软件评测师教程[J]. 北京：清华大学出版社，2005.

[12] 舒华峰. 自动组卷系统的设计与实现[D]. 吉林：吉林大学，2014，(15)：页码.

附录：

外文翻译

The Real-Time Specification for Java

New languages, programming disciplines, operating systems, and software engineering techniques sometimes hold considerable potential for real-time software developers. A promising area of interest—but one fairly new to the real-time community—is object-oriented programming.

Java, for example, draws heavily from object orientation and is highly suitable for extension to real-time and embedded systems. Recognizing this fit between Java and real-time software development, the Real-Time for Java Experts Group (RTJEG) began developing the real-time specification for Java (RTSJ)1 in March 1999 under the Java Community Process.

The goal of the RTJEG, of which we are both members, was to provide a platform—a Java execution environment and application program interface (API)—that lets programmers correctly reason about the temporal behavior of executing software. Programmers who write real-time systems applications must be able to determine a priori when certain logic will execute and that it will complete its execution before some deadline. This predictability is important in many real-time system applications, such as aircraft control systems, military command and control systems, industrial automation systems, transportation, and telephone switches. We began our effort by looking at the Java language specification3 and the Java virtual machine specification.4 For each feature of the language or runtime code, we asked if the stated semantics would let a programmer determine with reasonable effort and before execution the temporal behavior of the feature (or of the things the feature controls) during execution. We idenThe RTSJ provides a platform that will let programmers correctly reason about the temporal behavior of executing software. Two members of the Real-Time for Java Experts Group explain the RTSJ’s features and the thinking behind the specification’s design. Greg Bollella IBM James Gosling Sun Microsystems tified three features—scheduling, memory management, and synchronization—that did not allow such determination. Requirements defined in a workshop sponsored by the National Institute of Science and Technology (NIST) combined with input from other industry organizations helped us identify additional features and semantics. We decided to include four of these additional features: asynchronous event handling, asynchronous control transfer, asynchronous thread termination, and access to physical memory.

These plus the three features from our review of the Java and JVM specifications gave us seven main areas for the RTSJ. We believe these seven areas provide a real-time software development platform suitable for a wide range of applications. The “How Well Does the RTSJ Meet Its Goals?” sidebar gives more background on the requirements and principles that drove RTSJ development. The “RTSJ Timetable” sidebar lists important milestones and contacts for those interested in reviewing the draft specification. The RTSJ completed public review in February 2000, but the Java Community Process mandates that we not finalize the specification until we complete the reference implementation and test suites. As the community gains experience with the RTSJ, small changes to the specification may occur. Our goal in writing this article is to provide insights into RTSJ’s design rationale—particularly how the NIST requirements and other goals affected it—and to show how this important specification fits into the overall strategic direction for defining an object-oriented programming system optimized for real-time systems development.

SCHEDULING The Java specification provides only broad guidance for scheduling: When there is competition for processing resources, threads with higher priority are generally executed in preference to threads with lower priority. Such preference is not, however, a guarantee that the highest priority thread will always be running, and thread priorities cannot be used to reliably implement mutual exclusion. Obviously, if you are writing software with temporal constraints, you need a stronger semantic statement about the order in which threads should execute. The typical way to define these semantics is through algorithms that determine how to choose the next thread for execution. The RTSJ specifies a minimum scheduling algorithm, which must be in all RTSJ implementations. Minimum requirements At the very least, all implementations must provide a fixed-priority preemptive dispatcher with no fewer than 28 unique priorities. “Fixed-priority” means that the system does not change thread priority (for example, by aging). There is one exception: The system can change thread priorities as part of executing the priority inversion avoidance algorithm (which preserves priority inheritance). Without exception, threads can change their own or another thread’s priorities.

The application program must see the minimum 28 priorities as unique; for example, it must know that a thread with a lower priority will never execute if a thread with a higher priority is ready. Thus, you cannot simplistically map 28 priorities into, say, a smaller number because of the underlying system. You can, however, implement the RTSJ on a platform that provides fewer than 28 native priorities. It would then be up to you to use whatever means available to provide the appearance of uniqueness. Why 28 priorities? We chose this number because real-time scheduling theory indicates that you can expect close to optimal schedulability with 32 priorities.5 We chose to leave four priorities for other tasks because the RTSJ will likely be only a part of the system, and some systems have only 32 native priorities. You can, of course, add scheduling algorithms to this minimum requirement. The RTSJ provides three classes—Scheduler, SchedulingParameters, and ReleaseParameters—and subclasses of these that encapsulate temporal requirements. These classes are bound to schedulable objects (threads or event handlers). The required scheduler, an instance of the class PriorityScheduler, uses the values set in these parameter objects.

Thread creation The RTSJ defines the RealtimeThread (RT) class to create threads, which the resident scheduler executes. RTs can access objects on the heap and therefore can incur delays because of garbage collection. Another option in creating threads is to use a subclass of RT, NoHeapRealtimeThread. NHRTs cannot access any objects on the heap, which means that they can run while the garbage collector is running (and thus avoid delays from garbage collection). NHRTs are suitable for code with a very low tolerance of nonscheduled delays. RTs, on the other hand, are more suitable for code with a higher tolerance for longer delays. Regular Java threads will do for code with no temporal constraints. MEMORY MANAGEMENT Garbage-collected memory heaps have always been considered an obstacle to real-time programming because the garbage collector introduces unpredictable latencies. We wanted the RTSJ to require the use of a real-time garbage collector, but the technology is not sufficiently advanced. Instead, the RTSJ extends the memory model to support memory management in a way that does not interfere with the real-time code’s ability to provide deterministic behavior. These extensions let you allocate both short- and long-lived objects outside the garbage-collected heap. There is also sufficient flexibility to use familiar solutions, such as preallocated object pools. Memory areas The RTSJ introduces the notion of a memory area— a region of memory outside the garbage-collected heap that you can use to allocate objects. Memory areas are not garbage-collected in the usual sense. Strict rules on assignments to or from memory areas keep you from creating dangling pointers, and thus maintain Java’s pointer safety. Objects allocated in memory areas may contain references to objects in the heap. Thus, the garbage collector must be able to scan memory outside the heap for references to objects within the heap to preserve the garbage-collected heap’s integrity. This scanning is not the same as building a reachability graph for the heap.

The collector merely adds any reference to heap objects to its set of pointers. Because NHRTs can preempt the collector, they cannot access or modify any pointer into the heap. The RTSJ uses the abstract class MemoryArea to represent memory areas. This class has three subclasses: physical memory, immortal memory, and scoped memory. Physical memory lets you create objects within memory areas that have particular important characteristics, such as memory attached to a nonvolatile RAM. Immortal memory is a special case. Figure 1 shows how object allocation using immortal memory compares to manual allocation and automatic allocation using a Java heap. Traditional programming languages use manual allocation in which the application logic determines the object’s life—a process that tends to be time-consuming and error-prone. The one immortal memory pool and all objects allocated from it live until the program terminates. Immortal object allocation is common practice in today’s hard real-time systems. With scoped memory, there is no need for traditional garbage collection and the concomitant delays. The RTSJ implements scoped memory through either the MemoryParameters field or the ScopedMemory.enter() method. Scoped memory Figure 1c shows how scoped memory compares to immortal memory and other allocation disciplines. Scoped memory, implemented in the abstract class ScopedMemory, lets you allocate and manage objects using a memory area, or syntactic scope, which bounds the lifetime of any objects allocated within it. When the system enters a syntactic scope, every use of “new” causes the system to allocate memory from the active memory area. When a scope terminates or the system leaves it, the system normally drops the memory’s reference count to zero, destroys any objects allocated within, and calls their finalizers. You can also nest scopes. When the system enters a nested scope, it takes all subsequent allocations from the memory associated with the new scope. When it exits the nested scope, the system restores the previous scope and again takes all subsequent allocations from that scope. Two concrete subclasses are available for instantiation as MemoryAreas: LTMemory (LT for linear time) and VTMemory (VT for variable time). In this context, “time” refers to the cost to allocate a new object. LTMemory requires that allocations have a time cost linear to object size (ignoring performance variations from hardware caches or similar optimizations).

You specify the size of an LTMemory area when you create it, and the size remains fixed. Although VTMemory has no such time restrictions, you may want to impose some restrictions anyway to minimize the variability in allocation cost. You build a VTMemory area with an initial size and specify a maximum size to which it can grow. You can also opt to perform real-time garbage collection in a VTMemory area, although the RTSJ does not require that. If you decide to do this, you can build the VTMemory object with a garbage collection object to specify an implementation-specific garbage-collection mechanism. However, if you implement VTMemory, NHRTs must be able to use it. Because, as Figure 1c shows, control flow governs the life of objects allocated in scoped memory areas, you must limit references to those objects. The RTSJ uses a restricted set of assignment rules that keep longer-lived objects from referencing objects in scoped memory, which are possibly shorter lived. The virtual machine must detect illegal assignment attempts and throw an appropriate exception when they occur. The RTSJ implements scoped memory in two separate mechanisms, which interact consistently: the ScopedMemory.enter() method and the memory area field of MemoryParameters. You specify either one when you create the threads. Thus, several related threads can share a memory area, and the area will remain active until the last thread has exited. This flexibility means that the application can allocate new objects from a memory area that has characteristics appropriate either to the entire application or to particular code regions. SYNCHRONIZATION In synchronization, the RTSJ uses “priority” somewhat more loosely than the conventional real-time literature. “Highest priority thread” merely indicates the most eligible thread—the thread that the scheduler would choose from among all the threads ready to run. It does not necessarily presume a strict priority-based dispatch mechanism. Wait queues The system must queue all threads waiting to acquire a resource in priority order.

These resources include the processor as well as synchronized blocks. If the active scheduling policy permits threads with the same priority, the threads are queued first-in, firstout. Specifically, the system Figure 1. How immortal and scoped memory differ from other methods of determining an object’s life. (a) The Java heap uses automatic allocation, in which the visibility determines the object’s life (if there are no references to the object, the system can deallocate it). Automatic allocation requires a garbage collector, however, which incurs delays. (b) In allocation using the RTSJ immortal memory, the object’s life ends only when the Java virtual machine (JVM) terminates. (c) RTSJ scoped memory uses syntactic scope, a special type of memory area outside the garbage-collected heap that lets you manage objects with well-defined lifetimes. When control reaches a certain point in the logic, the system destroys any objects within it and calls their finalizers.

Avoiding priority inversion The synchronized primitive’s implementation must have a default behavior that ensures there is no unbounded priority inversion. This applies to conventional Java code if it runs within the overall RTSJ implementation as well as to real-time threads. The priority inheritance protocol—a well-known real-time scheduling algorithm6—must be implemented by default. The specification also provides a mechanism by which you can override the default systemwide policy or control the policy to be used for a particular monitor, as long as the implementation supports that policy. The specification of monitor control policy is extensible, so future implementations can add mechanisms. A second policy, priority ceiling emulation (or highest locker), is also specified for systems that support it.6 Determinism Conforming implementations must provide a fixed upper bound on the time required for the application code to enter a synchronized block for an unlocked monitor. Sharing and communication among threads Implementers are most likely to use a combination of regular Java threads, RTs, and NHRTs. The RTSJ permits locking between different thread types—even in the most contentious case, which is between regular threads and NHRTs.

If an NHRT attempts to lock an object that either an RT or regular thread has already locked, priority inheritance happens as normal. There is one catch: The non-NHRT that has had its priority boosted cannot execute when the garbage collector is executing. Thus, if a garbage collection is in progress, the boosted thread is suspended until collection completes. This, of course, causes the NHRT to incur a delay because of the collection. To address this, the RTSJ provides mechanisms that allow NHRTs to communicate (a form of synchronization) with RTs and regular Java threads while avoiding garbage-collector-induced delays in the NHRTs. The RTSJ provides queue classes for communication between NHRTs and regular Java threads. Figure 2 shows a wait-free write queue, which is unidirectional from real-time to non-real-time. NHRTs typically use the write (real-time) operation; regular threads typically use the read operation. The write side is nonblocking (any attempt to write to a full queue immediately returns a “false”) and unsynchronized (if multiple NHRTs are allowed to write, they must synchronize themselves), so the NHRT will not incur delays from garbage collection. The read operation, on the other hand, is blocking (it will wait until there is data in the queue) and synchronized ( it allows multiple readers). When an NHRT sends data to a regular Java thread, it uses the wait-free enqueue operation, and the regular thread uses a synchronized dequeue operation. A read queue, which is unidirectional from nonreal-time to real-time, works in the converse manner. Because the write is wait-free, the arrival dynamics are incompatible and data can be lost within it. To avoid delays in allocating memory elements, class constructors statically allocate all memory used for queue elements, giving the queue a finite limit. If the regular thread is not removing elements from the queue at a high-enough rate, the queue may become full.

Java的实时规范

新语言、编程规程、操作系统和软件工程技术有时对实时软件开发人员具有相当大的潜力。面向对象编程是一个有希望的领域，但对实时社区来说，这是一个相当新的领域。

例如，Java大量地从面向对象中提取，并且非常适合于对实时和嵌入式系统的扩展,在Java社区过程中，Java专家小组(RTJEG)在1999年3月开始开发Java(RTSJ)1的实时规范。

RTJEG的目标是提供一个平台——Java执行环境和应用程序接口(API)——让程序员正确地推断出执行软件的时间行为。编写实时系统应用程序的程序员必须能够在某些逻辑执行的时候确定一个先验，并在某个期限之前完成它的执行。这种可预测性在许多实时系统应用中很重要，例如飞机控制系统、军事指挥和控制系统、工业自动化系统、交通和电话交换机。我们通过查看Java语言特异性和Java虚拟机规范来开始我们的工作。对于语言或运行时代码的每个特性，我们询问声明的语义是否会让程序员在执行过程中，在执行之前，让程序员以合理的努力来决定，然后执行该特性(或特性控制的特性)的时间行为。RTSJ提供了一个平台，让程序员能够正确地推断出执行软件的时间行为。Java专家小组的两个实时成员解释了RTSJ的特性以及规范设计背后的思想。Greg Bollella IBM的James Gosling Sun Microsystems公司整顿了三个特性——调度、内存管理和同步——这并不允许这样的决定。由国家科学技术研究院(NIST)主办的研讨会上定义的需求与其他行业组织的投入帮助我们确定了附加的特征和语义。我们决定将其中的四个附加特性包括:异步事件处理、异步控制传输、异步线程终止以及对物理内存的访问。

这些加上我们对Java和JVM规范的回顾，为RTSJ提供了七个主要区域。我们相信这七个领域提供了一个适合广泛应用的实时软件开发平台。“RTSJ如何达到它的目标?”边栏给出了驱动RTSJ开发的需求和原则的更多背景。“RTSJ时间表”边栏列出了那些有兴趣审查草案的人的重要里程碑和联系。RTSJ在2000年2月完成了公共审查，但是Java社区过程要求我们在完成参考实现和测试套件之前不确定规范。随着社区获得RTSJ的经验，对规范的微小更改可能会发生。我们写这篇文章的目的是为了深入了解RTSJ的设计理念——特别是NIST的需求和其他的目标是如何影响它的——并说明这个重要的规范是如何适应于为实时系统开发优化面向对象编程系统的总体战略方向的。

调度Java规范只提供了对调度的广泛指导:在处理资源的竞争中，优先级较高的线程通常优先于低优先级的线程。但是，这样的首选项并不能保证优先级最高的线程始终运行，并且线程优先级不能用于可靠地实现互斥。显然，如果您正在编写具有时间限制的软件，那么您需要对线程执行的顺序有更强的语义声明。定义这些语义的典型方法是通过确定如何选择下一个线程执行的算法。RTSJ指定了一个最小的调度算法，它必须在所有RTSJ实现中。至少，所有实现的最低要求必须提供一个固定优先的优先级调度程序，不少于28个独特的优先级。“固定优先级”意味着系统不改变线程优先级(例如，通过老化)。有一个例外:系统可以将线程优先级更改为执行优先级反转规避算法的一部分(保留优先级继承)。如果没有异常，线程可以更改自己或另一个线程的优先级。

调度Java规范只提供了对调度的广泛指导:当有处理资源的竞争时，具有更高优先级的线程通常会优先选择较低优先级的线程。然而，这样的优先级并不能保证最高优先级的线程总是在运行，而线程优先级不能用于可靠地实现互斥。显然，如果您正在编写带有时间约束的软件，那么您需要一个更强的语义语句来说明线程应该执行的顺序。定义这些语义的典型方法是通过算法来决定如何选择下一个线程来执行。RTSJ指定最小调度算法,必须在所有RTSJ的实现。至少，所有的实现都必须提供一个固定优先级的优先级调度程序，它不少于28个唯一的优先级。“几个”意味着不改变系统线程优先级(例如,通过老化)。有一个例外:系统可以改变线程优先级的执行优先级反转避免算法(保留优先级继承)。毫无例外，线程可以更改它们自己或其他线程的优先级。

应用程序必须将最小28个优先级视为惟一;例如，它必须知道，如果具有更高优先级的线程已经准备好，那么具有较低优先级的线程将永远不会执行。因此，您不能简单地将28个优先级映射为一个较小的数字，因为底层系统。但是,您可以在一个平台上实现RTSJ提供少于28本地优先级。然后，您就可以使用任何可用的方法来提供惟一性的外观。为什么要有28个优先事项?我们之所以选择这个数字，是因为实时调度理论表明，您可以期望有32个优先级的接近最优的调度能力。5我们选择离开四个优先级为其他任务,因为RTSJ可能只有一个系统的一部分,和一些系统只有32本地优先级。当然，您可以将调度算法添加到这个最低要求中。RTSJ提供了三个classes-Scheduler SchedulingParameters,ReleaseParameters-and这些封装时间需求的子类。这些类绑定到可调度的对象(线程或事件处理程序)。所需的调度器,PriorityScheduler类的一个实例,使用这些参数中设定的值对象。

RTSJ线程创建定义RealtimeThread(RT)类来创建线程,居民调度程序执行。RTs可以访问堆上的对象，因此会因为垃圾收集而导致延迟。创建线程的另一种选择是使用RT的子类,NoHeapRealtimeThread。nhrt不能访问任何堆上的对象,这意味着它们可以运行垃圾收集器运行时从垃圾收集(从而避免延误)。nhrt是适合代码非常低公差的不定期的延迟。另一方面，RTs更适合于对较长时间延迟的更宽容的代码。普通Java线程将为没有时间限制的代码进行处理。内存管理一直被认为是垃圾收集内存堆实时编程的一个障碍,因为垃圾收集器,引入了不可预测的延迟。我们希望RTSJ需要实时垃圾收集器的使用,但技术不够先进。相反,RTSJ扩展内存模型来支持内存管理,不干扰实时代码提供确定性行为的能力。这些扩展让你分配两堆外的短期和长期存活的对象进行垃圾回收。也有足够的灵活性来使用熟悉的解决方案，例如预先分配的对象池。内存区域RTSJ介绍内存区域的概念——一个地区以外的内存垃圾回收堆分配对象,您可以使用。内存区域并不是通常意义上的垃圾收集。严格的对内存区域的赋值规则可以防止您创建悬空指针，从而维护Java的指针安全性。在内存区域中分配的对象可能包含对堆中的对象的引用。因此,垃圾收集器必须能够扫描内存堆中对象的引用的堆外保留堆垃圾收集的完整性。这种扫描与为堆构建可达性图不一样。

收集器只是将堆对象的任何引用添加到它的指针集。因为nhrt可以抢占收藏家,他们不能访问或修改任何指针到堆。RTSJ使用抽象类MemoryArea代表内存区域。这个类有三个子类:物理内存、不朽内存和作用域内存。物理内存允许您在具有特定重要特征的内存区域内创建对象，例如附加在非易失性RAM中的内存。不朽的记忆是一个特例。图1显示了使用不朽内存的对象分配如何与使用Java堆的手动分配和自动分配进行比较。传统的编程语言使用手动配置的应用程序逻辑决定了对象的导向的过程往往是耗时且容易出错。一个不朽的内存池和从它分配的所有对象都将一直存在，直到程序终止。在当今的硬实时系统中，不朽的对象分配是常见的做法。有了作用域内存，就不需要传统的垃圾收集和随之而来的延迟。RTSJ实现通过MemoryParameters字段或作用域内存ScopedMemory.enter()方法。作用域内存图1c显示了作用域内存与不朽内存和其他分配规程的比较。作用域内存,在抽象类中实现ScopedMemory,允许您使用内存区域分配和管理对象,或语法范围,范围内分配的任何对象的生命周期。当系统进入一个语法范围时，每次使用“new”都会导致系统从活动内存区域分配内存。当范围终止或系统离开时，系统通常会将内存的引用计数降为0，破坏分配给内部的任何对象，并调用它们的终结器。您也可以嵌套作用域。当系统进入一个嵌套的范围时，它将从与新作用域相关联的内存中获取所有后续的分配。当它退出嵌套范围时，系统将恢复先前的作用域，并再次从该范围获取所有后续的分配。两个具体子类可用于实例化MemoryAreas:LTMemory(LT的线性时间)和VTMemory变量时间(VT)。在这种情况下，“time”指的是分配新对象的成本。LTMemory要求分配有一个时间成本的线性对象大小(忽略性能变化从硬件缓存或类似的优化)。

当您创建它时，您指定了LTMemory区域的大小，并且它的大小仍然是固定的。虽然VTMemory没有这样的时间限制,您可能想要强加一些限制无论如何变化分配成本降到最低。你建立VTMemory区域初始大小和指定一个最大尺寸它可以生长。你也可以选择执行实时垃圾收集在VTMemory地区,尽管RTSJ不要求。如果你决定这样做,您可以构建VTMemory对象的垃圾收集对象指定一个特定于实现的垃圾收集机制。然而,如果你实现VTMemory,nhrt必须能够使用它。因为，如图1c所示，控制流控制在作用域内存区域中分配的对象的生命，您必须限制对这些对象的引用。RTSJ使用受限制的组分配规则,防止长期对象引用对象作用域内存,可能短住。虚拟机必须检测非法的分配尝试，并在发生时抛出一个适当的异常。RTSJ实现在两个不同的作用域内存机制,持续互动:ScopedMemory.enter()方法和内存区域的MemoryParameters领域。您在创建线程时指定任何一个。因此，几个相关的线程可以共享一个内存区域，并且该区域将保持活动状态，直到最后一个线程退出。这种灵活性意味着应用程序可以从具有适合整个应用程序或特定代码区域的特征的内存区域中分配新对象。同步的同步,RTSJ使用“优先级”比传统的更松散实时文学。“最高优先级的线程”只是表示最合格的线程调度程序会选择从所有的线程可以运行。它不一定认为严格的基于优先级的调度机制。等待队列系统必须排队等待以优先顺序获取资源的所有线程。

这些资源包括处理器和同步块。如果活动调度策略允许具有相同优先级的线程，那么线程将首先在队列中排队。具体来说，系统图1。不朽和作用域内存与其他确定对象生命的方法是不同的。(一)Java堆使用自动分配,可见性决定了对象的生活(如果没有对象的引用,该系统可以释放)。然而，自动分配需要一个垃圾收集器，这会导致延迟。(b)在使用RTSJ不朽内存分配,对象的生命结束只有当Java虚拟机(JVM)终止。(c)RTSJ作用域内存的使用语法范围,一种特殊类型的内存区域外的垃圾收集堆允许您管理对象定义良好的一生。当控制到达逻辑的某个点时，系统会破坏其中的任何对象，并调用它们的终结器。

为了避免优先级反转，同步原语的实现必须有一个默认的行为，以确保没有无限的优先级反转。这适用于普通Java代码如果它运行在整个RTSJ实现以及实时线程。优先级继承protocol-a知名实时调度algorithm6-must默认实现。该规范还提供了一种机制，您可以覆盖默认的系统范围策略，或控制用于特定监视器的策略，只要实现支持该策略。monitor控制策略的规范是可扩展的，因此未来的实现可以添加机制。第二种策略，优先级上限仿真(或最高存储)，也为支持它的系统指定。6决定论符合实现必须提供一个固定的上限为应用程序代码所需的时间进入一个同步块解锁监控。共享和线程间的通信实现人员最有可能使用普通Java线程的组合,RTs,nhrt。RTSJ允许锁定不同线程之间types-even最有争议的情况下,在常规线程和nhrt。

如果NHRT试图锁定一个RT或常规线程已经锁定的对象，那么优先级继承就会正常。有一个问题:non-NHRT有其优先级提高不能执行垃圾回收器执行。因此，如果一个垃圾收集正在进行中，那么这个被提升的线程将被挂起，直到收集完成。这当然会导致NHRT因为收集而延迟。为了解决这个问题,RTSJ提供机制,允许nhrt通信(同步)的一种形式与RTs和普通Java线程,同时避免在nhrt garbage-collector-induced延迟。RTSJ提供队列类nhrt和普通Java线程之间的通信。图2显示了一个无等待写队列,这是单向从实时、非实时。nhrt通常使用写(实时)操作;常规线程通常使用读操作。写端阻塞(任何试图立即写信给一个完整的队列返回“false”)和同步(如果多个NHRT可以写,他们必须同步),所以从垃圾收集NHRT不会造成延误。读操作,另一方面,阻塞(它会等待,直到有数据队列)和同步(它允许多个读者)。当一个NHRT普通Java线程发送数据,它使用无等待队列操作,和常规的线程使用一个同步操作出列。一个读队列，它是单向的，从非实时到实时的，以相反的方式工作。因为写无等待,动力学是不相容的,数据可能会丢失。为了避免在分配内存元素时出现延迟，类构造函数静态地分配用于队列元素的所有内存，从而使队列具有有限的限制。如果常规线程没有以足够高的速率从队列中删除元素，那么队列可能会满。