当前位置:首页 >> 计算机软件及应用 >>

本科生毕业设计


本科毕业设计(论文)
题目:基于 javaEE 的办公管理平台

院(系) 专 班 姓 学 导 业 级 名 号 师

2012 年 06 月

1

******大学毕业设计(论文)任务书
院(系) 专业 班 姓名 学号 1.毕业设计(论文)题目: 基于 javaEE 的办公管理平台

2.题目背景和意义: 办公自动化是 70 年代中期发达国家为解决办公业务量急剧增加对企业 生产率产生巨大影响的背景下,发展起来的一门综合技术。它的基本任务是利用先进的科学 技术,使人们借助各种设备决绝对一部分办公业务的处理,达到提高生产率,工作效率和质 量,方便管理和决策的目的。目前互联网发展迅速,如果能充分利用互联网,企业的办公人 员只要在有互联网的地方就能办公,这不仅是方便了办公人员,而且大大提高了办公效率, 并且,能加强企业的制度化、规范化管理,对于增强企业的市场竞争能力具有重要的意义。 3.设计(论文)的主要内容(理工科含技术指标) :该办公系统主要有四大功能模块的设计与实 现,分别是:活动管理、资产管理、报销管理、事假管理。活动管理主要为公司需组织什么 活动时而方便审批和管理,而资产管理是公司固定资产的带出,归还,维修等的管理。对于 报销管理主要是出差办公报销包括打车报销、住宿报销、餐饮报销等等。事假管理主要是方 便请假审批流程的管理。以上的几大功能模块都需用工作流技术来实现。 4.设计的基本要求及进度安排(含起始时间、设计地点) : 第二周——第三周:查资料、阅读文献;写出开题报告;第四周——第六周:学习 jBPM 技 术与 SSH 框架,整合教学资料。第七周——第九周:制定论文总体方案。第十周——第十 三周:关键技术研究、软件编制。第十四周——第十五周:软件系统调试。第十六周—— 第十七周:写毕业论文并准备毕业答辩。 5.毕业设计(论文)的工作量要求 ① 实验(时数)*或实习(天数) : ② 图纸(幅面和张数)*: ③ 其他要求: 指导教师签名: 学生签名: 系(教研室)主任审批: 年 月 日 年 月 日 年 月 日 300 机时

摘要





办公自动化(Office Automation,简称 OA)是将现代化办公和计算机网络功能 结合起来的一种新型的办公方式。企业办公自动化系统在此基础上实现企业的快 速运转和交流,进而有效提高企业办公效率。 本文在分析了企业办公自动化需求基础上,设计并实现了企业办公自动化系 统。该系统主要包括用户登录、活动管理、请假管理、资产管理、员工管理、报 销管理等功能。系统的实现解决了传统手工操作效率低、出错率高和交互能力差 等问题。 本系统采用了 Spring、Struts2、Hibernate、JSP、JavaBean 技术设计开发并采 用数据库 MySql 完成数据库设计。最终实现一个能够满足企业办公网络化,自动 化的管理需求,提高企业内部的管理水平的系统,可较好的提升企业在市场中的 综合竞争力。

关键词:办公自动化,数据库,JSP

1

Abstract
Office Automation(referred to as OA) is a new way of office which combines with a modern office and computer network. Enterprise Office Automation System on the basis of the enterprise operation and realize the fast communication, thus effectively improving office efficiency. By analysis demand the needs the enterprise office automation system is designed and implemented user login, activity management, vacate management, property management, staff management and reimburse managerment functions. The realization of the system to solve the traditional manual operation efficiency is low, the error rate is high and poor ability to interact. The system uses the technology of Struts, JSP, JavaBean to design and develop and database SQL Server 2000 to complete the database design. This system can satisfy the enterprise work network, the automated management demand, raised the enterprise internal management level, then promotes the enterprise of comprehensive competitive power in the market .

KeyWords:Office automation,database,JSP

2

目录

目录 1 绪论 ............................................... 1
1.1 办公自动化系统研究背景及应用 .................................. 1 1.2 本文研究目标及意义 ............................................ 2 1.3 国内外现状 .................................................... 3 1.4 本文组织结构 .................................................. 6 1.5 本文主要完成工作 .............................................. 7

2

系统分析 ........................................... 8
2.1 总体需求分析 .................................................. 8 2.2 可行性分析 .................................................... 8 2.2.1 经济可行性 ................................................ 8 2.2.2 技术可行性 ................................................ 9 2.3 设计技术及开发环境 ........................................... 10 2.3.1 设计技术 ................................................. 10 2.3.2 开发及运行环境 ........................................... 12

3 系统平台总体设计 ................................... 13
3.1 项目规划 ..................................................... 13 3.2 系统结构及功能模块 ........................................... 13 3.2.1 系统结构 ................................................. 13 3.2.2 功能模块 ................................................. 14 3.3 数据库设计 ................................................... 16

4

医药公司办公管理平台实现 .......................... 21
4.1 登录模块 ..................................................... 21 4.2 公文申请模块 ................................................. 21 4.2.1 活动申请界面设计 ......................................... 21 4.2.2 新增活动申请 ............................................. 22 4.3 领导审批模块 .................................................. 25 4.3.1 活动任务审批列表界面设计 ................................... 25 4.3.2 审批 ..................................................... 25 4.4 记录查看模块 ................................................. 29 4.4.1 活动申请记录查看页面 ..................................... 29
1

4.4.2

活动记录详情 ............................................. 29

4.5 用户管理模块 ................................................. 29 4.5.1 新增用户信息 ............................................. 29 4.5.2 修改、删除、查看用户信息 ................................. 32 4.6 资产信息管理模块 ............................................. 32

5 总 致

结 ............................................. 33 谢 ............................................. 34

参考文献 ............................................. 35 毕业设计(论文)知识产权声明 ......................... 37 毕业设计(论文)独创性声明 ........................... 38 附录:............................................... 39

2

1

绪论

1
1.1

绪论

办公自动化系统研究背景及应用
在互联网技术还没有得到广泛应用的早期,各企业信息之间的交流、办公业

务的处理都是人工操作完成的,随着社会进入信息时代和社会生活的快节奏化, 传统的企业信息交流方式及处理办公业务方式已不能满足企业对大量信息快速传 递和处理需求,不能适应时代的发展趋势,于是需要一种新的技术改善现状,因 此办公自动化系统在适应时代发展需求中产生。 20 世纪 70 年代中期在企业和行政机关中兴起使用公自动化系统,而后 因其给企业和单位带来的便利而迅速被用于中小型企业单位中,其是 采用一 系列现代化的办公设备和先进的通信技术,广泛、全面、迅速地收集、整理、 加工、存储和使用信息,使企业内部人员方便快捷地共享信息,高效地协同 工作;改变过去复杂、低效的手工办公方式,为科学管理和决策服务,从而 达到提高行政效率的目的。一个企业实现办公自动化的程度也是衡量其实现 现代化管理的标准。 我国专家在第一次全国办公自动化规划讨论会上提出办 公自动化的定义为:利用先进的科学技术,使部分办公业务活动物化于人以 外的各种现代化办公设备中,由人与技术设备构成服务于某种办公业务目的 的人——机信息处理系统。 办公自动化系统可分为三个功能层次:OA 系统、信息管理级 OA 系统 和决策支持级 OA 系统。三者一体化使办公信息的流通更为合理,减少许多 不必要的重复输入信息环节,以提高整个办公系统的效率。 第一个层次:事务型办公自动化系统。只限于单机或简单的小型局域网 上的文字处理、电子表格、数据库等辅助工具的应用。 办公事务 OA 中,最 为普遍的应用有文字处理、会议管理、文件收发登录、文档管理、办公日程 管理、人事管理、报表处理等。此外,在办公事务处理级上可以使用多种 OA 子系统,如电子出版系统、电子文档管理系统、智能化的中文检索系统(如 全文检索系统)、光学汉字识别系统、汉语语音识别系统等。在公用服务业、 公司等经营业务方面,使用计算机替代人工处理的工作日益增多,如订票、 售票系统,柜台或窗口系统,银行业的储蓄业务系统等。

1

西安工业学毕业设计(论文)

第二个层次:信息管理型 OA 系统。随着信息利用重要性的不断增加, 在办公系统中对和本单位的运营目标关系密切的综合信息的需求日益增加 出 现了信息管理型的办公系统,其把事务型(或业务型)办公系统和综合信息 (数据库)一体化,优化日常的工作,提高办公效率和质量。作为一个现代 化的政府机关或企、事业单位必须具备供本单位的各个部门共享的这一综合 数据库,因此可在政府机关用信息管理型系统对政策、法令、法规,有关上 级政府和下属机构的公文、信函等综合政务信息进行处理;在公司企业单位 中处理在综合数据库中的工商法规、经营计划、市场动态、供销业务、库存 统计、用户信息等。 第三个层次:决策支持型 OA 系统。它建立在信息管理级 OA 系统的基 础上。其使用由综合数据库系统所提供的信息,针对所需要做出决策的课题 构造选用决策数字模型,结合有关内部和外部的条件,由计算机执行决策程 序,做出相应的决策。 其具有集成化、智能化、多媒体化和运用电子数据交 换等新的特点,用于软硬件及网络产品、单一办公系统同社会公众信息系统 的集成;用于面向日常事务处理,辅助人们完成智能性劳动,如:汉字识别, 对公文内容的理解和深层处理,辅助决策及处理意外等;用于包括对数字、 文字、图像、声音和动画的多媒体综合处理;用在通过数据通讯网,在计算 机间进行交换和自动化处理。

1.2

本文研究目标及意义
由于我国的企业办公自动化起步较慢,存在没有好的应用系统支持协同

工作,仍然是个人办公,网络处在闲置状态,企业的投资没有产生应有的效 益等问题,这些阻碍了我国办公自动化的进程。虽然已经建立了自己的 Intranet 网络,但企业内部的交流效益并不高。面对目前我国企业办公自动化 程度不高的现状,研究企业办公自动化系统的意义十分重大。为了能跟上时 代的步伐,让各企业在激烈的竞争中立于不败之地,一个可应用于一般型企 业的办公自动化系统是上市企业必不可少的。 本系统的研究和实现在一定程度上弥补了我国在办公自动化方面存在的 缺陷,本系统的研究和最终目标是实现一个能运用于处理一般性办公业务, 能在企业中进行信息交流的办公自动化系统。其基本的功能包括活动管理 ,

2

西安工业学毕业设计(论文)

请假管理,报销管理,资产管理,员工管理等。在各种功能下的子功能模块 可进行的操作包括:浏览、更新、删除、添加。 虽然诸如 Lotus 1-2-3 和 MS Office 系列的许多应用软件可以提高办公效 率,但是这仅仅是针对个人办公而言。办公自动化不仅兼顾个人办公效率的 提高,更重要的是可以实现群体协同工作。协同工作意味着要进行信息的交 流,工作的协调与合作。由于网络的存在,这种交流与协调几乎可以在瞬间 完成,并且不必担心对方是否在电话机旁边或是否有传真机可用。 能处理办 公业务的的企业办公自动化系统是现代企业所必需的,从这可看出本系统的 发展前景远大。 目前,办公自动化已经成为企业界的共识。众多企业认识到尽快进行办 公自动化建设,并占据领先地位,将有助于保持竞争优势,使企业的发展形 成良性循环。

1.3

国内外现状
办公自动化建设的本质是提高决策效能为目的的。 通过实现办公自动化,

或者说实现数字化办公,可以优化现有的管理组织结构,调整管理体制。在 提高效率的基础上,增加协同办公能力,强化决策的一致性,最后实现提高 决策效能的目的。 办公自动化建设与现阶段政府上网工程之间的关系。政府上网工程一直 是近一两年业界炒作和关注的热点之一, 政府上网工程是由于互连网的普及, 政府部门把一些政务信息发布到 Intenet 上,进而在网上建立与老百姓沟通 的渠道,以实现政务公开和政府行为接受监督的目的。从实际效果来看,很 多政府部门只是在网上存放一些静态的政府信息,实质性的 工作却非常少。 并且,在很多情况下,很多人将办公自动化和政府上网混为一谈。这种现象 导致很多部门重上网工程轻办公自动化工程。甚至把上网工程误认为是办公 自动化工程。实际上,从网络划分的角度,政府上网工程是外网建设,办公 自动化工程是内网建设,办公自动化工程是政府信息化的基础,政府上网工 程是政府信息化的对外表现形式,办公自动化工程在政府信息化建设中所占 的比重远高于政府上网工程。只有办公自动化工程的建设并运转成功,政府 上网才会有源源不断的信息发布,政府上网才有意义,否则政府上网工程就

3

西安工业学毕业设计(论文)

会变成无源之水。当然,政府上网工程的宣传对我国信息化建设也起了一定 的推动作用。 办公自动化应该是尽快向数字化办公发展。所谓数字化办公即几乎所有 的办公业务都在网络环境下实现。从技术发展角度来看,特别是互连网技术 的发展,安全技术的发展和软件理论的发展,实现数字化办公是可能的。从 管理体制和工作习惯的角度来看,全面的数字化办公还有一段距离。首先数 字化办公必然冲击现有的管理体制,使现有管理体制发生变革,而管理体制 的变革意味着权利和利益的重新分配;另外管理人员原有的工作习惯、工作 方式和法律体系有很强的惯性,短时间内改变尚需时日。尽管如此,全面实 现数字化办公是办公自动化发展的必然趋势。 实现数字化办公既不同于传统的 OA,也不同于 MIS 的建设,它的结构是 Intranet 网的结构,它的构建思路是自上而下的,即首先把整个内部网看成 是一个整体,这个整体的对象是网上所有用户,它必需有一个基础,这个基 础称为内网平台;就好象 PC 必需有一个操作系统为基础一样。内网平台负责 所有用户对象的管理、负责所有网络资源(含网络应用)的管理、网络资源的 分层授权、 网络资源的开放标准和提供常用的网络服务(如邮件、 论坛、 导航、 检索和公告等)。在平台的基础之上,插接各种业务应用(可理解为传统的 MIS),这些应用都是网络资源。用户通过统一的浏览器界面入网,网络根据 用户的权限提供相应的信息、功能和服务,使用户在网络环境下办公; 办公自动化于 50 年代在美国和日本首先兴起, 最初只是具有电子数据处 理(EDP)的簿记功能,60 年代被管理信息系统(MIS)取代,直到 70 年代后期 才形成涉及多种技术的新型综合学科一办公自动化(OA)。80 年代,国外办公 自动化得到了飞速发展,许多著名的计算机软硬件公司都跻身于这一巨大的 市场。进入 90 年代以来,办公自动化在世界主要发达国家得到蓬勃发展。我 国办公自动化是 80 年代中期才发展起来的。1985 年全国召开了第一次办公 自动化规划会议,对我国办公自动化建设进行了规划。1986 年 5 月在国务院 电子振兴领导小组办公自动化专家组第一次专家会议上,定义了办公自动化 系统功能层次和结构模式。随后国务院率先开发了“南海办公自动化系统”。 我国 OA 的应用和发展历程,可以分为以下三个阶段:

4

西安工业学毕业设计(论文)

第一代 OA 系统,是从 20 世纪 80 年代中期到 90 年代中期以个人电脑、 办公套件为主要标志,实现了数据统计和文档写作电子化,即将办公信息载 体从原始纸介质方式转向比特方式。 第二代 OA 系统,是从 90 年代中期开始的以网络技术和协同工作技术为 主要特征,实现了工作流程自动化,即将收发文从传统的手工方式转向工作 流自动化方式。 第三代 OA 系统, 是融信息处理、 业务流程和知识管理于一体的应用系统。 办公自动化系统的发展恰好与数据、信息和知识的演变同步,即由以数 据为主要处理内容的第一代办公自动化发展到以信息为主要处理内容的第二 代办公自动化,再发展到以知识为主要处理内容的第三代办公自动化。办公 自动化的三个发展阶段中完成了两个飞跃, 即由数据处理向信息处理的飞跃, 由信息处理向知识处理的飞跃。在办公自动化系统的发展中,使用办公自动 化系统的人员范围逐步扩大,由氽业行政人员扩展到企业的管理层,再扩展 到企业的全体员工。另外,在运作机制上,也是从办公室的结构化数据处理 到企业内部和外部信息的处理,再到有用知识的处理。从简单的电子邮件、 群件,到构建 Web 应用等各种方式中获取、存储、提炼和再用知识。 在部署实施基于知识管理的第三代办公自动化系统过程中,企业与机构 需要: (1)把知识管理融入 BPR(业务流程重组)知识管理只有与业务流程紧密 相连,才能获得成功。将知识创造与发布同企业的业务流程相结合,不仅可 以节省大量开支,更重要的是能够产生巨大的价值,通过知识管理实现对业 务流程中无序的知识进行系统化管理,实现知识共享和再利用,从而提高业 务水平和效率。 (2)改造企业文化知识管理的成功首先取决于鼓励信息共享的企业文 化。改造传统的企业文化、建立有利于知识共享的新型企业文化,是企业能 够在知识经济时代不断发展的关键因素。 (3) 建立学习型企业所谓学习型企业是指通过不断的学习来提高竞争力 的企业。这里所说的学习并不仅仅是看书、办学习班,而是包括了企业在系 统研究项目和产品开发、营销、技术支持过程中学习,强调全员学习、全程 学习和团队学习。

5

西安工业学毕业设计(论文)

第三代办公自动化系统建立在企业 Intranet 平台之上, 帮助企业实现动 态的内容显示和知识的实际管理,使企业的每一个员工能够在协作中不断获 得学习的机会和进步。 底层是企业的基本信息支撑环境, 它包括 MRPII、 MIS 系统的信息化支撑, 以及对企业外部 Intemet 的信息获取。三类系统的相互作用体现了 Intranet 的思想,通过设计和实现优秀的 Internet 信息获取工具,可以有效地利用外 部的有用信息为企业内部的经营管理过程服务,帮助企业更好地把握来自市 场的机遇与挑战。第二层是企业多维知识仓库。存在于底层企业信息支撑环 境中的企业信息资源是烦杂而海量的,需要在数据挖掘与模式提取的工具支 持下,发掘其中有价值的模式与知识,进行紧密而科学的组织,这是支持知 识管理系统实现的有利依据。 第三代办公自动化系统可以这样概括:它仍是以网络 (Internet/Intranet/Extranet)为中心,以数据、信息所提炼和组织的知识 为主要处理内容的办公自动化系统 。 大部分国内外中小型企业自成立至今,办公模式为传统的办公模式,并 主要以纸介质为主,在信息革命的浪潮中,显然已经远远不能满足高效率、 快节奏的现代工作和生活的需要。如何实现信息处理的自动化和办公的无纸 化逐步得到了公司领导的重视。 而今公司普遍使用计算机来提高员工的工作效率,但是在需要许多员工 一起协同工作的现代工作环境中,公司更需要提高整体的工作效率。利用网 络通讯基础及先进的网络应用平台,建设一个安全、可靠、开放、高效的信 息网络和办公自动化、信息管理电子化系统,为管理公司提供现代化的日常 办公条件及丰富的综合信息服务,实现档案管理自动化和办公事务处理自动 化,以提高办公效率和管理水平,实现公司各部门日常业务工作的规范化、 电子化、标准化,实现信息的在线查询、借阅。最终实现“无纸”办公。

1.4

本文组织结构与内容
本文详细的介绍了医药办公管理系统的设计与实现。本文以实现办公自

动化功能为目标,对医药办公管理系统进行了研究,设计并开发出了医药办

6

西安工业学毕业设计(论文)

公管理系统。基于以上的研究,本文在以后的章节中按系统需求分析、系统 设计与系统实现的思路做了如下安排: 第1章 绪论,介绍了办公自动化的背景,研究目标与意义,以及本文

主要完成的工作,阐述了国内外现状并对本文结构进行了简单的介绍。 第2章 系统分析,总体需求分析和可行性分析,以及开发环境与相关

技术介绍,介绍了医药办公管理系统所用到的技术,包括 JAVA,MySQL 和 SSH 框架等技术。 第3章 能模块。 第4章 医药公司办公管理平台实现,介绍了该系统的界面实现以及具 系统平台总体设计,介绍了医药办公管理系统的系统结构与功

体的设计思路。 第5章 总结,对全文进行总结和展望。

1.5

本文主要完成工作
本文将要完成企业办公自动化系统的设计。在用户使用过程中,系统会

根据用户的身份赋予其能操作和使用的功能,其中包括的功能模块分别为: 1、实现活动管理。 2、实现报销管理。 3、实现请假管理。 4、实现资产管理。 5、实现员工登陆功能 6、实现员工管理模块,可增加、删除、修改、查看员工信息。

7

2

系统分析

2 系统分析
2.1 总体需求分析
根据对一些医药公司的调查,通常的办公业务都是手工办理。例如报销 事项,都是走人工流程,有时因找领导签字而花费大量的时间,大大的影响 了办公效率。因此需要一个能运用于企业的办公自动化系统。 本系统适用于中小型企业,中小企业规模相对较小,但其在功能上对系统 的需求却是全面的。主要通过收发公文为主的方式,与其它员工交流各种信息, 基于工作流的方式实现诸如请假申请、公文审批;员工管理等日常办公功能。即 完全采用计算机技术处理办公业务,使企业内部人员能够方便快捷地交流信息, 高效地协同工作,既兼顾个人办公效率的提高,又可以实现群体协同工作。 经调查和分析,本系统将要实现的是能够满足中小型企业的需求功能, 能够处理和解决企业基本的办公业务,因此设计了 7 大功能模块,包括用户 登录、活动管理、请假管理、报销管理、资产管理、员工管理和退出登录。 系统需实现的是对用户登录的验证及监督,对活动公文、请假公文、报销公 文、资产申请公文的申请和审批,对员工信息查看、添加、浏览和删除。这 些功能的实现使企业办公业务自动化,减少人力和物力的支出,加强了公司 处理业务的能力。

2.2

可行性分析
本系统的开发是为了解决传统手工办公操作效率低、信息交流方式不灵活和

办公自动化不高的问题,其对于处理一般性的办公业务可行性较强,适用于中小 型企业。下面将从经济可行性和技术可行性两方面对系统进行分析。 2.2.1 经济可行性

本系统主要的功能是一般性的办公业务,适用于中小型企业。由于中小企业 的经济实力有限,所以要想方便办公的同时也要着重考虑投入/产出比问题。一般 商业软件是无法两者兼顾的,由于从基础语言开始开发成本高、周期长,更不现 实;因此利用现有软件进行改进,即二次开发,通过对几个商业化软件功能进行 修改、增删和开发来实现中小企业建立具有自身个性的办公自动化系统,通过系

8

西安工业学毕业设计(论文)

统集成的方法来将各个功能集成为一个整体发挥作用,通过两次开发的方式来实 现降低成本、节约开支、提高效率。本系统应能够适应企业的不断变化,具有可 扩展性、易升级性和开放性。因此,它的市场将是无可限量的,将给企业带来的 经济效率也是很大的。 2.2.2 技术可行性

在软、硬件方面对系统的需求来看,由于中小企业信息化水平比较低,软硬件 配置较差;而且资金实力并不雄厚。所以其对硬件的配置要求是尽可能的低,对 软件配置的要求则是系统最好是基于日常办公软件如 OFFICE 系列上的应用系统, 这样既不用花大量资金添置软件,员工又较容易学会使用应用。本系统所实现的 功能是一般性质的办公业务,总体的开发时间不用很长,它用到的硬件平台不高, 软件基本上是开源且较易懂,项目开发过程中遇到的技术上的问题在网上或书上 可找到,因此是在技术上是可行的。 该系统所用的软件平台有数据库 MySql、开发工具包 JDK1.6、服务器 Tomcat 6.0 都是开源的其中操作的细节和配置都易学。 本系统开发出来时在技术上具有 代表当时办公自动化信息系统的先进性,本系统在建成后一段时间内,不会因技 术的落后而需要大规模的调整,并且能够跟随时逐步的升级而保持整个系统的先 进性。同时本系统对计算机硬件要求不算太高,运行速度较快,对企业办公很方 便。 本系统最重要的是用到了 Struts 网络编程, 其为基于 Java 的 Web 应用程序开 发提供了一个框架。本系统的工作流程就是基于 Struts 下,分为以下步骤: (1) 浏览器向服务器发出请求,Controller 获得这些请求。 (2) Controller 根据配置文件 struts-config.xml 中的定义将这些请求发送到相 应的 Action,对应图中的 Model。 (3) Action 完成相应的业务逻辑处理后,将处理结果返回到 Controller。 (4) Controller 再根据配置文件 struts-config.xml 中的定义将处理结果显示到 用户视图 View。 本系统正是利用了 Struts 工作流程来完成此次设计的整个流程,如图 2.2 所示:

9

西安工业学毕业设计(论文)

Controller Servlet

Model JavaBean

浏览器

View Jsp

Struts-config.xml

图 2.2 本系统工作流图

2.3
2.3.1

设计技术及开发环境
设计技术

自从 Servlet 技术产生以来,J2EE 的 Web 开发技术与开发框架便层出不穷。 这些技术和框架的产生,在给我们的开发带来方便的同时,也让我们眼花缭乱, 导致疲于学习这些框架。然而一直保持优势地位的不多,目前 J2EE 的主流框架技 术是——JSP、Struts2、Spring、Hibernate,目前这种组合是最好的选择。 1、JSP 页面技术 JSP 产生于 Servlet 之后,主要是为了解决 Servlet 中输出 HTML 代码效 率低的问题而产生的。JSP 技术比较简单,类似于 ASP、PHP 这些脚本语言。JSP 的技术主要是由以下两个部分组成: JSP 的基本语法:两个注释、3 个脚本元素、8 个动作指令。 JSP 的九大内置对象:request 请求对象、response 响应对象、pageContext 页面上下文对象、 session 会话对象、 application 应用程序对象、 输出对象、 out config 配置对象、page 页面对象和 exception 例外对象。 2、Struts2 Struts 是一个基于 J2EE 平台的 MVC 框架,主要是采用 Servlet 和 JSP 技术来实现的,是开发 Web 应用程序的开放源码框架。Struts 把 Servlet、JSP、自 定义标签和信息资源(message resources)整合一个统一的框架中,开发人员利用其 进行开发时不用再自己编码实现全套 MVC 模式,极大地节省了时间。 Struts 2 是 Struts 的下一代产品, 是在 struts 和 WebWork 的技术基础上 进行了合并的全新的 Struts 2 框架。 其全新的 Struts 2 的体系结构与 Struts 1 的体系
10

数据库

西安工业学毕业设计(论文)

结构的差别巨大。Struts 2 以 WebWork 为核心,采用拦截器的机制来处理用户的 请求,这样的设计也使得业务逻辑控制器能够与 Servlet API 完全脱离开,所以 Struts 2 可以理解为 WebWork 的更新产品。虽然从 Struts 1 到 Struts 2 有着太大的 变化,但是相对于 WebWork,Struts 2 只有很小的变化。 3、Spring 技术 Spring 在英文里有春天、弹簧、跳跃和泉眼的意思。Spring 也表示是一 个开源框架, 是为了解决企业应用程序开发复杂性由 Rod Johnson 创建的。 框架的 主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时 为 J2EE 应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前 只可能由 EJB 完成的事情。然而,Spring 的用途不仅限于服务器端的开发。从简 单性、可测试性和松耦合的角度而言,任何 Java 应用都可以从 Spring 中受益。 4、Hibernate 技术 Hibernate 是一个开放源代码的对象关系映射框架, 它对 JDBC 进行了非 常轻量级的对象封装,使得 Java 程序员可以随心所欲的使用对象编程思维来操纵 数据库。 Hibernate 可以应用在任何使用 JDBC 的场合,既可以在 Java 的客户端 程序使用, 也可以在 Servlet/JSP 的 Web 应用中使用, 最具革命意义的是, Hibernate 可以在应用 EJB 的 J2EE 架构中取代 CMP,完成数据持久化的重任。 5、工作流引擎 技术 jBPM 是一款开源的工作流产品,它没有采用 BPEL 或 WfMC 标准去 实现流程引擎,采用的是一种轻量级的 XML 结构的流程描述语言 JPDL(jBPM Process Definition Language) 。相比 WfMC 和 BPEL 两种标准而言,JPDL 语言更 加简单,也更容易读懂。jBPM 是一种基于 Java 语言实现的工作流产品,它的主 要使用场合为基于 J2EE 的 B/S 系统当然,如果我们需要在基于 Java 的 C/S 环 境中使用 jBPM 也是完全可行的。 jBPM 使用 Hibernate 作为持久层工具,它可以在 Oracle、DB2、Sybase、 Microsoft SQL Server、 MySQL 和 Informix 等常用的主流数据库下使用。 jBPM 是 一款功能强大、小巧灵活的工作流引擎,它既可以以嵌入式模式与我们的业务模 块运行在同一个应用之内,也可以以独立的模式单独运行在一个应用当中。 jBPM 使用的是 LGPL 协议。开源协议有很多种,LGPL 是其中之一。 LGPL 是一个为类库使用而设计的开源协议, 它允许商业软件通过类库引用 (link)
11

西安工业学毕业设计(论文)

方式使用 LGPL 类库,而不需要开源商业软件的代码。这使得采用 LGPL 协议的 开源代码可以被商业软件作为类库引用并发布和销售。 2.3.2 开发及运行环境

1、开发环境 (1) 操作系统:Windows XP (2) 数据库:MySql (3) 开发工具包:JDK1.6 (4) 开发平台:MyEclipse8.6 2、运行环境 (1) 服务器:Tomcat6.0 (2) 浏览器:IE8.0

12

3

系统平台总体设计

3 系统平台总体设计
3.1 项目规划
整个管理系统将要实现主要功能是:用户登录、活动管理、请假管理、报销 管理、资产管理、员工管理、 ,而其中的各个功能又分为几个小功能模块。该系统 的功能结构图如 3.1 所示:
用户登录

活动管理

请假管理

资产管理

活 动 申 请

活 动 审 批

活 动 记 录

请 假 申 请

请 假 审 批

请 假 记 录

资 产 申 请

资 产 审 批

资 产 记 录

资 产 信 息

用户管理

报销管理 新 增 资 产 修 改 修 改 删 除 资 产 查 看 资 产

新 增 用 户

修 改 用 户

删 除 用 户

查 看 用 户

报 销 申 请

报 销 审 批

报 销 记 录

图 3.1 功能结构图

3.2
3.2.1

系统结构及功能模块
系统结构

本系统采用严格的 JavaEE 应用结构,主要有如下几个分层。 ? 表现层:由 JSP 页面组成。 ? MVC 层:使用 MVC 框架技术。 ? 业务逻辑层:主要由 Spring IoC 容器管理的业务逻辑组件组成。 ? DAO 层:由 5 个 DAO 组件组成。 ? 领域对象层:由 6 个 PO 组成,并在 Hibernate Session 管理下,完成数据 库访问。
13

西安工业学毕业设计(论文)

? 数据库服务层:使用 MySQL 数据库存储持久化数据。 整个系统的结构图如图 3.2 所示。
Spring 容器

用户界面 负责业务 数据收集 呈现系统 状态

MVC框架 控制器 负责用户 请求和业 务逻辑组 件的交互

业务逻辑 层 负责实现 系统的业 务逻辑功 能

领域对象 DAO层 通过操作 领域对象 来操作持 久层数据 处于 Hibernate Session管 理之下, 映射到对 应数据表 数据持久 化服务 负责持久 化保存应 用状态

图 3.2 系统结构图

3.2.2

功能模块

由于本系统可执行的是一般性质的办公业务,提供给中小型企业使用,也可 增加功能后提供给大型企业和行政机关。本系统具有一般适用性,其所实现的功 能(如图 3.3)满足企业对日常性办公业务的管理方便企业内部员工的沟通,方便员 工及时的了解公司的动态,是企业的日常管理步入科学系统的轨道上。
用户登录

活 动 管 理

用 户 管 理

请 假 管 理

报 销 管 理

资 产 管 理

图 3.3 基本功能图

3.2.2.1

登录功能

本系统将要实现用户登录功能。接受用户输入的登录名和密码信息,先 做客户端的有效性检验,通过检验后提交给服务器端,由服务器端提交信息 与数据库里的信息相比较,如果二者不符则返回相应的出错信息,否则登录 进入系统。 本系统中对于登录模块的设计是供企业内部员工使用,使用权的授予是 由系统管理员决定的,只有在系统管理员首次在员工管理模块中添加了你的 信息后,授予你登录的“姓名”和“密码”后你才能安全登录,在此同时也 授予你登录的权限,在权限的范围内你能够完成相应操作。
14

西安工业学毕业设计(论文)

3.2.2.2

活动管理功能

该功能是为了满足企业员工在发起活动申请时需要走的流程处理,通过 该功能模块,用户只需要在自己的客户端提交相关的活动申请单,系统会自 动调用工作流引擎,首先将你的公文分发给各部门经理会签,只有都同意后, 公文才转交给总经理审批,只有总经理审批通过后,该活动才能被执行。 一般员工在该功能模块的权限是新建活动申请单、提交申请单、观察流 程进度、对拒绝后的申请单进行修改并重新提交、删除新增或是拒绝后的申 请单。而经理与总经理在该模块的权限是对流转到自己手上的活动申请单进 行审批,同意或是拒绝,并且可以发表审批意见。 3.2.2.3 报销管理功能

报销一般是公司经常要处理的业务,该功能模块就是为了解决人工报销 流程的一些弊端。拥有此功能模块,用户可以在任何有网络的地方提交自己 的报销单给相关人审批,一旦审批结束,就可以上交相关报销单据,等待报 销金额发放,而前面的审批流程通过办公自动化系统,已经在线处理完成, 从而大大的调高了办公效率,节约了资源。 普通员工在该功能模块拥有的权限是:新增并提交自己的报销申请单、 修改新增或是拒绝后的报销单、删除新增或是拒绝后的报销单、观察审批流 程等。而经理与财务主管则拥护审批的权限,可以对流转到自己手上的公文 进行审批,同意或是拒绝,拒绝后的公文会打回给创建人,需修改后才能重 新提交。 3.2.2.4 请假管理功能

请假也是员工经常碰到的问题,以前的请假都是员工自己跑腿,一级一级 的找领导签字。领导一般都是比较忙的,经常不在公司,所以要找领导签字, 如果一次就能把流程走下来,那就是很幸运了,一般,员工都会提前好几天 就走请假流程,只有这样才能保证,到时能走完流程。该功能模块就能很好 的解决这个问题,这个环节最耗时耗力的就是找领导签字,而领导在上班期 间很少在公司,如果领导不在公司也能办理这样一些业务,那么问题就可以 解决了。该功能模块就是为了解决这样一些问题。 普通员工在该功能模块拥有的权限是:新增和提交线上请假单、修改新增 或拒绝的请假单、删除新增或拒绝的请假单、观察审批进程。而部门经理与
15

西安工业学毕业设计(论文)

总经理拥有的权限是:对流转到自己手上的请假单进行审批,同意或是拒绝, 拒绝的申请单工作流引擎会打回给创建人,需创建人修改后才能重新提交。 3.2.2.5 资产管理功能

该功能模块是为了解决很多公司在员工借用公司资产的管理,有了该功 能,资产的管理更方便、更安全。员工通过在线申请资产,通过部门经理审 批,通过后再到资产管理员审批,最终管理员确认借出,最后归还时,由管 理员确认归还。一般,公司经常性的资产申请是电脑和手机,因为这 也是办 公时必备的工具,所以针对该情况,开发了该功能模块。 普通员工拥有的功能是:新增申请单、提交新增或是拒绝修改后的申请 单、修改新增或是拒绝的申请单、删除新增或是拒绝的申请单、观察审批进 度等。部门经理具有审批权限,同意或是拒绝。而管理员不但有审批权限而 且具有借出和归还确认的权限。 3.2.2.6 员工管理功能

实现员工信息的增加、删除、修改、查看详细信息操作。本系统实现对 员工管理主要是能够登录此系统的员工。浏览员工信息、添加新员工、删除 员工、修改员工信息等功能操作只有系统管理员才能进行操作。一般员工或 是经理都没有赋予相应的权限。 3.2.2.7 资产信息管理功能

实现资产信息的增加、删除、修改、查看操作。该功能只是一个辅助模 块,但用户使用资产管理模块,新增资产申请的时候,方便用户了解 资产信 息,能根据公司现有的资产提出申请。这样避免了用户申请库存没有的资产 而影响了工作效率。

3.3

数据库设计
本系统数据库采用 MySql 数据库,系统数据库名称为 managesys。数据库除

了工作流引擎默认表外另有 6 张表,这 6 张表构成了整个系统的数据处理。 1、数据表树型结构图包括了本系统所有数据表。

16

西安工业学毕业设计(论文)

图 3.2 数据表树型结构图

2、主要数据表设计如下: (1) tbl_activity(活动信息表)。 tbl_activity 表(如表 3.1)主要用于保存活动相关信息。
表 3.1 tbl_activity (活动信息表) 列名 activityId activityName creater createTime endTime updateTime content site idea status processInstanceId nextPersonName userId 数据类型 int varchar varchar varchar varchar Varchar Varchar Varchar Varchar int varchar varchar int 长度 11 50 50 50 50 50 255 50 255 1 50 50 11 是否主键 是 描述 自动编号 活动名称 创建人 创建时间 结束时间 更新时间 申请理由 活动地点 审批意见 状态 工作流实例 ID 下一级审批人姓名 用户 ID

17

西安工业学毕业设计(论文)

(2) tbl_property (资产信息表)。 tbl_property 表(如表 3.2)主要用于保存资产信息。
表 3.2 tbl_property (资产信息表) 列名 propertyId propertyName creater createTime endTime updateTime content idea status processInstanceId day nextPersonName userId 数据类型 int varchar varchar varchar varchar varchar varchar varchar int varchar int varchar int 长度 11 50 50 50 50 50 255 255 1 50 11 50 11 是否主键 是 描述 自动编号 资产名称 创建人 创建时间 结束时间 更新时间 申请理由 审批意见 状态 工作流实例 ID 申请天数 下一级审批人姓名 用户 ID

(3) tbl_reimburse (报销表)。 tbl_reimburse 表(如表 3.3)存储报销单信息。
表 3.3 tbl_reimburse (报销表) 列名 reimburseId reimburseName creater createTime endTime updateTime content idea status processInstanceId nextPersonName userId 数据类型 int varchar varchar varchar varchar varchar varchar varchar int varchar varchar int 长度 11 50 50 50 50 50 255 255 1 50 50 11 是否主键 是 描述 自动编号 报销单名称 创建人 创建时间 结束时间 更新时间 申请理由 审批意见 状态 工作流实例 ID 下一级审批人姓名 用户 ID

(4) tbl_vacate(请假表) 。
18

西安工业学毕业设计(论文)

tbl_vacate (如表 3.4)存储请假信息。
表 3.4 tbl_vacate(请假表) 列名 vacateId vacateName creater createTime endTime updateTime content idea status statusprocessInstanceId nextPersonName userId leaveLong 数据类型 int varchar varchar varchar varchar varchar varchar varchar int varchar varchar int int 长度 11 50 50 50 50 50 255 255 1 50 50 11 11 是否主键 是 描述 自动编号 请假单名称 创建人 创建时间 结束时间 更新时间 申请理由 审批意见 状态 工作流实例 ID 下一级审批人姓名 用户 ID 请假天数

(5) tbl_user(用户信息表) 。 tbl_user (如表 3.5)主要用于保存用户信息。
表 3.5 tbl_user(用户信息表) 列表 userId userName password userAge mail fatherId sex role department phone employedTime birthday address 数据类型 int varchar varchar int varchar int int int int int varchar varchar varchar 长度 11 50 50 11 50 11 1 1 1 11 50 50 255 是否主键 是 描述 用户编号(自动生成) 用户姓名 密码 年龄 邮箱 上级 ID 性别 角色 部门 电话号码 入职时间 生日 地址

(6) tbl_goods(资产表) 。 tbl_goods (如表 3.6)存储资产信息。
表 3.6 tbl_goods(资产表)

19

西安工业学毕业设计(论文) 列名 goodsId goodsName goodsNumber 数据类型 int varchar int 长度 11 50 11 是否主键 是 描述 自动编号 资产名称 数量

20

4 医药公司办公管理平台实现

4
4.1 登录模块

医药公司办公管理平台实现

本系统中对于登录模块的设计是供企业内部员工使用, 使用权的授予是由系 统管理员决定的,只有在系统管理员首次在员工管理模块中添加了你的信息后, 授予你登录的“姓名”和“密码”后你才能安全登录,在此同时也授予你登录的 权限, 在权限的范围内你能够完成相应操作。用户输入的登录信息被后台的数据 库匹配了才能够安全登录。否则是非法登录不能进入本系统主页。 用户输入自己的“用户名”和相匹配的“密码”后,后台的管理服务会 对登录的用户的身份进行验证,若匹配后进入系统首页,否则会提示“用户的用 户名或密码不正确!”,并且,并根据用户事先被赋予的使用权限,提供相应的 服务和管理界面。

4.2

公文申请模块
本系统是一个以工作流引擎为核心的管理系统,主要包括四大功能模块:活

动管理、报销管理、请假管理、资产管理。其设计思路都是一样,只是具体业务 有所不同。这里以活动管理为例进行详细设计说明,其它模块与此类似,就不在 此说明。 4.2.1 活动申请界面设计

创建 ApplyForActivity.jsp 页面,该页面主要用来显示活动申请信息列表, 定义了新增活动、提交、修改、删除功能按钮,活动管理界面如图 4.1 所示。

21

西安工业学毕业设计(论文)

图4.1 活动管理页面

4.2.2 (1)

新增活动申请 界面设计

创建 AddActivity.jsp 页面,定义活动输入信息字段、包括名称、创建人、 开始时间、结束时间、活动地点、申请理由。新增活动申请界面如图 4.2 所示 。

图4.2 新增活动申请页面

(2)

控制层设计

首先,在 Struts-config.xml 中配置 ActivityAction.java,配置制作视图导向路 径。 <action name="*_ActivityAction" class="activityAction" method="{1}"> <result name="applyforactivity">activityManager/ApplyForActivity.jsp </result>
22

西安工业学毕业设计(论文)

</action> 其次,开发 ActivityAction.java,实现方法 addActivity()。该申请流程的审批 对象都是动态加载的, 所以在新增活动申请时,必须在工作流程中设入审批对象 以及提交对象,这里以用户的 Id 号为标志,所以设值就以用户的 Id。设置好工 作流的变量后,即可开始该工作流实例,获得工作流实例 Id,保存到活动记录的 工作流字段,即可关联两者。调用 service 层的 addActivity()方法,保存具体的活 动信息。该方法具体代码如下所示: public String addActivity(){ Map<String,Object> map=new HashMap<String,Object>(); List<User> users=userService.findUserByRole(2); int bossId=userService.findUserByRole(3).get(0).getUserId(); map.put("owner", user.getUserId()+""); map.put("boss",bossId+""); activity.setCreateTime(new Date()); activity.setCreater(user.getUserName()); activity.setStatus(1); activity.setNextPersonName("经理审批"); activity.setUserId(user.getUserId()); int activityId=activeService.saveActive(activity); jBPMUtil.setProcessEngine(Constant.pe); ProcessInstance processInstance=jBPMUtil.startPIByKey("action", map, activityId+""); activity.setProcessInstanceId(processInstance.getId()); activeService.updateActivity(activity); activitys=activeService.findAll(user.getUserId()); return "applyforactivity"; } 再者,信息初始化完成,调用 taskService.completeTask(―任务 Id‖,‖流出方 向‖,‖活动 Id‖)提交任务,使该活动进入工作流程中,进行流转。
23

西安工业学毕业设计(论文)

(3)

业务逻辑层设计

业务层接口类 ActiveService.java,通过 ActiveServiceImpl.java 实现 addActivity()方法。 ActiveServiceImpl.java 类实现如下: 1. 添加所属包和引入包的声明。 2. 添加 ActiveDao 属性和 setter 方法,在调用该类时,Spring 会自动调用 setter 方法为 ActiveDao 属性注入一个实例对象。 3. 通过 ActiveDao 接口中 addActivity()方法保存对象。 (4) 数据持久层设计 添加活动申请时,需要将活动信息持久化到数据库中,对应的数据表为 tbl_activity。 1. 持久化类的实现 活动信息主表 activity 对应的持久类为 Activity.java。 2. 映射文件实现 活动信息主表 tbl_activity 和持久类 Activity.java 的映射关系在 Activity.hbm.xml 文件中定义。 3. Dao 实现 对持久类 Activity.java 相关操作主要提供了一个接口 ActivityDao.java 和一个实现类 ActivityDaoImpl.java。实现类主要包括了对活动信息的增 加、修改、删除、查看的操作。 4. Spring 相关实现 Spring 主要负责与 Hibernate 整合,实现相关配置以及 DAO 管理、与 Struts 整合实现 Action 管理、业务逻辑管理等功能。 (1) Spring 整合 Hibernate 实现配置

系统通过在 Web.xml 中配置 Spring 监听器来启动 Spring。系统启动 时通过 ContextLoaderListencer 初始化 Spring 容器,然后 ContextLoaderListenner 监听器通过初始化参数 ContextConfigLocation 找 到配置文件 applicationContext.xml 并加载。 通过 Spring 可以将 Hibernate 的相关配置以及 Dao 管理集中到 Spring 的配置文件 applicationContext
24

西安工业学毕业设计(论文)

中定义,该文件在开发系统、搭建工程时自动创建,在该文件中配置 SessionFactory,添加 ActivityDao 的定义信息。通过这些配置,系统启动 时,自动创建 Hibernate 的 SessionFactory,Spring 将管理 SessionFactory 为系统的 DAO 提供支持。 (2) Spring 整合 Struts 实现 Action

在 Spring 的配置文件 Struts-congfig.xml 中添加活动管理的 Action, 并引入 Spring 的代理插件,将来自客户端的所有 Action 请求,自动让 Spring 进行代理。在 Spring 的配置文件 applieationContext 中,添加对应 的 Action 文件 ActivityAction。

4.3 领导审批模块
4.3.1 活动任务审批列表界面设计 创建 CompleteTask.java 页面,该页面主要列出用户在该模块下代办的任 务列表,其中的审批按钮可以进入具体的审批页面。效果图如图 4.3。

图4.3 活动审批任务列表页面

4.3.2 (1)

审批 审批界面设计

创建 showActivityInfo.jsp 页面,该页面可以看到活动的具体信息,并且可以 对该公文发表意见。有同意和拒绝两个功能按钮。效果如图 4.4 所示。

25

西安工业学毕业设计(论文)

图4.4 活动审批页面

(2)

控制层设计

首先,在 Struts-config.xml 中配置 ActivityAction.java,配置制作视图导向路 径。 <action name="*_ActivityAction" class="activityAction" method="{1}"> <result name="taskList">activityManager/CompletTask.jsp</result> <result name="showActivityInfo">activityManager/ShowActivityInfo.jsp </result> </action> 其次,开发 ActivityAction.java,实现方法 completeTask ()。根据任务 id 完 成具体的任务。核心代码如下: if(user.getRole()==2){ joinTaskId=(String) session.get("taskId"); joinTask=ts.getTask(joinTaskId); ProcessInstance processInstance=this.getPI(ts, joinTaskId); task=ts.createTaskQuery() .processInstanceId(processInstance.getId()) .activityName(processInstance.findActiveActivityNames() .iterator().next()) .uniqueResult(); } String result=request.getParameter("result");
26

西安工业学毕业设计(论文)

Map<String,Object> v=new HashMap<String,Object>(); if("拒绝".equals(result)){ activity.setStatus(0); activity.setNextPersonName("经理审批"); v.put(Sign.VAR_SIGN, "拒绝"); ts.setVariables(joinTask.getId(), v); Sign sign=new Sign(task.getId(),joinTask,"同意","拒绝"); pe.execute(sign); } if(user.getRole()==2 && "同意".equals(result)){ activity.setNextPersonName(admin.getUserName()); v.put(Sign.VAR_SIGN, "同意"); ts.setVariables(joinTask.getId(), v); Sign sign=new Sign(task.getId(),joinTask,"同意","拒绝"); pe.execute(sign); } if(user.getRole()==3 && "同意".equals(result)){ activity.setStatus(4); activity.setNextPersonName(user.getUserName()); Map<String,String> map=new HashMap<String,String>(); map.put("advice", advice); ts.completeTask((String) session.get("taskId"), result, map); } activeService.updateActivity(activity);

??

27

西安工业学毕业设计(论文)

(3)

业务逻辑层设计

业务层接口类 ActiveService.java,通过 ActiveServiceImpl.java 实现 updateActivity()方法。 ActiveServiceImpl.java 类实现如下: 通过 ActiveDao 接口中 updateActivity()方法保存对象。 (4) 数据持久层设计 修改活动申请时,需要将活动信息持久化到数据库中,对应的数据表为 tbl_activity。 1. 持久化类的实现 活动信息主表 tbl_activity 对应的持久类为 Activity.java。 2. 映射文件实现 活动信息主表 tbl_activity 和持久类 Activity.java 的映射关系在 Activity.hbm.xml 文件中定义。 3. Dao 实现

对持久类 Activity.java 相关操作主要提供了一个接口 ActivityDao.java 和一个实现类 ActivityDaoImpl.java。实现类主要包括了对活动信息的增 加、修改、删除、查看的操作。 4. Spring 相关实现 Spring 主要负责与 Hibernate 整合,实现相关配置以及 DAO 管理、与 Struts 整合实现 Action 管理、业务逻辑管理等功能。 (1) Spring 整合 Hibernate 实现配置

系统通过在 Web.xml 中配置 Spring 监听器来启动 Spring。系统启动 时通过 ContextLoaderListencer 初始化 Spring 容器,然后 ContextLoader Listenner 监听器通过初始化参数 ContextConfigLocation 找到配置文件 ap plicationContext.xml 并加载。 通过 Spring 可以将 Hibernate 的相关配置以 及 Dao 管理集中到 Spring 的配置文件 applicationContext 中定义, 该文件 在开发系统、搭建工程时自动创建,在该文件中配置 SessionFactory,添 加 ActivityDao 的定义信息。通过这些配置,系统启动时,自动创建 Hib ernate 的 SessionFactory,Spring 将管理 SessionFactory 为系统的 DAO 提
28

西安工业学毕业设计(论文)

供支持。 (2) Spring 整合 Struts 实现 Action

在 Spring 的配置文件 Struts-congfig.xml 中添加活动管理的 Action, 并引入 Spring 的代理插件,将来自客户端的所有 Action 请求,自动让 Spring 进行代理。在 Spring 的配置文件 applieationContext 中,添加对应 的 Action 文件 ActivityAction。

4.4
4.4.1

记录查看模块
活动申请记录查看页面

创建 ActivityRecord.jsp 页面,该界面主要展示所有活动记录状态为“通过” 的活动记录,其中有详情查看操作。效果图如图 4.5 所示。

图4.5 活动记录列表页面

4.4.2

活动记录详情

该界面的具体实现过程与前面相同,这里略去。

4.5
4.5.1 (1)

用户管理模块
新增用户信息 界面设计

创建 AddUser.jsp 页面,该页面包括的字段有用户姓名、密码、性别、出生 日期、入职时间、部门、角色、联系电话、邮箱、地址。页面效果如图 4.6 所示。

29

西安工业学毕业设计(论文)

图4.6 用户新增页面

(2)

控制层设计

首先,在 Struts-config.xml 中配置 UserAction.java,配置制作视图导向路径。 <action name="*_UserAction" class="userAction" method="{1}"> <result name="userInfo">userManager/UserList.jsp</result> <result name="updateUser">userManager/UpdateUser.jsp</result> <result name="detailUser">userManager/DetailUser.jsp</result> </action> 其次, 开发 UserAction.java, 实现方法 addUser()。 Struts2 自动获取表单数据, 通过 userService 接口的 addUser()方法保存用户信息。具体实现代码如下: public String addUser(){ int fatherId=0; if(user.getRole()==2) fatherId=3; if(user.getRole()==1) fatherId=userService.findOneUserByRoleAndDept(2, user.getDepartment()).get(0).getUserId();

30

西安工业学毕业设计(论文)

user.setFatherId(fatherId); userService.addUser(user); if(pageBean.getCurrentPage()==0) pageBean.setCurrentPage(1); pageBean=userService.findUsersByValue(pageBean.getCurrentPage(),pageBe an.getPageSize()); return "userInfo"; } (3) 业务逻辑层设计

业务层接口类 UserService.java,通过 UserServiceImpl.java 实现 addUser() 方法。 UserServiceImpl.java 类实现: 通过 UserDao 接口中 addUser()方法保存对象。 (4) 数据持久层设计 新增用户时,需要将用户信息持久化到数据库中,对应的数据表为 tbl_user。 1. 持久化类的实现 活动信息主表 tbl_user 对应的持久类为 User.java。 2. 映射文件实现 活动信息主表 tbl_user 和持久 User.java 的映射关系在 User.hbm.xml 文 件中定义。 3. Dao 实现

对持久类 User.java 相关操作主要提供了一个接口 UserDao.java 和一个 实现类 UserDaoImpl.java。实现类主要包括了对用户信息的增加、修改、 删除、查看的操作。 4. Spring 相关实现

Spring 主要负责与 Hibernate 整合,实现相关配置以及 DAO 管理、与 Struts 整合实现 Action 管理、业务逻辑管理等功能。 (1) Spring 整合 Hibernate 实现配置 系统通过在 Web.xml 中配置 Spring 监听器来启动 Spring。系统启动
31

西安工业学毕业设计(论文)

时通过 ContextLoaderListencer 初始化 Spring 容器,然后 ContextLoader Listenner 监听器通过初始化参数 ContextConfigLocation 找到配置文件 ap plicationContext.xml 并加载。 通过 Spring 可以将 Hibernate 的相关配置以 及 Dao 管理集中到 Spring 的配置文件 applicationContext 中定义, 该文件 在开发系统、搭建工程时自动创建,在该文件中配置 SessionFactory,添 加 ActivityDao 的定义信息。通过这些配置,系统启动时,自动创建 Hib ernate 的 SessionFactory,Spring 将管理 SessionFactory 为系统的 DAO 提 供支持。 (2) Spring 整合 Struts 实现 Action 在 Spring 的配置文件 Struts-congfig.xml 中添加活动管理的 Action, 并引入 Spring 的代理插件,将来自客户端的所有 Action 请求,自动让 Spring 进行代理。在 Spring 的配置文件 applieationContext 中,添加对应 的 Action 文件 UserAction。 4.5.2 修改、删除、查看用户信息

该功能实现过程与上相同,这里略去。

4.6

资产信息管理模块
该模块主要实现过程与用户管理模块完全相同, 包括的功能是对资产的 “增

删改查” ,这里限于篇幅,不做过多说明。

32

5

总结

5 总



本文经过审题、分析、设计、调试到最后实现了企业办公自动化系统,企业 办公自动化系统的实现从人力和物力上减轻了企业对办公业务的处理, 提高了企 业的整体运转效率,未来必将会有远大的发展前景。 本系统主要完成了登录管理、用户管理、活动管理、报销管理、资产管理、 请假管理功能的设计。其所用的技术是目前比较流行的 JSP、Struts2、Spring、 Hibernate 完成整个设计流程。本系统实现较简单,交互界面友好,用户使用方 便,而且安全性能可靠,可扩展性较强,适用于中小型企业。 本系统的应用满足了企业的办公网络化,自动化的管理需求,提高了企业 内部的管理水平, 进而全面提升了企业在市场中的综合竞争力。本系统存在的主 要缺陷就是其中的功能还不够全,而不同规模的企业对办公自动化程度也不一 样,因此为了完善本系统可根据企业的需求扩展其功能。

33

致谢





能够顺利完成本次设计,首先感谢图书管给学生提供的知识宝库,我从中学会了 挺多东西,希望更多的同学能够很好的利用图书馆资源。 其次,能够顺利的完成,我必须感谢我的指导老师,老师给我的指导和帮助让我 解决了一些难题,顺利的完成了后续的工作。 另外,也要感谢我的同学和好友,是他们让我的大学生活丰富多彩,是他们给我 勇气和快乐。 另外,我要感谢几年来教我的老师们,是你们孜孜不倦的教诲及谆谆教导让我学 习了基本的专业的知识、做人的道理及解决问题的方法,为本文的完成打下了基础并 为以后的学习和工作打下基础。 再次,我要感谢我的父母,是他们辛勤的劳动和汗水养育了我,是你们的叮咛和 督促,让我在遇到困难的时候能够勇敢面对。 衷心感谢帮助过我的老师,祝全体老师工作顺利,身体健康。

34

参考文献

参考文献

[1] [2] [3] [4] [5] [6] [7] [8] [9]

耿祥义,张跃平.JAVA 2 实用教程[M].清华大学出版社.2004.2. 李忠. 企业办公自动化系统集成的探索, 内蒙古民族大学学报 (自然科学版) , 2004,19(4) :379-380. 王立.UML 与软件工程基础[M].高等教育出版社.2004.2. 王景洪.办公自动化与电子政务,河南机电高等专科学校学报,2003,4:81. 蔡剑,景楠.Java Web 应用开发[M].高等教育出版社.2005.1. Rod J. J2EE development frameworks [J], Computer, 2005, (1):107-110. Johnson, R. J2EE Development Frameworks [J], IT Systems Perspectives, 2005,107-110. 邱哲,马斗.Struts 设计开发大全[M].清华大学出版社.2006.2. 企 业 办 公 自 动 化 系 统 OA 市 场 发 展 趋 势 , http://hi.baidu.com/jingliushui/blog/item/40bf3f8719fccc2ac65cc39e.html , 2007,3,8. 曹 振 丽 , 张 海 峰 , 井 闽 等 . 计 算 机 网 络 安 全 及 其 防 范 技 术 [J], China Education Info, 2008, (8): 67-69. Takoua Abdellatif. Enhancing the management of a J2EE application serverusing a component-based architecture [J], Software Engineering and Advanced Applications, 2005, 3: 70-77. John Grundy, Guoliang Ding. Automatic validation of deployed J2EE components using aspects [J], Automated Software Engineering, 2002, 12: 47-56. 李长树.办公自动化系统的设计方法与实施策略,计算机应用研究,2000, 17(7) :47-50. 沃尔斯.Spring in Action [M].人民邮电出版社.2005.6. 刘晓华.JSP 应用开发详解[M].电子工业出版社.2007.5. Dennis M.Sosnoski. Java 中 的 XML: 数 据 绑 定 [EB/OL] , http://www-128.ibm.com/developerworks/cn/xml/x-databdopt/part1/. [ 美 ]Stephanie Bodoff,Dale Green,Kim Haase 等 著 . The J2EE Tutorial Pearson Education[M],2002. STEPHEN ASBURY, SCOTT R.WEINER 著. JAVA 企业级应用开发指南 (原 书第二版)[M],机械工业出版社,2004,1. 李芝兴,杨瑞龙.Java EE Web 编程[M] .机械工业出版社.2008.5. 许杰星, 李强. MySql 开发者 SQL 权威指南[M] . 机械工业出版社. 2007.6. 陈刚.ECLIPSE 从入门到精通[M] .清华大学出版社.2006.2. 赛奎春.JSP 应用与项目实践[M] .机械工业出版社.2005.4.
35

[10] [11]

[12]

[13] [14] [15] [16] [17] [18] [19] [20] [21] [22]

参考文献

[23] [24] [25] [26] [27] [28]

何主洁、黄婷儿.数据库设计教程[M] .机械工业出版社.2006.8. 伊晓强编著.J2EE 全实例教程[M],希望电子出版社,北京,2000. [美]Pau1S.Wang.Java 与面向对象程序设计 [M],高等教育出版社,2004. 黄明,梁旭.Java 信息系统设计与开发实例[M],机械工业出版社,2004. [美]Bruce Eckel 著 侯捷译.Java 编程思想[M] 第二版(Thinking in java second) ,北京:机械工业出版社,2002. 李刚 轻量级 JavaEE 企业应用实战(第三版).电子工业出版社. 2011.7.

36

毕业设计(论文)知识产权声明

毕业设计(论文)知识产权声明

本人完全了解西安工业大学有关保护知识产权的规定,即:本科学生在校攻读 学士学位期间毕业设计(论文)工作的知识产权属于西安工业大学。本人保证毕业离 校后,使用毕业设计(论文)工作成果或用毕业设计(论文)工作成果发表论文时署 名单位仍然为西安工业大学。学校有权保留送交的毕业设计(论文)的原文或复印 件,允许毕业设计(论文)被查阅和借阅;学校可以公布毕业设计(论文)的全部或 部分内容,可以采用影印、缩印或其他复制手段保存毕业设计(论文)。 (保密的毕业设计(论文)在解密后应遵守此规定)

毕业设计(论文)作者签名: 指导教师签名: 日期:

37

毕业设计(论文)独创性声明

毕业设计(论文)独创性声明

秉承学校严谨的学风与优良的科学道德,本人声明所呈交的毕业设计(论文)是 我个人在导师指导下进行的研究工作及取得的研究成果。尽我所知,除了文中特别 加以标注和致谢的地方外,毕业设计(论文)中不包含其他人已经发表或撰写过的成 果,不包含他人已申请学位或其他用途使用过的成果。与我一同工作的同志对本研 究所做的任何贡献均已在论文中作了明确的说明并表示了致谢。 毕业设计(论文)与资料若有不实之处,本人承担一切相关责任。

毕业设计(论文)作者签名: 指导教师签名: 日期:

38

附录:

毕业设计(论文)外文翻译

题目:Java 技术与 SSH 框架

院 (系) : 专 班 学 学 业: 级: 生: 号:

指导教师:
外 文出 处:

2012 年 5 月 6 日

39

译文:

Java 技术与 SSH 框架
Duke,Java 语言的吉祥物语言最开始只是太阳微系统(Sun MicroSystems) 公司在 1990 年 12 月开始研究的一个内部项目。 太阳微系统公司的一个叫做帕特 里克?诺顿的工程师被公司自己开发的 C++和 C 语言编译器搞得焦头烂额,因为 其中的 API 极其难用。帕特里克决定改用 NeXT,同时他也获得了研究公司的一 个叫做 “Stealth 计划” 的项目的机会。 “Stealth 计划” 后来改名为 “Green 计划” , 詹姆斯·高斯林和麦克?舍林丹也加入了帕特里克的工作小组。他们和其他几个 工程师一起在加利福尼亚州门罗帕克市沙丘路的一个小工作室里面研究开发新 技术,瞄准下一代智能家电(如微波炉)的程序设计,太阳公司预料未来科技将 在家用电器领域大显身手。 团队最初考虑使用 C++语言, 但是很多成员包括太阳 的首席科学家比尔?乔伊,发现 C++和可用的 API 在某些方面存在很大问题。工 作小组使用的是内嵌类型平台, 可以用的资源极其有限。 很多成员发现 C++太复 杂以至很多开发者经常错误使用。 他们发现 C++缺少垃圾回收系统, 还有可移植 的安全性、分布程序设计、和多运行续功能。最后,他们想要一种易于移植到各 种设备上的平台。 根据可用的资金,比尔?乔伊决定开发一种集 C 语言和 Mesa 语言大成的新 语言,在一份报告上,乔伊把它叫做“未来”,他提议太阳公司的工程师应该在 C++的基础上,开发一种面向对象的环境。最初,高斯林试图修改和扩展 C++的 功能,他自己称这种新语言为 C++ ++ --,但是后来他放弃了。他将要创造出一 种全新的语言,被他命名为“Oak”(橡树),以他的办公室外的橡树命名。就 像很多开发新技术的秘密工程一样,工作小组没日没夜地工作到了 1992 年的夏 天,他们能够演示新平台的一部分了,包括 Green 操作系统,Oak 的程序设计语 言,类库及其硬件。最初的尝试是面向一种类 PDA 设备,被命名为 Star7,这种 设备有鲜艳的图形界面和被称为“Duke”的智能代理来帮助用户。1992 年 12 月 3 日,这台设备进行了展示。同年 11 月,Green 计划被转化成了“FirstPerson 有 限公司”,一个太阳公司的全资子公司,团队也被重新安排到了帕洛阿尔托。
39

FirstPerson 团队对建造一种高度交互的设备感兴趣,当时代华纳发布了一个关于 电视机顶盒的征求提议书时(Request for proposal),FirstPerson 改变了他们的 目标,作为对征求意见书的响应, 提出了一个机顶盒平台的提议。但是有线电 视业界觉得 FirstPerson 的平台给予用户过多的控制权,因此 FirstPerson 的投标 败给了 SGI。与 3DO 公司的另外一笔关于机顶盒的交易也没有成功,由于他们 的平台不能在电视工业产生任何效益,公司被并回太阳公司。 Java 和互联网 1994 年 6 月、7 月间,在经历了一场历时三天的脑力激荡的 讨论后,约翰·盖吉、詹姆斯·高斯林、比尔·乔伊、帕特里克·诺顿、韦恩·罗 斯因和埃里克·斯库米,团队决定再一次改变了努力的目标,这次他们决定将该 技术应用于万维网。他们认为随着 Mosaic 浏览器的到来,因特网正在向同样的 高度互动的远景演变,而这一远景正是他们在有线电视网中看到的。作为原型, 帕特里克·诺顿写了一个小型万维网浏览器,WebRunner,后来改名为 HotJava。 Java 和“Java”由于商标搜索显示,Oak 已被一家显卡制造商注册。于是同年, Oak 被改名为 Java。当使用十六进制编辑器打开由 Java 源代码编译出的二进制 文件 (.class 文件) 的话, 最前面的 32 位将显示为 CA FE BA BE, 即词组 “CAFE BABE”(咖啡屋宝贝)。[编辑] Java 和浏览器 1994 年 10 月,HotJava 和 Java 平台为公司高层进行演示。 1994 年, Java 1.0a 版本已经可以提供下载, 但是 Java 和 HotJava 浏览器的第一次公开发布却是在 1995 年 3 月 23 日 SunWorld 大会上 进行的。升阳公司的科学指导约翰·盖吉声明 Java 技术。这个发布是与网景公 司的执行副总裁马克· 安德森的惊人发布一起进行的,宣布网景将在其浏览器中 包含对 Java 的支持。 1996 年 1 月, 升阳公司成立了 Java 业务集团, 专门开发 Java 技术。Java 近况在流行几年之后,Java 在浏览器中的地位被逐步侵蚀。它在简单 交互性动画方面的用途已经完全被 Adobe 公司的 Flash 排挤,2005 年 Java 倾向 只被用于雅虎游戏那样的更为复杂的应用程序。Java 同时遭受到来自微软的反 对,他们决定在新版本的 Internet Explorer 和 Windows 中不再附带 Java 平台。与 此相反。在万维网的服务器端和手持设备上,Java 变得更加流行。很多网站在后 端使用 JSP 和其他的 Java 技术。 在桌面系统上, 独立的 Java 程序还是相对少见, 这是因为 Java 平台的运行开销较大,而许多人的电脑上没有安装 Java,由于网 络带宽在以前较小,下载 Java 曾经是个耗时的事情。但是随着计算机计算能力、
40

网络带宽在 10 年中取得了很大的进步, 同时虚拟机和编译器的质量得到了提高, 许多应用程序得到了广泛的使用,包括:开源软件:NetBeans 和 Eclipse 等软件 开发工具、JEdit、Azureus BitTorrent 客户端、JNode 操作系统、Apache 软件基 金会的 Ant、Derby、Hadoop、Jakarta、POI 和 Tomcat、JBoss 和 GlassFish 应用 服务器;商用软件:EIOffice(永中 Office)、纯 Java 3D 游戏合金战士 Chrome、 IBM Websphere、ColdFusion 和 WebLogic。 目前 Java 提供以下三个版本: Java Platform, Enterprise Edition (Java EE: Java 平台企业版)、Java Platform, Standard Edition(Java SE:Java 平台标准版)、Java Platform, Micro Edition(Java ME:Java 平台微型版)Java Platform, Card Edition。 Java 开放源代码项目 2006 年 SUN 在 JavaOne 公布 Java 开放源代码项目,并推 出 OpenJDK 计划。[2] Java 虚拟机、Java 编译器和 Java 类库以 GNU 通用公共许 可证公开。 Java 语言之所以被开发, 是要达到以下五个目的: 应当使用面向对象程序设 计方法学、 应当允许同一程序在不同的计算机平台执行、应当包括内建的对计算 机网络的支持、应当被设计成安全地执行远端代码、应当易于使用,并借鉴以前 那些面向对象语言(如 C++)的长处。Java 技术主要分成几个部分:Java 语言、 运行环境 JVM、类库。一般情况下说 Java 时并不区分指的是哪个部分。Java 在 1.5 版本时, 做了重大改变, 太阳公司并 1.5 版本重命名为 Java 5.0。 面向对象 Java 的特点之一就是面向对象,是程序设计方法的一种。“面向对象程序设计语言” 的核心之一就是开发者在设计软件的时候可以使用自定义的类型和关联操作。 代 码和数据的实际集合体叫做 “对象” 一个对象可以想像成绑定了很多 。 “行为 (代 码)”和“状态(数据)”的物体。对于数据结构的改变需要和代码进行通信然 后操作, 反之亦然。 面向对象设计让大型软件工程的计划和设计变得更容易管理, 能增强工程的健康度, 减少失败工程的数量。面向对象设计另外一个目标就是能 产生很多的有关联的类,可以让软件的再开发变得简单。举例来说,很多软件工 程都有同样的功能, 尤其是很多应用了同一原理组织的软件工程。软件的二次开 发者想自己为软件开发插件以增强功能的时候, 绝对不想看到混乱的开发代码和 管理计划。 面向对象的目的就是不生产难懂且难以使用的代码,为软件各个功能 群之间创建有效的通信通道。 很多开源软件社区正在计划给软件作者提供更多的
41

类来让软件的二次开发变得简便。跨平台性 Java 语言的第二个特性就是跨平台 性,也就是说使用 Java 语言编写的程序可以在编译后不用经过任何更改,就能 在任何硬件设备条件下运行。这个特性经常被称为“一次编译,到处运行”。执 行 Java 应用程序必须安装 Java Runtime Environment(JRE),JRE 内部有一个 Java 虚拟机(Java Virtual Machine,JVM)以及一些标准的类库(Class Library)。 通过 JVM 的虚拟机才能在电脑系统执行 Java 应用程序(Java Application),这 与.Net Framework 的情况一样, 所以电脑上没有安装 JVM, 那么这些程序将不能 够执行。实现跨平台性的方法是大多数编译器在进行 Java 语言程序的编码时候 会生成一个用字节码(Bytecode)写成的“半成品”,这个“半成品”会在 Java 虚拟机(解释层)的帮助下运行,虚拟机会把它转换成当前所处硬件平台的原始 代码。之后,Java 虚拟机会打开标准库,进行数据(图片、线程和网络)的访问 工作。主要注意的是,尽管已经存在一个进行代码翻译的解释层,有些时候 Java 的字节码代码还是会被 JIT 编译器进行二次编译。有些编译器,比如 GCJ,可以 自动生成原始代码而不需要解释层。 但是这些编译器所生成的代码只能应用于特 定平台。并且 GCJ 目前只支持部分的 Java API。甲骨文公司对于 Java 的许可是 “全兼容的”,这也导致了微软和升阳关于微软的程序不支持 RMI 和 JNI 接口、 并且增加特性为己所用的法律争端。升阳最终赢得了官司,获得了大约两千万美 元的赔偿,法院强制要求微软执行升阳公司关于 Java 的许可要求。作为回应, 微软不再在 Windows 系统中捆绑 Java,最新的 Windows 版本,Windows Vista 和 Internet Explorer 7.0 版本也不再提供对于 Java 应用程序和控件的支持。但是 升阳公司和其他使用 Java 运行时系统的公司对于微软的操作对用户提供无偿的 第三方插件和程序支持。 Java 语言使用解释层最初是为了轻巧性。 所以这些程序 的运行效率比 C 语言和 C++要低很多,用户也对此颇有微词。很多最近的调查 显示 Java 的程序运行速度比几年前要高出许多,有些同样功能的程序的效率甚 至超过了 C++和 C 语言编写的程序。 Java 语言在最开始应用的时候是没有解释层的, 所有需要编译的代码都直接 转换成机器的原始代码。 这样做的后果就是获得了最佳的性能,但是程序臃肿异 常。从 JIT 技术开始,Java 的程序都经过一次转换之后才变成机器码。很多老牌 的第三方虚拟机都使用一种叫做“动态编译”的技术,也就是说虚拟机实时监测
42

和分析程序的运行行为, 同时选择性地对程序所需要的部分进行编译和优化。所 有这些技术都改善了代码的运行速度,但是又不会让程序的体积变得失常。程序 的轻便性事实上是软件编写很难达到的一个目标, Java 虽然成功地实现了 “一次 编译,到处运行”,但是由于平台和平台之间的差异,所编写的程序在转换代码 的时候难免会出现微小的、不可察觉的错误和意外。有些程序员对此非常头疼, 他们嘲笑 Java 的程序不是“一次编译,到处运行”,而是“一次编译,到处调 试”。 平台无关性让 Java 在服务器端软件领域非常成功。很多服务器端软件都使 用 Java 或相关技术创建。 Java 的性能和复杂性: 关于 Java 的批评 Java 试图通过新的方式解决软件编写的复杂性。很多人认 为 Java 语言做到了它承诺的一切。但是 Java 并不是一门完美的语言。整体性问 题并不是所有的工程和环境需要企业级别的复杂性, 比如一个简单的个人网站或 者独自编程的程序师所写的程序。这些程序师会发现 Java 的复杂管理对于自己 要做的程序来说过于强大了。 一些人觉得 Java 在面向对象上面做的没有 Ruby 和 Smalltalk 纯粹。但是最新出现的用 Java 实现的语言 Groovy 解决了这些问题。 作为一种已经创建的新技术,Java 显然综合了很多语言的特性,比如 C++、 C 语言、Python 等等。一些对于 Java 的评论认为 Java 的不变性在动摇。 语言问题有些程序师不喜欢原始类型(primitive type)和类(class)的分离, 尤其是那些曾经使用过 Smalltalk 和 Ruby 的程序师。 Java 的代码相对于其他的代 码来说过于冗长,这与它的轻便化声明相违背。Java 是一种单层继承的语言。这 也导致了程序师在试图使用多重继承时候的不便, 而很多语言都可以使用这个特 性。但是 Java 可以使用接口类,把多重继承可能导致的风险减少到最小。Java 不支持运算符重载, 这是为了防止运算符重载使得代码的功能变得不清晰。但是 用 Java 实现的语言 Groovy 可以进行运算符重载。过去 Java 对于文本的操作和 其他语言,比如 Perl 和 PHP 相比差的较多,但 Java 在 1.4 版本时候引入了正则 表达式。 类库问题使用 Swing 平台编写的带有 GUI 图形用户接口) ( 的程序和其他原 始程序非常不同。选用 AWT 工具包编写程序的程序师看到的都是原始接口,而
43

且也无法获得先进的 GUI 编程支持,如果使用的话,就要提供每个平台上面所 需的 API,这将是一项庞大的工程。Swing 则是完全用 Java 语言所写的程序,避 免了接口元素重复的问题, 只使用所有平台都支持的最基本的绘图机制。但是很 多用户不知道如何在 Java 风格和 Windows 风格之间进行转换,结果造成了 Java 程序的接口在很多程序中非常特殊。苹果电脑已经提供了优化过的 Java 运行时 程序,包含了 Mac OS X 的经典 Aqua 接口风格。性能问题由于 Java 编译器和虚 拟机的不同对 Java 代码的性能影响比语言本身的影响大的多, 所以统一讨论 Java 的程序的性能经常是有误导性的。据 IBM 的数据,在同样的硬件上 2001 年时的 IBM JDK 版本的性能是 1996 年的 JDK 版本的十倍左右。见 IBM 东京研究院的 数据: http://www.is.titech.ac.jp/ppl2004/proceedings/ishizaki_slides.pdf 而即使是 在同一时期,不同公司的 JDK 和 JRE 的性能也不一样,比如 SUN、IBM、BEA 等公司都有自己开发的 JDK 和 JRE。 Java 语言的一些特性不可避免的有额外的性能代价, 例如数组范围检查、 运 行时类型检查等等。 Java 程序的性能还会因为不同的动态复杂性和垃圾处理机制 使用的多少而各有不同。如果 JVM 的实现比较优化的话,那么这些功能甚至可 以增加存储器分配的性能。 这和总是使用 STL 或者托管 C++的程序的情况类似。 尽管如此,仍然有许多人认为 Java 的性能低。这部分归因于 Sun 公司最初 的 JVM 实现使用未优化的解释机制来运行字节码。一些新版本的 JVM 使用 Just-In-Time(JIT)编译器,在加载字节码的时候将其编译成针对运行环境的本 地代码来实现一些本地编译器的优化特性。Just-In-Time 机制和本地编译的性能 比较仍旧是一个有争议的话题。JIT 编译需要很多时间,对于运行时间不长或者 代码很多的大型程序并不适宜。但是不算 JIT 编译阶段的话,程序的运行性能在 很多 JVM 下可以和本地编译的程序一争短长,甚至在一些计算比较密集的数值 计算领域也是这样。 目前, Java 已经使用更先进的 HotSpot 技术来代替 JIT 技术, Java 的性能有了更进一步的提升。另外,在使用-server 选项运行 java 程序时, 也可以对 java 进行更深入的优化,比如在运行时将调用较多的方法内联(inline) 到程序中来提高运行速度,这就是所谓的“动态优化”,而本地编译器是无法做 到这一点的;这也是一些 java 代码比对应用 C/C++等语言编写的本地代码运行 的更快的原因之一。微软的.NET 平台也使用 JIT 编译器,所以也有类似问题。
44

Java 的设计目的主要是安全性和可携性, 所以对于一些特性, 比如对硬件架 构和存储器地址访问的直接访问都被去除了。 如果需要间接调用这些底层功能的 话,就需要使用 JNI(Java 本地接口)来调用本地代码,而间接访问意味着频繁 调用这些特性时性能损失会很大,微软的.NET 平台也有这样的问题。所以到目 前为止,性能敏感的代码,例如驱动程序和 3D 视频游戏,还是大多使用本地编 译,甚至直接以不直接支持面向对象的 C 语言或机器码编写。但最近已经有了 许多用纯 Java 编写的 3D 游戏,其效果与用 C 语言编写的不相上下,例如“合 金战士”(英文名:Chrome)。这主要是因为新版的 Java 3D 技术已经能像 C++ 一样调用硬件加速,也就是使用显卡来加速,无论是 C++还是 Java 语言写的 3D 游戏都是使用显卡及 GPU 来处理,从而使得 CPU 可以专注于其他方面的工作。 垃圾回收机制: 自动垃圾回收(Garbage Collection)C++语言被用户诟病的原因之一是大多 数 C++编译器不支持垃圾收集机制。 通常使用 C++编程的时候, 程序员于程序中 初始化对象时, 会在主机存储器堆栈上分配一块存储器与地址,当不需要此对象 时, 进行解构或者删除的时候再释放分配的存储器地址。如果对象是在堆栈上分 配的,而程序员又忘记进行删除,那么就会造成存储器泄漏(Memory Leak)。 长此以往, 程序运行的时候可能会生成很多不清除的垃圾,浪费了不必要的存储 器空间。因此如果同一存储器地址被删除两次的话,程序会变得不稳定,甚至崩 溃。因此有经验的 C++程序员都会在删除之后将指针重置为 0,然后在删除之前 先判断指针是否为 0。C++中也可以使用“智能指针”(Smart Pointer)或者使用 C++托管扩展编译器的方法来实现自动化存储器释放,智能指针可以在标准类库 中找到,而 C++托管扩展被微软的 Visual C++ 7.0 及以上版本所支持。智能指针 的优点是不需引入缓慢的垃圾收集机制,而且可以不考虑线程安全的问题,但是 缺点是如果不善使用智能指针的话,性能有可能不如垃圾收集机制,而且不断地 分配和释放存储器可能造成存储器碎片,需要手动对堆进行压缩。除此之外,由 于智能指针是一个基于模板的功能, 所以没有经验的程序员在需要使用多态特性 进行自动清理时也可能束手无策。 Java 语言则不同, 上述的情况被自动垃圾收集 功能自动处理。 对象的创建和放置都是在存储器堆栈上面进行的。当一个对象没 有任何参考的时候, Java 的自动垃圾收集机制就发挥作用, 自动删除这个对象所
45

占用的空间,释放存储器以避免存储器泄漏。注意程序员不需要修改 finalize 方 法,自动垃圾收集也会发生作用。但是存储器泄漏并不是就此避免了,当程序员 疏忽大意地忘记解除一个对象不应该有的参考的时候,存储器泄漏仍然不可避 免,例如以下的程序: String str = "這是一段字串"; System.out.println(s); for(int i){ System.out.println("Hallo Would"+i); } 在循环开始之前,字符串 str 已经不会再用到了,但未将这个参考指向 null, 因此字符串 str 无法被 gc 所回收。 这种存储器泄漏必须等到一个函数退出之后才 会被系统取回,自不过发生的机率要比不激活垃圾收集机制的 C++程序少很多。 但是总体来讲,自动垃圾收集机制要安全和简单许多。 不同厂商、不同版本的 JVM 中的存储器垃圾回收机制并不完全一样,通常 越新版本的存储器回收机制越快,IBM、BEA、SUN 等等开发 JVM 的公司都曾 宣称过自己制造出了世界上最快的 Template:WhatJVM,JVM 性能的世界纪录也 在不断的被打破并提高。 IBM 有一篇有关 Java 存储器回收机制比不激活垃圾收集机制的 C++存储器 处理快数倍的技术文章,而著名的 Java 技术书籍《Java 编程思想》(Thinking in Java)也有一段论述 Java 存储器及性能达到甚至超过 C++的章节。 Java 的设计者们不想让 Java 有多重继承的特性,因为 C++的多重继承显示 了这种特性的困难。Java 的接口功能可以提供同样的功能,但是又不会很复杂。 应用程序开发接口在 Java 语言中,应用程序接口(API)化身成类,并且分组成 为包。每个包中包含有相关的接口和类。对于不同的平台,Java 提供了不同版本 的包。API 的设定由 sun 公司和其他公司通过 JCP(Java 社区程序)决定。任何 公司和个人都可以参与这个工程,对 API 进行设计。2004 年,IBM 和 BEA 公司 准备联合对官方的 Java 开源软件工程进行支持,但是 2005 年初,sun 公司拒绝 了这个支持。 Spring
46

Spring Framework 是一个开源的 Java/Java EE 全功能栈(full-stack)的应用 程序框架,以 Apache 许可证形式发布,也有.NET 平台上的移植版本。该框架基 于 Expert One-on-One Java EE Design and Development(ISBN 0-7645-4385-7)一 书中的代码,最初由 Rod Johnson 和 Juergen Hoeller 等开发。Spring Framework 提供了一个简易的开发方式, 这种开发方式,将避免那些可能致使底层代码变得 繁杂混乱的大量的属性文件和帮助类。Spring 中包含的关键特性:强大的基于 JavaBeans 的采用控制翻转(Inversion of Control,IoC)原则的配置管理,使得 应用程序的组建更加快捷简易。一个可用于从 applet 到 Java EE 等不同运行环 境的核心 Bean 工厂。数据库事务的一般化抽象层,允许声明式(Declarative) 事务管理器, 简化事务的划分使之与底层无关。 内建的针对 JTA 和 单个 JDBC 数据源的一般化策略,使 Spring 的事务支持不要求 Java EE 环境,这与一般的 JTA 或者 EJB CMT 相反。 JDBC 抽象层提供了有针对性的异常等级(不再从 SQL 异常中提取原始代 码),简化了错误处理,大大减少了程序员的编码量。再次利用 JDBC 时,你无 需再写出另一个 '终止' (finally) 模块。并且面向 JDBC 的异常与 Spring 通用数 据访问对象(Data Access Object)异常等级相一致。 以资源容器,DAO 实现和事务策略等形式与 Hibernate,JDO 和 iBATIS SQL Maps 集成。利用众多的翻转控制方便特性来全面支持,解决了许多典型的 Hibernate 集成问题。所有这些全部遵从 Spring 通用事务处理和通用数据访问对 象异常等级规范。 灵活的基于核心 Spring 功能的 MVC 网页应用程序框架。 开发者通过策略 接口将拥有对该框架的高度控制,因而该框架将适应于多种呈现(View)技术, 例如 JSP,FreeMarker,Velocity,Tiles,iText 以及 POI。值得注意的是,Spring 中间层可以轻易地结合于任何基于 MVC 框架的网页层,例如 Struts, WebWork,或 Tapestry,提供诸如事务管理等服务的面向方面编程框架。 在设计应用程序 Model 时,MVC 模式(例如 Struts)通常难于给出一个简 洁明了的框架结构。Spring 却具有能够让这部分工作变得简单的能力。程序开发 员们可以使用 Spring 的 JDBC 抽象层重新设计那些复杂的框架结构。 Struts 技术介绍
47

Struts 项目是 Apache 软件基金会(ASF)赞助的一个开源项目。它最初是 Jakarta 项目中的一个子项目,并在 2004 年 3 月成为 ASF 的顶级项目。它通过采 用 Java Servlet/JSP 技术, 实现了基于 Java EE Web 应用的 Model-View-Controller 〔MVC〕设计模式的应用框架〔Web Framework〕,是 MVC 经典设计模式中的 一个经典产品。 MVC 结构在 Struts 中,已经由一个名为 ActionServlet 的 Servlet 充当 控制 器 (Controller) 的角色, 根据描述模型、 视图、 控制器对应关系的 struts-config.xml 的配置文件,转发视图(View)的请求,组装响应数据模型(Model)。在 MVC 的 模型(Model)部分,经常划分为两个主要子系统(系统的内部数据状态与 改变数据状态的逻辑动作),这两个概念子系统分别具体对应 Struts 里的 ActionForm 与 Action 两个需要继承实现超类。在这里,Struts 可以与各种标准的 数据访问技术结合在一起,包括 Enterprise Java Beans(EJB), JDBC 与 JNDI。 在 Struts 的视图(View)端,除了使用标准的 JavaServer Pages(JSP)以外,还 提供了大量的标签库使用, 同时也可以与其他表现层组件技术 (产品) 进行整合, 比如 Velocity Templates,XSLT 等。通过应用 Struts 的框架,最终用户可以把大 部分的关注点放在自己的业务逻辑(Action)与 映射关系的配置文件 (struts-config.xml)中。 发展历程在 Java EE 的 Web 应用发展的初期,除了使用 Servlet 技术以外, 普遍是在 JavaServer Pages(JSP)的源代码中,采用 HTML 与 Java 代码混合的 方式进行开发。因为这两种方式不可避免的要把表现与业务逻辑代码混合在一 起,都给前期开发与后期维护带来巨大的复杂度。为了摆脱上述的约束与局限, 把业务逻辑代码从表现层中清晰的分离出来, 2000 年, Craig McClanahan 采用了 MVC 的设计模式开发 Struts。 后来该框架产品一度被认为是最广泛、 最流行 JAVA 的 WEB 应用框架。 Struts 2 的合并示意图 2006 年, WebWork 与 Struts 这两个优秀的 Java EE Web 框架(Web Framework〕的团体,决定合作共同开发一个新的,整合了 WebWork 与 Struts 优点,并且更加优雅、扩展性更强的框架,命名为“Struts 2”,原 Struts 的 1.x 版本产品称为“Struts 1”。至此,Struts 项目并行提供与维护两个主要版 本的框架产品——Struts 1 与 Struts 2。很多开发人员认为 Struts 目前尚不成熟,
48

应用的成本较高。 附带的一点点建议: Struts 的优点主要集中体现在两个方面: Taglib 和页面导航。Taglib 是 Struts 的标记库,灵活动用,能大大提高开发效率。 Struts 这个名字来源于在建筑和旧式飞机中使用的支持金属架。它的目的是为了 减少在运用 MVC 设计模型来开发 Web 应用的时间。你仍然需要学习和应用该 架构,不过它将可以完成其中一些繁重的工作。Struts 跟 Tomcat、Turbine 等诸 多 Apache 项目一样,是开源软件,这是它的一大优点,使开发者能更深入的了 解其内部实现机制。 Hibernate 开源框架介绍 Hibernate 是一种 Java 语言下的对象关系映射解决方案。 它是使用 GNU 宽 通用公共许可证发行的自由、 开源的软件。它为面向对象的领域模型到传统的关 系型数据库的映射,提供了一个使用方便的框架。 概览它的设计目标是将软件 开发人员从大量相同的数据持久层相关编程工作中解放出来。 无论是从设计草案 还是从一个遗留数据库开始,开发人员都可以采用 Hibernate。 Hibernate 不仅负责从 Java 类到数据库表的映射(还包括从 Java 数据类型到 SQL 数据类型的映射),还提供了面向对象的数据查询检索机制,从而极大地 缩短的手动处理 SQL 和 JDBC 上的开发时间。 .NET 上的 HibernateHibernate 有 个在 .NET Framework 上的实现版本,称为 NHibernate,在 ADO.NET Entity Framework 发表之前, NHibernate 是在 .NET Framework 上经常被使用的 ORM 实现。 Hibernate 的架构有三个主要部分组成: 1 连接管理:Hibernate 的连接管理服务提供的数据库连接的有效管理。数据 库连接是与数据库进行交互, 因为它需要大量资源的开放和关闭数据库连接的最 昂贵的部分。 2 交易管理:事务管理服务提供给用户能够同时执行多个数据库报表。 3 对象关系映射:对象关系映射是从对象映射模型的数据表示为关系数据模 型的技术。这部分是用来休眠选择,插入,更新和删除记录窗体的基础表。当我 们传递一个对象到 Session.save()的方法时,Hibernate 读取该对象的变量的状 态,并执行必要的查询。 Hibernate 是很好的工具尽可能对象关系映射的关注,但在连接管理和事务管
49

理方面, 它在性能和能力缺乏。 所以通常冬眠与其他正在使用的连接管理和事务 管理工具。例如 Apache 的二溴氯丙烷是用于与 Hibernate 的连接池。Hibernate 提供了使用中的灵活性。它被称为―轻型‖的体系结构时,我们只使用对象关系映 射的组成部分。而在―全面解决‖的体系结构的所有三个组件对象关系映射,连接 管理和事务管理)的使用。

50

原文:

Java Technology and SSH Frame
Duke, the Java mascotJames Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991. Java was originally designed for interactive television, but it was too advanced for the digital cable television industry at the time. The language was initially called Oak after an oak tree that stood outside Gosling's office; it went by the name Green later, and was later renamed Java, from a list of random words.Gosling aimed to implement a virtual machine and a language that had a familiar C/C++ style of notation. Sun Microsystems released the first public implementation as Java 1.0 in 1995. It promised "Write Once, Run Anywhere" (WORA), providing no-cost run-times on popular platforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998–1999), new versions had multiple configurations built for different types of platforms. For example, J2EE targeted enterprise applications and the greatly stripped-down version J2ME for mobile applications (Mobile Java). J2SE designated the Standard Edition. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively. In 1997, Sun Microsystems approached the ISO/IEC JTC1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a de facto standard, controlled through the Java Community Process. At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System. Sun distinguishes between its Software Development Kit (SDK) and Runtime Environment (JRE) (a subset of the SDK); the primary distinction involves the JRE's lack of the compiler, utility programs, and header files.On November 13, 2006, Sun released much of Java as open source software under the terms of the GNU General Public License (GPL). On May 8, 2007, Sun finished the process, making all of Java's core code available under free software/open-source distribution terms, aside from a
51

small portion of code to which Sun did not hold the copyright.Sun's vice-president Rich Green has said that Sun's ideal role with regards to Java is as an "evangelist." Following Oracle Corporation's acquisition of Sun Microsystems in 2009–2010, Oracle has described itself as the "steward of Java technology with a relentless commitment to fostering a community of participation and transparency". PrinciplesThere were five primary goals in the creation of the Java language:1.It should be "simple, object oriented, and familiar"、2.It should be "robust and secure". 3.It should be "architecture neutral and portable"、4.It should execute with "high performance"、5.It should be "interpreted, threaded, and dynamic". Java PlatformMain articles: Java (software platform) and Java Virtual Machine One characteristic of Java is portability, which means that computer programs written in the Java language must run similarly on any supported hardware/operating-system platform. This is achieved by compiling the Java language code to an intermediate representation called Java bytecode, instead of directly to platform-specific machine code. Java bytecode instructions are analogous to machine code, but are intended to be interpreted by a virtual machine (VM) written specifically for the host hardware. End-users commonly use a Java Runtime Environment (JRE) installed on their own machine for standalone Java applications, or in a Web browser for Java applets. Standardized libraries provide a generic way to access host-specific features such as graphics, threading, and networking. A major benefit of using bytecode is porting. However, the overhead of interpretation means that interpreted programs almost always run more slowly than programs compiled to native executables would. Just-in-Time compilers were introduced from an early stage that compile bytecodes to machine code during runtime.ImplementationsSun Microsystems officially licenses the Java Standard Edition platform for Linux, Mac OS X, and Solaris. Although in the past Sun has licensed Java to Microsoft, the license has expired and has not been renewed. Through a network of third-party vendors and licensees, alternative Java environments are available for these and other platforms. Sun's trademark license for usage of the Java brand insists that all implementations be "compatible". This resulted in a legal dispute with Microsoft after Sun claimed that the Microsoft implementation did not support RMI or JNI and had added platform-specific features of their own. Sun sued in 1997, and in 2001 won a settlement of US$20 million, as well as a court order enforcing the terms of the license from Sun. As a result, Microsoft no longer ships Java with Windows, and in
52

recent versions of Windows, Internet Explorer cannot support Java applets without a third-party plugin. Sun, and others, have made available free Java run-time systems for those and other versions of Windows.Platform-independent Java is essential to the Java EE strategy, and an even more rigorous validation is required to certify an implementation. This environment enables portable server-side applications, such as Web services, Java Servlets, and Enterprise JavaBeans, as well as with embedded systems based on OSGi, using Embedded Java environments. Through the new GlassFish project, Sun is working to create a fully functional, unified open source implementation of the Java EE technologies.Sun also distributes a superset of the JRE called the Java Development Kit (commonly known as the JDK), which includes development tools such as the Java compiler, Javadoc, Jar, and debugger. Java performance and garbage collectors: Programs written in Java have a reputation for being slower and requiring more memory than those written in C. However, Java programs' execution speed improved significantly with the introduction of Just-in-time compilation in 1997/1998 for Java 1.1, the addition of language features supporting better code analysis (such as inner classes, StringBuffer class, optional assertions, etc.), and optimizations in the Java Virtual Machine itself, such as HotSpot becoming the default for Sun's JVM in 2000. Currently, Java code has approximately half the performance of C code. Some platforms offer direct hardware support for Java; there are microcontrollers that can run java in hardware instead of a software JVM, and ARM based processors can have hardware support for executing Java bytecode through its Jazelle option. Automatic memory managementJava uses an automatic garbage collector to manage memory in the object lifecycle. The programmer determines when objects are created, and the Java runtime is responsible for recovering the memory once objects are no longer in use. Once no references to an object remain, the unreachable memory becomes eligible to be freed automatically by the garbage collector. Something similar to a memory leak may still occur if a programmer's code holds a reference to an object that is no longer needed, typically when objects that are no longer needed are stored in containers that are still in use. If methods for a nonexistent object are called, a "null pointer exception" is thrown. One of the ideas behind Java's automatic memory management model is that programmers can be spared the burden of having to perform manual memory management. In some languages, memory for the creation of objects is implicitly allocated on the stack, or explicitly allocated and deallocated from the heap. In the
53

latter case the responsibility of managing memory resides with the programmer. If the program does not deallocate an object, a memory leak occurs. If the program attempts to access or deallocate memory that has already been deallocated, the result is undefined and difficult to predict, and the program is likely to become unstable and/or crash. This can be partially remedied by the use of smart pointers, but these add overhead and complexity. Note that garbage collection does not prevent "logical" memory leaks, i.e. those where the memory is still referenced but never used. Garbage collection may happen at any time. Ideally, it will occur when a program is idle. It is guaranteed to be triggered if there is insufficient free memory on the heap to allocate a new object; this can cause a program to stall momentarily. Explicit memory management is not possible in Java. Java does not support C/C++ style pointer arithmetic, where object addresses and unsigned integers (usually long integers) can be used interchangeably. This allows the garbage collector to relocate referenced objects and ensures type safety and security. As in C++ and some other object-oriented languages, variables of Java's primitive data types are not objects. Values of primitive types are either stored directly in fields (for objects) or on the stack (for methods) rather than on the heap, as commonly true for objects (but see Escape analysis). This was a conscious decision by Java's designers for performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their wrapper class. Java contains multiple types of garbage collectors. By default, HotSpot uses the Concurrent Mark Sweep collector, also known as the CMS Garbage Collector. However, there are also several other garbage collectors that can be used to manage the Heap. For 90% of applications in Java, the CMS Garbage Collector is good enough. A class that is not declared public may be stored in any .java file. The compiler will generate a class file for each class defined in the source file. The name of the class file is the name of the class, with .class appended. For class file generation, anonymous classes are treated as if their name were the concatenation of the name of their enclosing class, a $, and an integer. The keyword public denotes that a method can be called from code in other classes, or that a class may be used by classes outside the class hierarchy. The class hierarchy is related to the name of the directory in which the .java file is located. The keyword static in front of a method indicates a static method, which is
54

associated only with the class and not with any specific instance of that class. Only static methods can be invoked without a reference to an object. Static methods cannot access any method variables that are not static. The keyword void indicates that the main method does not return any value to the caller. If a Java program is to exit with an error code, it must call System.exit() explicitly. The method name "main" is not a keyword in the Java language. It is simply the name of the method the Java launcher calls to pass control to the program. Java classes that run in managed environments such as applets and Enterprise JavaBean do not use or need a main() method. A java program may contain multiple classes that have main methods, which means that the VM needs to be explicitly told which class to launch from. The main method must accept an array of String objects. By convention, it is referenced as args although any other legal identifier name can be used. Since Java 5, the main method can also use variable arguments, in the form of public static void main(String... args), allowing the main method to be invoked with an arbitrary number of String arguments. The effect of this alternate declaration is semantically identical (the args parameter is still an array of String objects), but allows an alternative syntax for creating and passing the array. The Java launcher launches Java by loading a given class (specified on the command line or as an attribute in a JAR) and starting its public static void main(String[]) method. Stand-alone programs must declare this method explicitly. The String[] args parameter is an array of String objects containing any arguments passed to the class. The parameters to main are often passed by means of a command line. Criticism of Java: A number of criticisms have been leveled at Java programming language for various design choices in the language and platform. Such criticisms include the implementation of generics, the handling of unsigned numbers, the implementation of floating-point arithmetic, and security vulnerabilities. Class libraries: Java Platform and Class libraries diagramJava libraries are the compiled bytecodes of source code developed by the JRE implementor to support application development in Java. Examples of these libraries are: The core libraries, which include:
55

Collection libraries that implement data structures such as lists, dictionaries, trees, sets, queues and double-ended queue, or stacks XML Processing (Parsing, Transforming, Validating) libraries Security Internationalization and localization libraries The integration libraries, which allow the application writer to communicate with external systems. These libraries include: The Java Database Connectivity (JDBC) API for database access Java Naming and Directory Interface (JNDI) for lookup and discovery RMI and CORBA for distributed application development JMX for managing and monitoring applications User interface libraries, which include: The (heavyweight, or native) Abstract Window Toolkit (AWT), which provides GUI components, the means for laying out those components and the means for handling events from those components The (lightweight) Swing libraries, which are built on AWT but provide (non-native) implementations of the AWT widgetry APIs for audio capture, processing, and playback A platform dependent implementation of Java Virtual Machine (JVM) that is the means by which the byte codes of the Java libraries and third party applications are executed Plugins, which enable applets to be run in Web browsers Java Web Start, which allows Java applications to be efficiently distributed to end-users across the Internet Licensing and documentation. DocumentationMain article: Javadoc Javadoc is a comprehensive documentation system, created by Sun Microsystems, used by many Java developers. It provides developers with an organized system for documenting their code. Javadoc comments have an extra asterisk at the beginning, i.e. the tags are /** and */, whereas the normal multi-line comment tags comments in Java and C are set off with /* and */. Sun has defined and supports four editions of Java targeting different application environments and segmented many of its APIs so that they belong to one of the platforms. The platforms are:Java Card for smartcards.、Java Platform, Micro Edition (Java ME) — targeting environments with limited resources、Java Platform, Standard
56

Edition (Java SE) — targeting workstation environments、Java Platform, Enterprise Edition (Java EE) — targeting large distributed enterprise or Internet environments. The classes in the Java APIs are organized into separate groups called packages. Each package contains a set of related interfaces, classes and exceptions. Refer to the separate platforms for a description of the packages available.The set of APIs is controlled by Sun Microsystems in cooperation with others through the Java Community Process program. Companies or individuals participating in this process can influence the design and development of the APIs. This process has been a subject of controversy. Sun also provided an edition called PersonalJava that has been superseded by later, standards-based Java ME configuration-profile pairings. Spring Framework The Spring Framework is an open source application framework for the Java platform. The first version was written by Rod Johnson who released the framework with the publication of his book Expert One-on-One J2EE Design and Development in October 2002. The framework was first released under the Apache 2.0 license in June 2003. The first milestone release, 1.0, was released in March 2004, with further milestone releases in September 2004 and March 2005. The Spring 1.2.6 framework won a Jolt productivity award and a JAX Innovation Award in 2006. Spring 2.0 was released in October 2006, and Spring 2.5 in November 2007. In December 2009 version 3.0 GA was released. The current version is 3.0.5. The core features of the Spring Framework can be used by any Java application, but there are extensions for building web applications on top of the Java EE platform. Although the Spring Framework does not impose any specific programming model, it has become popular in the Java community as an alternative to, replacement for, or even addition to the Enterprise JavaBean (EJB) model. ModulesThe Spring Framework comprises several modules that provide a range of services: Inversion of Control container: configuration of application components and lifecycle management of Java objects Aspect-oriented programming: enables implementation of cross-cutting routines Data access: working with relational database management systems on the Java platform using JDBC and object-relational mapping tools Transaction management: unifies several transaction management APIs and coordinates transactions for Java objects
57

Model-view-controller: an HTTP and Servlet-based framework providing hooks for extension and customization Remote Access framework: configurative RPC-style export and import of Java objects over networks supporting RMI, CORBA and HTTP-based protocols including web services (SOAP) Convention-over-configuration: a rapid application development solution for Spring-based enterprise applications is offered in the Spring Roo module Batch processing: a framework for high-volume processing featuring reusable functions including logging/tracing, transaction management, job processing statistics, job restart, skip, and resource management Authentication and authorization: configurable security processes that support a range of standards, protocols, tools and practices via the Spring Security sub-project (formerly Acegi Security System for Spring). Remote Management: configurative exposure and management of Java objects for local or remote configuration via JMX Messaging: configurative registration of message listener objects for transparent message consumption from message queues via JMS, improvement of message sending over standard JMS APIs Testing: support classes for writing unit tests and integration tests Inversion of Control containerCentral to the Spring Framework is its Inversion of Control container, which provides a consistent means of configuring and managing Java objects using callbacks. The container is responsible for managing object lifecycles: creating objects, calling initialization methods, and configuring objects by wiring them together. Objects created by the container are also called Managed Objects or Beans. Typically, the container is configured by loading XML files containing Bean definitions which provide the information required to create the beans. Objects can be obtained by means of Dependency lookup or Dependency injection. Dependency lookup is a pattern where a caller asks the container object for an object with a specific name or of a specific type. Dependency injection is a pattern where the container passes objects by name to other objects, via either constructors, properties, or factory methods. In many cases it's not necessary to use the container when using other parts of the Spring Framework, although using it will likely make an application easier to configure and customize. The Spring container provides a consistent mechanism to
58

configure applications and integrates with almost all Java environments, from small-scale applications to large enterprise applications. The container can be turned into a partially-compliant EJB3 container by means of the Pitchfork project. The Spring Framework is criticized by some as not being standards compliant. However, SpringSource doesn't see EJB3 compliance as a major goal, and claims that the Spring Framework and the container allow for more powerful programming models. Aspect-oriented programming frameworkThe Spring Framework has its own AOP framework which modularizes cross-cutting concerns in aspects. The motivation for creating a separate AOP framework comes from the belief that it would be possible to provide basic AOP features without too much complexity in either design, implementation, or configuration. The SAOP framework also takes full advantage of the Spring Container. The Spring AOP framework is interception based, and is configured at runtime. This removes the need for a compilation step or load-time weaving. On the other hand, interception only allows for public or protected method execution on existing objects at a join point. Compared to the AspectJ framework, Spring AOP is less powerful but also less complicated. Spring 1.2 includes support to configure AspectJ aspects in the container. Spring 2.0 added more integration with AspectJ; for example, the pointcut language is reused and can be mixed with SpAOP-based aspects. Further, Spring 2.0 added a Spring Aspects library which uses AspectJ to offer common Spring features such as declarative transaction management and dependency injection via AspectJ compile-time or load-time weaving. SpringSource also uses AspectJ for AOP in other Spring projects such as Spring Roo and Spring Insight, with Spring Security also offering an AspectJ-based aspect library. Spring AOP has been designed to make it able to work with cross-cutting concerns inside the Spring Framework. Any object which is created and configured by the container can be enriched using Spring AOP. The Spring Framework uses Spring AOP internally for transaction management, security, remote access, and JMX. Since version 2.0 of the framework, Spring provides two approaches to the AOP configuration:schema-based approach.@AspectJ-based annotation style. The Spring team decided not to introduce new AOP-related terminology; therefore, in the Spring reference documentation and API, terms such as aspect, join point,
59

advice, pointcut, introduction, target object (advised object), AOP proxy, and weaving all have the same meanings as in most other AOP frameworks (particularly AspectJ). Data access frameworkSpring's data access framework addresses common difficulties developers face when working with databases in applications. Support is provided for all popular data access frameworks in Java: JDBC, iBatis, Hibernate, JDO, JPA, Oracle TopLink, Apache OJB, and Apache Cayenne, among others. For all of these supported frameworks, Spring provides these features: Resource management - automatically acquiring and releasing database resources Exception handling - translating data access related exception to a Spring data access hierarchy Transaction participation - transparent participation in ongoing transactions Resource unwrapping - retrieving database objects from connection pool wrappers Abstraction for BLOB and CLOB handling All these features become available when using Template classes provided by Spring for each supported framework. Critics say these Template classes are intrusive and offer no advantage over using (for example) the Hibernate API.. directly. In response, the Spring developers have made it possible to use the Hibernate and JPA APIs directly. This however requires transparent transaction management, as application code no longer assumes the responsibility to obtain and close database resources, and does not support exception translation. Together with Spring's transaction management, its data access framework offers a flexible abstraction for working with data access frameworks. The Spring Framework doesn't offer a common data access API; instead, the full power of the supported APIs is kept intact. The Spring Framework is the only framework available in Java which offers managed data access environments outside of an application server or container. While using Spring for transaction management with Hibernate, the following beans may have to be configured. Transaction management frameworkSpring's transaction management framework brings an abstraction mechanism to the Java platform. Its abstraction is capable of working with local and global transactions (local transaction does not require an application server).working with nested transactions.working with transaction safepoints.working in almost all environments of the Java platform In comparison, JTA only supports nested transactions and global transactions, and requires an application server (and in some cases also deployment of applications in an application server).
60

The Spring Framework ships a PlatformTransactionManager for a number of transaction management strategies: Transactions managed on a JDBC Connection Transactions managed on Object-relational mapping Units of Work Transactions managed via the JTA TransactionManager and UserTransaction Transactions managed on other resources, like object databases Next to this abstraction mechanism the framework also provides two ways of adding transaction management to applications: Programmatically, by using Spring's TransactionTemplate Configuratively, by using metadata like XML or Java 5 annotations Together with Spring's data access framework — which integrates the transaction management framework — it is possible to set up a transactional system through configuration without having to rely on JTA or EJB. The transactional framework also integrates with messaging and caching engines. The BoneCP Spring/Hibernate page contains a full example project of Spring used in conjunction with Hibernate. Model-view-controller frameworkThe Spring Framework features its own MVC framework, which wasn't originally planned. The Spring developers decided to write their own web framework as a reaction to what they perceived as the poor design of the popular Jakarta Struts web framework, as well as deficiencies in other available frameworks. In particular, they felt there was insufficient separation between the presentation and request handling layers, and between the request handling layer and the model. Like Struts, Spring MVC is a request-based framework. The framework defines strategy interfaces for all of the responsibilities which must be handled by a modern request-based framework. The goal of each interface is to be simple and clear so that it's easy for Spring MVC users to write their own implementations if they so choose. MVC paves the way for cleaner front end code. All interfaces are tightly coupled to the Servlet API. This tight coupling to the Servlet API is seen by some as a failure on the part of the Spring developers to offer a high-level abstraction for web-based applications[citation needed]. However, this coupling makes sure that the features of the Servlet API remain available to developers while offering a high abstraction framework to ease working with said API. The DispatcherServlet class is the front controller of the framework and is responsible for delegating control to the various interfaces during the execution
61

phases of a HTTP request. The most important interfaces defined by Spring MVC, and their responsibilities, are listed below: HandlerMapping: selecting objects which handle incoming requests (handlers) based on any attribute or condition internal or external to those requests HandlerAdapter: execution of objects which handle incoming requests Controller: comes between Model and View to manage incoming requests and redirect to proper response. It essentially is like a gate that directs the incoming information. It switches between going into model or view. View: responsible for returning a response to the client. It is possible to go straight to view without going to the model part. It is also possible to go through all three. ViewResolver: selecting a View based on a logical name for the view (use is not strictly required) HandlerInterceptor: interception of incoming requests comparable but not equal to Servlet filters (use is optional and not controlled by DispatcherServlet). LocaleResolver: resolving and optionally saving of the locale of an individual user MultipartResolver: facilitate working with file uploads by wrapping incoming requests Each strategy interface above has an important responsibility in the overall framework. The abstractions offered by these interfaces are powerful, so to allow for a set of variations in their implementations, Spring MVC ships with implementations of all these interfaces and together offers a feature set on top of the Servlet API. However, developers and vendors are free to write other implementations. Spring MVC uses the Java java.util.Map interface as a data-oriented abstraction for the Model where keys are expected to be string values. The ease of testing the implementations of these interfaces seems one important advantage of the high level of abstraction offered by Spring MVC. DispatcherServlet is tightly coupled to the Spring Inversion of Control container for configuring the web layers of applications. However, applications can use other parts of the Spring Framework—including the container—and choose not to use Spring MVC. Because Spring MVC uses the Spring container for configuration and assembly, web-based applications can take full advantage of the Inversion of Control features offered by the container. This framework allows for multilayering. It allows for the code to be broken apart and used more effectively in segments, while allowing the mvc to do the work. It allows for back and forth transmission of data. Some designs
62

are more linear without allowing a forward and backward flow of information. MVC is designed very nicely to allow this interaction. It is used more than just in web design, but also in computer programming. It's very effective for web design. Basically allows a checks and balance system to occur where before being viewed it can be properly examined. Remote access frameworkSpring's Remote Access framework is an abstraction for working with various RPC-based technologies available on the Java platform both for client connectivity and exporting objects on servers. The most important feature offered by this framework is to ease configuration and usage of these technologies as much as possible by combining Inversion of Control and AOP. The framework also provides fault-recovery (automatic reconnection after connection failure) and some optimizations for client-side use of EJB remote stateless session beans. Convention-Over-Configuration Rapid Application DevelopmentSpring Roo is Spring's Convention-over-configuration solution for rapidly building applications in Java. It currently supports Spring Framework, Spring Security and Spring Web Flow, with remaining Spring projects scheduled to be added in due course. Roo differs from other rapid application development frameworks by focusing on: The following diagram represents the Spring Framework Architecture Struts Introduction Apache StrutsFrom Wikipedia, the free encyclopediaJump to: navigation, search "Struts" redirects here. For the structural component, see strut. For other meanings, see strut (disambiguation). This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. Please help to improve this article by introducing more precise citations where appropriate. Apache Struts is an open-source web application framework for developing Java EE web applications. It uses and extends the Java Servlet API to encourage developers to adopt a model-view-controller (MVC) architecture. It was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000. Formerly located under the Apache Jakarta Project and known as Jakarta Struts, it became a top level Apache project in 2005. Design goals and overviewIn a standard Java EE web application, the client will typically submit information to the server via a web form. The information is then
63

either handed over to a Java Servlet that processes it, interacts with a database and produces an HTML-formatted response, or it is given to a JavaServer Pages (JSP) document that intermingles HTML and Java code to achieve the same result. Both approaches are often considered inadequate for large projects because they mix application logic with presentation and make maintenance difficult. The goal of Struts is to separate the model (application logic that interacts with a database) from the view (HTML pages presented to the client) and the controller (instance that passes information between view and model). Struts provides the controller (a servlet known as ActionServlet) and facilitates the writing of templates for the view or presentation layer (typically in JSP, but XML/XSLT and Velocity are also supported). The web application programmer is responsible for writing the model code, and for creating a central configuration file struts-config.xml that binds together model, view and controller. Requests from the client are sent to the controller in the form of "Actions" defined in the configuration file; if the controller receives such a request it calls the corresponding Action class that interacts with the application-specific model code. The model code returns an "ActionForward", a string telling the controller what output page to send to the client. Information is passed between model and view in the form of special JavaBeans. A powerful custom tag library allows it to read and write the content of these beans from the presentation layer without the need for any embedded Java code. Struts is categorized as a request-based web application framework.Struts also supports internationalization by web forms, and includes a template mechanism called "Tiles" that (for instance) allows the presentation layer to be composed from independent header, footer, and content components.HistoryThe Apache Struts Project was launched in May 2000 by Craig R. McClanahan to provide a standard MVC framework to the Java community. In July 2001, version 1.0 was released. Struts 2 was originally known as WebWork 2. After having been developed separately for several years, WebWork and Struts were combined in 2008 to create Struts 2. Competing MVC frameworksAlthough Struts is a well-documented, mature, and popular framework for building front ends to Java applications, there are other frameworks categorized as "lightweight" MVC frameworks such as Spring MVC, Stripes, Wicket, Play!, and Tapestry. The new XForms standards and frameworks may also be another option to building complex web Form validations with Struts in the
64

future. The WebWork framework spun off from Apache Struts aiming to offer enhancements and refinements while retaining the same general architecture of the original Struts framework. However, it was announced in December 2005 that Struts would re-merge with WebWork. WebWork 2.2 has been adopted as Apache Struts2, which reached its first full release in February 2007. In 2004 Sun launched an addition to the Java platform, called JavaServer Faces (JSF). Aside from the original Struts framework, the Apache project previously offered a JSF-based framework called Shale, which was retired in May 2009. In this section we will discuss about Architecture. Struts is famous for its robust Architecture and it is being used for developing small and big software projects. Struts is an open source framework used for developing J2EE web applications using Model View Controller (MVC) design pattern. It uses and extends the Java Servlet API to encourage developers to adopt an MVC architecture. Struts framework provides three key components: A request handler provided by the application developer that is used to resource which will be responsible for completing the response. A tag library which helps developers to create the interactive form based applications with server pages.Learn Struts 2.2.1 framework!Struts provides you the basic infrastructure infrastructure for implementing MVC allowing the developers to concentrate on the business logic.The main aim of the MVC architecture is to separate the business logic and application data from the presentation data to the user. Here are the reasons why we should use the MVC design pattern.They are resuable : When the problems recurs, there is no need to invent a new solution, we just have to follow the pattern and adapt it as necessary. They are expressive: By using the MVC design pattern our application becomes more expressive. 1). Model: The model object knows about all the data that need to be displayed. It is model who is aware about all the operations that can be applied to transform that object. It only represents the data of an application. The model represents enterprise data and the business rules that govern access to and updates of this data. Model is not aware about the presentation data and how that data will be displayed to the browser. 2). View : The view represents the presentation of the application. The view object refers to the model. It uses the query methods of the model to obtain the contents and renders it. The view is not dependent on the application logic. It remains same if there
65

mapped

to a particular URI. A response handler which is used to transfer the control to another

is any modification in the business logic. In other words, we can say that it is the responsibility of the of the view's to maintain the consistency in its presentation when the model changes. 3). Controller: Whenever the user sends a request for something then it always go through the controller. The controller is responsible for intercepting the requests from view and passes it to the model for the appropriate action. After the action has been taken on the data, the controller is responsible for directing the appropriate view to the user. In GUIs, the views and the controllers often work very closely together. The Struts framework is composed of approximately 300 classes and interfaces which are organized in about 12 top level packages. Along with the utility and helper classes framework also provides the classes and interfaces for working with controller and presentation by the help of the custom tag libraries. It is entirely on to us which model we want to choose. The view of the Struts architecture is given below: The Struts Controller Components:Whenever a user request for something, then the request is handled by the Struts Action Servlet. When the ActionServlet receives the request, it intercepts the URL and based on the Struts Configuration files, it gives the handling of the request to the Action class. Action class is a part of the controller and is responsible for communicating with the model layer. The Struts View Components: The view components are responsible for presenting information to the users and accepting the input from them. They are responsible for displaying the information provided by the model components. Mostly we use the Java Server Pages (JSP) for the view presentation. To extend the capability of the view we can use the Custom tags, java script etc. The Struts model component:The model components provides a model of the business logic behind a Struts program. It provides interfaces to databases or backends systems. Model components are generally a java class. There is not any such defined format for a Model component, so it is possible for us to reuse Java code which are written for other projects. We should choose the model according to our client requirement. Hibernate FrameWork: Hibernate is an object-relational mapping (ORM) library for the Java language, providing a framework for mapping an object-oriented domain model to a traditional relational database. Hibernate solves object-relational impedance mismatch problems by replacing direct persistence-related database accesses with high-level object handling functions.
66

Hibernate is free software that is distributed under the GNU Lesser General Public License.Hibernate's primary feature is mapping from Java classes to database tables (and from Java data types to SQL data types). Hibernate also provides data query and retrieval facilities. Hibernate generates the SQL calls and attempts to relieve the developer from manual result set handling and object conversion and keep the application portable to all supported SQL databases with little performance overhead. Mapping Java classes to database tables is accomplished through the configuration of an XML file or by using Java Annotations. When using an XML file, Hibernate can generate skeletal source code for the persistence classes. This is unnecessary when annotation is used. Hibernate can use the XML file or the annotation to maintain the database schema. Facilities to arrange one-to-many and many-to-many relationships between classes are provided. In addition to managing association between objects, Hibernate can also manage reflexive associations where an object has a one-to-many relationship with other instances of its own type. Hibernate supports the mapping of custom value types. This makes the following scenarios possible: Overriding the default SQL type that Hibernate chooses when mapping a column to a property. Mapping Java Enum to columns as if they were regular properties. Mapping a single property to multiple columns. PersistenceHibernate provides transparent persistence for Plain Old Java Objects (POJOs). The only strict requirement for a persistent class is a no-argument constructor, not necessarily public. Proper behavior in some applications also requires special attention to the equals() and hashCode() methods. Collections of data objects are typically stored in Java collection objects such as Set and List. Java generics, introduced in Java 5, are supported. Hibernate can be configured to lazy load associated collections. Lazy loading is the default as of Hibernate 3.Related objects can be configured to cascade operations from one to the other. For example, a parent such as an Album object can be configured to cascade its save and/or delete operation to its child Track objects. This can reduce development time and ensure referential integrity. A dirty checking feature avoids unnecessary database write actions by performing SQL updates only on the modified fields of persistent objects.Hibernate Query Language (HQL)Hibernate provides an SQL inspired language called Hibernate Query Language (HQL) which allows SQL-like
67

queries to be written against Hibernate's data objects. Criteria Queries are provided as an object-oriented alternative to HQL. IntegrationHibernate can be used both in standalone Java applications and in Java EE applications using servlets or EJB session beans. It can also be included as a feature in other programming languages. For example, Adobe integrated Hibernate into version 9 of ColdFusion (which runs on J2EE app servers) with an abstraction layer of new functions and syntax added into CFML.Entities and componentsIn Hibernate jargon, an entity is a stand-alone object in Hibernate's persistent mechanism which can be manipulated independently of other objects. In contrast, a component is subordinate to other entities and can be manipulated only with respect to other entities. For example, an Album object may represent an entity but the Tracks object associated with the Album objects would represent a component of the Album entity if it is assumed that Tracks can only be saved or retrieved from the database through the Album object. Unlike J2EE, it can switch databases.HistoryHibernate was started in 2001 by Gavin King as an alternative to using EJB2-style entity beans. Its mission back then was to simply offer better persistence capabilities than offered by EJB2 by simplifying the complexities and allowing for missing features.Early in 2003, the Hibernate development team began Hibernate2 releases which offered many significant improvements over the first release.JBoss, Inc. (now part of Red Hat) later hired the lead Hibernate developers and worked with them in supporting Hibernate. As of 2010 update the current version of Hibernate is Version 3.x. This version introduced new features like a new Interceptor/Callback architecture, user defined filters, and JDK 5.0 Annotations (Java's metadata feature). As of 2010[update] Hibernate 3 (version 3.5.0 and up) is a certified implementation of the Java Persistence API 2.0 specification via a wrapper for the Core module which provides conformity with the JSR 317 standard.Application programming interface.A session is intended to last as long as the logical transaction on the database. Due to the latter feature Session implementations are not expected to be threadsafe nor to be used by multiple clients.

68


相关文章:
本科生毕业设计(论文)模板2017.doc
本科生毕业设计(论文)模板2017 - 方正小标宋简体,小初,居中 本科生毕业设计(论文) 题目:黑体,小二。 题 仿宋, 三号, 加粗,学生 姓名、 学号、 院系、专业...
本科生毕业设计手册.pdf
本科生毕业设计手册 - 中国石油大学胜利学院 本科生毕业设计(论文)手册 题 目
本科生毕业设计过程管理手册 -王协平_图文.pdf
本科生毕业设计过程管理手册 -王协平 - 本科生毕业设计(论文) 过程管理手册
如何做出一份高质量的毕业设计-本科生毕业设计指导书.doc
机电专业本科生毕业设计(设计类)指导讲座如何做出一份高质量的毕业设计 一、毕业设计工作量机电专业本科生毕业设计应交的内容和要求如下: 1.设计图纸:总量为 4 ...
中南大学本科生毕业设计题目一览表_图文.doc
中南大学本科生毕业设计题目一览表 - 中南大学本科生毕业设计题目一览表 学院:
2018本科生毕业设计格式要求.doc
2018本科生毕业设计格式要求_书信模板_表格/模板_实用文档。该文档主要是介绍了本科生毕业论文的方法 本科生毕业设计(论文)基本规范要求本科生毕业设计(论文)工作是...
本科生毕业设计(论文)工作记录本.doc
本科生毕业设计(论文)工作记录本 - 上海应用技术学院 SHANGHAI INSTITUTE OF TECHNOLOGY 本科生毕业设计(论文)工作 记录本 论文题目: 执行时间: 学生姓...
暨南大学关于本科生毕业设计(论文).txt
暨南大学关于本科生毕业设计(论文) - 暨南大学关于本科生毕业设计(论文) 工作的若干规定(试行) 本科生毕业设计(论文)教学过程是实现本科培养目标要求的重要教学环节...
本科生毕业设计要求简则.doc
本科生毕业设计要求简则 - 江西师范大学本科生毕业设计(论文)要求 毕业设计(论
西南石油大学本科生毕业设计(论文)撰写规范.pdf
西南石油大学本科生毕业设计(论文)撰写规范 - 西南石油大学本科生毕业设计(论文
上海交通大学关于本科生毕业设计(论文)工作的若干规定.doc
上海交通大学关于本科生毕业设计(论文) 上海交通大学关于本科生毕业设计(论文)工
关于指导本科生毕业设计的一点思考.pdf
关于指导本科生毕业设计的一点思考 - ! 短文选登 关于指导本科生毕业设计的一点
西安电子科技大学本科生毕业设计(论文)撰写规范.doc
西安电子科技大学本科生毕业设计(论文) 西安电子科技大学本科生毕业设计(论文)撰
华中科技大学本科生毕业设计(论文)规范化要求.doc
附录1: 本科生毕业设计(论文)规范化要求一、规范化要求的内容 (一)毕业设计(
西安电子科技大学本科生毕业设计(论文)撰写规范.doc
西安电子科技大学本科生毕业设计(论文)撰写规范 - 人生最大的幸福,是发现自己爱的人正好也爱着自己。 西安电子科技大学本科生毕业设计(论文)撰写规范 一. 毕业...
上海交通大学本科生毕业设计(论文)撰写规范.pdf
为了保证我校本科生毕业设计(论文)质量,特制定《上海 交通大学本科生毕业设计(论
福州大学本科生毕业设计(论文)撰写规范(二OO四年六月制.doc
福州大学本科生毕业设计(论文)撰写规范( 四年六月制定) 福州大学本科生毕业设计(论文)撰写规范(二 OO 四年六月制定) 2005-3-1 11:46:03 毕业设计(论文)是...
内蒙古科技大学本科生毕业设计.doc
内蒙古科技大学本科生毕业设计 - 内蒙古科技大学 本科生毕业设计说明书 题 目:
暨南大学关于本科生毕业设计(论文).txt
暨南大学关于本科生毕业设计(论文) - 本科生毕业设计(论文)教学过程是实现本科
本科生毕业设计规定.doc
本科生毕业设计规定 - 深圳大学本科生毕业论文(设计)工作规定 第一章 总则 第
更多相关标签: