【SSM】医疗健康平台-管理端-检查组管理

技能目标

掌握新增检查组功能的实现
掌握查询检查组功能的实现
掌握编辑检查组功能的实现
掌握删除检查组功能的实现

体检的检查项种类繁多，为了方便管理和快速筛选出类别相同的检查项，医疗健康将类别相同的检查项放到同一个检查组中进行管理，从而提高了管理效率。这些检查组可以在管理端进行管理，包括检查组的新增、查询、编辑和删除。

3-1 新增检查组

医疗健康中可以供用户检查的检查项有很多，如果想查找同一类别的检查项，每次都需要逐条筛选，不仅耗时，而且容易发生数据遗漏。为了提高工作效率、减少失误，统一管理这些检查项时，需要先新增一个检查组。

使用浏览器访问检查组管理页面 checkgroup.html。

在checkgroup.html 页面中单击“新增”按钮后会弹出新增检查组对话框，在对话框中填写基本信息和勾选检查项信息后，单击对话框中的“确定”按钮提交新增检查组的数据，实现检查组的新增。由此，可以将新增检查组分解成2 个功能，分别是弹出带有检查项数据的新增检查组对话框、完成检查组的新增。

1.弹出带有检查项数据的新增检查组对话框

（1）弹出新增检查组对话框为checkgroup.html页面的“新增”按钮绑定单击事件，在单击事件触发后弹出新增检查组对话框，再提交查询所有检查项的请求。

为checkgroup.html 页面的“新增”按钮绑定单击事件，并设置在单击时调用handleCreate( )方法。

<el-button type="primary" class="butT"  @click="handleCreate()">新增</el-button>

（2）接收和处理查询检查项请求客户端发起查询检查项的请求后，由CheckItemController类的findAll()方法接收页面提交的请求，并调用CheckItemService接口的findAll()方法查询所有检查项。

//查询检查项列表
    @RequestMapping("/findAll")
    public Result findAll(){
        try {
            List<CheckItem> list = checkItemService.findAll();
            //服务调用成功，返回查询结果与查询成功提示信息
            return new Result(true, MessageConstant.QUERY_CHECKITEM_SUCCESS,list);
        }catch (Exception e){
            e.printStackTrace();
            //服务调用失败，返回查询失败提示信息
            return new Result(false, MessageConstant.QUERY_CHECKITEM_FAIL);
        }
    }

（3）查询所有检查项在CheckItemServiceImpl类中重写CheckItemService接口的findAll()方法，并在方法中调用CheckItemDao接口的findAllCheckItem()方法从数据库中查询所有检查项。

在CheckItemService接口中定义findAll()方法，用于查询所有检查项。

List<CheckItem> findAll();//查询检查项列表

在CheckItemServiceImpl类中重写CheckItemService接口的findAll()方法，用于查询所有的检查项。

//查询检查项列表
    public List<CheckItem> findAll() {
        return checkItemDao.findAllCheckItem();//调用持久层接口
    }

在CheckItemDao接口中定义findAllCheckItem()方法，用于查询所有的检查项。

List<CheckItem> findAllCheckItem();//查询检查项列表

在CheckItemDao.xml映射文件中使用select元素映射查询语句，从数据库中查询所有的检查项。

<!--查询检查项列表-->
    <select id="findAllCheckItem" resultType="com.health.entity.CheckItem">
        SELECT * FROM t_checkitem
    </select>

（4）显示检查项查询结果由CheckItemController类中的findAll()方法将查询检查项的结果响应回checkgroup.html页面，checkgroup.html页面根据响应结果在新增检查组对话框中显示检查项信息。

2.完成检查组的新增

（1）提交新增检查组数据为checkgroup.html页面新增检查组对话框的“确定”按钮绑定单击事件，在单击事件触发后提交对话框中的数据。

<div slot="footer" class="dialog-footer">
    <el-button @click="dialogFormVisible = false">取消</el-button>
    <el-button type="primary" @click="handleAdd()">确定</el-button>
</div>

在checkgroup.html页面中定义handleAdd()方法，用于提交表单的数据。

handleAdd() {
    //发送Ajax请求，需要提交检查组基本信息和勾选的检查项信息
    axios.post("/checkgroup/add.do?checkitemIds=" + this.
        checkitemIds,this.formData).then((res) => {
        if(res.data.flag){
            this.dialogFormVisible = false;//成功,关闭新增对话框
            //弹出请求成功提示信息
            this.$message({
                type:'success',
                message:res.data.message
            });
        }else{
            //执行失败，弹出提示信息
            this.$message.error(res.data.message);
        }
    });
}

在entity包下创建检查组类CheckGroup，在类中声明检查组的属性，定义各个属性的getter/setter方法。

package com.health.entity;

import java.io.Serializable;
import java.util.List;

/**
 * 检查组
 */
public class CheckGroup implements Serializable {
    private Integer id;                   //主键
    private String code;                  //编码
    private String name;                  //名称
    private String helpCode;             //助记码
    private String sex;                   //适用性别
    private String remark;                //介绍
    private String attention;            //注意事项
    private List<CheckItem> checkItems;//一个检查组合包含多个检查项

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCode() {
        return code;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getHelpCode() {
        return helpCode;
    }

    public void setHelpCode(String helpCode) {
        this.helpCode = helpCode;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public String getAttention() {
        return attention;
    }

    public void setAttention(String attention) {
        this.attention = attention;
    }

    public List<CheckItem> getCheckItems() {
        return checkItems;
    }

    public void setCheckItems(List<CheckItem> checkItems) {
        this.checkItems = checkItems;
    }
}

（2）接收和处理新增检查组请求客户端发起新增检查组的请求后，由控制器类CheckGroupController的add()方法接收页面提交的请求，请求的参数中包含基本信息和对检查项的引用信息。

在controller包中创建控制器类CheckGroupController，在类中定义add()方法，用于处理新增检查组的请求。

/**
 * 检查组管理
 */
@RestController
@RequestMapping("/checkgroup")
public class CheckGroupController {
    @Autowired //查找服务
    private CheckGroupService checkGroupService;
    //新增检查组
    @RequestMapping("/add")
    public Result add(@RequestBody CheckGroup checkGroup, Integer[] checkitemIds){
        try{
            checkGroupService.add(checkGroup,checkitemIds);
            //调用服务成功，返回新增成功提示信息
            return new Result(true, MessageConstant.ADD_CHECKGROUP_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            //调用服务失败，返回新增失败提示信息
            return new Result(false, MessageConstant.ADD_CHECKGROUP_FAIL);
        }
    }
}

（3）保存新增检查组数据在CheckGroupServiceImpl类中重写CheckGroupService接口的add()方法，在方法中调用CheckGroupDao接口用于新增基本信息的add()方法，用于新增检查组对检查项引用信息的setCheckGroupAndCheckItem()方法。

在service包中创建接口CheckGroupService，在接口中定义新增检查组的add()方法。

/**
 * 检查组服务接口
 */
public interface CheckGroupService {
    //新增检查组
     void add(CheckGroup checkGroup, Integer[] checkitemIds);
}

在service.impl包中创建CheckGroupService接口实现类CheckGroupServiceImpl，并重写接口的add()方法，用于新增检查组。

/**
 * 检查组服务接口实现类
 */
@Service("checkGroupService")
@Transactional
public class CheckGroupServiceImpl implements CheckGroupService {
    @Autowired   //注入DAO对象
    private CheckGroupDao checkGroupDao;
    //新增检查组  同时需要关联检查项（设置多对多关系）
    public void add(CheckGroup checkGroup, Integer[] checkitemIds) {
        checkGroupDao.add(checkGroup);//调用持久层接口
        Integer checkGroupId = checkGroup.getId();//获取检查组id
        //关联检查项
        this.setCheckGroupAndCheckItem(checkGroupId,checkitemIds);
    }
    //设置检查组和检查项多对多关系的方法
    public void setCheckGroupAndCheckItem(Integer checkGroupId, Integer[] checkitemIds){
        //设置多对多关系
        if(checkitemIds != null && checkitemIds.length > 0){
            for (Integer checkitemId : checkitemIds) {//遍历检查项id
                Map<String,Integer> map = new HashMap<>();
                map.put("checkgroupId",checkGroupId);//检查组id
                map.put("checkitemId",checkitemId);//勾选的检查项id
                checkGroupDao.setCheckGroupAndCheckItem(map);//调用持久层接口
            }
        }
    }
}

在dao包下创建持久层接口CheckGroupDao，用于处理与检查组相关的操作。

/**
 * 检查组数据持久化层接口
 */
public interface CheckGroupDao {
     void add(CheckGroup checkGroup);//添加检查组
	//设置检查组和检查项多对多关系
     void setCheckGroupAndCheckItem(Map<String, Integer> map);
}

在CheckGroupDao接口同名的映射文件CheckGroupDao.xml。使用intert元素映射新增语句，分别新增检查组的基本信息和检查组对检查项的引用。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.health.dao.CheckGroupDao">
    <!--新增检查组-->
    <insert id="add" parameterType="com.health.entity.CheckGroup">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID()
        </selectKey>
        INSERT INTO t_checkgroup(code,name,helpCode,sex,remark,attention)
        VALUES
        (#{code},#{name},#{helpCode},#{sex},#{remark},#{attention})
    </insert>
</mapper>

（4）提示新增检查组的结果 CheckGroupController类中的add()方法将新增检查组的结果响应回checkgroup.html页面，checkgroup.html页面根据响应结果提示新增检查组成功或失败的信息。

在浏览器中访问checkgroup.html，单击“新增”按钮，弹出新增检查组对话框，在对话框中填写检查组的基本信息。

单击“检查项信息”选项卡，勾选检查组包含的检查项信息。

如果新增失败，页面会提示“新增检查组失败”。如果新增成功，页面会提示“新增检查组成功”。

由于查询检查组的功能暂未开发完成，刚新增的检查组数据并不会展示在检查组管理页面中。

查询数据库中检查组及引用的检查项数据。成功查询出新增的检查组以及检查组对应的检查项信息，说明新增检查组的操作执行成功。

绑定的检查则添加在这张表中

3-2 查询检查组

在实现新增检查组后，还不能立即从checkgroup.html中查看新增的检查组，为了便于查看检查组信息，可以在访问checkgroup.html页面时，自动将系统中的检查组查询出来并在页面上分页展示。

1.分页展示检查组

（1）提交分页查询检查组的请求

查看checkgroup.html页面中用于展示检查组的源代码。

<el-table size="small" current-row-key="id" :data="dataList" stripe >
 	......
</el-table>
<div class="pagination-container">
    <el-pagination class="pagiantion" ......></el-pagination>
</div>
<script>
    var vue = new Vue({
        el: '#app',
        data:{
            pagination: {                //分页属性
	currentPage:1,     //当前页码
	pageSize:10,       //每页显示的记录数
	total:0,                //总记录数
	queryString:""  //查询条件
            },
            dataList: [],//当前页要展示的分页列表数据
            ......
         },
         //钩子函数，Vue对象初始化完成后自动执行
         created(){  },
         ......    })</script>

:data="dataList"通过数据双向绑定的方式展示数据 el-pagination 分页组件，用于实现数据分页分页属性 pagination，包括当前页码、每页显示的记录数、总记录数和查询条件 dataList表示当前页要展示的数据。 created( )函数在 Vue 对象初始化完成后自动执行。

在checkgroup.html页面中定义findPage()方法，用于分页查询检查组。

findPage(){
    //定义分页参数
    var param = {
        currentPage:this.pagination.currentPage,//当前页
        pageSize:this.pagination.pageSize,       //每页显示记录数
        queryString:"%"+this.pagination.queryString+"%" //查询条件
    };
    //发送Ajax请求，进行分页查询
    axios.post("/checkgroup/findPage.do",param).then((res)=> {
        this.dataList = res.data.rows;           //查询结果
        this.pagination.total = res.data.total;//总记录数
    });
}

在钩子函数created( )中调用findPage( )方法，created( )函数在Vue 对象初始化完成后自动执行，访问checkgroup.html 页面后即可实现查询检查组并分页显示。

created() {
    this.findPage();//调用分页查询方法完成分页查询
}

（2）实现查询检查组控制器

在CheckGroupController类中定义findPage()方法，用于处理分页查询检查组的请求。

//分页查询检查组
    @RequestMapping("/findPage")
    public PageResult findPage(@RequestBody QueryPageBean pageBean){
        return checkGroupService.findPage(pageBean);//调用findPage()发送请求
    }

（3）创建查询检查组服务

在CheckGroupService接口中定义findPage()方法，用于分页查询检查组。

PageResult findPage(QueryPageBean queryPageBean);//分页查询检查组接口

（4）实现查询检查组服务

在CheckGroupServiceImpl类中重写CheckGroupService接口的findPage()方法，用于分页查询检查组。

    //分页查询
    public PageResult findPage(QueryPageBean queryPageBean) {
        Integer currentPage = queryPageBean.getCurrentPage();//获取当前页面
        Integer pageSize = queryPageBean.getPageSize();//获取每页显示的记录数
        String queryString = queryPageBean.getQueryString();//获取查询条件
        //分页插件，会在执行sql之前将分页关键字追加到SQL后面
        PageHelper.startPage(currentPage,pageSize);
        //调用持久层接口方法
        Page<CheckGroup> page = checkGroupDao.findByCondition(queryString);
        return new PageResult(page.getTotal(),page.getResult());//返回分页对象
    }

（5）实现持久层查询检查组

在CheckGroupDao接口中定义findByCondition()方法，用于分页查询检查组。

Page<CheckGroup> findByCondition(String queryString);//分页查询检查组

在CheckGroupDao.xml映射文件中使用select元素映射查询语句，进行检查组的条件查询、分页查询。

<!--根据条件查询、分页查询检查组-->
    <select id="findByCondition" parameterType="string" resultType="com.health.entity.CheckGroup">
        SELECT * FROM t_checkgroup
        <if test="value != null and value.length > 0">
            WHERE code like #{value} OR name like #{value}
            OR helpCode like #{value}
        </if>
    </select>

（6）测试分页展示检查组

重启服务器，访问当前页面

（7）完善checkgroup.html页面的handleAdd()方法

优化handleAdd()方法，在新增检查组成功后调用findPage()方法。以实现新增检查组成功后在checkgroup.html页面中查看最新添加的检查组。

//添加检查组
handleAdd() {
    axios.post("/checkgroup/add.do?checkitemIds=" +
 		this.checkitemIds,this.formData).then((res) => {
         if(res.data.flag){
              ......
              this.findPage();//分页查询检查组
          }
          ......
    });
}

2.页码切换

在checkgroup.html页面中定义handleCurrentChange()方法，用于实现页码切换。

//切换页码
handleCurrentChange(currentPage) {
    this.pagination.currentPage = currentPage;//指定最新的页码
    this.findPage();//调用分页查询检查组的方法
}

在checkgroup.html页面提供了分页组件el-pagination，为el-pagination 组件设置与页码相关的属性值。

给该数据表中添加测试数据

INSERT INTO `t_checkgroup` VALUES ('2', '0002', '视力色觉', 'SLSJ', '0', '视力色觉', NULL);
INSERT INTO `t_checkgroup` VALUES ('3', '0003', '血常规', 'XCG', '0', '血常规', NULL);
INSERT INTO `t_checkgroup` VALUES ('4', '0004', '尿常规', 'NCG', '0', '尿常规', NULL);
INSERT INTO `t_checkgroup` VALUES ('5', '0005', '肝功三项', 'GGSX', '0', '肝功三项', NULL);
INSERT INTO `t_checkgroup` VALUES ('6', '0006', '肾功三项', 'NGSX', '0', '肾功三项', NULL);
INSERT INTO `t_checkgroup` VALUES ('7', '0007', '血脂四项', 'XZSX', '0', '血脂四项', NULL);
INSERT INTO `t_checkgroup` VALUES ('8', '0008', '心肌酶三项', 'XJMSX', '0', '心肌酶三项', NULL);
INSERT INTO `t_checkgroup` VALUES ('9', '0009', '甲功三项', 'JGSX', '0', '甲功三项', NULL);
INSERT INTO `t_checkgroup` VALUES ('10', '0010', '子宫附件彩超', 'ZGFJCC', '2', '子宫附件彩超', NULL);
INSERT INTO `t_checkgroup` VALUES ('11', '0011', '胆红素三项', 'DHSSX', '0', '胆红素三项', NULL);

INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('2', '6');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('2', '7');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('2', '8');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('2', '9');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('2', '10');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '11');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '12');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '13');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '14');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '15');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '16');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '17');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '18');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '19');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '20');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '21');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '22');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '23');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '24');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '25');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '26');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '27');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '28');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('3', '29');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '30');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '31');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '32');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '33');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '34');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '35');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '36');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '37');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '38');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '39');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '40');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '41');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '42');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '43');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('4', '44');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('5', '45');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('5', '46');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('5', '47');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('6', '48');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('6', '49');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('6', '50');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('7', '51');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('7', '52');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('7', '53');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('7', '54');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('8', '55');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('8', '56');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('8', '57');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('9', '58');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('9', '59');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('9', '60');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('10', '61');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('10', '62');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('11', '63');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('11', '64');
INSERT INTO `t_checkgroup_checkitem`(checkgroup_id,checkitem_id) VALUES ('11', '65');

重启服务器，访问该页面

3.按条件查询检查组

在checkgroup.html页面为“查询”按钮绑定单击事件，在单击时调用handleCurrentChange(1)方法。

在查询条件输入框中输入查询条件，单击“查询”按钮进行条件查询。

3-3 编辑检查组

编辑检查组时，可以根据需求对检查组的基本信息或关联的检查项信息进行修改。

在checkgroup.html 页面中单击“编辑”按钮后会弹出编辑检查组对话框并显示检查组数据，修改对话框中的数后，单击“确定”按钮提交检查组数据，完成检查组的编辑。由此，可以将编辑检查组分解成2 个功能，分别是弹出带有检查组数据的编辑检查组对话框，以及完成检查组的编辑。

1.弹出带有检查组数据的编辑检查组对话框

（1）弹出编辑检查组对话框为页面中“编辑”按钮绑定单击事件，在单击事件触发后弹出编辑检查组对话框，再依次提交查询基本信息、查询所有检查项、查询检查组对检查项的引用的请求。

在checkgroup.html页面中定义handleUpdate()方法，用于弹出编辑检查组对话框后回显数据。

handleUpdate(row) {
    this.activeName = 'first';//每次弹出的编辑对话框默认显示基本信息区
    this.dialogFormVisible4Edit = true;//编辑对话框显示
    axios.get("/checkgroup/findById.do?id=" + row.id).then((res) => {
            ......//查询检查组基本信息
    });
    axios.get("/checkitem/findAll.do").then((res) => {//查询检查项信息
        if (res.data.flag){
            this.tableData = res.data.data;//查询检查项列表成功，为tableData赋值
            axios.get("/checkgroup/findCheckItemIdsByCheckGroupId.do?checkgroupId="+ 
                                                   row.id).then((res) => {
                ......
            });
        }
         ......//省略查询错误的提示信息
    });
}

为checkgroup.html 页面的“编辑”按钮绑定单击事件，并设置单击按钮时调用handleUpdate( )方法。

<el-button type="primary" class="mini" 
	@click="handleUpdate(scope.row)">编辑</el-button>

（2）接收和处理查询检查组请求检查组的数据包含基本信息和对检查项的引用信息，因此，客户端发起查询检查组的请求时，除了要提交查询检查组基本信息的请求，还要提交查询所有检查项的请求、查询检查组对检查项的引用的请求。

在CheckGroupController类中定义findById()方法，用于处理根据检查组 id 查询检查组基本信息的请求。

    //根据id查询检查组
    @RequestMapping("/findById")
    public Result findById(Integer id){
        try{
            //调用服务接口 findById()，发送请求
            CheckGroup checkGroup = checkGroupService.findById(id);
            //服务调用成功，返回查询结果与查询成功提示信息
            return new Result(true,
                    MessageConstant.QUERY_CHECKGROUP_SUCCESS,checkGroup);
        }catch (Exception e){
            e.printStackTrace();
            //服务调用失败，返回查询失败提示信息
            return new Result(false, MessageConstant.QUERY_CHECKGROUP_FAIL);
        }
    }

在CheckGroupController类中定义findCheckItemIdsByCheckGroupId()方法，用于处理根据检查组 id 查询检查组对检查项的引用的请求。

    //根据检查组id查询与之关联的检查项id
    @RequestMapping("/findCheckItemIdsByCheckGroupId")
    public Result findCheckItemIdsByCheckGroupId(Integer checkgroupId){
        try{
            //调用服务接口，发送请求,返回关联的id列表
            List<Integer> list = checkGroupService.findCheckItemIdsByCheckGroupId(checkgroupId);
            //服务调用成功，返回查询结果与查询成功提示信息
            return new Result(true,
                    MessageConstant.QUERY_CHECKITEM_SUCCESS,list);
        }catch (Exception e){
            e.printStackTrace();
            //服务调用失败，返回查询失败提示信息
            return new Result(false,MessageConstant.QUERY_CHECKITEM_FAIL);
        }
    }

（3）查询检查组数据 ①重写CheckGroupService接口的findById()方法，在方法中调用CheckGroupDao接口中查询基本信息的findById()方法；

②重写findCheckItemIdsByCheckGroupId()方法，在方法中调用CheckGroupDao接口中查询检查组对检查项的引用的findCheckItemIdsByCheckGroupId()方法。

在CheckGroupService接口中定义findById()方法，用于根据检查组id 查询检查组的基本信息；定义findCheckItemIdsByCheckGroupId( )方法，用于根据检查组id 查询检查组对检查项的引用。

     CheckGroup findById(Integer id);//根据id查询检查组
     
     List<Integer> findCheckItemIdsByCheckGroupId(Integer checkgroupId);//根据检查组id查询与之关联的检查项id

在CheckGroupServiceImpl类中重写CheckGroupService接口的findById()方法和findCheckItemIdsByCheckGroupId()方法。

    //根据id查询检查组
    public CheckGroup findById(Integer id) {
        return checkGroupDao.findById(id);//调用持久层接口
    }

    //根据检查组id查询与之关联的检查项id
    public List<Integer> findCheckItemIdsByCheckGroupId(Integer checkgroupId) {
        //调用持久层接口
        return checkGroupDao.findCheckItemIdsByCheckGroupId(checkgroupId);
    }

在CheckGroupDao接口中定义findById()方法，用于根据检查组 id 查询检查组基本信息；定义 findCheckItemIdsByCheckGroupId( )方法，用于根据检查组 id 查询检查组对检查项的引用。

 CheckGroup findById(Integer id);//根据id查询检查组

 List<Integer> findCheckItemIdsByCheckGroupId(Integer checkgroupId);//根据检查组id查询与之关联的检查项id

在CheckGroupDao.xml映射文件中使用select元素映射查询语句，分别查询检查组基本信息、查询检查组对检查项的引用。

<!--根据id查询检查组-->
    <select id="findById" parameterType="int" resultType="com.health.entity.CheckGroup">
        SELECT * FROM t_checkgroup WHERE id = #{id}
    </select>

    <!--根据检查组id查询与之关联的检查项id-->
    <select id="findCheckItemIdsByCheckGroupId" parameterType="int" resultType="int">
         SELECT checkitem_id FROM t_checkgroup_checkitem WHERE checkgroup_id = #{checkgroup_id}
    </select>

（4）显示查询结果将CheckGroupController 类中findById( )方法的查询结果、CheckItemController 类中findAll( )方法的查询结果、CheckGroupController 类中findCheckItemIdsByCheckGroupId( )方法的查询结果依次返回到checkgroup.html页面。

找到检查组编码为0001 的检查组，单击其右侧的“编辑”按钮，弹出编辑检查组对话框。

2.完成检查组的编辑

（1）提交编辑检查组数据为编辑检查组对话框的“确定”按钮绑定单击事件，在单击事件触发后提交对话框中的检查组数据。

为编辑检查组对话框中的“取消”和“确定”按钮绑定单击事件，并设置单击时要执行的操作。

<div slot="footer" class="dialog-footer">
    <el-button @click="dialogFormVisible4Edit = false">取消</el-button>
    <el-button type="primary" @click="handleEdit()">确定</el-button>
</div>

在checkgroup.html页面中定义handleEdit()方法，用于提交编辑检查组数据。

handleEdit(){
    axios.post("/checkgroup/edit.do?checkitemIds="
        + this.checkitemIds,this.formData).then((res) => {
        if (res.data.flag){
            this.dialogFormVisible4Edit = false;//关闭编辑对话框
            //弹出提示信息
            this.$message({
                type:'success',
                message:res.data.message
            });
            this.findPage();//执行分页查询
        }else{
            //执行失败，弹出提示信息
            this.$message.error(res.data.message);
        }
    });
}

（2）接收和处理编辑检查组请求客户端发起编辑检查组数据的请求后，由控制器类CheckGroupController 的edit( )方法接收页面提交的请求，请求的参数中包含检查组基本信息和对检查项的引用。

在CheckGroupController类中定义edit()方法，用于处理编辑检查组的请求。

    //编辑检查组
    @RequestMapping("/edit")
    public Result edit(@RequestBody CheckGroup checkGroup, Integer[] checkitemIds){
        try{
            //调用服务接口 edit()，发送请求
            checkGroupService.edit(checkGroup,checkitemIds);
            //调用服务成功，返回编辑成功提示信息
            return new Result(true, MessageConstant.EDIT_CHECKGROUP_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            //调用服务失败，返回编辑失败提示信息
            return new Result(false, MessageConstant.EDIT_CHECKGROUP_FAIL);
        }
    }

（3）编辑检查组数据在CheckItemServiceImpl类中重写CheckGroupService接口的edit()方法，在方法中调用CheckGroupDao接口中的相关方法实现编辑检查组。

在CheckGroupService接口中定义edit()方法，用于编辑检查组。

void edit(CheckGroup checkGroup, Integer[] checkitemIds);//编辑检查组

在CheckGroupServiceImpl类中重写CheckGroupService接口的edit()方法。

    //编辑检查组，同时需要设置关联关系
    public void edit(CheckGroup checkGroup, Integer[] checkitemIds) {
        checkGroupDao.edit(checkGroup);//编辑检查组基本信息
        checkGroupDao.deleteAssociation(checkGroup.getId());//删除关联检查项
        //重新建立关联检查项
        this.setCheckGroupAndCheckItem(checkGroup.getId(),checkitemIds);
    }

在CheckGroupDao接口中定义edit()方法以编辑检查组基本信息；定义deleteAssociation( )方法以删除检查组对检查项的引用。

     void edit(CheckGroup checkGroup);//编辑检查组基本信息

     void deleteAssociation(Integer checkgroupId);//删除检查组和检查项的关联关系（操作中间关系表）

在CheckGroupDao.xml映射文件中使用update元素映射修改语句，修改检查组的基本信息。

在CheckGroupDao.xml映射文件中使用delete元素映射删除语句，删除检查组对检查项的引用。

<!--编辑检查组基本信息-->
    <update id="edit" parameterType="com.health.entity.CheckGroup">
        UPDATE t_checkgroup
        <set>
            <if test="name != null">
                name = #{name},
            </if>
            <if test="sex != null">
                sex = #{sex},
            </if>
            <if test="code != null">
                code = #{code},
            </if>
            <if test="helpCode != null">
                helpCode = #{helpCode},
            </if>
            <if test="attention != null">
                attention = #{attention},
            </if>
            <if test="remark != null">
                remark = #{remark},
            </if>
        </set>
        WHERE id = #{id}
    </update>

    <!--清理检查组和检查项的关联关系-->
    <delete id="deleteAssociation" parameterType="int">
        DELETE FROM t_checkgroup_checkitem WHERE checkgroup_id = #{checkgroup_id}
    </delete>

（4）提示编辑结果 CheckGroupController 类中的edit( )方法将编辑检查组的结果返回checkgroup.html 页面，checkgroup.html页面根据返回结果提示编辑成功或失败的信息。

3-4 删除检查组

对于检查组列表中重复出现的、与检查项搭配不合理的检查组，或者是已经过时的检查组，除了可以进行编辑外，还可以进行删除。

（1）弹出提示对话框

为checkgroup.html 页面中的“删除”按钮绑定单击事件，并设置在单击“删除”按钮时调用handleDelete( )方法。

<el-button size="mini" type="danger" 
	@click="handleDelete(scope.row)">删除</el-button>

在 checkgroup.html 页面中实现 handleDelete( )方法，用于删除检查组。

handleDelete(row) {
    this.$confirm('你确定要删除当前数据吗？','提示',{
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning'
    }).then(() => {
        axios.get("/checkgroup/delete.do?id=" + row.id).then((res) => {
                if (res.data.flag){//处理成功
                    this.$message({
                        type:'success',
                        message: res.data.message
                    });
                    this.findPage();//调用分页查询
                }else{ this.$message.error(res.data.message);//处理失败}
            });
    })
    ......省略“取消”
}

（2）实现删除检查组控制器

在CheckGroupController 类中定义方法 delete( )，用于处理根据检查组 id 删除检查组的请求。

    //根据id删除检查组
    @RequestMapping("/delete")
    public Result delete(Integer id){
        try {
            checkGroupService.delete(id);//调用服务接口，发送请求
            //服务调用成功，返回删除成功提示信息
            return new Result(true, MessageConstant.DELETE_CHECKGROUP_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            //服务调用失败，返回删除失败提示信息
            return new Result(false,MessageConstant.DELETE_CHECKGROUP_FAIL);
        }
    }

（3）创建删除检查组服务

在CheckGroupService接口中定义delete()方法，用于根据检查组id 删除检查组。

void delete(Integer id);//根据id删除检查组

（4）实现删除检查组服务

在CheckGroupServiceImpl类中重写CheckGroupService接口的delete()方法，用于根据检查组id删除检查组。

    //根据id删除检查组
    public void delete(Integer id) {
        //调用持久层接口，根据检查组id查询检查组与套餐是否有关联关系
        long count = checkGroupDao.selectCountByCheckGroupId(id);
        if (count > 0){
            //不能删除，已经被套餐表关联
            throw new RuntimeException(MessageConstant.DELETE_CHECKGROUP_FAIL);
        }else{
            checkGroupDao.deleteAssociation(id);//根据检查组id删除关联检查项信息
            checkGroupDao.deleteById(id);//删除检查组
        }
    }

（5）实现持久层删除检查组

在CheckGroupDao接口中定义selectCountByCheckGroupId()方法和deleteById()方法。

     long selectCountByCheckGroupId(Integer id);//根据检查组id查询检查组与套餐的关联关系

     void deleteById(Integer id);//根据id删除检查组

在CheckGroupDao.xml映射文件中使用select元素映射查询语句，查询套餐对检查组的引用；使用delete元素映射删除语句，删除检查组基本信息。

 <!--根据检查组id查询检查组与套餐表是否有关联关系-->
    <select id="selectCountByCheckGroupId" parameterType="int" resultType="long">
        SELECT count(1) FROM t_setmeal_checkgroup
                WHERE checkgroup_id = #{checkgroup_id}
    </select>

    <!--根据id删除检查组-->
    <delete id="deleteById" parameterType="int">
        DELETE FROM t_checkgroup WHERE id = #{id}
    </delete>

（6）测试删除检查组