spring boot+iview 前后端分离架构之数据字典的实现（二十六）

公众号

大家可以直接微信扫描上面的二维码关注我的公众号，然后回复【bg26】 里面就会给到源代码的下载地址同时会附上相应的视频教程，并定期在我的公众号上给大家推送相应的技术文章，欢迎大家关注我的公众号。

数据字典

通过第二十四章和二十五章我们已经实现了我们的整个的鉴权体系了，那么我们就可以开始编写我们的具体的模块的实现了，在第八章的时候我们编写了相应的接口文档，我们现在可以直接找到我们的bg-admin\bg-admin-doc\接口文档中的数据字典接口文档.md文件打开，如下所示：

我们接下来就照着接口文档来编写我们相应的数据字典的实现，首先我们编写我们的DictDao.xml，代码如下：

DictDao.xml的实现如下

  
    
    
    
    
    
  


  
  
    update t_dict set dictCode = #{dictCode},dictText=#{dictText},dictValue=#{dictValue} where id = #{id}
  

  
  
    select count(*) from t_dict where dictType = #{dictType} and dictCode = #{dictCode}
    
      and id != #{id}
    
  

  
  
    select * from t_dict where 1=1
    
      and (
      dictType  like concat('%',#{search},'%') or
      dictCode  like concat('%',#{search},'%') or
      dictText  like concat('%',#{search},'%') or
      dictValue  like concat('%',#{search},'%')
      )
    
    
      
        and dictCode like concat('%',#{dictCode},'%')
      
    
  

DictDao的实现如下

接着编写我们的DictDao，代码实现如下：

package com.github.bg.admin.core.dao;

import com.github.bg.admin.core.entity.Dict;
import org.apache.ibatis.annotations.Param;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

/**
 * @author linzf
 * @since 2019-07-08
 * 类描述：数据字典的dao
 */
public interface DictDao extends Mapper {

    /**
     * 功能描述：更新字典数据
     * @param dictCode 字典编码
     * @param dictText 字典文本
     * @param dictValue 字典值
     * @param id 字典流水id
     * @return 返回更新结果
     */
    int updateDict(@Param("dictCode")String dictCode, @Param("dictText")String dictText, @Param("dictValue")String dictValue, @Param("id")String id);

    /**
     * 功能描述：验证字典的类型和编码是否重复
     * @param id 字典流水ID
     * @param dictType 字典类型
     * @param dictCode 字典编码
     * @return 返回验证结果
     */
    int checkTypeAndCode(@Param("id") String id,@Param("dictType") String dictType,@Param("dictCode") String dictCode);

    /**
     * 功能描述：获取数据字典列表
     * @param search 模糊匹配数据字典的dictType、dictText、dictValue、dictCode
     * @param dictCodeArray 分段模糊查询dictCode
     * @return 返回查询结果
     */
    List queryDictList(@Param("search") String search, @Param("dictCodeArray")String [] dictCodeArray);

}

分页工具的实现

在编写我们的service的时候我们首先要实现我们的两个分页插件，分别是entity底下的Page和和util底下的PageUtil，代码如下：

Page的实现

package com.github.bg.admin.core.entity;

import java.util.List;

/**
 * @author linzf
 * @since 2019-04-26
 * 类描述：分页的实体类
 */
public class Page {

    /**
     * 每页显示多少条数据
     */
    private int pageSize;
    /**
     * 当前第几页
     */
    private int current;
    /**
     * 总记录数
     */
    private long total;
    /**
     * 集合数据
     */
    private List rows;

    public Page(){
        super();
    }

    public Page(int pageSize, int current, long total, List rows){
        this.pageSize = pageSize;
        this.current = current;
        this.total = total;
        this.rows = rows;
    }


    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getCurrent() {
        return current;
    }

    public void setCurrent(int current) {
        this.current = current;
    }

    public long getTotal() {
        return total;
    }

    public void setTotal(long total) {
        this.total = total;
    }

    public List getRows() {
        return rows;
    }

    public void setRows(List rows) {
        this.rows = rows;
    }
}

PageUtil的实现

package com.github.bg.admin.core.util;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class PageUtil {

    private PageUtil() {
    }

    public static void startPage(Map reqMap) {
        int page = Integer.parseInt(reqMap.getOrDefault("page", "1"));
        int size = Integer.parseInt(reqMap.getOrDefault("size", "20"));
        PageHelper.startPage(page, (size > 0 && size <= 500) ? size : 20);
    }

    @Deprecated
    public static HashMap getResultMap(List result) {
        return getResult(result);
    }

    public static HashMap getResult(List result) {
        PageInfo pageInfo = new PageInfo<>(result);
        HashMap res = new HashMap<>(4);
        res.put("page", pageInfo.getPageNum());
        res.put("size", pageInfo.getPageSize());
        res.put("total", pageInfo.getTotal());
        res.put("rows", pageInfo.getList());
        return res;
    }

    public static void startPageObject(Map reqMap) {
        int page = Integer.parseInt(reqMap.getOrDefault("page", "1").toString());
        int size = Integer.parseInt(reqMap.getOrDefault("size", "20").toString());
        PageHelper.startPage(page, (size > 0 && size <= 500) ? size : 20);
    }
}

主键生成工具UuidGenId的实现

package com.github.bg.admin.core.util;

import tk.mybatis.mapper.genid.GenId;

import java.util.UUID;

/**
 * 类描述：生成主键的类
 * @author linzf
 */
public class UuidGenId implements GenId {

    @Override
    public String genId(String table, String column) {
        return UUID.randomUUID().toString().replaceAll("-","");
    }

}

改造Dict的实体，改造位置如下：

    /**
     * 字典流水ID
     */
    @Id
    @Column(name = "id")
    @KeySql(genId = UuidGenId.class)
    private String id;

DictService的实现如下：

接着编写我们的DictService代码如下：

package com.github.bg.admin.core.service;

import com.github.bg.admin.core.constant.SystemStaticConst;
import com.github.bg.admin.core.dao.DictDao;
import com.github.bg.admin.core.entity.Dict;
import com.github.bg.admin.core.entity.Page;
import com.github.bg.admin.core.entity.ReturnInfo;
import com.github.bg.admin.core.util.PageUtil;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author linzf
 * @since 2019-05-06
 * 类描述：数据字典的service类
 */
@Service
public class DictService {

    /**
     * 字典的dao
     */
    @Autowired
    private DictDao dictDao;

    /**
     * 功能描述：加载全部的字典数据
     * @return 返回操作结果
     */
    public ReturnInfo loadAll(){
        try{
            List dictList = dictDao.queryDictList("",new String [0]);
            return new ReturnInfo(SystemStaticConst.SUCCESS, "加载全部的字典数据成功",dictList);
        }catch (Exception e){
            return new ReturnInfo(SystemStaticConst.FAIL, "加载全部的字典数据失败！失败原因：" + e.getMessage());
        }
    }

    /**
     * 功能描述：更新字典数据
     * @param dictCode 字典编码
     * @param dictText 字典文本
     * @param dictValue 字典值
     * @param id 字典流水id
     * @return 返回更新结果
     */
    public ReturnInfo updateDict(String dictCode,String dictText,String dictValue,String id){
        try{
            Dict dict = dictDao.selectByPrimaryKey(id);
            if (dictDao.checkTypeAndCode(dict.getId(), dict.getDictType(), dictCode) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "字典类型和字典编码已经存在，请修改以后再提交！");
            }
            if(dictDao.updateDict(dictCode, dictText, dictValue, id)>0){
                return  new ReturnInfo(SystemStaticConst.SUCCESS, "更新字典数据成功");
            }
            return new ReturnInfo(SystemStaticConst.FAIL, "更新字典数据失败！失败原因：查无此字典数据");
        }catch (Exception e){
            e.printStackTrace();
            return new ReturnInfo(SystemStaticConst.FAIL, "更新字典数据失败！失败原因：" + e.getMessage());
        }
    }

    /**
     * 功能描述：根据字典流水来获取字典数据
     * @param id 字典流水ID
     * @return 返回操作结果
     */
    public ReturnInfo getDict(String id){
        try{
            Dict dict = dictDao.selectByPrimaryKey(id);
            if(dict!=null){
                return new ReturnInfo(SystemStaticConst.SUCCESS, "获取字典数据成功", dict);
            }
        }catch (Exception e){
            return new ReturnInfo(SystemStaticConst.FAIL, "获取字典数据失败！失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.FAIL, "获取字典数据失败！失败原因：查无此字典数据");
    }

    /**
     * 功能描述：实现删除字典数据
     *
     * @param id 字典流水ID
     * @return 返回删除结果
     */
    public ReturnInfo deleteDict(String id) {
        try {
            if (dictDao.deleteByPrimaryKey(id) > 0) {
                return new ReturnInfo(SystemStaticConst.SUCCESS, "删除字典数据成功");
            }
            return new ReturnInfo(SystemStaticConst.FAIL, "删除字典数据失败！失败原因：该字典数据不存在");
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "删除字典数据失败！失败原因：" + e.getMessage());
        }
    }

    /**
     * 功能描述：实现增加字典数据
     *
     * @param dict 包含字典数据的实体
     * @return 返回操作结果
     */
    public ReturnInfo addDict(Dict dict) {
        try {
            if (dictDao.checkTypeAndCode(dict.getId(), dict.getDictType(), dict.getDictCode()) > 0) {
                return new ReturnInfo(SystemStaticConst.FAIL, "字典类型和字典编码已经存在，请修改以后再提交！");
            }
            dictDao.insert(dict);
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "增加字典数据失败，失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.SUCCESS, "增加字典数据成功", dict);
    }

    /**
     * 功能描述：验证字典的类型和编码是否重复
     *
     * @param id       字典流水ID
     * @param dictType 字典类型
     * @param dictCode 字典编码
     * @return 返回验证结果
     */
    public ReturnInfo checkTypeAndCode(String id, String dictType, String dictCode) {
        Map result = new HashMap<>(1);
        try {
            // 查询的结果大于0表示数据库已经存在该数据了，反之则不存在
            if (dictDao.checkTypeAndCode(id, dictType, dictCode) > 0) {
                result.put("success", "unPass");
            } else {
                result.put("success", "pass");
            }
        } catch (Exception e) {
            return new ReturnInfo(SystemStaticConst.FAIL, "验证请求处理失败，失败原因：" + e.getMessage());
        }
        return new ReturnInfo(SystemStaticConst.SUCCESS, "验证请求处理成功", result);
    }

    /**
     * 功能描述：获取数据字典列表
     *
     * @param search   模糊匹配数据字典的dictType、dictText、dictValue、dictCode
     * @param dictCode 模糊查询dictCode
     * @param pageSize 每页显示的记录的条数
     * @param current  当前访问第几页
     * @param orderKey     排序字段
     * @param orderByValue 排序方式，降序还是升序
     * @return 返回查询结果
     */
    public ReturnInfo queryDictList(String search,String dictCode, int pageSize, int current, String orderKey, String orderByValue) {
        PageHelper.startPage(current, (pageSize > 0 && pageSize <= 500) ? pageSize : 20,(orderKey != null && !"".equals(orderKey)) ? ((orderByValue != null && !"".equals(orderByValue)) ? (orderKey + " " + orderByValue) : orderKey) : "");
        String [] dictCodeArray = dictCode.split(" ");
        HashMap res = PageUtil.getResult(dictDao.queryDictList(search,dictCodeArray));
        return new ReturnInfo(SystemStaticConst.SUCCESS, "获取数据字典列表数据成功！", new Page(pageSize, current, (long) res.get("total"), (List) res.get("rows")));
    }

}

DictController的实现如下：

package com.github.bg.admin.core.controller;

import com.github.bg.admin.core.entity.Dict;
import com.github.bg.admin.core.entity.ReturnInfo;
import com.github.bg.admin.core.service.DictService;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;


/**
 * @author linzf
 * @since 2019/05/06
 * 类描述：数据字典的controller类
 */
@RestController
@RequestMapping("/dict")
public class DictController {

    @Autowired
    private DictService dictService;

    /**
     * 功能描述：加载全部的字典数据
     *
     * @return 返回操作结果
     */
    @ApiOperation(value = "加载全部的字典数据")
    @PostMapping("loadAll")
    public ReturnInfo loadAll() {
        return dictService.loadAll();
    }

    /**
     * 功能描述：更新字典数据
     *
     * @param dictCode  字典编码
     * @param dictText  字典文本
     * @param dictValue 字典值
     * @param id        字典流水id
     * @return 返回更新结果
     */
    @ApiOperation(value = "更新字典数据")
    @PostMapping("updateDict")
    public ReturnInfo updateDict(@RequestParam(name = "dictCode") String dictCode, @RequestParam(name = "dictText") String dictText, @RequestParam(name = "dictValue") String dictValue, @RequestParam(name = "id") String id) {
        return dictService.updateDict(dictCode, dictText, dictValue, id);
    }

    /**
     * 功能描述：根据字典流水来获取字典数据
     *
     * @param id 字典流水ID
     * @return 返回操作结果
     */
    @ApiOperation(value = "根据字典流水来获取字典数据")
    @PostMapping("getDict")
    public ReturnInfo getDict(@RequestParam(name = "id") String id) {
        return dictService.getDict(id);
    }

    /**
     * 功能描述：实现删除字典数据
     *
     * @param id 字典流水ID
     * @return 返回删除结果
     */
    @ApiOperation(value = "实现删除字典数据")
    @PostMapping("deleteDict")
    public ReturnInfo deleteDict(@RequestParam(name = "id") String id) {
        return dictService.deleteDict(id);
    }

    /**
     * 功能描述：实现增加字典数据
     *
     * @param dict 包含字典数据的实体
     * @return 返回操作结果
     */
    @ApiOperation(value = "实现增加字典数据")
    @PostMapping("addDict")
    public ReturnInfo addDict(Dict dict) {
        return dictService.addDict(dict);
    }

    /**
     * 功能描述：验证字典的类型和编码是否重复
     *
     * @param id       字典流水ID 允许为空
     * @param dictType 字典类型
     * @param dictCode 字典编码
     * @return 返回验证结果
     */
    @ApiOperation(value = "验证字典的类型和编码是否重复")
    @PostMapping("checkTypeAndCode")
    public ReturnInfo checkTypeAndCode(@RequestParam(name = "id", required = false) String id, @RequestParam(name = "dictType") String dictType, @RequestParam(name = "dictCode") String dictCode) {
        return dictService.checkTypeAndCode(id, dictType, dictCode);
    }

    /**
     * 功能描述：获取数据字典列表
     *
     * @param search       模糊匹配数据字典的dictType、dictText、dictValue、dictCode 允许为空
     * @param dictCode     模糊查询dictCode
     * @param pageSize     每页显示的记录的条数
     * @param current      当前访问第几页
     * @param orderKey     排序字段
     * @param orderByValue 排序方式，降序还是升序
     * @return 返回查询结果
     */
    @ApiOperation(value = "获取数据字典列表")
    @PostMapping("queryDictList")
    public ReturnInfo queryDictList(@RequestParam(name = "search", required = false) String search,
                                    @RequestParam(name = "dictCode", required = false) String dictCode,
                                    @RequestParam(name = "pageSize") int pageSize,
                                    @RequestParam(name = "current") int current,
                                    @RequestParam(name = "orderKey", required = false) String orderKey,
                                    @RequestParam(name = "orderByValue", required = false) String orderByValue) {
        return dictService.queryDictList(search, dictCode, pageSize, current, orderKey, orderByValue);
    }

}

运行项目查看效果

最后我们将我们的项目启动起来输入账号：admin密码：123456，然后访问我们的字典维护模块，我们可以正常的实现字典的增删改查，这样我们就已经实现了我们数据字典的整个模块的交互了。

上一篇文章地址：spring boot+iview 前后端分离架构之登录的实现（二十五）
下一篇文章地址：spring boot+iview 前后端分离架构之菜单管理的实现（二十七）