统一返回知识点

统一返回知识点

1.统一返回结果

1.使用泛型在工具类中创建统一返回类

/**
 * Created on 2021/6/1.
 * Author: lzy
 * Description: 请求结果统一返回
 */
@Data
public class RequestResult<T> {

    /**
     * 返回状态码
     * */
    private  String code;
    /**
     * 返回说明
     * */
    private  String msg;

    /**
     * 返回数据
     * */
    private T data;

}

2.使用系统常量来定义返回的状态码（constant）

/**
     *  返回成功状态码
     *
     * */
    public  static  final  String SYS_RESP_SUCCESS_CODE = "0000";

    /**
     *  返回成功状态说明
     *
     * */
    public  static  final  String SYS_RESP_SUCCESS_MSG = "SUCCESS";

    /**
     *  返回失败状态码
     *
     * */

    public  static  final  String SYS_RESP_FAILURE_CODE = "0001";
    /**
     *  返回失败说明
     *
     * */
    public  static  final  String SYS_RESP_FAILURE_MSG = "FAILURE";
	 /**
     * 系统默认分页的页面容量
     * */
    public static  final  int SYS_INIT_PAGE_SIZE = 3;

    /**
     * 系统默认的当前页面
     * */
    public static  final  int SYS_INIT_PAGE_NO = 1;

3.创建统一返回的工具类

/**
 * Created on 2021/6/1.
 * Author: lzy
 * Description: 封装统一返回的工具类()
 */

public class ResultBuildUtil {
    /**
    *@ClassName: ResultBuildUtil
    *@Description  返回成功不带数据
    *@Author lzy
    *@Date 2021/6/1
    */
    public  static <T> RequestResult<T> success(){
        return  success(null);
    }
    /**
    *@ClassName: ResultBuildUtil
    *@Description 返回成功带数据
    *@Author lzy
    *@Date 2021/6/1
    */
    public  static <T> RequestResult<T> success(T t){
        RequestResult<T> requestResult = new RequestResult<>();
        requestResult.setCode(SystemConstant.SYS_RESP_SUCCESS_CODE);
        requestResult.setMsg(SystemConstant.SYS_RESP_SUCCESS_MSG);
        requestResult.setData(t);
        return  requestResult;
    }
    /**
    *@ClassName: ResultBuildUtil
    *@Description 返回失败不带数据
    *@Author lzy
    *@Date 2021/6/1
    */
    public  static <T> RequestResult<T> failure(){
        RequestResult<T> requestResult = new RequestResult<>();
        requestResult.setCode(SystemConstant.SYS_RESP_FAILURE_CODE);
        requestResult.setMsg(SystemConstant.SYS_RESP_FAILURE_MSG);
        requestResult.setData(null);
        return  requestResult;
    }
    /**
    *@ClassName: ResultBuildUtil
    *@Description 返回失败不带数据，自定义状态和说明
    *@Author lzy
    *@Date 2021/6/1
    */
    public  static <T> RequestResult<T> failure(String errorCode,String errorMsg){
        RequestResult<T> requestResult = new RequestResult<>();
        requestResult.setCode(errorCode);
        requestResult.setMsg(errorMsg);
        requestResult.setData(null);
        return  requestResult;
    }
}

4.使用

 @GetMapping("/edcoByAuthor")
    public RequestResult<List<EdocEntry>> querySelectEdocByAuthor(@RequestParam String author){
        log.info("---- 跟据作者查询文档列表 ----");
        // 使用统一返回工具类
            return ResultBuildUtil.success(edocdbInfoService.queryEdocsByAuthor(author));
    }

2.统一返回分页结果

1.创建统一分页工具类

/**
 * Created on 2021/6/1.
 * Author: lzy
 * Description: 统一分页工具类
 */
@Data
public class PageSupport<T> {

    /**
     * 当前页码
     * */
    private int currPageNo;

    /**
     * 分页起始行
     * */
    private int pageIndex;

    /**
     * 页面显示容量
     * */
    private int pageSize;

    /**
     * 总条数
     * */
    private int totalCount;

    /**
     * 总页数
     * */
    private int totalPage;

    /**
     * 分页数据
     * */
    private Collection<T> data;
    /**
     * 当设置当前页码的时候，可以确定起始行数
     * */

    public void setCurrPageNo(int currPageNo) {
       if(currPageNo >0){
           this.currPageNo = currPageNo;
           this.pageIndex = (currPageNo -1)*pageSize;
       }
    }
    /**
     * 知道总条数，确定总页数
     * */
    public void setTotalCount(int totalCount) {
       if(totalCount > 0){
           this.totalCount = totalCount;
           this.totalPage = this.totalCount % this.pageSize == 0 ? this.totalCount / this.pageSize : this.totalCount / this.pageSize+1;
       }
    }
}

2.service实现业务接口使用分页查询（两个参数，当前页码和页面容量）

 @Override
    public PageSupport<EdocEntry> queryEdocsUsePage(Integer pageNo, Integer pageSize) {
        // 封装分页而数据
        PageSupport<EdocEntry> pageSupport = new PageSupport<>();

        // 设置页面容量，和页码，需要先设置
        if(null == pageSize || pageSize <= 0){
            // 使用系统默认页面容量（在常量类中）
            pageSupport.setPageSize(SystemConstant.SYS_INIT_PAGE_SIZE);
        }else {
            pageSupport.setPageSize(pageSize);
        }

        // 设置页码
        if(null == pageNo || pageNo <= 0){
            // 使用系统默认页面容量
            pageSupport.setCurrPageNo(SystemConstant.SYS_INIT_PAGE_NO);
        }else {
            pageSupport.setCurrPageNo(pageNo);
        }

        // 创建查询条件
        EdocEntryExample edocEntryExample = new EdocEntryExample();

        // 设置总条数
        pageSupport.setTotalCount((int)edocEntryDao.countByExample(edocEntryExample));

        // 根据分页数据获取对应的文档列表
        edocEntryExample.setOrderByClause("id desc");
        // 设置起始行
        edocEntryExample.setOffset(Long.valueOf( pageSupport.getPageIndex()));
        // 设置查询数量
        edocEntryExample.setLimit(pageSupport.getPageSize());

        // 将分页查询数据 ，存入分页对象
        pageSupport.setData(edocEntryDao.selectByExample(edocEntryExample));

        // 返回
        return pageSupport;
    }

3.调用接口使用

3.异常统一返回

1.创建系统自定义异常枚举EdocExceptionEnum

/**
 * Created on 2021/6/1.
 * Author: lzy
 * Description: 系统自定义异常枚举
 */
public enum  EdocExceptionEnum {

    /**
     * 系统异常
     * */
    SYSTEM_EXCPT("9000","系统异常"),
    /**
     * 传入参数为空
     */
    REQUEST_PARAM_EMPTY("1001","传入参数为空"),
    /**
     * 传入参数非法
     */
    REQUEST_PARAM_TLLEGAL("1002","传入参数非法"),
    /**
     * 数据库异常
     */
    DATABASE_OPRRATOR_EXCPT("3001","数据库操作异常"),
    /**
     * 网络异常
     */
    NETWORK_CONNECT_EXCPT("5001","网络连接异常");

    /**
     * 异常码
     * */
    private String excptCode;

    /**
     * 异常说明
     * */
    private String excptMsg;

    /**
     * 带参构造方法
     * */
    EdocExceptionEnum(String excptCode,String excptMsg){
        this.excptCode = excptCode;
        this.excptMsg = excptMsg;

    }

    public String getExcptCode() {
        return excptCode;
    }

    public String getExcptMsg() {
        return excptMsg;
    }
}

2.自定义异常 (业务功能+ Exception)

// 继承RuntimeException
// ALT+Insert Constructor 
// 生成系列号
public class EdocException extends RuntimeException {

    // 生成序列号 需要勾选seria Java | Serialization issues | Serializable class without 'serialVersionUID' 勾选上
    private static final long serialVersionUID = -7678037759463770915L;

    /**
     * 异常枚举属性
     * */
    private  EdocExceptionEnum edocExceptionEnum;

    public EdocException() {
    }

    public EdocException(String message) {
        super(message);
    }

    public EdocException(String message, Throwable cause) {
        super(message, cause);
    }

    public EdocException(Throwable cause) {
        super(cause);
    }

    public EdocException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

   //  构造方法 
    public  EdocException(EdocExceptionEnum edocExcepttionEnum){
        this.edocExceptionEnum = edocExcepttionEnum;

    }

    // 生成getter方法
    public EdocExceptionEnum getEdocExcepttionEnum() {
        return edocExceptionEnum;
    }
}

3.自定义异常统一处理类

/**
 * Created on 2021/6/1.
 * Author: lzy
 * Description: 自定义异常统一处理类
 */
@ControllerAdvice  //必须加这个注解
@Slf4j
public class EdocExceptionHandler {
    
    @ResponseBody  // 返回的异常数据类型，使用统一返回封装
    @ExceptionHandler(EdocException.class)
    public RequestResult<String> handEdocException(EdocException ee){
        log.error("----- 获取系统抛出的自定义异常，异常码：{}，异常信息：{}",ee.getEdocExcepttionEnum().getExcptCode(),ee.getEdocExcepttionEnum().getExcptMsg());
        return ResultBuildUtil.failure(ee.getEdocExcepttionEnum().getExcptCode(),ee.getEdocExcepttionEnum().getExcptMsg());
    }
}

4.使用自定义异常

 @GetMapping("/edocsUsePage")
    public RequestResult<PageSupport<EdocEntry>> querySelectEdocByAuthor(@RequestParam Integer pageNo, @RequestParam Integer pageSize){

        try {
            log.info("---- 查询文档列表使用分页，当前页码{}，页面容量 ----",pageNo,pageSize);
            // 调用业务接口，查询列表利用统一返回
            return ResultBuildUtil.success(edocdbInfoService.queryEdocsUsePage(pageNo,pageSize));
        }catch (Exception e){

            log.error("查询电子文档列表，产生异常，异常为：{}",e.getMessage());
            throw  new EdocException(EdocExceptionEnum.DATABASE_OPRRATOR_EXCPT);
        }

    }

4.数据校验

1.在controller使用@valid标注实体

/**
    *@ClassName: EdocdbInfoController
    *@Description 数据校验
    *@Author lzy
    *@Date 2021/6/1
    */
    @GetMapping("/testvaild")
	// @Valid 进行标注 ，使用BindingResult进行判断，是否抛出错误，通常前端传来的参数使用From接收
    public RequestResult<String> testVaild(@Valid EdocEntryFrom edocEntryFrom , BindingResult bindingResult){
        // 校验参数
        if(bindingResult.hasErrors()){
            return ResultBuildUtil.failure("7001",bindingResult.getFieldError().getDefaultMessage());
        }
        return ResultBuildUtil.success();

    }

2.在接受前端参数的实体上进行验证

@Data
public class EdocEntryFrom {

    /**
     * id
     */
    private Long id;

    /**
     * 类别id
     */
    @Range(min = 1,message = "cid非法")
    private Long cId;

    /**
     * 标题
     */
    @NotNull(message = "标题不能为空")
    private String title;

    /**
     * 摘要
     */
    @NotNull(message = "摘要不能为空")
    private String summary;

    /**
     * 发表者
     */
    private String uploadUser;

    /**
     * 创建时间
     */
    private Date createDate;

    private static final long serialVersionUID = 1L;



}

5.vo、po、dto、bo、pojo、entity、mode如何区分

  // 通过这个拷贝参数
  // BeanUtils.copyProperties(实体);


view <-- vo --> action

action <-- DTO --> service

serviece <-- DO --> Mapper

Mapper  <-- PO --> JDBC


VO
value object：值对象
通常用于业务层之间的数据传递，由new创建，由GC回收

PO
persistant object：持久层对象
是ORM(Objevt Relational Mapping)框架中Entity，PO属性和数据库中表的字段形成一一对应关系
VO和PO，都是属性加上属性的get和set方法；

DTO
data transfer object：数据传输对象
是一种设计模式之间传输数据的软件应用系统，数据传输目标往往是数据访问对象从数据库中检索数据


// 主要是以上三种，下面了解
BO
business object：业务对象
BO把业务逻辑封转为一个对象，通过调用DAO方法，结合PO或VO进行业务操作
PO组合，如投保人是一个PO，被保险人是一个PO，险种信息是一个PO等等，他们组合气来是第一张保单的BO

POJO
plian ordinary java object：简单无规则java对象
纯的传统意义的java对象，最基本的Java Bean只有属性加上属性的get和set方法
可以额转化为PO、DTO、VO；比如POJO在传输过程中就是DTO

DAO
data access object：数据访问对象
是sun的一个标准j2ee设计模式，这个模式中有个接口就是DAO，负责持久层的操作
主要用来封装对数据的访问，注意，是对数据的访问，不是对数据库的访问

Entity
实体，和PO的功能类似，和数据表一一对应，一个实体一张表