java毕业设计—— 基于java+JSP+SSH的任务调度系统设计与实现（毕业论文+程序源码）——任务调度系统

基于java+JSP+SSH的任务调度系统设计与实现（毕业论文+程序源码）

大家好，今天给大家介绍基于java+JSP+SSH的任务调度系统设计与实现，文章末尾附有本毕业设计的论文和源码下载地址哦。需要下载开题报告PPT模板及论文答辩PPT模板等的小伙伴，可以进入我的博客主页查看左侧最下面栏目中的自助下载方法哦

文章目录：

1、项目简介

1. 本系统采用了B/S体系结构，主要实现语言是JAVA，后台数据库使用的是MySql。整个系统实现角色将分为组长和组员，实现功能包括帐号注册、修改信息、项目管理、任务管理、消息管理、团队管理等功能。本任务调度系统的设计实现可以远程实现任务的调度与科学分配，并通过评估各项任务与参与人员，来使项目更好的进行任务调度。

---

2、资源详情

项目难度：中等难度
适用场景：相关题目的毕业设计
配套论文字数：14923个字84页
包含内容：整套源码+完整毕业论文+答辩PPT+任务书+辅导视频+运行截图

---

3、关键词：

任务调度；B/S；SSH

---

4、毕设简介

提示：以下为毕业论文的简略介绍，项目源码及完整毕业论文下载地址见文末。

引言
省略

计算越复杂，计算机的优越性体现的越明显。在多任务的项目中，计算机可通过各类算法，如关键路径算法或多机调度算法，来进行任务评估和总体任务调度，计算机与人们的生产生活密切相关，故现在开发任务调度系统。本系统运用了当前的流行框架Spring，Struts2，Hibernate，保证了可扩展性与可维护性。

1.1 课题研究意义及背景
省略

本人开发这套基于SSH的任务调度系统，使团队协作与任务分派更加科学高效，进而促进企业经济效益的提高。

1.2 论文的目的及设计要求
任务调度系统主要目的是对企事业单位项目的任务集进行调度分配，敏捷高效地处理任何或大或小的项目。使项目小组的工作效率大大提高，工作成本大大降低。本系统开发主要包括调度算法的设计，后台程序的处理，后台数据库的建立和维护，和前端页面的展示开发。算法要求高效性和可实现性，后台要求业务逻辑的合理性与科学性，数据库要求数据的完整性和一致性，前台页面又要求美观性与功能完备性。正因为此，本人选择采用SSH三大框架的整合技术和MySQL数据库进行系统的开发。

本系统的实现角色将包括项目组长和项目组员这两个角色，用户可同时扮演两种角色，共有的功能包括修改登录密码、发起项目、删除项目、参与项目、添加任务、删除任务、添加成员、删除成员、处理消息。其中组长部分的功能还包括组员管理、更新项目，其中组员部分的功能还包括申请加入与申请退出。并且，不光保证实现这些功能，还得为本任务调度系统提供一个良好的人机交互，提高系统友好性。

2 研究现状及设计目标
2.1 任务调度系统的现状
省略

2.2 任务调度系统优缺点分析
省略

2.3现行研究存在的问题及解决方法
2.3.1 现行研究存在的问题
省略

2.3.2 解决办法
考虑到目前任务调度系统的需求与研究现状，想要解决上述问题应该从以下几方面的要求出发：
1．数据库选用MySql，足以保证数据存放的持久性，当存储设备改变时，不用重写程序代码就可以方便的移植过去。
2．系统实现模式采用B/S架构，实现过程也做到模块化，把用户界面与跳转逻辑分开，把业务信息又按应用功能分开，同时与数据交互层分开，任一方的改变都不会过多影响对方。
3．开发平台选用Eclipse，语言选用JAVA作为主要的开发语言，该语言一次编写随处运行以及强大的可伸缩性对于系统的开发和维护提供了强有力的保障。
4．设计一个能兼顾树状任务集纵横两个方向的调度算法，充分利用参与人员的时间空档，来缩短整个项目的完成时间

2.4 本课题要达到的设计目标
本课题采用B/S模式，面向或大或小的项目管理而开发的任务调度系统，为了系统的安全性，该系统只允许已经注册到该系统的用户使用。系统有两种角色：项目组长和项目组员。各用户可同时承担所有角色，各角色功能如下：

1.共有功能：
a、注册、登录功能，个人信息管理功能，如对密码的修改。
b、部分项目管理功能，实现了对项目的管理操作，包括对项目的搜索、查看操作。
c、部分任务管理功能，实现了对所有项目任务的管理操作，包括对任务集的查看操作。

2．项目组长：
a、具有管理组员、处理申请功能
b、具有部分项目管理功能，包括对项目的删除操作。
3．项目组员：
a、具有申请加入与退出项目组的功能。

2.5 经济效益分析
省略

3 关键问题及分析
省略

3.1 问题分析与设计
在本次系统的设计中，势必会遇到许多以前没遇到过的问题，会需要许多曾经没有接触过的技术去攻克难点。所以，现将研究设计中要解决的问题总结如下：

3.1.1 核心问题即任务调度
此次所研究的问题是在3个约束下使由树状任务集组合而成的项目所用时间尽可能短。3个约束指的是：(1)对于每个任务, 必须等待其所有的前继任务完成后才能处理此任务;(2)对于每个组员, 任意时刻只能进行一个任务, 且必须满足完成一个任务后才能开始另一个任务;(3)不存在相同任务。

1、任务树和任务分类
由于项目的任务图呈树状结构，仅仅边的方向与正常的树相反，姑且可称之为任务树。任务树上的结点代表任务，有向边代表任务之间的次序关系。其中，叶结点任务为刚开始就可被进行的任务，根结点任务为最终进行的任务。当根结点任务完成，标志着整个项目完成。

设有一个项目, 项目由N任务组成.这N个任务可绘制出树状结构。在某个任务完成后, 剩下的未完成任务仍可绘制出树状结构。由任务树和问题的约束条件可知, 初始时只能调度某个叶节点任务.当某个任务结点的所有子节点任务全部完成, 则此任务结点就转换为叶节点任务。 现在分类任务:可调度任务是属于某空闲组员的叶节点任务; 准可调度任务是属于某非空闲组员的叶结点任务;不可调度任务是所有非叶节点任务;所有可调度任务和准可调任务的任务集为备选任务集 ;若某个任务X在某个任务Y之后,且中间再无其他任务，则成X为Y的直接后继任务。

2、调度策略分析
关键路径为图中的概念，树作为特殊的一种图，我们可将其概念引申过来，在这里我们将任务树中需要进行时间最长的路径称为关键路径，所以整个项目的完成时间在很大程度上由关键路径的有效调度所决定。值得注意的是，关键路径是在不断发生变化的，在某个任务完成后，剩余任务树的关键路径是有可能发生变化的，所以在调度中如果始终保持一条关键路径不变，就无法保证整个项目用时最短。所以我们首先采用动态关键路径策略。

除此之外，由于任务是从备选任务中调度，故多个可调度任务同时争夺一个组员的情况是很有可能发生的，于此同时还可能发生这多个任务的路径长度均为最长即均在关键路径上。考虑到这种情况，我们在这里可以采用最短用时策略，优先调度用时较短的那个任务。
在整个项目中，一个项目组是有一个或多个组员的，为了是各个任务尽早开始，故我们使任务选择最早空闲的组员即选择最早适合开始任务的空隙。这里采用首次适应调度策略。

3.1.2 数据表间联系
任务调度系统涉及到的数据复杂，业务逻辑关系也较复杂，尤其是调度算法的逻辑，所以可能需要用到临时表，表与表之间也需要通过外键联系起来。外键的联系保证在项目组任务调度过程中业务操作稳定的关键。底层数据库设计的好坏直接影响着整个系统的稳定运行。

由于任务调度系统涉及到了具体的用户更新维护项目信息、项目任务集信息、个人登录信息功能操作，数据库中的数据不能随意删除，以防出现信息丢失的问题。所以必须重视表间的联系，倘若不够完善，系统运行起来就会报出许多bug或error，结果造成的损失将无法弥补，程序的可维护性也大打折扣。

3.1.3 系统安全性
省略

4 调度算法设计
基于树状任务集组成的项目问题调度算法如下：
1、 按照约束对项目构造任务树
2、 根据任务树将可调度任务和准可调度任务加入备选任务集。如果任务集为空，则表示项目完成，转至第5步。
3、 根据动态关键路径策略从备选任务集中选出路径长度最长的可调度任务。若任务唯一，则选取此任务，若不唯一，则选取用时最短的任务。
4、 应用首次适应调度算法调度选出来的任务，接着从任务树上删除此任务结点，从备选任务集中删除此任务。回到第2步。
5、 结束

算法流程图如图4.1所示：

图4.1 算法流程图

5 需求分析
需求分析可以说是软件开发过程各个阶段中最重要的，其定义是回答“系统做什么”的问题。计算机与软件技术近年来不断发展，信息管理系统已经覆盖了人们生活的方方面面，对于日常的信息统计管理起着越来越大的作用，在目前的潮流驱动下，为了项目组任务调度和团队协作的需求，基于SSH的任务调度系统被设计和开发。

5.1 USE-CASE用例图
任务调度系统分为项目组长和项目组员这两类用户角色。如图5.1所示为本系统的用例图。

图5.1 用例图

5.2 类图
任务调度细分类很多，如若运用了设计模式，接口或者抽象类数目也很庞大。在需求分析阶段，设计核心类如图5.2所示：

图5.2任务调度系统底层核心类图

5.3 活动图
活动图通过动作来组织，用于描述系统中某一行为，在需求分析阶段，我选用了比较重要，跨度较大的两个行为：修改密码、任务调度，如图5.3、5.4所示分别为对应的活动图：

图5.3 修改密码活动图

图5.4 任务调度活动图

5.4 功能需求
1、登录验证功能：本系统只对注册用户开发，所以在进入本系统时，用户必须进行注册登录，系统会对用户名和密码进行验证，无误后才可进入本系统，用户名和密码错误的话会出现错误提示并要求用户重新输入。
2、项目管理功能：用户共有功能，实现了对项目的管理操作，包括对项目的搜索、查看、添加和删除操作。
3、消息处理功能：用户共有功能，实现了对消息的管理操作，包括发送消息，查看消息，删除消息操作。
4、项目任务管理功能：项目组长功能，实现了对项目任务集的管理操作，包括对任务的添加、删除操作。
5、项目组成员管理功能：项目组长功能，实现了对项目组成员的管理操作，包括对组员的添加和删除操作。

5、申请功能：项目组员功能，实现了对感兴趣项目的操作，包括申请加入该项目与申请退出该项目。

5.5 开发环境
操作系统：Windows 7
开发语言：Java语言
数据库：MySQL
WEB服务器：Tomcat 8
开发工具：StarUML、Eclipse neon.1
客户端浏览器：Chrome
©5.6 系统交互图

5.6.1 系统架构类交互图
工作流程的系统架构：
1、在接收到用户输入的请求后，显示层的对象，将请求发送到WEB层进行处理。
2、接收到请求对象后，WEB进行权限验证，验证通过后将请求转发到Serviec层中相应的处理对象。
3、Service层处理对象进行业务逻辑的处理，并在需要时将请求对象发送到Manager层进行中间业务处理。
4、在这个问题上根据验证结果如下处理业务代理：不符合授权消息请求返回;满足的特权的请求，该请求被转发到业务事项。
5、业务流程的业务对象。用于处理业务数据保留的操作中，通过访问数据库访问对象，任何例外处理期间的异常处理的对象进行操作。最后，将结果返回给代理对象上的业务信息。
6、业务代理回给用户界面的结果在处理对象的信息。

系统架构类的交互图如图5.5所示：

图5.5 系统架构类的交互图

项目从申请加入到任务调度主要涉及：搜索项目，查看项目，申请加入项目，任务调度，回送消息，分派任务。该流程时序图如下图5.6所示：

图 5.6 申请并调度任务的时序图

该系统功能均为注册用户才能使用，用户注册时序图如下图5.7所示：

图5.7 用户注册的时序图

5.6.2 系统协作图
交互图来说明系统如何实现的使用情况或特殊用途的情况。 UML提供了两种类型的交互图，时序图和协作图的。时序图描述系统定时的元素之间的相互作用;按照时间和空间的顺序来描述该系统的元件之间的相互作用的协作图。

用户注册协作图如图5.8所示：

图 5.8 用户注册的协作图

用户创建项目协作图如图5.9所示：

图5.9 用户创建项目协作图

5.6.3 系统状态图
状态图是由对象的类型建模来描述的动态行为中的一个对象的变化的生命周期。状态图显示了状态机，这是唯一的一个状态机与投影机，这意味着包括该状态机的状态图的所有功能的元件。用户注册，用户登录，创建项目，用这三种状态来完成创建项目过程，所以用户创建项目状态图如图5.10所示：

图 5.10 用户创建项目的状态图

用户注册时用户信息状态图如图5.11所示：

图5.11 用户注册状态图

6 系统设计
任务调度系统设计的好坏将对系统的开发和维护起着至关重要的作用。系统的实现需要符合所有用户的要求，只有对用户的要求考虑的全面，才会开发出功能强大稳定的任务调度系统。

6.1 系统体系结构
本系统采用的是B/S的体系结构模式，通过浏览器展示系统界面，所有的事务逻辑

6.2 系统功能结构
根据需求调研结果确定本任务调度系统的功能结构，最终系统实现的系统将分为组长和组员两个角色，其中两个角色共有功能包括修改登录密码、项目搜索、项目查看、项目管理、消息管理。组长部分的功能有任务管理、项目组成员管理，组员部分的功能有申请调动功能。如图6.1所示为任务调度系统的功能结构图。

图6.1 系统功能结构图

6.3 系统架构的设计目标
软件架构设计，以实现以下目标：
1.可行性。架构是可行的，是系统设计的基础。
2.可靠性。系统软件是为业务运营和用户管理极为重要，因此应该是可靠的软件系统。
3.安全性。进行软件系统的商业价值高的交易
安全系统是非常重要的。
4.可定制。同一组的软件，可以根据变化的客户和市场基础的各种需求进行调整。
5.可扩展性。出现在新的技术，应该允许一个软件系统新技术的进口，扩大现有系统的功能和性能。
6.可维护性。维护软件系统有两个方面，一个是排除现有的错误，第二个将需要新的软件，以反映在现有的系统中。可以有效地降低技术支持一个易于维护的系统成本。
7.可升级。应该能够使用该软件，用户数量的情况下迅速地提高用户的，保持合理的性能。只有这样，才能适应不断扩大的市场份额的可能性了。
8.客户体验。应该是易于使用的网站。该网站最终用户很有可能是不具备计算机专业技术人才。

6.4 系统架构设计
下面我们要发展的系统设计和基于信息系统的原则，系统模型系统的原则。我们对项目进行应用分层，如图6.2所示。

图6.2 系统体系架构图

1、开放接口层：直接封装Service接口，可以选择暴露成RPC接口；或者通过Web协议封装为http接口；网关控制层等，本项目中不提供此开放层。
2、终端显示层：各类客户端的模板渲染并执行的显示层。目前生产生活中主要是JSP渲染，JS渲染，velocity渲染，移动端展示层等，在本项目中主要变现为JS渲染。
3、Web层：对访问控制进行转发，业务逻辑前的预处理工作，如各类基本参数校验，或者简单业务处理等。
4、Service层：具体的业务逻辑服务层。
5、Manager层：通用业务处理层，包含特征：
1） 封装第三方平台，转化异常信息以及预处理业务和返回结果等；
2）下沉Service层通用能力，比如缓存方案、中间件通用处理；
3） 与DAO层交互，封装DAO的业务通用能力。缓存方案、中间件通用处理；
6、DAO层：数据访问层，与底层各类数据库或缓存方案进行数据交互。
7、外部接口或第三方平台：包括其他公司基础平台，或者RPC接口，也包括其它的HTTP接口，本项目中不依赖该层服务。
然后得到如图6.3所示的包图：

图6.3 网站模块包图

6.5 数据库表结构
6.5.1 数据库设计原则
数据库应用程序开始在数据库设计，数据库设计和数据的内容和组织。在设计数据库时，需要考虑的第一件事是在目标数据库的设计。一个良好的数据库，不应该有冗余数据，可以快速地创建一个记录，并且很容易维护。当然当到达所有数据库的设计目标，它是最完美的，但两者之间是相互排斥的，这是不可能同时实现的，例如，要消除冗余数据，就不可避免的要降低定位记录的速度。在本系统中考虑实际情况及需要，采用了以下的设计原则。

6.5.2 数据库设计概述
省略

6.5.3 数据库设计周期
省略

6.5.4 数据字典
在系统设计中，数据库的设计占据了非常重要的地位，系统的成败取决于数据库的设计，也可以说数据是设计的基础。由于前期的疏忽，使得数据库的设计不完善、不合理，这将在系统的开发中，甚至后期的维护中引发严重的问题。根据系统需求，创建了6张表，下面是表数据结构描述。

表1 USER（用户表）

表2 PROJECT（项目表）

表3 JOB（项目任务表）

7 系统实现
7.1 公共模块
7.1.1 模块功能
系统采用struts+hibernate+spring开发，采用了MVC模式，并且采用了分层思想，结构分为表现层，业务层和数据访问层。struts框架开发表现层；业务层封装业务流程，对于每个业务又有相应的service层和manager层，在这之中运用面向接口编程的原则；利用spring的ioc功能将实现类注入给表现层的action；数据访问层借助于hibernate实现，可适应不同数据库。

公共模块主要包括公共的配置文件，按业务模块将bean类分别放在相应的配置文件中，有助于统一管理，还包括一些拦截器，如统一编码为UTF-8的拦截器和检测登录状态拦截器等。

7.1.2 模块代码

applicationContext-common.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans >
	<!-- 启用spring注解支持 -->
	<context:annotation-config />
	<!-- 启动Spring自动扫描功能 -->
    <context:component-scan base-package="com.fcq.schedule.job" />
	<!--配数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl"
			value="jdbc:mysql://localhost:3306/generation_design?characterEncoding=utf8&amp;useSSL=true" />
		<property name="user" value="root" />
		<property name="password" value="123456" />
		<property name="maxPoolSize" value="80" />
		<property name="minPoolSize" value="1" />
		<property name="initialPoolSize" value="1" />
		<property name="maxIdleTime" value="20" />
	</bean>
	<!--定义Hibernate的SessionFactory -->
	<!-- SessionFactory使用的数据源为上面的数据源 -->
	<!-- 指定了Hibernate的映射文件和配置信息 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
				<prop key="show_sql">true</prop>
				<prop key="hibernate.jdbc.batch_size">20</prop>
				<!-- 自动创建数据表 -->
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		<!-- 使用配置文件 -->
		<property name="mappingLocations">
			<list>
				<value>classpath:com/fcq/schedule/job/po/*.hbm.xml</value>
			</list>
		</property>
		<!-- Spring自动加载annotatedClass -->
		<!-- <property name="annotatedClasses"> <list> <value>com.jialin.entity.User</value> 
			</list> </property> -->
	</bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
	<!-- 配置事务管理器 （声明式的事务） -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- 配置事务通知属性 -->
	<tx:advice id="txadvice" transaction-manager="transactionManager">
		<!-- 定义事务传播属性 -->
		<tx:attributes>
			<!-- <tx:method name="add*" propagation="REQUIRED" /> <tx:method name="delete*" 
				propagation="REQUIRED" /> <tx:method name="modify*" propagation="REQUIRED" 
				/> hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到 <tx:method name="*" propagation="REQUIRED" 
				read-only="true" /> -->
			<tx:method name="get*" read-only="false" propagation="REQUIRED" />
			<tx:method name="find*" read-only="false" propagation="REQUIRED" />
			<tx:method name="save*" read-only="false" propagation="REQUIRED" />
			<tx:method name="reg*" read-only="false" propagation="REQUIRED" />
			<tx:method name="modify*" read-only="false" propagation="REQUIRED" />
			<tx:method name="remove*" read-only="false" propagation="REQUIRED" />
			<tx:method name="*" propagation="REQUIRED" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- 配置事务切面；那些类那些方法使用事务 -->
	<aop:config>
		<!-- 只对业务逻辑层实施事务 -->
		<aop:pointcut id="allManagerMethod"
			expression="execution(* com.fcq.schedule.job.service..*.*(..))" />
		<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txadvice" />
	</aop:config>
</beans>
applicationContext-beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans >
	<!-- Spring管理Struts2的Action -->
	<bean name="registerAction" class="com.fcq.schedule.job.action.RegisterAction"
		scope="prototype">
		<property name="userManager" ref="userManager"></property>
	</bean>
	<bean name="loginAction" class="com.fcq.schedule.job.action.LoginAction"
		scope="prototype">
		<property name="userManager" ref="userManager"></property>
	</bean>
	<bean name="ajaxUserNameVerifyAction" class="com.fcq.schedule.job.action.AjaxUserNameVerifyAction"
		scope="prototype">
		<property name="userManager" ref="userManager"></property>
	</bean>
	<bean name="queryUserOrProjectAction" class="com.fcq.schedule.job.action.QueryUserOrProjectAction"
		scope="prototype">
		<property name="userManager" ref="userManager"></property>
		<property name="projectManager" ref="projectManager"></property>
	</bean>
	<bean name="userMainAction" class="com.opensymphony.xwork2.ActionSupport"
		scope="prototype"></bean>
	<!-- Spring管理Struts2的Interceptor -->
	<!-- <bean name="checkLoginInterceptor" class="com.fcq.schedule.job.interceptor.CheckLogin" 
		scope="prototype"></bean> -->

    <!--用户业务逻辑类 -->
    <bean name="userManager" class="com.fcq.schedule.job.service.impl.UserManagerImpl">
        <property name="userDao" ref="baseDao"></property>
    </bean>
    <bean id="baseDao" class="com.fcq.schedule.job.dao.impl.UserDao">
        <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>
    <!-- 项目业务逻辑类 -->
    <bean name="projectManager" class="com.fcq.schedule.job.service.impl.ProjectManagerImpl">
        <property name="projectDao" ref="projectDao"></property>
    </bean>
    <bean id="projectDao" class="com.fcq.schedule.job.dao.impl.ProjectDao">
        <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>
    <!-- 任务业务逻辑类 -->
    <bean name="jobManager" class="com.fcq.schedule.job.service.impl.JobManagerImpl">
        <property name="jobDao" ref="jobDao"></property>
    </bean>
    <bean id="jobDao" class="com.fcq.schedule.job.dao.impl.JobDao">
        <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>
	<!-- 任务关系业务逻辑类 -->
	<bean id="jobConnectionManager" class="com.fcq.schedule.job.service.impl.JobConnectionManagerImpl">
	   <property name="jobConnectionDao" ref="jobConnectionDao"></property>
	</bean>
	<bean id="jobConnectionDao" class="com.fcq.schedule.job.dao.impl.JobConnectionDao">
		<property name="hibernateTemplate" ref="hibernateTemplate" />
	</bean>
	<!-- 消息业务逻辑类 -->
	<bean id="messageManager" class="com.fcq.schedule.job.service.impl.MessageManagerImpl">
	   <property name="messageDao" ref="messageDao"></property>
	</bean>
	<bean id="messageDao" class="com.fcq.schedule.job.dao.impl.MessageDao">
		<property name="hibernateTemplate" ref="hibernateTemplate" />
	</bean>
</beans>

7.2 注册模块
7.2.1 模块功能
本系统出于安全性与经济效益的考虑，仅供已注册用户使用。故开发了该注册模块，让用户通过设置帐号、密码、邮箱就可注册成为本系统会员。

如图7.1所示为本任务调度系统的主页以及注册页面。

图7.1 主页暨注册页面

7.2.2 模块代码
注册form代码

<form action="register" class="uk-form" method="post"
							accept-charset="utf-8">
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="user.username"
									placeholder="用户名" type="text" onfocus="delData()">
							</div>
							<div class="uk-form-row" id="accDiv"></div>
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="user.email" placeholder="邮箱"
									type="text" onblur="formatEmail()" onfocus="delEmail()">
							</div>
							<div class="uk-form-row" id="emailDiv"></div>
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="user.password" value=""
									autocomplete="off" placeholder="密码" type="password"
									onblur="formatPwd()" onfocus="delPwd()">
							</div>
							<div class="uk-form-row" id="pwdDiv"></div>
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="passwordCF" value=""
									autocomplete="off" placeholder="密码确认" type="password"
									onblur="return verifyPwd()" onfocus="delCFPwd()">
							</div>
							<div class="uk-form-row" id="pwdCFDiv"></div>
							<div class="uk-form-row">
								<button
									class="uk-button uk-width-1-1 uk-text-bold uk-text-uppercase bg-blue text-white"
									type="submit" name="submit" value="submit">注册</button>
							</div>
						</form>

注册Controller层代码

ActionSupport子类代码 暨注册页面控制器代码：
public String execute() throws Exception {
		// TODO Auto-generated method stub
		try {
			userManager.regUser(user);
			Map session = ActionContext.getContext().getSession();
			session.put("user", user);
			return SUCCESS;
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return ERROR;
		}
	}
Service层代码
	public void regUser(User user) throws HibernateException {
		userDao.saveObject(user);
｝
DAO层代码
	public void saveObject(Object obj) throws HibernateException {
		// TODO Auto-generated method stub
		try {
			hibernateTemplate.save((User) obj);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

7.3 登录模块
7.3.1 模块功能
为了方便管理并且方便更高效的进行任务调度，本系统各项功能必须在已注册用户登录的状态下方可使用。用户进入系统之后首先要进入到系统的主页面及注册页面，可以在导航栏中选择进入登录页面，在登录页面中将验证用户输入的用户名以及密码是否正确，输入正确的用户名及密码才可以成功的登录系统，如果用户名或者密码错误将返回错误提示，

如图7.2所示为任务调度系统的登录页面：

图7.2 登录页面

7.3.2 模块代码
登录form代码

<form action="login" class="uk-form" method="post"
							accept-charset="utf-8">
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="user.username"
									placeholder="用户名" type="text" onfocus="delData()">
							</div>
							<div class="uk-form-row" id="accDiv"></div>
							<div class="uk-form-row">
								<input class="uk-width-1-1" name="user.password" value=""
									autocomplete="off" placeholder="密码" type="password"
									onblur="formatPwd()" onfocus="delPwd()">
							</div>
							<div class="uk-form-row" id="pwdDiv"></div>
							<div class="uk-form-row">
								<button
									class="uk-button uk-width-1-1 uk-text-bold uk-text-uppercase bg-blue text-white"
									id="submit" type="submit" name="submit" value="submit">登录</button>
							</div>
						</form>
登录Controller层代码
	public String execute() throws Exception {
		if(userManager.findUser(user)!=null){
			Map session = ActionContext.getContext().getSession();
			session.put("user", user);
			return SUCCESS;
		}else{
			return ERROR;
		}
	}
Service层代码
	public User findUser(User user) {
		// TODO Auto-generated method stub
		return (User) userDao.findByUsernameAndPassword(user);
	}

DAO层代码
	public User findByUsernameAndPassword(User user) throws HibernateException {
		// TODO Auto-generated method stub
		List<User> list = null;
		try {
			String hql = "from User  where  username=? and password=?";
			list = (List<User>) hibernateTemplate.find(hql, user.getUsername(), user.getPassword());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			return list.get(0);
		}
		return null;
	}

7.4 搜索模块
7.4.1 模块功能
该模块的目的主要是实现对已注册用户以及已发起的项目的搜索，来使用户根据自己的兴趣进行项目或者项目leader的选择，给用户提供了丰富的可能性。该模块支持模糊搜索，并标红搜索字段。

如图7.3所示为任务调度系统导航栏的搜索框：

图7.3 搜索框
如图7.4所示为任务调度系统的搜索结果页面：

图7.4 搜索结果页面

7.4.2 模块代码

前台Form代码
			<form action="queryUserOrProject">
				<div class="search_main">
					<button class="search_btn" type="submit"></button>
					<input class="search_text" name="UserOrProject" type="text"
						placeholder="用户/项目"> <span class="close_btn"></span>
				</div>
			</form>
搜索Controller层代码
	public String execute() throws Exception {
		// TODO Auto-generated method stub
		try {
			Map session = ActionContext.getContext().getSession();
			HttpServletRequest request = ServletActionContext.getRequest();
			String name = request.getParameter("UserOrProject");
			request.setAttribute("keyword", name);
			List<User> listUser = userManager.findByBlurUsername(name);
			List<Project> listProject = projectManager.findByBlurProjectName(name);
			request.setAttribute("listUser", listUser);
			request.setAttribute("listProject", listProject);
			return SUCCESS;
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return ERROR;
		}
	}
搜索Service层代码
	public List<User> findByBlurUsername(String username) {
		return (List<User>) userDao.findByBlurUsername(username);
	}
	public List<Project> findByBlurProjectName(String name) {
		return projectDao.findByBlurProjectName(name);
	}
搜索DAO层代码
		public List<User> findByBlurUsername(String username) throws HibernateException {
		List<User> list = null;
		try {
			String hql = "from User where username like '%" + username + "%'";
			list = (List<User>) hibernateTemplate.find(hql);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}
	public List<Project> findByBlurProjectName(String name) {
		List<Project> list = null;
		try {
			String hql = "from Project where name like '%" + name + "%'";
			list = (List<Project>) hibernateTemplate.find(hql);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;
	}

7.5 项目管理模块
7.5.1 模块功能
该模块为本系统的核心模块之一，该模块包括了添加项目，删除项目，编辑项目等功能，编辑项目主要指的是更新项目中的任务与参与者，这是进行任务调度必须有的一个关键步骤。

如图7.5所示为任务调度系统的项目编辑页面：

图7.5 项目编辑页面

7.5.2 模块代码
Controller层代码

	public String execute() throws Exception {
		// TODO Auto-generated method stub
		try {
			String[] path = { "config/applicationContext-beans.xml" };
			ApplicationContext context = new ClassPathXmlApplicationContext(path);
			User user = (User) context.getBean("user");
			project.setLeader(user);
			projectManager.saveProject(project);
			((ConfigurableApplicationContext) context).close();
			return SUCCESS;
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return ERROR;
		}
	}
Service层代码
	    public void saveProject(Project project) {
		  projectDao.saveProject(project);
	    }
	    public void removeProject(Project project) {
		projectDao.removeProject(project);
	     }
	public void modifyProject(Project project) {
		projectDao.modifyProject(project);
	}

	public Project findByName(String name) {
		return projectDao.findByName(name);
	}

	public Set<Project> findLeadProjectsByUsername(String username) {
		return projectDao.findLeadProjectsByUsername(username);
	}

	public Set<Project> findJoinProjectsByUsername(String username) {
		return projectDao.findJoinProjectsByUsername(username);
	}

	public List<Project> findByBlurProjectName(String name) {
		return projectDao.findByBlurProjectName(name);
	}
DAO层代码
	/**
	 * 保存项目
	 * 
	 * @param project
	 * @throws HibernateException
	 */
	public void saveProject(Project project) throws HibernateException {
		// TODO Auto-generated method stub
		try {
			hibernateTemplate.save(project);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 删除项目
	 * 
	 * @param project
	 * @throws HibernateException
	 */
	public void removeProject(Project project) throws HibernateException {
		try {
			hibernateTemplate.delete(project);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

	/**
	 * 更改项目
	 * 
	 * @param project
	 * @throws HibernateException
	 */
	public void modifyProject(Project project) throws HibernateException {
		try {
			hibernateTemplate.update(project);// 会把这个表中的所有字段更新一遍。
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

	/**
	 * 通过项目名查找项目
	 * 
	 * @param name
	 * @return
	 * @throws HibernateException
	 */
	public Project findByName(String name) throws HibernateException {
		List<Project> list = null;
		try {
			String hql = "from Project where name=?";
			list = (List<Project>) hibernateTemplate.find(hql, name);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		// hql:from 后面跟的类名＋类对象 where后用对象的属性做条件
		if (list != null && list.size() > 0) {
			return list.get(0);
		}
		return null;
	}

	/**
	 * 通过项目名模糊查找相关项目
	 * 
	 * @param name
	 * @return
	 */
	public List<Project> findByBlurProjectName(String name) {
		List<Project> list = null;
		try {
			String hql = "from Project where name like '%" + name + "%'";
			list = (List<Project>) hibernateTemplate.find(hql);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			return list;
		}
		return null;

	}

	/**
	 * 通过用户名查找该用户所领导的项目
	 * 
	 * @param username
	 * @return
	 */
	public Set<Project> findLeadProjectsByUsername(String username) {
		List<Project> list = null;
		Set<Project> set = new HashSet<Project>();
		try {
			String hql = "select p from Project p,User u where p.leader=u and u.username=? ";
			list = (List<Project>) hibernateTemplate.find(hql, username);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			for (Project l : list) {
				set.add(l);
			}
			return set;
		}
		return null;
	}

	/**
	 * 通过用户名查找该用户参与的项目集
	 * 
	 * @param username
	 * @return
	 */
	public Set<Project> findJoinProjectsByUsername(String username) {
		List<Project> list = null;
		Set<Project> set = new HashSet<Project>();
		try {
			String hql = "select p from Project p,User u where p.projectId in elements(u.joinProjects) and u.username=?";
			list = (List<Project>) hibernateTemplate.find(hql, username);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		if (list != null && list.size() > 0) {
			for (Project l : list) {
				set.add(l);
			}
			return set;
		}
		return null;
	}

7.6 任务调度模块
7.6.1 模块功能
该模块为本系统的核心模块之一，后台通过运行调度算法来计算项目最佳调度方式，并展现给用户，故只有一个核心调度算法，无层次划分。

7.6.2 模块代码
Dispatcher类代码

/**
 * 任务调度核心类|| 核心方法为dispatcherCore(project)
 */
public class Dispatcher {
	public UserManager userManager;
	public ProjectManager projectManager;
	public JobManager jobManager;
	public JobConnectionManager jobConnectionManager;
	Map<Integer, JobNode> mapJobNode;// 存储任务结点的Map集合。 在算法中为虚拟任务树
	Map<JobNode, JobConnection> mapJobConnectionByJobNode;// 存储任务结点的连接信息.该Map初始化完毕后不用动key为当前结点，value为向下指向该结点的连接信息的集合
	// 一个任务结点被分出去后，需要从下面这个Map中删除关于这个结点的连接信息。（需借助上面这个Map）看TA是不是叶子结点来选出备选集
	Map<JobNode, List<JobConnection>> mapJobConnectionListByNextJobNode;// 存储任务结点的连接信息.key为当前结点，value为从该结点向下指出去的连接信息的集合
	List<WorkerNode> listWorkerNode;// 初始化完成后无需再动
	List<JobNode> optionJob;

	public Dispatcher() {
		// TODO Auto-generated constructor stub
		userManager = new UserManagerImpl();
		projectManager = new ProjectManagerImpl();
		jobManager = new JobManagerImpl();
		jobConnectionManager = new JobConnectionManagerImpl();
	}

	public void dispatcherCore(Project project) {
		init(project);
		greedy(mapJobNode, listWorkerNode);

	}

	/**
	 * 初始化项目和项目参与人员，将其添加至集合中
	 * 
	 * @param project
	 */
	public void init(Project project) {
		Set<Job> setJob = project.getJobs();// 该项目含有的任务的集合
		mapJobNode = new HashMap<Integer, JobNode>();// 该项目JobNode的Map集合
		mapJobConnectionByJobNode = new HashMap<JobNode, JobConnection>();
		mapJobConnectionListByNextJobNode = new HashMap<JobNode, List<JobConnection>>();
		for (Job jobs : setJob) {
			JobNode jobNode = new JobNode(jobs.getJobId(), jobs.getWeight());
			mapJobNode.put(jobs.getJobId(), jobNode);
			JobConnection jobConnection = jobConnectionManager.findByJobId(jobs.getJobId());
			if (jobConnection != null) {
				mapJobConnectionByJobNode.put(jobNode, jobConnection);
			}
			List<JobConnection> listJobConnectionByNextJob = jobConnectionManager.findListByNextJobId(jobs.getJobId());
			if (listJobConnectionByNextJob != null) {
				mapJobConnectionListByNextJobNode.put(jobNode, listJobConnectionByNextJob);
			}
		}
		Set<User> setUser = userManager.findJoinerByProjectName(project.getName());// 项目参与者的集合
		listWorkerNode = new ArrayList<WorkerNode>();
		for (User set : setUser) {
			WorkerNode workerNode = new WorkerNode(set.getUserId());
			listWorkerNode.add(workerNode);
		}
	}

	public void greedy(Map<Integer, JobNode> mapJobNode, List<WorkerNode> listWorker) {
		int sum = 0;
		LinkedList<WorkerNode> listWorkerNode = (LinkedList) listWorker;
		// 每次循环都对Worker进行一次排序
		do {
			// 1、从任务树中选出备选任务集
			optionJob = selectOptionJob(mapJobNode);
			// 2、从备选任务集中选出路径长度最长的任务结点
			JobNode nowJobNode = selectLongestJobNode(optionJob);
			// 3、先将最长任务结点分配出去
			Collections.sort(listWorkerNode);
			WorkerNode nowWorkerNode = listWorkerNode.peek();
			System.out.println("将组员" + nowWorkerNode + "从第" + nowWorkerNode.getAvail() + "天到第"
					+ (nowWorkerNode.getAvail() + nowJobNode.getDay()) + "天的时间段分配给任务" + nowJobNode.getId());
			nowWorkerNode.setAvail(nowWorkerNode.getAvail() + nowJobNode.getDay());
			// 4、删除该任务结点
			deleteJobNode(nowJobNode);
		} while (optionJob.size() != 0);
	}

	/**
	 * 删除JobNode
	 * 
	 * @param jobNode
	 */
	public void deleteJobNode(JobNode jobNode) {
		// 4、将已分配到组员的任务删除分3步 ：1.从备选任务集中删除 2.从任务树中删除 3.删除该结点相关的连接
		optionJob.remove(jobNode);
		mapJobNode.remove(jobNode.getId());
		// 删除该结点相关连接又分3步：1、获得该结点连接 2、获得该结点后继结点的map V值 3、从该V值中删除该结点连接
		JobConnection jobConnection = mapJobConnectionByJobNode.get(jobNode);
		List<JobConnection> waitRemove = mapJobConnectionListByNextJobNode.get(jobConnection.getNextJob());
		waitRemove.remove(jobConnection);
	}

	/**
	 * 从任务树中选出备选任务集
	 * 
	 * @param map
	 * @return
	 */
	public List<JobNode> selectOptionJob(Map<Integer, JobNode> map) {
		List<JobNode> list = new ArrayList<JobNode>();
		for (JobNode values : map.values()) {
			if (isLeaf(values)) {// 如果是叶子结点
				list.add(values);
			}
		}
		return list;
	}

	/**
	 * 判断是否为叶子结点
	 * 
	 * @param jobNode
	 * @return
	 */
	public boolean isLeaf(JobNode jobNode) {
		if (!mapJobConnectionListByNextJobNode.get(jobNode).isEmpty()) {
			return false;
		}
		return true;
	}

	/**
	 * 从备选任务集中选出路径长度最长的任务
	 * 
	 * @param optionJobNode
	 * @return
	 */
	public JobNode selectLongestJobNode(List<JobNode> optionJobNode) {
		// 此时给一个函数计算路径
		JobNode longestJobNode = null;
		int max = 0;
		for (JobNode list : optionJobNode) {
			int nowLength = calculatePath(list);
			if (nowLength >= max) {
				max = nowLength;
				longestJobNode = list;
			}
		}
		return longestJobNode;
	}
	/**
	 * 计算给出任务结点的路径长度
	 * 
	 * @param jobNode
	 * @return
	 */
	public int calculatePath(JobNode jobNode) {
		int pathLength = 0;
		JobConnection jobConnection = mapJobConnectionByJobNode.get(jobNode);
		while (jobConnection != null) {
			jobNode = mapJobNode.get(jobConnection.getNextJob());
			pathLength++;
		}
		return pathLength;
	}
}	
JobNode类代码
public class JobNode implements Comparable<JobNode> {
	private Integer id;// 真实ID
	private Integer day;

	public JobNode(Integer id, Integer day) {
		// TODO Auto-generated constructor stub
		this.id = id;
		this.day = day;
	}

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if (obj == null) {
			return false;
		} else if (obj instanceof JobNode) {
			JobNode j = (JobNode) obj;
			if (this.id == j.getId() && this.day == j.getDay()) {
				return true;
			}
		}
		return false;
	}
｝
WorkerNode类代码
package com.fcq.schedule.job.core;
/**
 * 用来简化User类
 * @author 撒旦的奶爸
 *
 */
public class WorkerNode implements Comparable<WorkerNode> {
	private Integer id;// 真实ID
	private Integer avail;// worker空闲的时刻（即worker做完某一项工作的时间）

	public WorkerNode(Integer id) {
		this.id = id;
		this.avail = 0;
	}

	@Override
	public int compareTo(WorkerNode o) {
		int m = o.getAvail();
		if (avail < m)
			return -1;
		if (avail == m)
			return 0;
		return 1;
	}

	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		} else if (obj instanceof WorkerNode) {
			WorkerNode j = (WorkerNode) obj;
			if (this.id == j.getId()) {
				return true;
			}
		}
		return false;
	}
}

8 结论与展望
省略

参考文献
[1] 朱大勇, 杨德明, 向金珍. AOE网的关键路径算法在网络工序中的应用[J]. 计算机应用, 2000, 20(6):49-51.
[2] 刘芳, 王玲. 基于动态规划思想求解关键路径的算法[J]. 计算机应用, 2006, 26(6):1440-1442.
[3] 陶维. 基于SSH多架构Web系统设计及其应用[J]. 科技和产业, 2009, 9(3):101-104.
[4] 刘振元, 陈鑫鹏. 活动成本目标多模式资源受限项目调度的组合调度算法[C]// 中国系统工程学会学术年会. 2012.
[5] 谢志强, 杨静, 周勇,等. 基于工序集的动态关键路径多产品制造调度算法[J]. 计算机学报, 2011, 34(2):406-412.
[6] 王希望, 孟祥书, 王福顺. 基于SSH架构的Web系统的开发方法[J]. 河北农业大学学报:农林教育版, 2010, 12(4):538-541.
[7] 翟高粤. 基于J2EE技术的SSH框架的改进及应用[J]. 计算机时代, 2012(10):24-26.
[8] Liu L R, Du D H C, Chen H C. An efficient parallel critical path algorithm[C]// Design Automation Conference, 1991. ACM/IEEE. IEEE, 1991:535-540.
[9] Ren Y, Xing T, Chai X, et al. Study of Using Critical Path Method to Formulate the Algorithm of Software Project Schedule Planning[C]// International Conference on Information Management, Innovation Management and Industrial Engineering. IEEE, 2010:126-129.
[10] Mcgovern J, Tyagi S, Stevens M E, et al. Java Web Services Architecture[J]. 2003.

致 谢
省略

附录：外文资料
省略

中文译文
省略

---

5、资源下载

本项目源码及完整论文如下，有需要的朋友可以点击进行下载。如果链接失效可点击下方卡片扫码自助下载。

序号	毕业设计全套资源（点击下载）
本项目源码	基于java+JSP+SSH的任务调度系统设计与实现（源码+文档）_MySQL_JSP_BS_任务调度系统.zip