SpringBoot实战第四天

新增棋子

接口文档

从接口文档读取请求方式，响应数据类型等，战斗，爽！

没什么新东西，先上实体类

@Data
public class Chess {
    private Integer id;//主键ID
    private String ChessName;//棋子名
    private String content;//简介
    private String coverImg;//棋子图标
    private String state;//发布状态 已发布|草稿
    private Integer categoryId;//棋子分类id
    private Integer createUser;//创建人ID
    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间
    private int cost;//棋子费用
    private String chessClass;//棋子种族
    private String chessOrigin;//棋子特性
}

Controller层(参数校验下一步做)

@RestController
@RequestMapping("/chess")
public class ChessController {

    @Autowired
    private ChessService chessService;


    @PostMapping
    public Result add(@RequestBody Chess chess){
        chessService.add(chess);
        return Result.success();
    }

}

Srivice层

@Mapper
public interface ChessMapper {

    @Insert("insert into chess(chess_name,content,cover_img,state,category_id,create_user,create_time,update_time,cost,class,origin)" +
            "values(#{ChessName},#{content},#{coverImg},#{state},#{categoryId},#{createUser},#{createTime},#{updateTime},#{cost},#{chessClass},#{chessOrigin})")
    void add(Chess chess);
}

json没有传入创建时间，创建用户ID，那么创建时间和修改时间直接用LocalDateTime来获取设置，创建用户ID还是老规矩用ThreadLocal来获取设置

Mapper层

    @Override
    public void add(Chess chess) {
        chess.setCreateTime(LocalDateTime.now());
        chess.setUpdateTime(LocalDateTime.now());

        Map<String,Object> map = ThreadLocalUtil.get();
        Integer userID  = (Integer) map.get("id");
        chess.setCreateUser(userID);

        chessMapper.add(chess);
    }

 基本框架写好了，准备进行下一步的参数校验

新增棋子参数校验

在接口文档中对我们提出要求，发布状态之能是已发布或者是草稿状态，这一条件的校验用我们之前使用过的所有方法都是解决不了的，这时候就要用到自定义校验技术

自定义校验

        已有的注解不能满足所有的校验需求，特殊的情况需要自定义校验(自定义校验注解)

自定义注解步骤

1.自定义注解State

@Documented//元注解
@Constraint(validatedBy = {StateValidatiom.class})//指定提供校验规则的类
@Target({FIELD} )
@Retention(RUNTIME)
public @interface State {

    //提供校验失败后的提示信息
    String message() default "State参数值只能为\"已发布\"或者\"草稿\"";
    //指定分组
    Class<?>[] groups() default {};
    //负载 可以获取到State注解的附加信息
    Class<? extends Payload>[] payload() default {};
}

三个参数必备

还要在@Constraint注解中指定提供校验规则的类

2.自定义校验数据的类StateValidatiom实现ConstrainValidator接口

public class StateValidatiom implements ConstraintValidator<State,String> {
    @Override
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
        //提供校验规则
        //s:要校验的数据
        if(s == null){
            return false;
        }
        if (s.equals("已发布") || s.equals("草稿")){
            return true;
        }
        return false;
    }
}

3.在需要校验的地方使用自定义注解

    @State
    private String state;//发布状态 已发布|草稿

棋子分类列表查询(条件分页)

接口文档

读接口文档，目的明确，开工！

Controller层

    @GetMapping
    public Result<PageBean<Chess>> list(Integer pageNum,Integer pageSize,@RequestParam(required = false) Integer categoryId,@RequestParam(required = false) String state){
        PageBean<Chess> pageBean = chessService.list(pageNum,pageSize,categoryId,state);
        return Result.success(pageBean);
    }

这里用了一个实体类PageBean来封装每一页对应的棋子对象

PageBean实体类如下：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageBean <T>{
    private Long total;//总条数
    private List<T> items;//当前页数据集合
}

Service层 

    @Override
    public PageBean<Chess> list(Integer pageNum, Integer pageSize, Integer categoryId, String state) {

        Map<String,Object> map = ThreadLocalUtil.get();
        Integer userID  = (Integer) map.get("id");
        //创建pageBean对象用于封装查询到的对象
        PageBean<Chess> pageBean = new PageBean<>();



        //借助mybatis的插件pagehelper开启分页查询
        PageHelper.startPage(pageNum,pageSize);

        //调用mapper查询
        List<Chess> cs = chessMapper.list(userID,categoryId,state);
            //Page中提供了方法，可以获取PageHelper分页查询后，得到的总记录条数和当前页main数据
        Page<Chess> chessPage = (Page<Chess>) cs;
        //把数据填充到PageBean对象中
        pageBean.setTotal(chessPage.getTotal());
        pageBean.setItems(chessPage.getResult());
        return pageBean;
    }

这里用了一个mybatis的分页查询插件pagehelper

坐标如下

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

注意

代码是这么写的，如果换某几行看起来不会报错的代码，他照样会在查时报错，你要问为什么？

代码是这么写的 

Mapper层

    List<Chess> list(Integer userId, Integer categoryId, String state);

因为 categoryID和state是不一定会有的，所以选用配置文件写动态sql，

注意：xml配置文件的相对路径要与对应方法所在的Mapper层中的类的相对路径完全一致

 Mapper层类路径

xml配置文件路径

动态sql

<?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.cacb.mapper.ChessMapper">
<!--    动态sql-->
    <select id="list" resultType="com.cacb.pojo.Chess">
            select * from chess
            <where>
                <if test="categoryId != null">
                    category_id = #{categoryId}
                </if>

                <if test="state!=null">
                    and state=#{state}
                </if>
                and create_user=#{userId}
            </where>
    </select>
    
</mapper>

获取棋子详情

接口文档

阅读接口文档，没什么特殊要求，开工！

Controller层

    @GetMapping("detail")
    public Result<Chess> getChessByID(Integer id){
        Chess chess = chessService.getChessByID(id);
        if (chess == null){
            return Result.error("查询的棋子不存在！");
        }else {
            return Result.success(chess);
        }
    }

Service层

    @Override
    public Chess getChessByID(Integer chessID) {
        return chessMapper.getChessByID(chessID);
    }

Mapper层

    @Select("select * from chess where id=#{chessID}")
    Chess getChessByID(Integer chessID);

更新棋子

接口文档

没啥难度，注意下修改之前给个身份判定就行了，开工！

Controller层

    @PutMapping()
    public Result update(@RequestBody @Validated Chess chess){
        Chess chess_get = chessService.getChessByID(chess.getId());
        if (chess_get == null){return Result.error("您所要修改的棋子不存在");}
        Map<String,Object> map = ThreadLocalUtil.get();
        Integer userID  = (Integer) map.get("id");
        if (!chess_get.getCreateUser().equals(userID)){return Result.error("你所要修改的棋子不属于您！");}
        chessService.update(chess);
        return Result.success();

    }

做了一个身份判定和棋子信息存在判定

Service层

    @Override
    public void update(Chess chess) {
        chess.setUpdateTime(LocalDateTime.now());
        chessMapper.update(chess);
    }

Service层注入更新时间 

Mapper层 

    @Update("update chess set chess_name = #{ChessName} , content = #{content} , cover_img = #{coverImg} , " +
            " state = #{state},category_id = #{categoryId},update_time = #{updateTime} ," +
            "cost = #{cost} , chess_class = #{chessClass},chess_origin = #{chessOrigin} where id = #{id}")
    void update(Chess chess);

删除棋子

接口文档

也没啥难度，战斗，爽！

Controller层

    @DeleteMapping
    public Result delete(Integer id){
        Chess chess = chessService.getChessByID(id);
        if (chess == null){
            return Result.error("您所要删除的棋子不存在");
        }
        Map<String,Object> map = ThreadLocalUtil.get();
        Integer userID  = (Integer) map.get("id");
        if (!chess.getCreateUser().equals(userID)){return Result.error("你所要修改的棋子不属于您！");}
        chessService.delete(id);
        return Result.success();

    }

Service层

    @Override
    public void delete(Integer id) {
        chessMapper.delete(id);
    }

Mapper层

    @Delete("delete from chess where id = #{id}")
    void delete(Integer id);