SSM常用代码块

工具内层

Util：工具

       Util层就是用来存放工具类的地方，对于一些独立性很高的小功能，或者重复性很高的代码段，可以提取到Uitl层中

数据层

pojo：普通java对象

po：持久层，与数据库中的表相映射的java对象

vo：业务层之间数据传递的对象

pojo：简单无规则的java对象，只有属性+get+set+toString方法

        常用注解:

@TableName("表名")               //实现对象与表明的映射
@Data                           //实现get/set/toString方法
@TableId(type = IdType.AUTO)    //设定主键自增
@TableField("name")             //属性与字段的映射
@TableField(exist = false)      //表示当前属性不是数据库的字段，但在项目中必须使用，这样在新增等 
                                //使用bean的时候，mybatis-plus就会忽略这个，不会报错

entity：实体

严格和数据库相对应，数据库中有什么字段，entity包中的类就有什么字段

model：模型

一般里面存在的是实体类的模型，是用来给后端用的

view：视图

一般里面存放的时对实体类表的映射类（视图），使用来给前端使用的

数据访问层

DAO层：主要针对数据表的操作，可以理解为一张数据表，就有一个DAO层与指对应

mapper层：mapper层 = dao层，若使用mybatis框架，则其生成的类名字是mapper，其实就是dao层。

业务层

Service:接口

由于Dao里面存放了对表操作的方法，entity类中存放了映射表的POJO类。

Service的作用就是将Dao和entity类整合起来，进行再次封装，封装成一个方法，我们调用这个方法，就实现了对某个表的增删改查操作。

ServiceIpml：接口实现类

实现Service接口中的方法

控制层

Controller：负责请求转发，接受页面传递过来的参数，根据参数的不同，是调用不同的Service层方法进行操作，操作完成后将返回结果传递给页面。

常用注解

Pojo层

@TableName("user")              //实现对象与数据库表名的映射
@Data                           //自动生成get/set/toString方法
@Accessors(chain = true)        //开启链式加载
@TableId(type = IdType.AUTO)    //主键自增
@TableField(exist = false)      //该属性不存在

Controller层

@RestController             //此注解的方法表示一个控制器，返回json
@CrossOrigin                //解决跨域问题
@Autowired                  //完成对象间的依赖关系spring  di；相当于底层帮你维护了两个对象间的关系:new
@RequestMapping("路径")     //请求路径
@getMapping("")             //查询
@PostMapping("")            //新增
@PutMapping("")             //修改
@DeleteMapping("")          //删除
@ResponseBody               //将对象转化为json串
@RequestBody                //将json串转化为user对象

Service层

@Service
@Autowired
@Transactional      //事务开启 ，或者是基于接口的或者是基于类的代理被创建

demo1：判断服务器是否调用成功

package com.jt.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;


@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class SysResult {

    private Integer status;  //状态码信息
    private String msg;      //提示信息
    private Object data;     //封装业务数据

    public static SysResult fail(){

        return new SysResult(201,"服务器调用失败",null);
    }
    public static SysResult success(){

        return new SysResult(200,"业务执行成功",null);
    }
    /**
     * 1.方法要被别人调用
     * 2.该方法被调用时，调用者负责参数的传递
     * @param data
     * @return
     * */
    public static SysResult success(Object data){

        return new SysResult(200,"业务执行成功",data);
    }
    public static SysResult success(String msg, Object data){

        return new SysResult(200,msg,data);
    }
}

demo2：根据用户名判断数据是否有效

根据用户名和密码判断数据是否有效
* 步骤：
*       1.将明文进行加密处理。  md5加密/md5Hash/sha1
*       2.根据加密后的数据查询数据库
*       3.判断结果是否有效
*            有值：返回特定字符串token=123
*            null： u/p  不确定  返回null
  @Override
    @Transactional
    public String login(User user) {
        //1.获取原始密码
        String password = user.getPassword();
        //2.将密码进行加密处理
        String md5Str = DigestUtils.md5DigestAsHex(password.getBytes());
        //3.将密文传递给对象
        user.setPassword(md5Str);//username/password
        //根据对象中不为null的属性充当where条件
        QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
        //4.根据条件查询数据库
        User userDB = userMapper.selectOne(queryWrapper);
        //5.定义token数据  限定条件  token不能重复
        String uuid = UUID.randomUUID().toString()
                .replace("_", "");
        // UUID：随机字符串  3.4*10^38 种可能性  hash（时间戳+随机数）
        return userDB ==null?null:uuid;
    }

demo3：利用MP的方式实现分页查询

    /**
     * 利用MP的方式实现分页查询
     * API  selectPage(arg1,arg2)
     * arg1：MP中的分页对象   固定的
     * arg2：MP 分页中的条件构造器
     * @param  pageResult
     * @return
     * 动态sql：select * from user where username like "admin"
     * 条件：如果用户传递了query则凭借where条件  否则不拼接where条件
     * */
    @Override
    public PageResult getUserList(PageResult pageResult) {
        //1.定义mp的分页对象
        IPage iPage = new Page(pageResult.getPageNum(),pageResult.getPageSize());
        //2.构建查询条件构造器
        QueryWrapper queryWrapper = new QueryWrapper();
        //判断用户数据是否有效  有效为true  无效为false
        boolean flag = StringUtils.hasLength(pageResult.getQuery());
        queryWrapper.like(flag, "username", pageResult.getQuery());
        //经过MP分页查询将所有的分页数据封装到了iPage对象
        iPage = userMapper.selectPage(iPage, queryWrapper);
        long total = iPage.getTotal(); //从分页对象中获取总记录数
        List<User> rows = iPage.getRecords(); //从分页对象中获取分页后的结果
        return pageResult.setTotal(total).setRows(rows);
    }

demo4：新用户添加

    @Override
    @Transactional
    public void addUser(User user) {
        String password = user.getPassword();
        //密码加密操作
        String md5Pass = DigestUtils.md5DigestAsHex(password.getBytes());
        //为属性赋值操作
        user.setStatus(true).setPassword(md5Pass);
        //实现入库操作
        userMapper.insert(user);
    }

demo5：三级菜单信息获取

@Service
public class ItemCatServiceImpl implements ItemCatService{

    @Autowired
    private ItemCatMapper itemCatMapper;

    /**
     * 1.准备Map集合,实现数据封装
     * Map<key,value> = Map<parentId,List<ItemCat>>
     * 2.封装业务说明
     *      map中key~~parentId
     *         不存在:可以存储该key
     *               同时封装一个List集合,将自己作为第一个元素封装到其中.
     *         存在: 根据key获取所有子级集合,将自己追加进去 形成第二个元素.
     */

    public Map<Integer,List<ItemCat>> itemCatMap(){
        //1.定义Map集合
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //2.查询所有的数据库信息 1-2-3
        List<ItemCat> list = itemCatMapper.selectList(null);
        for(ItemCat itemCat :list){
            int parentId = itemCat.getParentId();//获取父级ID
            if(map.containsKey(parentId)){ //判断集合中是否已经有parentId
                //有key  获取list集合 将自己追加到集合中
                List<ItemCat> exeList = map.get(parentId);//引用对象
                exeList.add(itemCat);
            }else{
                //没有key,将自己封装为第一个list元素
                List<ItemCat> firstList = new ArrayList<>();
                firstList.add(itemCat);
                map.put(parentId,firstList);
            }
        }
        return map;
    }

    @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        Map<Integer,List<ItemCat>> map = itemCatMap();
        //1.如果level=1 说明获取一级商品分类信息 parent_id=0
        if(level == 1){
           return map.get(0);
        }

        if(level == 2){ //获取一级和二级菜单信息
            return getTwoList(map);
        }

        //3.获取三级菜单信息
        //3.1获取二级商品分类信息  BUG:有的数据可能没有子级 如何处理
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat : oneList){
            //从一级集合中,获取二级菜单列表
            List<ItemCat> twoList = oneItemCat.getChildren();
            for(ItemCat twoItemCat : twoList){
                //查询三级商品分类  条件:parentId=2级ID
                List<ItemCat> threeList = map.get(twoItemCat.getId());
                twoItemCat.setChildren(threeList);
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("耗时:"+(endTime - startTime)+"毫秒");
        return oneList;
    }

    public List<ItemCat> getTwoList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> oneList = map.get(0);
        for (ItemCat oneItemCat : oneList){//查询二级 parentId=1级Id
            List<ItemCat> twoList = map.get(oneItemCat.getId());
            oneItemCat.setChildren(twoList);
        }
        //二级嵌套在一级集合中,所有永远返回的都是1级.
        return oneList;
    }





    /**
     * 3层商品分类嵌套  1一级分类(children(2级商品分类))
     *                2一级分类(children(3级商品分类))
     * 一级查询条件   parent_id=0
     * 二级查询条件   parent_id=一级的ID
     * 三级查询条件   parent_id=二级的ID
     * @param level
     * @return
     */
   /* @Override
    public List<ItemCat> findItemCatList(Integer level) {
        long startTime = System.currentTimeMillis();
        //1.查询一级商品分类信息
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("parent_id",0 );
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);
        //2.查询二级商品分类信息
        for (ItemCat oneItemCat : oneList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id",oneItemCat.getId());
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            //3.查询三级商品分类信息
            for (ItemCat twoItemCat : twoList){
                queryWrapper.clear();
                queryWrapper.eq("parent_id",twoItemCat.getId());
                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
                twoItemCat.setChildren(threeList);
            }
            oneItemCat.setChildren(twoList);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("业务的执行时间为:"+(endTime-startTime)+"毫秒");
        return oneList;
    }*/
}

demo6：全局异常处理

//全局异常处理,内部依然采用环绕通知的方式
//异常处理之后返回的JSON串.
//该全局异常处理机制,捕获Controller层的异常(其它层向上抛出异常)
@RestControllerAdvice
public class MyException {
    /**
     * 业务: 如果后端报错,应该及时提示前端用户,返回统一的对象
     *      SysResult对象. status=201/msg="xxx失败"
     * 注解说明:
     *      @ExceptionHandler(RuntimeException.class)
     *      当遇到某种异常时,全局异常处理机制有效!!
     */
    @ExceptionHandler(RuntimeException.class)
    public Object exception(Exception e){
        //1.应该打印异常信息.
        e.printStackTrace();
        //2.返回特定的响应数据.
        return SysResult.fail();
    }
}

demo7：实现商品分类删除

 /**
     * 策略: 如果是父级,则应该删除子级
     * @param itemCat
     */
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        //1.判断是否为三级菜单
        if(itemCat.getLevel() == 3){
            //如果是三级.则直接删除
            itemCatMapper.deleteById(itemCat.getId());
            return; //程序终止.
        }

        //2.检查菜单是否为二级
        if(itemCat.getLevel() == 2){
            //应该先删除三级 根据parent_id= 2级ID即可.
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.eq("parent_id",itemCat.getId());
            itemCatMapper.delete(queryWrapper);
            //再删除2级菜单
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }

        //删除1级商品分类信息  先删除3级.再删除2级.
        //1.首先获取商品分类2级信息 parent_id= 1级ID
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("parent_id",itemCat.getId());
        List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
        for (ItemCat twoItemCat : twoList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id",twoItemCat.getId());
            itemCatMapper.delete(queryWrapper);//删除3级菜单
            itemCatMapper.deleteById(twoItemCat.getId());//删除2级
        }
        itemCatMapper.deleteById(itemCat.getId());  //删除1级.

    }

demo8：数据字典表翻译

创建字典表

CREATE TABLE `t_safe_dict` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `dict_id` varchar(32) NOT NULL COMMENT '唯一标识',
  `table_name` varchar(32) NOT NULL COMMENT '表',
  `fieid` varchar(32) NOT NULL COMMENT '字段',
  `dict_code` varchar(64) DEFAULT NULL COMMENT '字典编码',
  `dict_name` varchar(100) DEFAULT NULL COMMENT '字典名称',
  `data_status` char(1) DEFAULT NULL COMMENT '数据状态:1-有效；0-无效',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `t_safe_dict_dict_id_uindex` (`dict_id`)
) ENGINE=InnoDB AUTO_INCREMENT=183 DEFAULT CHARSET=utf8 COMMENT='数据字典表';

public class TranslateDict {
    /**
     *  数据字典表翻译
     */
    public static List<String> getSafeDict(Map<String,String> map) {
        List<String> riskTypeList = Arrays.asList(map.get("dictType").split(map.get("splitPara")));
        List<String> riskTypeName = new ArrayList<>();
        ISafeDictService iSafeDictService = ServiceClientFactory.getService(ISafeDictService.class);
        for (String riskType : riskTypeList) {
            SafeDict safeDict = iSafeDictService.getOne(Wrappers.<SafeDict>lambdaQuery()
                    .eq(SafeDict::getTableName,map.get("tableName")).eq(SafeDict::getFieid,map.get("fieldPara"))
                    .eq(SafeDict::getDictCode,riskType).eq(SafeDict::getDataStatus,"1"));
            if (safeDict != null) {
                riskTypeName.add(safeDict.getDictName());
            } else {
                riskTypeName.add(riskType);
            }
        }
        return riskTypeName;
    }
}}


调用方法：
        //遍历入参
        for (QrySafeRecordRqDTO qrySafeRecordRqDTO : pageResult.getBody()) {
        //判断OperationScene是否存在
            if (StringUtils.isNotEmpty(qrySafeRecordRqDTO.getOperationScene())) {
                Map<String, String> recordMap = new HashMap<>();
                recordMap.put("dictType", qrySafeRecordRqDTO.getOperationScene());
                //使用、隔开
                recordMap.put("splitPara", "、");
                //put表名
                recordMap.put("tableName", "t_safe_record");
                //put字段名
                recordMap.put("fieldPara", "operation_scene");
                qrySafeRecordRqDTO.setOperationScene(String.join("、", TranslateDict.getSafeDict(recordMap)));
            }