如何使用ssm实现安徽新华学院实验中心管理系统的设计与实现

@TOC

ssm040安徽新华学院实验中心管理系统的设计与实现+jsp

绪论

1.1研究背景

随着中国的科技的不断进步，计算机发展也慢慢的越来越成熟，人们对计算机也是越来越更加的依赖，科研、教育慢慢用于计算机进行管理。从第一台计算机的产生，到现在计算机已经发展到我们无法想象。给我们的生活改变很多很多，给我们提供了把很多的方便，计算机已经融入到我们的生活中，和我们的生活息息相关。

据调查，传统的安徽新华学院实验中心管理模式面对大量的课程信息、仪器信息、学生信息以及老师信息等，信息的及时更新等弊端凸显，传统的管理过度的依靠人力资源的登记，对于庞大的信息量，显然只依靠人力，很难准确的处理好大量的数据，传统的管理模式不仅效率低，出错率高，对于实验中心管理带来了诸多不便，因此，安徽新华学院传统的实验中心管理模式已经远远无法满足当今安徽新华学院的发展需求，我们急需对实验中心管理体系进行变革，开发基于计算机平台的安徽新华学院实验中心管理系统。现代化的利用计算机来进行实验中心管理很大程序上可以提高效率，人力方面也大大的节省，界面简单易操作，只要会计算机就可以快速的进行实验中心相关信息的管理。对经济方面也是很大的节省，其优点是显而易见的。

安徽新华学院实验中心管理系统的设计与实现充分地体现了计算机给实验中心管理带来的便捷，不仅节省了草稿纸张等的费用，而且在熟悉管理流程后，可以方便管理人员对实验中心相关信息的管理。

1.2设计原则

在开始开发项目之前，必须要先考虑项目的实用性、科学性，以及该项目是否能够真正让用户受益并尽可能的发挥项目的作用。因此，在开发前，通过以下几条原则对项目进行判断：

（1）可行性原则。项目需要保证经济可行性和技术可行性，这包括了项目在浏览端、服务端等方面上的经济和技术上是可以达成的。

（2）适应性原则。项目要保证可维护性和可扩展性，这是每个非短期项目都需要考虑的，并且不论是维护还是扩展，都必须要建立在适应用户的正常需求的基础上。

（3）安全性及保密性原则。要充分保证用户信息的安全性和保密性，不能因为开发上的疏忽，导致用户的信息泄露。

（4）系统工程原则。为了确保项目的整体性，在项目调查、项目分析、项目设计、项目开发的过程中，都需遵从项目工程的方法和步骤逐步进行。

（5）统一规划、分期实施、逐步完善原则。项目开发的过程中，要按照规划、分期实施，特别是要注意在项目开发过程中要有条理，从点到面，一步步完善，不要贪图进度，要循环渐进的对项目进行开发。

1.3研究内容

本系统是指开发一个界面简洁、扩展性较强、功能需求较为完善、数据较为精准，系统性能较为良好的轻量级的安徽新华学院实验中心管理系统。系统主要实现了学生模块、老师模块和管理员模块。其开发内容主要包括后台数据库的建立和维护以及前端应用程序的开发两个方面。经过调试、编译与实现，该程序界面友好、程序设计风格朴素，使用起来美观大方、方便易用。通过对系统的需求分析，设计出了本安徽新华学院实验中心管理系统，主要的研究内容有：

（1）概述。先讲解了本系统开发课题的背景，然后详细的介绍了本系统的设计原则，最后明确的指出了系统开发研究内容。

（2）系统关键技术介绍。介绍了Mysql、JSP、JAVA等开发工具以及B/S开发框架。

（3）系统的分析。对本项目进行系统分析，对系统可行性分析、性能分析以及功能模块进行了讲述。

（4）系统的设计。进行系统的设计，包括系统结构设计以及数据库设计。

（5）本系统的功能实现。介绍了本系统的主要功能模块，并进行主要功能的界面展示，通过这部分可对系统功能有总体把握。

（6）系统测试：介绍了系统测试过程。

26

2 相关技术简介

2.1 JSP技术

JSP（JavaServer Pages）主是一种动态网页技术标准。 JSP技术有点类似于ASP技术。它将Javascripts（Scriptlets）和JSP标记（标记）插入到传统的网页HTML文件（* .htm，* .html）中，以形成JSP文件（* .jsp）。使用JSP开发的Web应用程序是跨平台的，也就是说，它们可以在Linux下运行并在其他操作系统上运行。

JSP技术使用Java编程语言编写类似XML的标记和scriptlet来封装用于生成动态网页的处理逻辑。 JSP将Web逻辑与Web设计和显示分离，支持可重用的基于组件的设计，并使基于Web的应用程序开发变得快速而简单[1]。与Java Servlet一样，JSP在服务器端执行。通常，客户端返回HTML文本，因此只要它有浏览器，客户端就可以浏览。 JSP页面由HTML代码和嵌入其中的Java代码组成。服务器在客户端请求页面后处理Java代码，然后将生成的HTML页面返回到客户端的浏览器。 JSP易于使用Java技术，完全面向对象，平台无关且安全，主要用于Internet。

2.2 B/S结构

目前软件项目的开发存在两种架构模式，就是B/S模式和C/S模式，C/S模式就是较早流行的客户端和服务端模式，要使用新版应用需要暂停使用更新升级，就好比现在手机上的各种APP应用。而这次课题项目使用的是基于B/S,就是浏览器/服务端而开发的web项目。应用的更新都在服务端上进行，而且项目维护方便，不需要安装，只需要有浏览器和网络就可以了，越来越多的web项目被开发出来，也得到用户的认可。

B/S架构这种只需要用户在浏览器上运行不需要再下载客户端的模式，使用浏览器就可以实现和下载客户端的一样复杂的功能。给管理系统的用户带来了很大的方便，节约了大量的成本。现在B/S架构已经在Web开发上被广泛运用，它的基础内容也在不断的完善更新。

图2-1 B/S模式三层结构图

2.3 MYSQL数据库

本次开发的系统后台采用MySQL数据库来存放数据，MySQL实质是RDBMS（关系型数据库管理系统），源代码开放性比较高，数据库管理的语言采用SQL（结构化查询语言）进行数据管理，下面我们就简单介绍SQL语句的一些常用用法。通常我们要创建一个数据库时就会使用“CREATE DATABASE ”命令开头，使用某个数据库时就会以“use+数据库名称”命令，如果想要查看数据库里面数据表就会使用到“SHOW TABLES”命令，当然我们在操作数据表内容时也会使用到某些命令，比如删除就用“drop”，清空就用“delete from”，更新数据就用“update”，需要加入数据的话可以用“insert into ”等命令，这些就是SQL查询语句的惯用语法。这次采用mysql数据库还是源于它备受关注的实用性和可靠性，它里面的大部分功能一般的系统都还用不完，况且mysql小巧但它功能比较齐全，是一般系统软件的开发首选。MySQL开放的源代码通过360安全浏览器可以快速下载下来，程序员可以对这些免费的代码根据自身需求进行个性化定制操作。为了我们能够更好地使用MySQL，平时我们需要多加维护，有空的时候还是多多查看一些二进制日志、错误日志、常规查询日志等日志，它们能够帮助我们进行性能分析以及DBA检查，除了这个还需要注意每间隔一定时间就要更新缓冲区和缓存，这样能够降低碎片，利用OPTIMIZETABLE命令让数据表进行重新组织，还能节省许多空间避免空间浪费。

2.4 JAVA技术

Java是一门伟大的纯面向对象的编程语言和编程语言。同时，它还是Java语言从嵌入式开发到企业级开发的平台。Java凭借其一次编译，任何地方执行的优点，使得盛行的web应用程序有大量的Java编译，很好地支持网络发展跨平台开发所需的功能，成为服务器端主要流行的语言。Java EE至今仍然是企业发展最重要的服务器平台[1]。

鉴于Java语言是一种引用，它可以自动地收集浪费，编程人员不必担心面向对象的内存特性的管理，它具有一系列类别和类型的支持、多个接口和接口的继承，以及一种实现的机制关于类和接口之间的。

此外，Java语言支持Internet上的应用程序开发，Java的接口是Java net，它提供了一个类库，用于编程Web应用程序，可以是一种强大的异常处理机制和自动垃圾收集机制。

编程语言Java的一个目标是适应动态环境。Java程序要求，可以动态加载执行环境或网络，它也有助于软件升级。而且，能进行运行时间的实现，对运行时间类型的控制。

2.5 Tomcat简介

Tomcat在JSP 程序调试中应用广泛，它本身就是一款轻量级的源代码开放的能够支持jsp和servlets的目前比较主流的Web 服务器。普遍适用于中小型开发系统以及同时访问系统的用户数量比较少的场景。Tomcat默认模式实际上是Servlet容器，另外Tomcat服务器它能够处理html文件的功能，这点跟Web服务器和IIS同样。只是在处理html文件上，Tomcat服务器没有Apache服务器优越。Tomcat发展以来，目前已经更新到9.0版本了。之所以选择Tomcat服务器来源于它的先进技术，稳定性能等优点，当然最主要的还是Java程序开发者对Tomcat服务器的接纳和认可，Tomcat服务器也深受某些软件开发商的喜爱。

3 系统分析

3.1 可行性分析

在进行可行性分析时，我们通常根据软件工程里方法，通过四个方面来进行分析，分别是技术、经济、运行和法律可行性。因此，在基于对目标系统的基本调查和研究后，对提出的基本方案进行可行性分析

3.1.1 技术可行性

技术可行性一是考虑客观的技术可行性，二是考虑实际的技术可行性。从客观上、简单地说，现已经出现了类似的系统，因此客观上的可行性是满足的。从现有的实际情况上来看，该系统使用的是JAVA开发语言、MYSQL都是容易获得的，同时计算机的硬件性能也满足开发软件的需求；且在本科课程中都有进行相关软件的学习和开发。综上所述，该系统具有技术可行性。

3.1.2 经济可行性

开发该系统时，优先考虑了使用网页来完成该系统。从已有的Web网页开发的案例、资料中，可知Web所需要的软硬件简单，切开发成本低。且从引进该系统后的预想表现将会比传统方式优异，其具有高效、低成本的特点。可以大量节省管理的人力、物力，具有一定经济效益和社会效益。综上所述，该系统具有高经济可行性

3.1.3 操作可行性

在设计之初，我在网上参考了许多实验中心管理系统的界面布局设计，发现该系统界面展示比较简单，功能罗列齐全，操作流程简单明了，系统用户不用担心不会操作，系统各个功能模块都会有相应的提示，一看就明白，实在不知道的话，稍微指点就能上手，上手速度很快，时间不会耽误太多。

3.1.4 时间可行性

这次毕业设计学校预留的时间比较充分，从去年10月到今年5月几乎都是毕业设计制作阶段，从完成程序设计、编码、测试，到完成程序配套的论文，时间上面还有剩余，这点上是完全没有压力。

经过上面的分析，此次开发的系统从经济上、从技术上、从操作上、从时间上考虑都能过关。说明自己要开发的安徽新华学院实验中心管理系统可行性是完全可行，操作简单，时间、金钱上面毫无压力，该系统开发是完全可行。

3.2 系统性能分析

（1）系统的存储性：因为是实验中心管理系统，所以就会在数据库要求上比较严格，信息录入的比较多，而且丰富复杂， 这就需要一个强大的数据库来存放更多的数据和保证数据的时时性。

（2）系统的易学性：系统设计的应该简单易学的，设计的各种功能应该简单操作，不需要努力学习培训，缩短用户熟悉系统的进程。

（3）系统的数据要求：数据应该录入准确，需要更新时，数据应该可以及时的修改，数据还应该有独立保存，不能删除数据的时候会连带着把还需要的数据都删除掉。

（4）系统的安全性在设计过程中，其安全性主要体现在系统安全性、数据安全性这几个方面。系统安全性主要考虑系统操作的稳定性及该系统运行平台的稳定性；数据安全性主要考虑数据库服务器，用户可以根据自己的需求进行相应操作，以实现对数据的保密。

（5）系统的可靠性：安徽新华学院实验中心管理系统的可靠性主要体现在软件运行可靠性、数据处理可靠性等方面。运用软件工程设计的思想，尽量控制系统运行时可能存在的突发情况。

3.3 系统功能分析

本安徽新华学院实验中心管理系统主要满足3种类型用户的需求，这3种类型用户分别为学生、老师和管理员，他们分别实现的功能如下。

（1）管理员功能模块：管理员是这3类用户中权限最高的，可对系统进行全面管理，管理员登录后主要实现的功能模块包括个人中心、学生管理、老师管理、课程管理、仪器管理、专业管理、留言管理以及公告管理，管理员实现了对系统信息的查询、添加、修改和删除的功能。管理员用例图如图3-1所示。

图3-1 管理员用例图

（2）学生功能模块：学生登录后主要功能模块包括个人中心、学生管理、课程管理、仪器管理、专业管理、留言管理以及公告管理，学生只能查询，无权增删改。学生用例图如图3-2所示。

图3-2 学生用例图

（3）老师功能模块：老师登录后主要功能模块包括个人中心、学生管理、老师管理、课程管理、仪器管理、专业管理、留言管理以及公告管理。老师用例图如图3-3所示。

图3-3 老师用例图

3.4 系统流程分析

3.4.1操作流程

这是个安徽新华学院内部进行实验中心管理的程序，要求相关人员使用，所有系统设有登录界面，所有人员要想使用这个系统，就先要登录，根据系统提示输入个人特有的登录信息，进行登录系统，只有在登录成功的情况下才能进行功能操作。本安徽新华学院实验中心管理系统操作流程如图3-4所示。

图3-4操作流程图

3.4.2添加信息流程

用户在添加信息的过程中，编号不能手动输入，由系统生成，其他信息都要手动输入，输入后系统对输入的这些信息进行验证，验证通过就显示添加成功，相反添加失败。添加信息流程如图3-5所示。

图3-5添加信息流程图

3.4.3 删除信息流程

用户可选择要删除的信息进行信息删除操作，在删除信息时系统提示是否确定删除信息，是则删除信息成功，系统数据库将信息进行删除。删除信息流程图如图3-6所示。

图3-6 删除信息流程图

4 系统设计

4.1 系统架构设计

B/S系统架构是本系统开发采用的结构模式，使用B/S模式开发程序以及程序后期维护层面需要的经济成本是很低的，用户能够承担得起。使用这样的模式开发，用户使用起来舒心愉悦，不会觉得别扭，操作很容易就熟练了。而且方便管理。采用B/S体系结构开发的应用软件仅仅需要在客户端安装谷歌浏览器或者其他浏览器就可以操作，对于维护和升级操作则在服务器端就能完成，不用在客户端进行操作，这样就节省了许多开销，B/S模式能够保证软件应用的跨平台性和通用性，采用它开发软件是最佳选择。B/S模式示意图如图4-1所示。

图4-1 B/S模式示意图

4.2 系统结构设计

系统的设计和划分是系统的核心研究问题，以确定整体结构和功能模块。该系统的结构化设计的思想，是自顶向下的方式将系统分成若干个子系统，以及反过来的子系统分成模块，其被划分成子模块，层划分各计算机可执行模块可迄今用作一个单独的程序。

本安徽新华学院实验中心管理系统的结构图如图4-2所示。

图4-2系统结构图

4.3 数据库设计

一个好的数据库可以关系到程序开发的优劣，数据库设计离不开表结构的设计，还有表与表之间的联系，以及系统开发需要设计的数据表内容等信息。在进行数据库设计期间，还是需要多花时间进行考虑，最终设计出配套程序的数据库出来。

4.3.1数据库E-R图设计

本安徽新华学院实验中心管理系统采用的是MYSQL数据库数据存储快，因为安徽新华学院实验中心管理系统，主要的就是对信息的管理，信息内容比较多，这就需要好好的设计一个好的数据库，分类要清楚，不能添加信息的时候，造成信息太过混乱，设计好的数据库首先就需要先把各个实体之间的关系表达明确。

根据系统的功能模块划分，具体分析了本系统中大部分的实体，本安徽新华学院实验中心管理系统的实体属性E-R图如下图所示：

（1）管理员信息实体E- R图，如图4-5所示：

图4-5 管理员信息实体图

（2）老师信息实体E- R图，如图4-6所示：

图4-6 老师信息实体图

（3）学生实体E- R图，如图4-7所示：

图4-7学生实体图

（4）仪器实体E- R图，如图4-8所示：

图4-8 仪器实体图

（5）专业实体E- R图，如图4-9所示：

图4-9 专业实体图

（6）留言实体E- R图，如图4-10所示：

图4-10 留言实体图

4.3.2数据库表设计

本安徽新华学院实验中心管理系统采用了MYSQL数据库管理系统，各个数据库表的设计结果如下：

表4-1 users管理员信息表

列名	数据类型	长度	允许空	说明
id	int	20	否	编号
username	varchar	100	是	用户名
password	varchar	100	是	密码
role	varchar	100	是	角色
addtime	timestamp		是	新增时间

表4-2 laoshixinxi老师信息表

列名	数据类型	长度	允许空	说明
id	int	11	否	编号
name	varchar	255	是	用户名称
account	varchar	255	是	账号
password	varchar	255	是	密码
img_photo	varchar	255	是	头像
sex_types	tinyint	255	是	性别
role	varchar	255	是	身份

表4-3 xueshengxinxi学生信息表

列名	数据类型	长度	允许空	说明
Id	int	11	否	编号
name	varchar	255	是	用户名称
account	varchar	255	是	账号
password	varchar	255	是	密码
img_photo	varchar	255	是	头像
sex_types	varchar	255	是	性别
role	varchar	255	是	身份

表4-4　 yiqi仪器信息表

列名	数据类型	长度	允许空	说明
id	int	20	否	编号
serial	varchar	200	是	仪器名称
lx_types	tinyint	4	是	仪器类型
`zy_types	tinyint	4	是	归属专业

表4-5　zhuanye专业信息表

列名	数据类型	长度	允许空	说明
id	int	20	否	编号
serial	varchar	200	是	名称

表4-6　 liuyanxinxi留言信息表

列名	数据类型	长度	允许空	说明
id	int	11	否	编号
note	varchar	255	是	留言信息
yhnote	varchar	11	是	留言人
note_time	timestamp		是	留言时间
reply	varchar	255	是	回复
glreply	varchar	11	是	回复人
`reply_time	timestamp		是	回复时间

5 系统实现

5.1 登录模块的实现

用户要想进入本系统必须进行登录操作，在登录界面输入正确的用户名、密码和选择登录类型，点击登录按钮进行登录系统，系统登录界面展示如图5-1所示。

图5-1系统登录界面图

5.2 学生管理模块的实现

管理员登录后可查看、添加和删除学生信息，老师可查看学生信息，学生可修改个人信息，学生管理界面展示如图5-2所示，添加学生信息界面展示如图5-3所示。

图5-2 学生信息管理界面图

图5-3 添加学生信息界面图

5.3 老师管理模块的实现

管理员可增删改查老师信息，老师可修改个人信息，老师管理界面展示如图5-4所示。

图5-4 老师管理界面图

5.4 课程管理模块的实现

管理员能够增删改查课程信息，老师可查看修改个人课程信息，学生只可查看课程信息，课程管理界面展示如图5-5所示，添加课程信息界面展示如图5-6所示。

图5-5 课程管理界面图

图5-6 添加课程信息界面图

5.5 仪器管理模块的实现

管理员可增删改查仪器信息，学生和老师可查看仪器信息，仪器管理界面展示如图5-7所示。

图5-7 仪器管理界面图

5.6 专业管理模块的实现

管理员能够增删改查专业信息，老师和学生可查看专业信息，专业管理界面展示如图5-8所示。

图5-8 专业管理界面图

5.7 留言管理模块的实现

学生、老师管理员均有留言管理功能，留言管理界面展示如图5-9所示。

图5-9 留言管理界面图

UserController.java

package com.controller;


import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.TokenEntity;
import com.entity.UserEntity;
import com.service.TokenService;
import com.service.UserService;
import com.utils.CommonUtil;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.ValidatorUtils;

/**
 * 登录相关
 */
@RequestMapping("users")
@RestController
public class UserController{
	
	@Autowired
	private UserService userService;
	
	@Autowired
	private TokenService tokenService;

	/**
	 * 登录
	 */
	@IgnoreAuth
	@PostMapping(value = "/login")
	public R login(String username, String password, String role, HttpServletRequest request) {
		UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
		if(user != null){
			if(!user.getRole().equals(role)){
				return R.error("权限不正常");
			}
			if(user==null || !user.getPassword().equals(password)) {
				return R.error("账号或密码不正确");
			}
			String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
			return R.ok().put("token", token);
		}else{
			return R.error("账号或密码或权限不对");
		}

	}
	
	/**
	 * 注册
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }

	/**
	 * 退出
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}
	
	/**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	UserEntity user = userService.selectOne(new EntityWrapper<UserEntity>().eq("username", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
    	user.setPassword("123456");
        userService.update(user,null);
        return R.ok("密码已重置为：123456");
    }
	
	/**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,UserEntity user){
        EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
    	PageUtils page = userService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/list")
    public R list( UserEntity user){
       	EntityWrapper<UserEntity> ew = new EntityWrapper<UserEntity>();
      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
        return R.ok().put("data", userService.selectListView(ew));
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
		Integer id = (Integer)request.getSession().getAttribute("userId");
        UserEntity user = userService.selectById(id);
        return R.ok().put("data", user);
    }

    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody UserEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(userService.selectOne(new EntityWrapper<UserEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        userService.insert(user);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody UserEntity user){
//        ValidatorUtils.validateEntity(user);
        userService.updateById(user);//全部更新
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        userService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}

LaoshixinxiController.java

package com.controller;

import java.text.SimpleDateFormat;
import java.util.*;
import javax.servlet.http.HttpServletRequest;

import com.annotation.IgnoreAuth;
import com.entity.LaoshixinxiEntity;
import com.service.TokenService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;

import com.entity.LaoshixinxiEntity;

import com.service.LaoshixinxiService;
import com.utils.PageUtils;
import com.utils.R;

/**
 * 
 * 后端接口
 * @author
 * @email
 * @date 2021-02-25
*/
@RestController
@Controller
@RequestMapping("/laoshixinxi")
public class LaoshixinxiController {
    private static final Logger logger = LoggerFactory.getLogger(LaoshixinxiController.class);

    @Autowired
    private LaoshixinxiService laoshixinxiService;

    @Autowired
    private TokenService tokenService;

    /**
     * 登录
     */
    @IgnoreAuth
    @PostMapping(value = "/login")
    public R login(String username, String password, String role, HttpServletRequest request) {
        LaoshixinxiEntity user = laoshixinxiService.selectOne(new EntityWrapper<LaoshixinxiEntity>().eq("account", username));
        if(user != null){
            if(!user.getRole().equals(role)){
                return R.error("权限不正常");
            }
            if(user==null || !user.getPassword().equals(password)) {
                return R.error("账号或密码不正确");
            }
            String token = tokenService.generateToken(user.getId(),user.getName(), "users", user.getRole());
            return R.ok().put("token", token);
        }else{
            return R.error("账号或密码或权限不对");
        }

    }

    /**
     * 注册
     */
    @IgnoreAuth
    @PostMapping(value = "/register")
    public R register(@RequestBody LaoshixinxiEntity user){
        if(laoshixinxiService.selectOne(new EntityWrapper<LaoshixinxiEntity>().eq("account", user.getAccount())) !=null) {
            return R.error("老师已存在");
        }
        user.setRole("老师");
        laoshixinxiService.insert(user);
        return R.ok();
    }

    /**
     * 退出
     */
    @GetMapping(value = "logout")
    public R logout(HttpServletRequest request) {
        request.getSession().invalidate();
        return R.ok("退出成功");
    }

    /**
     * 密码重置
     */
    @IgnoreAuth
    @RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
        LaoshixinxiEntity user = laoshixinxiService.selectOne(new EntityWrapper<LaoshixinxiEntity>().eq("username", username));
        if(user==null) {
            return R.error("账号不存在");
        }
        user.setPassword("123456");
        laoshixinxiService.update(user,null);
        return R.ok("密码已重置为：123456");
    }

    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
        Integer id = (Integer)request.getSession().getAttribute("userId");
        LaoshixinxiEntity user = laoshixinxiService.selectById(id);
        return R.ok().put("data", user);
    }
    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("Controller:"+this.getClass().getName()+",page方法");
        Object role = request.getSession().getAttribute("role");
        PageUtils page = null;
        if(role.equals("老师")){
            params.put("yh",request.getSession().getAttribute("userId"));
            page = laoshixinxiService.queryPage(params);
        }else{
            page = laoshixinxiService.queryPage(params);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        logger.debug("Controller:"+this.getClass().getName()+",info方法");
        LaoshixinxiEntity laoshixinxi = laoshixinxiService.selectById(id);
        if(laoshixinxi!=null){
            return R.ok().put("data", laoshixinxi);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody LaoshixinxiEntity laoshixinxi, HttpServletRequest request){
        logger.debug("Controller:"+this.getClass().getName()+",save");
        Wrapper<LaoshixinxiEntity> queryWrapper = new EntityWrapper<LaoshixinxiEntity>()
            .eq("name", laoshixinxi.getName())
            .eq("account", laoshixinxi.getAccount())
            .eq("password", laoshixinxi.getPassword())
            .eq("sex_types", laoshixinxi.getSexTypes())
            .eq("role", laoshixinxi.getRole())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        LaoshixinxiEntity laoshixinxiEntity = laoshixinxiService.selectOne(queryWrapper);
        if("".equals(laoshixinxi.getImgPhoto()) || "null".equals(laoshixinxi.getImgPhoto())){
            laoshixinxi.setImgPhoto(null);
        }
        if(laoshixinxiEntity==null){
            laoshixinxi.setRole("老师");
            laoshixinxiService.insert(laoshixinxi);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody LaoshixinxiEntity laoshixinxi, HttpServletRequest request){
        logger.debug("Controller:"+this.getClass().getName()+",update");
        //根据字段查询是否有相同数据
        Wrapper<LaoshixinxiEntity> queryWrapper = new EntityWrapper<LaoshixinxiEntity>()
            .notIn("id",laoshixinxi.getId())
            .eq("name", laoshixinxi.getName())
            .eq("account", laoshixinxi.getAccount())
            .eq("password", laoshixinxi.getPassword())
            .eq("sex_types", laoshixinxi.getSexTypes())
            .eq("role", laoshixinxi.getRole())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        LaoshixinxiEntity laoshixinxiEntity = laoshixinxiService.selectOne(queryWrapper);
        if("".equals(laoshixinxi.getImgPhoto()) || "null".equals(laoshixinxi.getImgPhoto())){
                laoshixinxi.setImgPhoto(null);
        }
        if(laoshixinxiEntity==null){
            laoshixinxiService.updateById(laoshixinxi);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        logger.debug("Controller:"+this.getClass().getName()+",delete");
        laoshixinxiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}

DictionaryController.java

package com.controller;

import java.text.SimpleDateFormat;
import java.util.*;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;

import com.entity.DictionaryEntity;

import com.service.DictionaryService;
import com.utils.PageUtils;
import com.utils.R;

/**
 * 字典表
 * 后端接口
 * @author
 * @email
 * @date 2021-02-26
*/
@RestController
@Controller
@RequestMapping("/dictionary")
public class DictionaryController {
    private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);

    @Autowired
    private DictionaryService dictionaryService;

    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params){
        logger.debug("Controller:"+this.getClass().getName()+",page方法");
        PageUtils page = dictionaryService.queryPage(params);
        return R.ok().put("data", page);
    }
    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id){
        logger.debug("Controller:"+this.getClass().getName()+",info方法");
        DictionaryEntity dictionary = dictionaryService.selectById(id);
        if(dictionary!=null){
            return R.ok().put("data", dictionary);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
        logger.debug("Controller:"+this.getClass().getName()+",save");
        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
            .eq("dic_code", dictionary.getDicCode())
            .eq("dic_name", dictionary.getDicName())
            .eq("code_index", dictionary.getCodeIndex())
            .eq("index_name", dictionary.getIndexName())
            .eq("super_id", dictionary.getSuperId())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
        if(dictionaryEntity==null){
            dictionaryService.insert(dictionary);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
        logger.debug("Controller:"+this.getClass().getName()+",update");
        //根据字段查询是否有相同数据
        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
            .notIn("id",dictionary.getId())
            .eq("dic_code", dictionary.getDicCode())
            .eq("dic_name", dictionary.getDicName())
            .eq("code_index", dictionary.getCodeIndex())
            .eq("index_name", dictionary.getIndexName())
            .eq("super_id", dictionary.getSuperId())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
        if(dictionaryEntity==null){
            dictionaryService.updateById(dictionary);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }


    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
        logger.debug("Controller:"+this.getClass().getName()+",delete");
        dictionaryService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
}

jquery.icheck.js

/*!
 * iCheck v0.9.1, http://git.io/uhUPMA
 * =================================
 * Powerful jQuery plugin for checkboxes and radio buttons customization
 *
 * (c) 2013 Damir Foy, http://damirfoy.com
 * MIT Licensed
 */

(function($) {

  // Cached vars
  var _iCheck = 'iCheck',
    _iCheckHelper = _iCheck + '-helper',
    _checkbox = 'checkbox',
    _radio = 'radio',
    _checked = 'checked',
    _unchecked = 'un' + _checked,
    _disabled = 'disabled',
    _determinate = 'determinate',
    _indeterminate = 'in' + _determinate,
    _update = 'update',
    _type = 'type',
    _click = 'click',
    _touch = 'touchbegin.i touchend.i',
    _add = 'addClass',
    _remove = 'removeClass',
    _callback = 'trigger',
    _label = 'label',
    _cursor = 'cursor',
    _mobile = /ipad|iphone|ipod|android|blackberry|windows phone|opera mini|silk/i.test(navigator.userAgent);

  // Plugin init
  $.fn[_iCheck] = function(options, fire) {

    // Walker
    var handle = ':' + _checkbox + ', :' + _radio,
      stack = $(),
      walker = function(object) {
        object.each(function() {
          var self = $(this);

          if (self.is(handle)) {
            stack = stack.add(self);
          } else {
            stack = stack.add(self.find(handle));
          };
        });
      };

    // Check if we should operate with some method
    if (/^(check|uncheck|toggle|indeterminate|determinate|disable|enable|update|destroy)$/i.test(options)) {

      // Normalize method's name
      options = options.toLowerCase();

      // Find checkboxes and radio buttons
      walker(this);

      return stack.each(function() {
        if (options == 'destroy') {
          tidy(this, 'ifDestroyed');
        } else {
          operate($(this), true, options);
        };

        // Fire method's callback
        if ($.isFunction(fire)) {
          fire();
        };
      });

    // Customization
    } else if (typeof options == 'object' || !options) {

      // Check if any options were passed
      var settings = $.extend({
          checkedClass: _checked,
          disabledClass: _disabled,
          indeterminateClass: _indeterminate,
          labelHover: true
        }, options),

        selector = settings.handle,
        hoverClass = settings.hoverClass || 'hover',
        focusClass = settings.focusClass || 'focus',
        activeClass = settings.activeClass || 'active',
        labelHover = !!settings.labelHover,
        labelHoverClass = settings.labelHoverClass || 'hover',

        // Setup clickable area
        area = ('' + settings.increaseArea).replace('%', '') | 0;

      // Selector limit
      if (selector == _checkbox || selector == _radio) {
        handle = ':' + selector;
      };

      // Clickable area limit
      if (area < -50) {
        area = -50;
      };

      // Walk around the selector
      walker(this);

      return stack.each(function() {

        // If already customized
        tidy(this);

        var self = $(this),
          node = this,
          id = node.id,

          // Layer styles
          offset = -area + '%',
          size = 100 + (area * 2) + '%',
          layer = {
            position: 'absolute',
            top: offset,
            left: offset,
            display: 'block',
            width: size,
            height: size,
            margin: 0,
            padding: 0,
            background: '#fff',
            border: 0,
            opacity: 0
          },

          // Choose how to hide input
          hide = _mobile ? {
            position: 'absolute',
            visibility: 'hidden'
          } : area ? layer : {
            position: 'absolute',
            opacity: 0
          },

          // Get proper class
          className = node[_type] == _checkbox ? settings.checkboxClass || 'i' + _checkbox : settings.radioClass || 'i' + _radio,

          // Find assigned labels
          label = $(_label + '[for="' + id + '"]').add(self.closest(_label)),

          // Wrap input
          parent = self.wrap('<div class="' + className + '"/>')[_callback]('ifCreated').parent().append(settings.insert),

          // Layer addition
          helper = $('<ins class="' + _iCheckHelper + '"/>').css(layer).appendTo(parent);

        // Finalize customization
        self.data(_iCheck, {o: settings, s: self.attr('style')}).css(hide);
        !!settings.inheritClass && parent[_add](node.className);
        !!settings.inheritID && id && parent.attr('id', _iCheck + '-' + id);
        parent.css('position') == 'static' && parent.css('position', 'relative');
        operate(self, true, _update);

        // Label events
        if (label.length) {
          label.on(_click + '.i mouseenter.i mouseleave.i ' + _touch, function(event) {
            var type = event[_type],
              item = $(this);

            // Do nothing if input is disabled
            if (!node[_disabled]) {

              // Click
              if (type == _click) {
                operate(self, false, true);

              // Hover state
              } else if (labelHover) {

                // mouseleave|touchend
                if (/ve|nd/.test(type)) {
                  parent[_remove](hoverClass);
                  item[_remove](labelHoverClass);
                } else {
                  parent[_add](hoverClass);
                  item[_add](labelHoverClass);
                };
              };

              if (_mobile) {
                event.stopPropagation();
              } else {
                return false;
              };
            };
          });
        };

        // Input events
        self.on(_click + '.i focus.i blur.i keyup.i keydown.i keypress.i', function(event) {
          var type = event[_type],
            key = event.keyCode;

          // Click
          if (type == _click) {
            return false;

          // Keydown
          } else if (type == 'keydown' && key == 32) {
            if (!(node[_type] == _radio && node[_checked])) {
              if (node[_checked]) {
                off(self, _checked);
              } else {
                on(self, _checked);
              };
            };

            return false;

          // Keyup
          } else if (type == 'keyup' && node[_type] == _radio) {
            !node[_checked] && on(self, _checked);

          // Focus/blur
          } else if (/us|ur/.test(type)) {
            parent[type == 'blur' ? _remove : _add](focusClass);
          };
        });

        // Helper events
        helper.on(_click + ' mousedown mouseup mouseover mouseout ' + _touch, function(event) {
          var type = event[_type],

            // mousedown|mouseup
            toggle = /wn|up/.test(type) ? activeClass : hoverClass;

          // Do nothing if input is disabled
          if (!node[_disabled]) {

            // Click
            if (type == _click) {
              operate(self, false, true);

            // Active and hover states
            } else {

              // State is on
              if (/wn|er|in/.test(type)) {

                // mousedown|mouseover|touchbegin
                parent[_add](toggle);

              // State is off
              } else {
                parent[_remove](toggle + ' ' + activeClass);
              };

              // Label hover
              if (label.length && labelHover && toggle == hoverClass) {

                // mouseout|touchend
                label[/ut|nd/.test(type) ? _remove : _add](labelHoverClass);
              };
            };

            if (_mobile) {
              event.stopPropagation();
            } else {
              return false;
            };
          };
        });
      });
    } else {
      return this;
    };
  };

  // Do something with inputs
  function operate(input, direct, method) {
    var node = input[0];
      state = /er/.test(method) ? _indeterminate : /bl/.test(method) ? _disabled : _checked,
      active = method == _update ? {
        checked: node[_checked],
        disabled: node[_disabled],
        indeterminate: input.attr(_indeterminate) == 'true' || input.attr(_determinate) == 'false'
      } : node[state];

    // Check, disable or indeterminate
    if (/^(ch|di|in)/.test(method) && !active) {
      on(input, state);

    // Uncheck, enable or determinate
    } else if (/^(un|en|de)/.test(method) && active) {
      off(input, state);

    // Update
    } else if (method == _update) {

      // Handle states
      for (var state in active) {
        if (active[state]) {
          on(input, state, true);
        } else {
          off(input, state, true);
        };
      };

    } else if (!direct || method == 'toggle') {

      // Helper or label was clicked
      if (!direct) {
        input[_callback]('ifClicked');
      };

      // Toggle checked state
      if (active) {
        if (node[_type] !== _radio) {
          off(input, state);
        };
      } else {
        on(input, state);
      };
    };
  };

  // Add checked, disabled or indeterminate state
  function on(input, state, keep) {
    var node = input[0],
      parent = input.parent(),
      checked = state == _checked,
      indeterminate = state == _indeterminate,
      callback = indeterminate ? _determinate : checked ? _unchecked : 'enabled',
      regular = option(node, callback + capitalize(node[_type])),
      specific = option(node, state + capitalize(node[_type]));

    // Prevent unnecessary actions
    if (node[state] !== true) {

      // Toggle assigned radio buttons
      if (!keep && state == _checked && node[_type] == _radio && node.name) {
        var form = input.closest('form'),
          inputs = 'input[name="' + node.name + '"]';

        inputs = form.length ? form.find(inputs) : $(inputs);

        inputs.each(function() {
          if (this !== node && $.data(this, _iCheck)) {
            off($(this), state);
          };
        });
      };

      // Indeterminate state
      if (indeterminate) {

        // Add indeterminate state
        node[state] = true;

        // Remove checked state
        if (node[_checked]) {
          off(input, _checked, 'force');
        };

      // Checked or disabled state
      } else {

        // Add checked or disabled state
        if (!keep) {
          node[state] = true;
        };

        // Remove indeterminate state
        if (checked && node[_indeterminate]) {
          off(input, _indeterminate, false);
        };
      };

      // Trigger callbacks
      callbacks(input, checked, state, keep);
    };

    // Add proper cursor
    if (node[_disabled] && !!option(node, _cursor, true)) {
      parent.find('.' + _iCheckHelper).css(_cursor, 'default');
    };

    // Add state class
    parent[_add](specific || option(node, state));

    // Remove regular state class
    parent[_remove](regular || option(node, callback) || '');
  };

  // Remove checked, disabled or indeterminate state
  function off(input, state, keep) {
    var node = input[0],
      parent = input.parent(),
      checked = state == _checked,
      indeterminate = state == _indeterminate,
      callback = indeterminate ? _determinate : checked ? _unchecked : 'enabled',
      regular = option(node, callback + capitalize(node[_type])),
      specific = option(node, state + capitalize(node[_type]));

    // Prevent unnecessary actions
    if (node[state] !== false) {

      // Toggle state
      if (indeterminate || !keep || keep == 'force') {
        node[state] = false;
      };

      // Trigger callbacks
      callbacks(input, checked, callback, keep);
    };

    // Add proper cursor
    if (!node[_disabled] && !!option(node, _cursor, true)) {
      parent.find('.' + _iCheckHelper).css(_cursor, 'pointer');
    };

    // Remove state class
    parent[_remove](specific || option(node, state) || '');

    // Add regular state class
    parent[_add](regular || option(node, callback));
  };

  // Remove all traces
  function tidy(node, callback) {
    if ($.data(node, _iCheck)) {
      var input = $(node);

      // Remove everything except input
      input.parent().html(input.attr('style', $.data(node, _iCheck).s || '')[_callback](callback || ''));

      // Unbind events
      input.off('.i').unwrap();
      $(_label + '[for="' + node.id + '"]').add(input.closest(_label)).off('.i');
    };
  };

  // Get some option
  function option(node, state, regular) {
    if ($.data(node, _iCheck)) {
      return $.data(node, _iCheck).o[state + (regular ? '' : 'Class')];
    };
  };

  // Capitalize some string
  function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
  };

  // Executable handlers
  function callbacks(input, checked, callback, keep) {
    if (!keep) {
      if (checked) {
        input[_callback]('ifToggled');
      };

      input[_callback]('ifChanged')[_callback]('if' + capitalize(callback));
    };
  };
})(jQuery);

声明

本博客适用于广泛的学术和教育用途，包括但不限于个人学习、开发设计，产品设计。仅供学习参考，旨在为读者提供深入理解和学术研究的材料。