[大数据]SSM综合练习-山东医院项目

0.讲给世界听：

???什么是快，什么是慢。
???如果Javaweb项目是我写这篇大博客的重要节点的话，那么这篇博客就是我Java知识体系中的一道分水岭。
???这篇博客注定了写起来会很麻烦，我现在还差最后一章：十五章学习结束就可以完成培训内容了，我现在已经开始了实战阶段的经历。没有任何培训的伙伴有写他的想法。。网上也没有找到类似的内容。
???我要完成他吗，即使写完了也没有什么人看。有什么意义呢？
???我要完成他吧，毕竟我们最后还是要以自己的方式来理解世界的。
???而且不写出来我的Java知识体系博客没有办法闭合，我的面试没有抓手。毕竟自己是一个遗忘属性点满地点人啊。
???什么是快，什么是慢。快即是慢，慢即是快。写完这个博客再开始学习下一章吧。

一.开发背景

是培训进度使然，亦是我学习Java的必然。
附录：培训给的学习资料。这个可以上网继续搜索的。
链接：https://pan.baidu.com/s/1UDJ_rKJjIJO-TwVazmuxvA
提取码：1111

1.1任务要求视频（只有这一个视频）：

1.2山东医院问题“

???系统的用户和权限：
??????管理员：所有权限
??????前台挂号员：密码管理、挂号信息管理
??????住院办理员：住院办理、住院结算、密码管理
??????医药管理员：药品管理、在院发药、密码管理
??????医生：收费项登记、密码管理
??????做登录的人员的 过滤器：以及 判断
??????当前登录人 的状态，是否被删除 ，
??????当前登录人的角色 是否被 禁用，，
??????当前登录人 对应的 菜单 资源 是否 被 禁用
???项目中的问题：
??????发药库存的问题 ：
??????开药之后的药品数量 ： 就不能退药 了
??????发药之后 库存应该是 现在的库存 - 医生给开的药品数量
??????收费项目登记 ：只登记 所做的检查 的 项目
??????住院结算中 详情中的 感冒药 为 单独 查询 药品表 查询出来，，展示 出来
??????分页显示：可以 封装一个 包装类， 把收费项目的类 和 药品 的类 包含进去 从而 就可以 分页展示
??????//去掉收费项目详情 中的 分页
??????发药的时候 只能给 住院的 人 发药 。所以：在院发药中 查出来的 是 住院表 中的 信息
??????发药的问题：发药的时候 要异步检测一下 余额是否 大于 当前药品的价格否则 ，不能发药成功
??????住院结算：详情展示：跟 收费项目 登记中的 详情 是不一样的
??????科室表 不能写死

1.36人打分卡:

???我主要完成系统的用户和权限问题，对应打分卡的p1,p6

二.系统分析

这里是缺失的部分。样式，要求都给我们了。没有进行分析的过程。
以后的项目有这个过程，我会写上的。
这里写上为了结构的完整性。

2.1需求分析：

医院管理平台，具体的完成情况见视频。

2.2功能分析：

随便选一个任务卡，完成他就可以了。

三.系统设计：

3.1用例图设计系统功能

山东医院后台是一个管理医院内部人员使用的系统。也就是说不是所有人都能使用他，不同的人有不同的身份，管理不同的功能。主要分为管理员，药品管理员，医生，医院前台，住院办理员这五类。
其角色权限划分如下：
???1.管理员：用户管理，角色管理，资源管理，门诊医生管理，收费项管理，密码管理。
???2.药品管理员：药品管理，在院发药，密码管理。
???3.医生：收费项目登记，密码管理。
???4.医院前台：挂号信息管理，密码管理。
???住院办理员：住院办理，住院结算，密码管理。
我主要复制角色权限管理部分，用户管理，角色管理，资源管理，密码管理功能。
下面以管理员为例绘制其所对应的用例图如下：

3.2绘制系统流程图

本系统首先要进行验证码的校验，校验完后开始对用户的角色进行识别，角色识别合格后对用户的身份进行识别，如果用户正常存在则对用户是否正常使用进行识别。满足以上识别条件后，进入后台系统后，在系统首页的菜单栏可以选择各种链接来进行各种操作。由于不同权限的用户对于系统有
不同的功能，下面以我主要做的管理员为例。(门诊医生管理，收费项管理这俩功能没有做，就不写上了)

3.3系统演示

具体的操作的话我就不说了，因为我会直接放视频，我给的资料直接运行也可以得到结果。

3.3.1p6-登录功能

关于以下功能的演示：
???用户的角色校验功能
???用户名，密码，验证码为空校验及错误校验+提示
???验证码更换
???系统正常拦截非登录校验
???登录到系统首页
???用户的真实姓名显示
???退出登录
视频如下：

3.3.2p6-密码管理

关于以下功能的演示：
???原密码，新密码，重复密码的非空验证和强度验证
???新密码和原密码，新密码和确认密码的一致性验证
???原密码的准确性验证
???修改密码成功
视频如下：

3.3.3p1-逻辑实现

关于以下功能的演示：
???左侧菜单栏的显示
???登录不同的角色，查看左侧不同的菜单
???实现，新增加的菜单，赋予新的角色，创建新用户拥有新角色，左侧得到相对应的菜单
???失效菜单，不可以显示
???禁用角色，所有该角色下用户不可以登录
???禁用角色，该用户不可以登录
视频如下：

3.3.4p1-用户管理

关于以下功能的演示：

视频如下：

3.3.5p1-角色管理

关于以下功能的演示：

视频如下：

3.3.6p1-资源管理

关于以下功能的演示：

视频如下：

3.4系统开发环境

类似这样的：

我的idea是2019.3.4版本，试用
数据库是5.7的，windows系统。

3.5文件家组织结构

在编写代码之前，首先需要将系统中可能用到的文件夹创建好，这样可以方便网站开发工作，同时规范网站的整体架构，本系统的文件夹组织结构如下：

四.数据库的分析与设计

4.1数据库分析

这个都是给好的数据库设计表，按照页面也特别好猜测数据库。这是我当时分析时画的。我要做的就是权限相关的那几个表。因为他们正好是一个闭环。

4.2数据库设计

整体设计需要十一个表，我做和权限相关的四个表。之前的Javaweb前置项目里我说过权限模块。这里不用重复。ER图不画了。

4.2.1逻辑设计

用户表

角色表

菜单表

角色-菜单表

4.2.2具体数据表

用户表

角色表

菜单表

角色-菜单表

补充：接口设计：

这个以后加上，但是目前理解不到，先空着吧。

五.公共设计

5.1代码生成器

这个在36-Mybatis-13里说过，我不在重复。发一下代码
pom.xml

       <!-- 反向生成插件依赖-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>
        <dependency>
            <groupId>com.liferay</groupId>
            <artifactId>javax.servlet.jsp.jstl</artifactId>
            <version>1.2.3.LIFERAY-PATCHED-2</version>
        </dependency>


	 		<resources>
	            <resource>
	                <directory>src/main/resources</directory>
	                <!--所在的目录-->
	                <includes>
	                    <!--包括目录下的.properties,.xml 文件都会被扫描到-->
	                    <include>**/*.properties</include>
	                    <include>**/*.xml</include>
	                </includes>
	                <filtering>false</filtering>
	            </resource>
	        </resources>
  <!--反向生成插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <configuration>
                    <!--配置文件的路径-->
                    <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC
        "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<!-- 配置生成器:标了序号的部分都需要修改为自己的内容 -->
<generatorConfiguration>
    <!--1、数据库驱动jar:添加自己的jar路径 -->
    <classPathEntry location="D:\zyrj\A01Java\a07_maven\maven_repository\mysql\mysql-connector-java\8.0.23\mysql-connector-java-8.0.23.jar"/>
    <context id="MyBatis" targetRuntime="MyBatis3">
        <!--去除注释 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!--2、数据库连接 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/ssm_xm_shandong_hospital?useUnicode=true&amp;characterEncoding=utf-8"
                        userId="kaikeba"
                        password="kaikeba">
            <property name="nullCatalogMeansCurrent" value="true"/>
        </jdbcConnection>
        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer;
        为 true时把JDBC DECIMAL和NUMERIC类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!--3、生成实体类 指定包名 以及生成的地址 （可以自定义地址，但是路径不存在不会自动创建 使用Maven生成在target目录下，会自动创建） -->
        <javaModelGenerator targetPackage="com.kkb.pojo" targetProject="src\main\java">
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!--4、生成SQLmapper.xml映射文件 -->
        <sqlMapGenerator targetPackage="com.kkb.mapper"
                         targetProject="src\main\resources"></sqlMapGenerator>
        <!--5、生成Dao（Mapper）接口文件,-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.kkb.mapper"
                             targetProject="src\main\java"></javaClientGenerator>
        <!--6、要生成哪些表(更改tableName和domainObjectName就可以) -->
        <!-- tableName:要生成的表名
        enableCountByExample:Count语句中加入where条件查询，默认为true开启
        enableUpdateByExample:Update语句中加入where条件查询，默认为true开启
        enableDeleteByExample:Delete语句中加入where条件查询，默认为true开启
        enableSelectByExample:Select多条语句中加入where条件查询，默认为true开启
        selectByExampleQueryId:Select单个对象语句中加入where条件查询，默认为true开启 -->
        <!--        <table tableName="Team" enableCountByExample="false" enableUpdateByExample="false"-->
        <!--               enableUpdateByPrimaryKey="false" enableDeleteByExample="false" enableDeleteByPrimaryKey="false"-->
        <!--               enableSelectByExample="false" selectByExampleQueryId="false">-->
        <!--            <property name="useActualColumnNames" value="true"/>-->
        <!--        </table>-->
        <table tableName="menu">

        </table>
        <table tableName="role">

        </table>
        <table tableName="user">

        </table>
    </context>
</generatorConfiguration>

其自动生成的文件如下：

5.2用户工具类

我在代码里的很多地方用到了使用session获取用户名,，角色id的方法

package com.kkb.util;

import javax.servlet.http.HttpSession;

/**
 * 用户工具类
 * 功能：存取用户名，角色id
 */
public class UserUtil {
    public static void setUserName(HttpSession session, String username){
        session.setAttribute("adminUserName",username);
    }

    public static String getUserName(HttpSession session){
        String userName = (String) session.getAttribute("adminUserName");
        return userName;
    }

    public static void setRoleId(HttpSession session, Integer rId){
        session.setAttribute("rId",rId);
    }

    public static int getRoleId(HttpSession session){
        return (int) session.getAttribute("rId");
    }
}

5.3返回结果的统一封装类

一共有五个。这里放第一个：返回结果的统一封装类：
他可以：
???返回集合，返回单个对象，返回分页对象
???返回的状态码为200，展示给用户的信息为ok。
???还可以返回菜单集合，用户集合，角色集合

package com.kkb.vo;

import com.github.pagehelper.PageInfo;
import com.kkb.pojo.Menu;
import com.kkb.pojo.Role;
import com.kkb.pojo.User;

import java.util.List;

/**
 *  返回结果的统一封装类
 */
public class ResultVO<T> {
    private List<T> list; //返回集合
    private T obj;//返回单个对象

    private PageInfo<T> pageInfo;// 返回分页对象
    private Integer code=200;// 表示返回的状态码
    private String msg="ok";// 表示可以展示给用户的信息

    private List<Menu> menuList; // 返回菜单集合1
    private List<Menu> menu; // 返回菜单集合1
    private List<User> userList; // 返回用户集合
    private List<Role> roleList; // 返回角色集合

    public ResultVO(PageInfo<T> pageInfo, List<Role> roleList) {
        this.pageInfo = pageInfo;
        this.roleList = roleList;
    }

    public ResultVO(List<Menu> menuList,List<Menu> menu,T obj) {
        this.menuList = menuList;
        this.menu = menu;
        this.obj = obj;
    }

    public ResultVO(List<T> list, List<User> userList) {
        this.list = list;
        this.userList = userList;
    }

    public ResultVO(T obj, List<Menu> menuList) {
        this.obj = obj;
        this.menuList = menuList;
    }

    public PageInfo<T> getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo<T> pageInfo) {
        this.pageInfo = pageInfo;
    }


    public ResultVO() {
    }


    public ResultVO(T obj) {
        this.obj = obj;
    }

    public ResultVO(List<T> list, T obj) {
        this.list = list;
        this.obj = obj;
    }

    public ResultVO(List<T> list) {
        this.list = list;
    }

    public ResultVO(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public ResultVO(List<T> list, T obj, List<User> userList) {
        this.list = list;
        this.obj = obj;
        this.userList = userList;
    }


    public List<Menu> getMenu() {
        return menu;
    }

    public void setMenu(List<Menu> menu) {
        this.menu = menu;
    }

    public List<User> getUserList() {
        return userList;
    }

    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    public List<Menu> getMenuList() {
        return menuList;
    }

    public void setMenuList(List<Menu> menuList) {
        this.menuList = menuList;
    }

    public List<Role> getRoleList() {
        return roleList;
    }

    public void setRoleList(List<Role> roleList) {
        this.roleList = roleList;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "ResultVO{" +
                "list=" + list +
                ", obj=" + obj +
                ", code=" + code +
                ", msg='" + msg + '\'' +
                ", menuList=" + menuList +
                ", userList=" + userList +
                ", roleList=" + roleList +
                '}';
    }
}

六.具体代码设计

6.1系统登录模块

这里是总-分-总的模式

6.1.1登录流程

登录大体的思路是这样的。
首先进行登录的时候，未登录/登录不成功的人是不可以访问系统的。
登录时本系统首先要进行验证码的校验，校验完后开始对用户的角色进行识别，角色识别合格后对用户的身份进行识别，如果用户正常存在则对用户是否正常使用进行识别。满足以上识别条件后，进入后台系统，在系统首页显示用户的真实姓名，点击退出返回登录页面。

6.1.2系统正常拦截非登录校验

这个用了过滤器方法来实现此功能，逻辑是这样的。当我们成功登录页面后，会把用户名信息以session形式保存。未成功登录页面时，session里没有对应的用户名信息。过滤器通过判断session来过滤登录信息。如果用户名不为空，则正常登录，否则显示对应错误信息。
过滤器代码如下：
???web.xml里没有与之相关的过滤器配置。我把过滤路径放在@WebFilter里了。
???web.xml里有的两个过滤器是为了post请求中文乱码问题，使用Rest风格的URI 将页面普通的post请求转为指定的delete或者put请求。

package com.kkb.filter;

import com.kkb.util.UserUtil;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebFilter({"/pages/index.html","/pages/doctor/*","/pages/hospital/*","/pages/medicine/*","/pages/registration/*","/pages/resource/*","/pages/role/*","/pages/user/*"})
public class AccessControllerFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化过滤器");
    }

    // 通过判断session来过滤登录信息
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request1=(HttpServletRequest) request ;
        HttpServletResponse response1=(HttpServletResponse) response;
        String userName = UserUtil.getUserName(request1.getSession());
        StringBuffer requestURL = request1.getRequestURL();
        String s = requestURL.toString();
        if(userName!=null||s.equals("http://localhost/role/getroleinfo.do")){
            chain.doFilter(request, response);
        }else {
            response1.sendError(404,"很遗憾，权限不足");
        }
    }

    @Override
    public void destroy() {
        System.out.println("过滤器销毁");
    }
}

与之相关的登录代码

  UserUtil.setUserName(request.getSession(), uLoginname);
  UserUtil.setRoleId(request.getSession(),role);

6.1.3验证码更换及校验

关于验证码的部分，我全都放在了前端。
输入及显示验证码如下：

<input type="text" id="inputVerify" name="verify" class="input-medium" placeholder="验证码">
<span id="verify" style="margin-left: 10px; font-size: 20px; color: #1c6a9e;"  onclick="changeVerify()">7777</span>

验证码验证

function isVerify() {
    let initData = $("#verify").html();
    let inputData = $("#inputVerify").val();
    if(inputData == ''){
        alert("请输入验证码");
        return false;
    } else {
        if(inputData.toUpperCase() == initData.toUpperCase()){
            return true;
        } else{
            alert("验证码输入有误，请重新输入")
            return false;
        }
    }
}

生成验证码

function changeVerify() {
    //生成4位i随机数
    let str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
    let arr = str.split("");
    let result = "";
    for(let i=0;i<4;i++)
    {
        let n = Math.floor(Math.random() * arr.length);
        result += arr[n];
    }
    $("#verify").html(result);
}

放入总校验

   $(function (){
        $("#inputVerify").blur(function() {
            isVerify();
        });
    });

6.1.4用户的角色校验功能

不是一上来就可以直接校验角色的，要先显示角色列表。
获取角色列表的前端方法：

请选择角色：<select id="role">

</select>

$(function (){
    $.getJSON("/role/getroleinfo.do",null,function (vo){
        let list=vo.list;
        let str="";
        for (let i=0;i<list.length;i++){
            str+="<option value=\""+list[i].rId+"\">"+list[i].rName+"\n";
        }
        $("#role").html(str);
    });
})

获取角色列表的后端方法：
角色controller:

  @Resource
    private RoleService roleService;

    /**
     * 获取全部的角色信息
     * @return
     */
    @RequestMapping("getroleinfo.do")
    public ResultVO<Role> getRoleInfo(){
        List<Role> roles = roleService.queryAll();
        return new ResultVO<>(roles);
    }

角色service:

@Resource
private RoleMapper roleMapper;

/**
 * 查询所有的角色信息
 * @return
 */
public List<Role> queryAll(){
    List<Role> roles = roleMapper.selectByExample(null);
    return roles;
}

角色mapper及对应的xml

  List<Role> selectByExample(RoleExample example);

  <select id="selectByExample" parameterType="com.kkb.pojo.RoleExample" resultMap="BaseResultMap">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    from role
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>
  </select>

之后就是进行角色的判断。
他的思路是这样的：
前端在登录方法传入用户名，密码，用户角色。登录成功跳转到系统首页。失败返回对应错误信息。

<h2 class="form-signin-heading">&nbsp;&nbsp;&nbsp;登录系统</h2>
<input id="uLoginname" type="text" name="username" class="input-block-level" placeholder="账号"><span id="uNameMsg"></span>
<input id="uPassword" type="password" name="password" class="input-block-level" placeholder="密码"><span id="uPassMsg"></span>
请选择角色：<select id="role">

</select>
<input type="text" id="inputVerify" name="verify" class="input-medium" placeholder="验证码">
<span id="verify" style="margin-left: 10px; font-size: 20px; color: #1c6a9e;"  onclick="changeVerify()">7777</span>
   
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<button id="access" class="btn btn-large btn-primary" type="button" onclick="login()">登录</button></p>

function login(){
    let uLoginname = $("#uLoginname").val();
    let uPassword=$("#uPassword").val();
    let role = $("#role option:selected").val();
    $.getJSON("/login.do",{uLoginname:uLoginname,uPassword:uPassword,role:role},function (vo){
        if(vo.code==200){
            let uId=vo.obj.uId;
            alert("登陆成功");
            window.location.href="/pages/index.html?rId="+vo.obj.rId+"&uId="+uId;
        }else {
            alert(vo.msg);
        }
    });
}

后端接收这些参数。
???1，后端获取角色列表，并遍历角色列表
???2，如果登录角色id=遍历到的角色id，正常使用的往下走，否则结果集中填写对应错误信息
???3，根据传入的三个参数，进行模糊查询，返回符合条件用户信息
???4，获取角色的状态码
???5，如果该角色是被正常使用的往下走，否则结果集中填写对应错误信息
???6，如果该用户正常存在的往下走，否则结果集中填写对应错误信息
???7，通过用户的状态码判断用户是否正常存在。如果该用户是被正常使用的往下走，否则结果集中填写对应错误信息
???8，通过用户工具类存入对应用户信息，角色信息到session。并把用户信息存入结果集中
所以判断还是很多的。

登录controller

    @Resource
    private UserService userService;
    @Resource
    private RoleService roleService;

   /**
     * 登录操作
     * @param request
     * @return
     */
    @RequestMapping("login.do")
    public ResultVO<User> login(HttpServletRequest request) {
        // 1，获取登录名称，密码。登录角色Id
        String uLoginname = request.getParameter("uLoginname");
        String uPassword = request.getParameter("uPassword");
        int role = Integer.parseInt(request.getParameter("role"));
        // 2，获取角色列表
        List<Role> roles = roleService.queryAll();
        // 3，定义结果集
        ResultVO<User> vo = new ResultVO<>();
            for (Role r : roles) {// 4，遍历角色列表
                if (r.getrId() == role) {// 5，如果登录角色id=遍历到的角色id，正常使用的往下走，否则结果集中填写对应错误信息
                    // 6，模糊查询，返回符合条件用户信息
                    List<User> users = userService.queryLPR(uLoginname, uPassword, role);
                    // 7，获取角色的状态码
                    Integer rState = r.getrState();
                    if (rState == 0) {// 8.1如果该角色是被正常使用的往下走，否则结果集中填写对应错误信息
                        if (users.size() > 0) {// 8.2如果该用户正常存在的往下走，否则结果集中填写对应错误信息
                            if (users.get(0).getuState() == 0) {// 8.3如果该用户是被正常使用的往下走，否则结果集中填写对应错误信息
                                // 9，设置用户的登录名称，和其角色id，并把用户信息存入结果集中
                                UserUtil.setUserName(request.getSession(), uLoginname);
                                UserUtil.setRoleId(request.getSession(),role);
                                vo.setObj(users.get(0));

                                System.out.println(vo);// 看一下结果
                            } else {
                                vo.setCode(500);
                                vo.setMsg("该用户已被禁用或删除");
                            }
                        } else {
                            vo.setCode(500);
                            vo.setMsg("密码错误或角色不匹配，请重新输入");
                        }
                    } else {
                        vo.setCode(500);
                        vo.setMsg("该角色已被删除或禁用");
                    }
                }
            }
        return vo;
    }

获取角色列表方法同上。
模糊查询，返回符合条件用户信息方法
用户service

@Resource
private UserMapper userMapper;

public List<User> queryLPR(String uLoginname,String uPassword,int rId){
    UserExample example=new UserExample();
    UserExample.Criteria criteria = example.createCriteria();
    criteria.andULoginnameEqualTo(uLoginname);
    criteria.andUPasswordEqualTo(uPassword);
    criteria.andRIdEqualTo(rId);
    List<User> users = userMapper.selectByExample(example);
    return users;
}

用户mapper

   List<User> selectByExample(UserExample example);

  <select id="selectByExample" parameterType="com.kkb.pojo.UserExample" resultMap="BaseResultMap">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    from user
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>
  </select>

这里讲一下：
???1，Criteria 表示通过面向对象化的设计，将数据查询条件封装为一个对象。简单来讲，Criteria Query可以看作是传统SQL的对象化表示
???2，distinct是为了降重，Base_Column_List是表示*，但是用这个字段效率更高，，如果只有一个参数，那么_parameter 就代表该参数，如果有多个参数，那么_parameter 可以get(0)得到第一个参数， 最后就是排序了。

6.1.5用户名，密码为空校验及错误校验+提示

这里都是前端内容。没什么好说的，直接附代码：

  <input id="uLoginname" type="text" name="username" class="input-block-level" placeholder="账号"><span id="uNameMsg"></span>
  <input id="uPassword" type="password" name="password" class="input-block-level" placeholder="密码"><span id="uPassMsg"></span>

function validataPwd() {
    var pwd = $("#uPassword").val();
    var msg = $("#uPassMsg");
    if(pwd == "") {
        msg.html("密码不能为空").css("color", "red");
        return false;
    } else if(pwd.length < 8) {
        msg.html("密码长度必须大于8位").css("color", "red");
        return false;
    } else {
        msg.html("ok").css("color", "green");
        return true;
    }
}

function validatauLoginname() {
    var pwd = $("#uLoginname").val();
    var msg = $("#uNameMsg");
    if(pwd == "") {
        msg.html("账户名不能为空").css("color", "red");
        return false;
    } else if(pwd.length < 8) {
        msg.html("账户名长度必须大于8位").css("color", "red");
        return false;
    } else {
        msg.html("ok").css("color", "green");
        return true;
    }
}

总验证：

$(function (){
    $("#uPassword").blur(function() {
        validataPwd();
    });
    $("#uLoginname").blur(function() {
        validatauLoginname();
    });
    $("#inputVerify").blur(function() {
        isVerify();
    });
});

6.1.6登录到系统首页

这个是有些麻烦的，前端是一个固定的方法，BUI框架。
失效菜单不可以展示。

   BUI.use('common/main',function(){
        //let configTest = new Array();
        $(function () {
            $.getJSON("/getInfo.do",null,function (vo) {
                // 获取封装菜单数据
                let menuList = vo.obj.role.menuList;

                let totalItems = new Array();
                    for (let i = 0; i < menuList.length; i++) {
                        if (menuList[i].m_state == 0){// 失效菜单，不可以展示
                            let itemList = {id:menuList[i].m_id.toString(),text:menuList[i].m_name,href:menuList[i].m_url};
                            totalItems.push(itemList);
                        }
                    }
                    console.log("totalList")
                    console.log(totalItems)
                    let config = [
                        {id:'1',menu:[
                                {text:'快速通道',items: totalItems}
                            ]}
                    ];
                    new PageUtil.MainPage({
                        modulesConfig : config
                    });

            })
        })
    }); 

后端逻辑如下：
首先，通过用户的roleId查找相连的资源list，然后通过角色id查询对应的菜单资源集合，并把菜单资源添加到对应的角色中，最后把对应的角色信息添加给对应的用户，并把用户返回给前端
登录croller:

/**
 * 权限管理功能
 * @param request
 * @return
 */
@RequestMapping("getInfo.do")
public ResultVO getUserInfo(HttpServletRequest request){
    // 获取登录后的用户信息
    HttpSession session = request.getSession();
    User userInfo = (User) session.getAttribute("userInfo");

    // 通过用户的roleId查找相连的资源list，
    // 实际上涉及到了三表操作：通过角色id查询对应的菜单资源集合，并把菜单资源添加到对应的角色中，
    // 然后把对应的角色信息添加给对应的用户，并把用户返回给前端
    Role role = roleService.findById(userInfo.getrId());
    userInfo.setRole(role);
    System.out.println(userInfo);
    return new ResultVO(userInfo);
}

查询角色service：

查询未被删除的角色，根据角色id查询对应菜单。如果该角色可以被正常使用，
把对应的的菜单资源放到角色中。

   /**
     * 通过roleId查找相连的资源list
     * @param id
     * @return
     */
    public Role findById(Integer id){
        // 先查询role
        // 查询未被删除的角色
        RoleExample roleExample = new RoleExample();
        RoleExample.Criteria criteria = roleExample.createCriteria();
        criteria.andRStateEqualTo(0);
        criteria.andRIdEqualTo(id);
        List<Role> roles = roleMapper.selectByExample(roleExample);
        Role role = roles.get(0);

        // 通过roleId 查询 menu菜单
        List<Menu> menus = roleMapper.selectMenusByRoleId(id);
        System.out.println(menus);

        role.setMenuList(menus);
        System.out.println(role);
        return role;
    }

mapper：
第一个，查询未被删除的角色，用到是自动生成的方法。
第二个，通过roleId 查询 menu菜单的方法需要我们自定义。

List<Menu> menus = roleMapper.selectMenusByRoleId(id);

    /**
     * 通过roleId 查询菜单列表
     * @param id
     * @return
     */
    List<Menu> selectMenusByRoleId(@Param("id") Integer id);

  <select id="selectMenusByRoleId" parameterType="java.lang.Integer" resultType="map">
    select m.m_id,m.m_name,m.m_url,m.m_state from role_menu rm,menu m
    where rm.r_id = #{id} and rm.m_id = m.m_id and m.m_state = 0;
  </select>

6.1.7用户的真实姓名显示

这个没什么难度，直接附代码了。
前端：

<div style="float:right; color:#fff;">欢迎您，<span class="dl-log-user" id="trueName">
  $.getJSON("/getusername.do", null, function (vo) {
            $("#trueName").html(vo.obj.uTruename);
        });

后端：

   /**
     * 获取用户的真实姓名
     * @param request
     * @return
     */
    @RequestMapping("getusername.do")
    public ResultVO<User> getUserName(HttpServletRequest request) {
        // 获取用户的登录名，根据用户的登录名称获取用户的信息返回给前台，前台展示真实姓名
        String userName = UserUtil.getUserName(request.getSession());
        List<User> users = userService.queryByLoginName(userName);
        return new ResultVO<>(users.get(0));
    }

public List<User> queryByLoginName(String uLoginname){
    UserExample example=new UserExample();
    UserExample.Criteria criteria = example.createCriteria();
    criteria.andULoginnameEqualTo(uLoginname);
    List<User> users = userMapper.selectByExample(example);
    return users;
}

    List<User> selectByExample(UserExample example);
<select id="selectByExample" parameterType="com.kkb.pojo.UserExample" resultMap="BaseResultMap">
    select
    <if test="distinct">
      distinct
    </if>
    <include refid="Base_Column_List" />
    from user
    <if test="_parameter != null">
      <include refid="Example_Where_Clause" />
    </if>
    <if test="orderByClause != null">
      order by ${orderByClause}
    </if>
  </select>

6.1.8退出登录

这个就是清空session了。
前端

<div style="float:right; color:#fff;">欢迎您，<span class="dl-log-user" id="trueName">-</span><a id="exit"
                                                                                                 title="退出系统"
                                                                                                     class="dl-log-quit">[退出]</a>
        </div>

$("#exit").click(function () {
            $.getJSON("/exit.do", null, function (vo) {
                if (vo.code == 200) {
                    window.parent.location.href="/pages/login.html";
                }
            });
        });

后端：

/**
 * 退出操作
 * @param request
 * @return
 */
@RequestMapping("exit.do")
public ResultVO exit(HttpServletRequest request) {
    // 清空session,返回空结果集
    request.getSession().invalidate();
    return new ResultVO();
}

6.1.9总代码

登录页面

<!DOCTYPE html>
<html>
<head>
    <title>枣阳市第二人民医院管理系统--中软高科2015</title>
	<meta charset="UTF-8">
   <link rel="stylesheet" type="text/css" href="../Css/bootstrap.css" />
    <link rel="stylesheet" type="text/css" href="../Css/bootstrap-responsive.css" />
    <link rel="stylesheet" type="text/css" href="../Css/style.css" />
    <script type="text/javascript" src="../Js/jquery.js"></script>
    <script type="text/javascript" src="../Js/bootstrap.js"></script>
    <script type="text/javascript" src="../Js/ckform.js"></script>
    <script type="text/javascript" src="../Js/common.js"></script>
    <style type="text/css">
        body {
            padding-top: 40px;
            padding-bottom: 40px;
            background-color: #f5f5f5;
        }

        .form-signin {
            max-width: 300px;
            padding: 19px 29px 29px;
            margin: 0 auto 20px;
            background-color: #fff;
            border: 1px solid #e5e5e5;
            -webkit-border-radius: 5px;
            -moz-border-radius: 5px;
            border-radius: 5px;
            -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
            -moz-box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
            box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
        }

        .form-signin .form-signin-heading,
        .form-signin .checkbox {
            margin-bottom: 10px;
        }

        .form-signin input[type="text"],
        .form-signin input[type="password"] {
            font-size: 16px;
            height: auto;
            margin-bottom: 15px;
            padding: 7px 9px;
        }

    </style>
    <script>

        function validataPwd() {
            var pwd = $("#uPassword").val();
            var msg = $("#uPassMsg");
            if(pwd == "") {
                msg.html("密码不能为空").css("color", "red");
                return false;
            } else if(pwd.length < 8) {
                msg.html("密码长度必须大于8位").css("color", "red");
                return false;
            } else {
                msg.html("ok").css("color", "green");
                return true;
            }
        }

        function validatauLoginname() {
            var pwd = $("#uLoginname").val();
            var msg = $("#uNameMsg");
            if(pwd == "") {
                msg.html("账户名不能为空").css("color", "red");
                return false;
            } else if(pwd.length < 8) {
                msg.html("账户名长度必须大于8位").css("color", "red");
                return false;
            } else {
                msg.html("ok").css("color", "green");
                return true;
            }
        }

        // 验证码验证
        function isVerify() {
            let initData = $("#verify").html();
            let inputData = $("#inputVerify").val();
            if(inputData == ''){
                alert("请输入验证码");
                return false;
            } else {
                if(inputData.toUpperCase() == initData.toUpperCase()){
                    return true;
                } else{
                    alert("验证码输入有误，请重新输入")
                    return false;
                }
            }
        }

        // 生成验证码
        function changeVerify() {
            //生成4位i随机数
            let str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
            let arr = str.split("");
            let result = "";
            for(let i=0;i<4;i++)
            {
                let n = Math.floor(Math.random() * arr.length);
                result += arr[n];
            }
            $("#verify").html(result);
        }

        $(function (){
            $("#uPassword").blur(function() {
                validataPwd();
            });
            $("#uLoginname").blur(function() {
                validatauLoginname();
            });
            $("#inputVerify").blur(function() {
                isVerify();
            });
        });

        $(function (){
            $.getJSON("/role/getroleinfo.do",null,function (vo){
                let list=vo.list;
                let str="";
                for (let i=0;i<list.length;i++){
                    str+="<option value=\""+list[i].rId+"\">"+list[i].rName+"\n";
                }
                $("#role").html(str);
            });
        })

        function login(){
            let uLoginname = $("#uLoginname").val();
            let uPassword=$("#uPassword").val();
            let role = $("#role option:selected").val();
            $.getJSON("/login.do",{uLoginname:uLoginname,uPassword:uPassword,role:role},function (vo){
                if(vo.code==200){
                    let uId=vo.obj.uId;
                    alert("登陆成功");
                    window.location.href="/pages/index.html?rId="+vo.obj.rId+"&uId="+uId;
                }else {
                    alert(vo.msg);
                }
            });
        }
    </script>
</head>
<body>
<div class="container">

    <form class="form-signin" method="post" >
        <h2 class="form-signin-heading">&nbsp;&nbsp;&nbsp;登录系统</h2>
        <input id="uLoginname" type="text" name="username" class="input-block-level" placeholder="账号"><span id="uNameMsg"></span>
        <input id="uPassword" type="password" name="password" class="input-block-level" placeholder="密码"><span id="uPassMsg"></span>
        请选择角色：<select id="role">

        </select>
        <input type="text" id="inputVerify" name="verify" class="input-medium" placeholder="验证码">
        <span id="verify" style="margin-left: 10px; font-size: 20px; color: #1c6a9e;"  onclick="changeVerify()">7777</span>
       
        <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<button id="access" class="btn btn-large btn-primary" type="button" onclick="login()">登录</button></p>
    </form>

</div>
</body>
</html>

首页：

<!DOCTYPE HTML>
<html>
<head>
    <title>枣阳市第二人民医院信息管理系统</title>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <link href="../assets/css/dpl-min.css" rel="stylesheet" type="text/css"/>
    <link href="../assets/css/bui-min.css" rel="stylesheet" type="text/css"/>
    <link href="../assets/css/main-min.css" rel="stylesheet" type="text/css"/>
</head>
<body>

<div class="content">
    <div class="dl-main-nav">
        <div class="dl-inform">
            <div class="dl-inform-title"><s class="dl-inform-icon dl-up"></s></div>
        </div>
        <ul id="J_Nav" class="nav-list ks-clear" style="float:left">
            <!--<li class="nav-item dl-selected"><div class="nav-item-inner nav-home">信息采编系统</div></li>-->
            <li style=" color:#fff; font-size:20px; margin-top:10px; margin-left:20px;">山东省第二人民医院管理平台</li>
        </ul>
        <div style="float:right; color:#fff;">欢迎您，<span class="dl-log-user" id="trueName">-</span><a id="exit"
                                                                                                     title="退出系统"
                                                                                                     class="dl-log-quit">[退出]</a>
        </div>
    </div>
    <ul id="J_NavContent" class="dl-tab-conten">
    </ul>
</div>

<script type="text/javascript" src="../assets/js/jquery-1.6.js"></script>
<script type="text/javascript" src="../assets/js/bui.js"></script>
<script type="text/javascript" src="../assets/js/common/main-min.js"></script>
<script type="text/javascript" src="../assets/js/config-min.js"></script>


<script>

   BUI.use('common/main',function(){
        //let configTest = new Array();
        $(function () {
            $.getJSON("/getInfo.do",null,function (vo) {
                // 获取封装菜单数据
                let menuList = vo.obj.role.menuList;

                let totalItems = new Array();
                    for (let i = 0; i < menuList.length; i++) {
                        if (menuList[i].m_state == 0){// 失效菜单，不可以展示
                            let itemList = {id:menuList[i].m_id.toString(),text:menuList[i].m_name,href:menuList[i].m_url};
                            totalItems.push(itemList);
                        }
                    }
                    console.log("totalList")
                    console.log(totalItems)
                    let config = [
                        {id:'1',menu:[
                                {text:'快速通道',items: totalItems}
                            ]}
                    ];
                    new PageUtil.MainPage({
                        modulesConfig : config
                    });

            })
        })
    }); /**/

    $(function () {
        $("#exit").click(function () {
            $.getJSON("/exit.do", null, function (vo) {
                if (vo.code == 200) {
                    window.parent.location.href="/pages/login.html";
                }
            });
        });

        $.getJSON("/getusername.do", null, function (vo) {
            $("#trueName").html(vo.obj.uTruename);
        });
    });

</script>
</body>
</html>

登录控制层

package com.kkb.controller;

import com.kkb.pojo.Role;
import com.kkb.pojo.User;
import com.kkb.service.MenuService;
import com.kkb.service.RoleService;
import com.kkb.service.UserService;
import com.kkb.util.UserUtil;
import com.kkb.vo.ResultVO;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.List;

@Controller
@RequestMapping("")
@ResponseBody
public class LoginController {
    @Resource
    private UserService userService;
    @Resource
    private RoleService roleService;
    @Resource
    private MenuService menuService;

    /**
     * 登录操作
     * @param request
     * @return
     */
    @RequestMapping("login.do")
    public ResultVO<User> login(HttpServletRequest request) {
        // 1，获取登录名称，密码。登录角色Id
        String uLoginname = request.getParameter("uLoginname");
        String uPassword = request.getParameter("uPassword");
        int role = Integer.parseInt(request.getParameter("role"));
        // 2，获取角色列表
        List<Role> roles = roleService.queryAll();
        // 3，定义结果集
        ResultVO<User> vo = new ResultVO<>();
        for (Role r : roles) {// 4，遍历角色列表
            if (r.getrId() == role) {// 5，如果登录角色id=遍历到的角色id，正常使用的往下走，否则结果集中填写对应错误信息
                // 6，模糊查询，返回符合条件用户信息
                List<User> users = userService.queryLPR(uLoginname, uPassword, role);
                // 7，获取角色的状态码
                Integer rState = r.getrState();
                if (rState == 0) {// 8.1如果该角色是被正常使用的往下走，否则结果集中填写对应错误信息
                    if (users.size() > 0) {// 8.2如果该用户正常存在的往下走，否则结果集中填写对应错误信息
                        if (users.get(0).getuState() == 0) {// 8.3如果该用户是被正常使用的往下走，否则结果集中填写对应错误信息
                            // 9，设置用户的登录名称，和其角色id，并把用户信息存入结果集中
                            UserUtil.setUserName(request.getSession(), uLoginname);
                            UserUtil.setRoleId(request.getSession(),role);
                            vo.setObj(users.get(0));

                            System.out.println(vo);// 看一下结果
                        } else {
                            vo.setCode(500);
                            vo.setMsg("该用户已被禁用或删除");
                        }
                    } else {
                        vo.setCode(500);
                        vo.setMsg("密码错误或角色不匹配，请重新输入");
                    }
                } else {
                    vo.setCode(500);
                    vo.setMsg("该角色已被删除或禁用");
                }
            }
        }
        return vo;
    }

    /**
     * 权限管理功能
     * @param request
     * @return
     */
    @RequestMapping("getInfo.do")
    public ResultVO getUserInfo(HttpServletRequest request){
        // 获取登录后的用户信息
        HttpSession session = request.getSession();
        User userInfo = (User) session.getAttribute("userInfo");

        // 通过用户的roleId查找相连的资源list，
        // 实际上涉及到了三表操作：通过角色id查询对应的菜单资源集合，并把菜单资源添加到对应的角色中，
        // 然后把对应的角色信息添加给对应的用户，并把用户返回给前端
        Role role = roleService.findById(userInfo.getrId());
        userInfo.setRole(role);
        System.out.println(userInfo);
        return new ResultVO(userInfo);
    }

    /**
     * 获取用户的真实姓名
     * @param request
     * @return
     */
    @RequestMapping("getusername.do")
    public ResultVO<User> getUserName(HttpServletRequest request) {
        // 获取用户的登录名，根据用户的登录名称获取用户的信息返回给前台，前台展示真实姓名
        String userName = UserUtil.getUserName(request.getSession());
        List<User> users = userService.queryByLoginName(userName);
        return new ResultVO<>(users.get(0));
    }

    /**
     * 退出操作
     * @param request
     * @return
     */
    @RequestMapping("exit.do")
    public ResultVO exit(HttpServletRequest request) {
        // 清空session,返回空结果集
        request.getSession().invalidate();
        return new ResultVO();
    }
}

主要的服务处代码：
1.获取角色列表
???roleService.queryAll();
???这个代码直接生成。
2.模糊查询，返回符合条件用户信息
???userService.queryLPR(uLoginname, uPassword, role);
???这个需要加入对应的查询条件
3.查询角色对应的资源菜单
???roleService.findById(userInfo.getrId());
???这个比较麻烦，直接照搬上面写的。
???首先，通过用户的roleId查找相连的资源list，然后通过角色id查询对应的菜单资源集合，并把菜单资源添加到对应的角色中，最后把对应的角色信息添加给对应的用户，并把用户返回给前端。
4.根据用户名，获取真实的用户姓名
???把登录名的条件加上
???userService.queryByLoginName(userName);

6.2密码管理模块

界面：

<table>
    <tr>
        <td align="right">原密码:</td>
        <td><input id="oripass" type="password"/><span id="oripassMsg"></span></td>
    </tr>
    <tr>
        <td align="right">新密码:</td>
        <td><input id="newpass" type="password"/><span id="passMsg"></span></td>
    </tr>
    <tr>
        <td align="right">确认密码:</td>
        <td><input id="renewpass" type="password"/><span id="repassMsg"></span></td>
    </tr>
    <tr>
        <td colspan="2" align="center"><br/>
            <input id="save" type="button" value="保存" class="btn btn-primary"/>
        </td>
    </tr>
</table>

6.2.1原密码，新密码，重复密码的非空验证和强度验证,新密码和确认密码的一致性验证

  let password = null;
        function validatanewPwd(){
            let newpass = $("#newpass").val();
            let renewpass=$("#renewpass").val();
            let msg2 = $("#repassMsg");
            if (renewpass!=newpass){
                msg2.html("两次输入密码不一样").css("color", "red");
                return false;
            }else {
                msg2.html("ok").css("color", "green");
                return true;
            }
        }
        function validataPwd() {
            let newpass = $("#newpass").val();
            let msg = $("#passMsg");
            if (newpass == "") {
                msg.html("密码不能为空").css("color", "red");
                return false;
            } else if (newpass.length < 8) {
                msg.html("密码长度必须大于等于8位").css("color", "red");
                return false;
            } else if (newpass.length >= 8 && /\d/.test(newpass)) {
                msg.html("weak").css("color", "red");
                if (newpass.length >= 8 && /\d/.test(newpass) && /[a-z]/.test(newpass)) {
                    msg.html("middle").css("color", "orange");
                    if (newpass.length >= 8 && /\d/.test(newpass) && /[a-z]/.test(newpass) && /[A-Z]/.test(newpass)) {
                        msg.html("strong").css("color", "green");
                        return true;
                    }
                    return true;
                }
                return false;
            }
        }

        function validataOriPwd() {
            let newpass = $("#oripass").val();
            let msg = $("#oripassMsg");
            if (newpass == "") {
                msg.html("密码不能为空").css("color", "red");
                return false;
            } else if (newpass.length < 8) {
                msg.html("密码长度必须大于等于8位").css("color", "red");
                return false;
            } else if (newpass.length >= 8 && /\d/.test(newpass)) {
                msg.html("weak").css("color", "red");
                if (newpass.length >= 8 && /\d/.test(newpass) && /[a-z]/.test(newpass)) {
                    msg.html("middle").css("color", "orange");
                    if (newpass.length >= 8 && /\d/.test(newpass) && /[a-z]/.test(newpass) && /[A-Z]/.test(newpass)) {
                        msg.html("strong").css("color", "green");
                        return true;
                    }
                    return true;
                }
                return false;
            }
        }

        $(function () {
            $("#newpass").blur(function () {
                validataPwd();
            });
            $("#renewpass").blur(function () {
                validatanewPwd();
            });
            $("#oripass").blur(function () {
                validataOriPwd();
            });
        });

6.2.2新密码和原密码的一致性验证，原密码的准确性验证，修改密码成功.原密码的准确性验证,修改密码成功

这个，我们获取用户名的原密码。再把原密码与新密码进行比较
前端：有五个判断。

  $(function () {
                $.getJSON("/getInfo.do", null, function (vo) {
                    password = vo.obj.uPassword;
                });

                $("#save").click(function () {
                    let oripass = $("#oripass").val();
                    let newpass = $("#newpass").val();
                    let renewpass = $("#renewpass").val();
                    if (oripass == null) {
                        alert("请输入原密码");
                    } else {
                        if (oripass != password) {
                            console.log(oripass);
                            alert("原密码错误");
                        } else {
                            if(oripass == newpass){
                                alert("新密码与原密码一致，请重新输入新密码");
                            }else{
                                if (newpass == null || renewpass == null) {
                                    alert("请输入新密码，并重复一次");
                                } else {
                                    if (newpass != renewpass) {
                                        alert("两次输入不相同");
                                    } else {
                                        $.getJSON("/user/updatePassword.do", {newpass: newpass}, function (vo) {
                                            if (vo.code == 200) {
                                                alert("修改成功");
                                                window.parent.location.href = "/pages/login.html";
                                            } else {
                                                alert(vo.msg);
                                            }
                                        });
                                    }
                                }
                            }
                        }
                    }
                });
            }
        );

后端：
1，获取用户密码用的是获取系统首页的方法
2，修改密码方法
croller:

/**
 * 更该密码
 * @param request
 * @param newpass
 * @return
 */
@RequestMapping("updatePassword.do")
public ResultVO<User> updatePassword(HttpServletRequest request, String newpass){
    int i = userService.updatePassword(UserUtil.getUserName(request.getSession()), newpass);
    if (i>0){
        return new ResultVO<>();
    }else {
        return new ResultVO<>(500,"服务器内部错误");
    }
}

6.3用户管理模块

6.3.1CRUD-查询

查询要实现的功能为：
???获取展现所有用户信息
???用户名称的模糊查询功能实现
???全选,全不选
???分页，在首页时，首页和上一页不可点
???分页，在尾页时，尾页和下一页都不可点
???分页，当分页大于5页时，页码的省咯
首页界面：

<form id="myform" class="form-inline definewidth m20" action="index.html" method="get">
    用户名称：
    <input type="text" name="username" id="username" class="abc input-default" placeholder="" value="">&nbsp;&nbsp;
    <button type="button" class="btn btn-primary" onclick="loadData()">查询</button>
</form>
<table class="table table-bordered table-hover definewidth m10">
    <thead>
    <tr>
        <th width="5%"><input type="checkbox" id="checkall" onclick="checkall()"></th>
        <th>用户账户</th>
        <th>真实姓名</th>
        <th>角色</th>
        <th width="10%">操作</th>
    </tr>
    </thead>
    <thead id="thead">

    </thead>

</table>
<table class="table table-bordered table-hover definewidth m10">
    <tr>
        <th colspan="5">
            <div class="inline pull-right page">
                <span id="total">-</span> 条记录 <span id="pageNum">-</span>/<span id="pages">-</span>页
                <a id="firstPage" onclick="loadData(1)" >首页</a>
                <a onclick="loadData(prePage)" id="prePage">上一页</a>
                <span id="page"></span>
                <a id="nextPage" onclick="loadData(nextPage)">下一页</a>
                <a id="lastPage" onclick="loadData(pages)">最后一页</a></div>
            <div>
                <button type="button" class="btn btn-success" id="newNav">添加用户</button>&nbsp;&nbsp;&nbsp;<button
                    type="button" class="btn btn-success" id="delPro" onClick="delAll();">删除选中
            </button>
            </div>
        </th>
    </tr>
</table>

分页参数

  /* 当前页*/
        let pageNum=null;
        /*下一页*/
        let nextPage=null;
       /*上一页*/
        let prePage=null;
        /*总页数*/
        let pages=null;
        /*第一页*/
        let isFirstPage=null;
        /*最后一页*/
        let isLastPage=null;

全选与全不选方法：
这个check名称是再查询方法里，我们再查询方法添加页面。每一行的名称为check。

/*全选与全不选的方法*/
function checkall() {
    // 一个一个信息前的框
    var alls = document.getElementsByName("check");
    // 表格的框
    var ch = document.getElementById("checkall");
    // 如果选中了表格的框，所有的框都为ture,否则都为false
    if ($(ch).prop("checked")) {
        for (var i = 0; i < alls.length; i++) {
            $(alls[i]).prop("checked",true);
        }
    } else {
        for (var i = 0; i < alls.length; i++) {
            $(alls[i]).prop("checked",false);
        }
    }
}

前端的查询方法如下：
这个方法还是有点东西的，首先我们获取输入的用户名，向后台传入用户名及分页信息。后台根据这个返回对应的用户信息集合，角色信息集合。这样后台的控制层至少有两个方法。获取角色信息的原因是前台要通过角色表的数据显示对应用户的角色名称。
我们获取到后台对应的用户，角色，分页信息后，加载对应页数的链接，我设置为5条数据为一页。然后加上分页限制。最后面把用户列表和分页信息填充。再填充的时候，我们根据uState判断用户是否已经删除。填充内容是一个动态循环方法。格式都再我们的方法内。

    let list2=new Array();

   /**
    * 查询方法
    * @param data
    */
   function loadData(data) {
        let username = $("#username").val();
        $.getJSON("/user/list.do", {username: username,pageNum:data}, function (vo) {
            // 获取信息
            let list = vo.pageInfo.list; // 用户信息集合
            let total=vo.pageInfo.total; // 总记录数
            let roleList=vo.list;// 角色信息集合
            pages=vo.pageInfo.pages; // 总页数
            pageNum=vo.pageInfo.pageNum;
            prePage=vo.pageInfo.prePage;
            nextPage=vo.pageInfo.nextPage;
            isFirstPage=vo.pageInfo.isFirstPage;
            isLastPage=vo.pageInfo.isLastPage;

            // 加载对应页数的链接
            let href="<a id=\"page"+1+"\" οnclick=\"loadData(1)\">"+1+"</a>";
            for (let i=2;i<=pages;i++){
                if (i==6){
                    break;
                }
                href+="<a id=\"page"+i+"\" οnclick=\"loadData("+i+")\">"+i+"</a>"
            }
            $("#page").html(href);

            // 分页限制
           if(isFirstPage){//如果是第一页：上一页和首页禁用
                $("#firstPage").hide();
                $("#prePage").hide();
            }
            if(isLastPage){//如果已经是最后一页：下一页和末页禁用
                $("#nextPage").hide();
                $("#lastPage").hide();
            }/* */
            if (!isFirstPage){
                $("#firstPage").show();
                $("#prePage").show();
            }
            if (!isLastPage){
                $("#nextPage").show();
                $("#lastPage").show();
            }

            // 用户列表和其他分页信息填充
            let str = "";
            for (let i = 0; i < list.length; i++) {
                let obj = list[i];
                let uLoginname = obj.uLoginname;
                let uTruename = obj.uTruename == null ? '' : obj.uTruename;
                let rId = obj.rId;
                let uId = obj.uId;
                let rName=null;
                list2.push(uId);
                for (let j=0;j<roleList.length;j++){
                    if (rId==roleList[j].rId){
                        rName=roleList[j].rName;
                    }
                }
                let uState = obj.uState;
                let btnStr = "";
                if (uState != 2) {
                    btnStr = '<button type="button" name="deleteBtn" onclick="deleteUser(' + uId + ')">删除</button>&nbsp;&nbsp;' +
                        '<button type="button" name="updateBtn" onclick="updateUser(' + uId + ')">编辑</button>';
                } else if (uState==2){
                    btnStr = '<button name="deleteBtn" class="btn btn-sm btn-danger disabled">已删除</button>';
                }
                str += '<tr>' +
                    '<td style="vertical-align:middle;"><input type="checkbox" name="check" value='+uId+' onclick="notcheckall()"></td>' +
                    '            <td>' + uLoginname + '</td>' +
                    '            <td>' + uTruename + '</td>' +
                    '            <td>' + rName + '</td>' +
                    '            <td>' + btnStr + '</td>' +
                    // '                <a href="editUser.html">编辑</a>&nbsp;&nbsp;<a href="javascript:alert(\'删除成功！\');">删除</a>             ' +
                    '            </td>' +
                    '    </tr>'
            }
            $("#thead").html(str);
            $("#total").html(total);
            $("#pages").html(pages);
            $("#pageNum").html(pageNum);
        });

    }

后端：
controller:
这里我单独创建了一个结果集返回对应数据。这个单独的结构集只存储分页信息和角色信息。

/**
 * 用户查询
 * @param username
 * @param pageNum
 * @param pageSize
 * @return
 */
@RequestMapping(value = "list.do")
public ResultVOUserIndex<User> queryByPage(String username, Integer pageNum, Integer pageSize){
    /*每一页五条数据显示,设置分页信息*/
    if(pageNum==null||pageNum<=0){
        pageNum=1;
    }
    if(pageSize==null||pageSize<=0){
        pageSize=5;
    }
    // 获取符合条件的用户信息
    PageInfo<User> userPageInfo = userService.queryAll(username, pageNum, pageSize);
    // 查询所有的角色信息
    List<Role> roles = roleService.queryAll();
    System.out.println("用户列表：");
    System.out.println( new  ResultVOUserIndex<>(userPageInfo,roles));
    // 使用专门的结果集返回对应数据（创建一个专门的结果集返回查询信息）
    return new ResultVOUserIndex<>(userPageInfo,roles);
}

用户查询里有两个方法，获取符合条件的用户信息和查询所有的角色信息
我们不用管第二个：
分页查询符合条件的用户信息时，我们要注意我们传入的是一个模糊查询条件。

   /**
     * 分页查询符合条件的用户信息
     * @param username
     * @param pageNum
     * @param pageSize
     * @return
     */
   public PageInfo<User> queryAll(String username, int pageNum, int pageSize){
        UserExample example=new UserExample();
        UserExample.Criteria criteria = example.createCriteria();
        if (username!=null||!username.trim().equals("")){
            criteria.andUTruenameLike("%"+username.trim()+"%");
        }
        PageHelper.startPage(pageNum,pageSize);
        List<User> users = userMapper.selectByExample(example);
        return new PageInfo<>(users);
    }

返回用户分页数据的结果集。

package com.kkb.vo;

import com.github.pagehelper.PageInfo;
import com.kkb.pojo.Role;

import java.util.List;

/**
 * 返回分页数据，
 * 这里用于返回用户的分页信息
 * @param <T>
 */
public class ResultVOUserIndex<T> {
    private PageInfo<T> pageInfo;
    private List<Role> list;

    public PageInfo<T> getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo<T> pageInfo) {
        this.pageInfo = pageInfo;
    }

    public List<Role> getList() {
        return list;
    }

    public void setList(List<Role> list) {
        this.list = list;
    }

    public ResultVOUserIndex(PageInfo<T> pageInfo, List<Role> list) {
        this.pageInfo = pageInfo;
        this.list = list;
    }

    @Override
    public String toString() {
        return "ResultVOUserIndex{" +
                "pageInfo=" + pageInfo +
                ", list=" + list +
                '}';
    }
}