项目开发经验规范总结-时刻更新

缺乏、安全感 2023-06-13 04:40 68阅读 0赞

## 1、常用规范类 ##

### 1.1、异常相关 ###

#### 1.1.1、业务异常类 ####

package com.healerjean.proj.exception;
    
    
    import com.healerjean.proj.enums.ResponseEnum;
    
    /** * 系统业务异常 */
    public class BusinessException extends RuntimeException { 
    
        private int code;
    
        public BusinessException(int code) { 
            this.code = code;
        }
    
        public BusinessException(String message) { 
            super(message);
            this.code = ResponseEnum.逻辑错误.code;
        }
    
        public BusinessException(int code, String message) { 
            super(message);
            this.code = code;
        }
    
        public BusinessException(ResponseEnum responseEnum) { 
            super(responseEnum.msg);
            this.code = responseEnum.code ;
        }
    
        public BusinessException(ResponseEnum responseEnum,String message) { 
            super(message);
            this.code = responseEnum.code ;
        }
    
        public BusinessException(String message, Throwable cause) { 
            super(message, cause);
            this.code = ResponseEnum.逻辑错误.code;
        }
    
        public BusinessException(int code ,Throwable e) { 
            super(e);
            this.code = code;
        }
    
        public BusinessException(ResponseEnum responseEnum, Throwable t) { 
            super(responseEnum.msg, t);
            this.code = responseEnum.code;
        }
    
    
        public void setCode(int code) { 
            this.code = code;
        }
    
        public int getCode() { 
            return code;
        }
    
    }

#### 1.1.2、参数异常类 ####

package com.healerjean.proj.exception;
    
    import com.healerjean.proj.enums.ResponseEnum;
    
    /** * @author HealerJean * @ClassName ParameterErrorException * @date 2019/10/17 16:19. * @Description 参数错误 */
    public class ParameterErrorException extends com.healerjean.proj.exception.BusinessException { 
    
        public ParameterErrorException() { 
            super(ResponseEnum.参数错误);
        }
    
        public ParameterErrorException(ResponseEnum responseEnum) { 
            super(ResponseEnum.参数错误, responseEnum.msg);
        }
    
        public ParameterErrorException(String msg) { 
            super(ResponseEnum.参数错误, msg);
        }
    
    
    }

#### 1.1.3、接口异常类 ####

package com.healerjean.proj.exception;
    
    import com.healerjean.proj.enums.ResponseEnum;
    
    /** * @author HealerJean * @ClassName HaoDanKuApiException * @date 2019/10/15 20:08. * @Description */
    public class HaoDanKuApiException extends BusinessException { 
    
    
        public HaoDanKuApiException( ) { 
            super(ResponseEnum.好单库口请求异常);
        }
    
        public HaoDanKuApiException(String msg) { 
            super(ResponseEnum.好单库接口数据异常, msg);
        }
    
        public HaoDanKuApiException(Throwable e) { 
            super(ResponseEnum.好单库口请求异常, e);
        }
    
    }

#### 1.1.4、异常全局处理 ####

package com.healerjean.proj.config;
    
    import com.healerjean.proj.dto.ResponseBean;
    import com.healerjean.proj.enums.ResponseEnum;
    import com.healerjean.proj.exception.BusinessException;
    import com.healerjean.proj.exception.ParameterErrorException;
    import com.healerjean.proj.utils.JsonUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.http.HttpEntity;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.http.converter.HttpMessageConversionException;
    import org.springframework.validation.BindException;
    import org.springframework.web.HttpRequestMethodNotSupportedException;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
    
    import javax.servlet.http.HttpServletResponse;
    import javax.validation.UnexpectedTypeException;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * @author HealerJean * @version 1.0v * @ClassName ControllerHandleExceptionConfig * @date 2019/5/31 20:19. * @Description */
    @Slf4j
    @ControllerAdvice
    public class ControllerHandleConfig { 
    
        /** * 不支持的请求方始 */
        @ExceptionHandler(value = HttpRequestMethodNotSupportedException.class)
        @ResponseStatus(value = HttpStatus.METHOD_NOT_ALLOWED)
        public ResponseBean methodNotSupportExceptionHandler(HttpRequestMethodNotSupportedException e) { 
            log.error("不支持的请求方式", e);
            return ResponseBean.buildFailure(ResponseEnum.不支持的请求方式.code, e.getMessage());
        }
    
    
        /** * 参数类型错误 * 1、(BindException : 比如 Integer 传入String ) * Field error in object 'demoDTO' on field 'age': rejected value [fasdf]; codes [typeMismatch.demoDTO.age,typeMismatch.age,typeMismatch.java.lang.Integer,typeMismatch]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [demoDTO.age,age]; arguments []; default message [age]]; default message [Failed to convert property value of type 'java.lang.String' to required type 'java.lang.Integer' for property 'age'; nested exception is java.lang.NumberFormatException: For input string: "fasdf"] */
        @ExceptionHandler(value = { BindException.class})
        @ResponseStatus(HttpStatus.BAD_REQUEST)
        @ResponseBody
        public ResponseBean bindExceptionHandler(BindException e) { 
            log.error("====参数类型错误===", e);
            return ResponseBean.buildFailure(ResponseEnum.参数类型错误.code, e.getMessage());
        }
    
    
        /** * 参数格式问题 */
        @ExceptionHandler(value = { MethodArgumentTypeMismatchException.class, HttpMessageConversionException.class, UnexpectedTypeException.class})
        @ResponseStatus(HttpStatus.BAD_REQUEST)
        @ResponseBody
        public ResponseBean httpMessageConversionExceptionHandler(Exception e) { 
            log.error("====参数格式异常===", e);
            return ResponseBean.buildFailure(ResponseEnum.参数格式异常.code, e.getMessage());
        }
    
    
    
        /** * 参数错误 */
        @ExceptionHandler(value = ParameterErrorException.class)
        @ResponseStatus(HttpStatus.BAD_REQUEST)
        @ResponseBody
        public ResponseBean parameterErrorExceptionHandler(ParameterErrorException e) { 
            log.error("参数异常------------参数错误：code：{},message：{}", e.getCode(), e.getMessage());
            return ResponseBean.buildFailure(e.getCode(), e.getMessage());
        }
    
    
        /** * 业务异常，给前台返回异常数据 */
        @ExceptionHandler(value = BusinessException.class)
        @ResponseStatus(HttpStatus.BAD_REQUEST)
        @ResponseBody
        public ResponseBean businessExceptionHandler(BusinessException e) { 
            log.error("业务异常------------异常信息：code:{},message{}" ,e.getCode(), e.getMessage());
            return ResponseBean.buildFailure(e.getCode(),e.getMessage());
        }
    
    
    
    
        /** * 所有异常报错 */
        @ExceptionHandler
        @ResponseBody
        public HttpEntity<ResponseBean> allExceptionHandler(HttpServletResponse response, Exception e) { 
            log.error("====系统错误===", e);
            response.setStatus(ResponseEnum.系统错误.code);
            return returnMessage(ResponseBean.buildFailure(ResponseEnum.系统错误));
        }
    
        private HttpEntity<ResponseBean> returnMessage(ResponseBean responseBean) { 
            HttpHeaders header = new HttpHeaders();
            header.add("Content-Type", "application/json");
            header.add("Charset", "UTF-8");
            return new HttpEntity<>(responseBean, header);
        }
    
    
    
        /** * 参数非法 * 1、(BindException : 比如 Integer 传入abc ) */
        // @ExceptionHandler(value = {MethodArgumentTypeMismatchException.class, HttpRequestMethodNotSupportedException.class, HttpMessageConversionException.class, BindException.class, UnexpectedTypeException.class})
        // @ResponseBody
        // public HttpEntity<ResponseBean> httpMessageConversionExceptionHandler(HttpServletResponse response, Exception e) { 
        // log.error("====参数格式异常===", e);
        // // 等同于 @ResponseStatus(HttpStatus.BAD_REQUEST)
        // // 但是setStatus 不能比随便设置,最好一般情况下不要和HttpStatus 有重复的，这样有可能会造成没有输出Response body
        // response.setStatus(ResponseEnum.参数格式异常.code);
        // return returnMessage(ResponseBean.buildFailure(ResponseEnum.参数格式异常));
        // }
        // @ExceptionHandler(value ={HttpMessageConversionException.class, BindException.class} )
        // @ResponseBody
        // public HttpEntity<ResponseBean> httpMessageConversionExceptionHandler(Exception e) { 
        // log.error("====参数格式异常===", e);
        // return new ResponseEntity<>(ResponseBean.buildFailure(ResponseEnum.参数格式异常),HttpStatus.BAD_REQUEST);
        // }
    
    }

### 1.2、枚举 ###

#### 1.2.1、响应枚举 ####

package com.healerjean.proj.enums;
    
    import java.util.Arrays;
    import java.util.List;
    
    /** * @author HealerJean * @version 1.0v * @ClassName ResponseEnum * @date 2019/6/13 20:45. * @msgcription */
    public enum ResponseEnum { 
    
    
        正常(200, "访问正常"),
    
        参数错误(301, "参数错误"),
        参数格式异常(302, "参数格式异常"),
        不支持的请求方式(303, "不支持的请求方式"),
        参数类型错误(304, "参数类型错误"),
        逻辑错误(305, "逻辑错误"),
        未登陆(306, "未登陆"),
        登陆成功(307, "登陆成功"),
        重复操作(308, "重复操作"),
        非法操作(309, "非法操作"),
    
        请求无法被服务器理解(400, "请求无法被服务器理解"),
        未授权(401, "未授权"),
        访问禁止(403, "访问禁止"),
        页面丢失(404, "页面丢失"),
        系统错误(500, "系统错误"),
        未知错误(999, "未知错误"),
    
    
        用户已经存在(1000, "用户已经存在"),
        用户不存在(1001, "用户不存在"),
    
        微信接口请求异常(2001,"微信接口请求异常"),
        淘宝接口请求异常(2002,"淘宝接口请求异常"),
        淘宝接口数据异常(2003,"淘宝接口数据异常"),
        好单库口请求异常(2004,"好单库口请求异常"),
        好单库接口数据异常(2005,"好单库接口数据异常"),
    
        ;
    
    
        public int code;
        public String msg;
    
    
        ResponseEnum(int code, String msg) { 
            this.code = code;
            this.msg = msg;
        }
    
    
        public static boolean checkExist( Integer code){ 
            for (ResponseEnum value : ResponseEnum.values()){ 
                if (value.code == code){ 
                    return true;
                }
            }
            return false;
        }
    
    
        public static ResponseEnum toEnum(int code){ 
            for (ResponseEnum value : ResponseEnum.values()){ 
                if (value.code == code){ 
                    return value;
                }
            }
            return ResponseEnum.未知错误;
        }
    
        public static String getMsg(int code){ 
            for (ResponseEnum value : ResponseEnum.values()){ 
                if (value.code == code){ 
                    return value.msg;
                }
            }
            return ResponseEnum.未知错误.msg;
        }
    
    
        public ResponseEnum value(String enumName){ 
            return valueOf( enumName ) ;
        }
    
        public static List<ResponseEnum> getList(){ 
            return Arrays.asList(values());
        }
    
    
    }

#### 1.2.2、业务枚举 ####

package com.healerjean.proj.enums;
    
    /** * @author HealerJean * @ClassName BusinessEnum * @date 2019/9/30 14:39. * @Description */
    public interface BusinessEnum { 
    
    
        /** * 验证码枚举 */
        enum VerifyCodeTypeEnum { 
    
            图片验证码("captcha", "图片验证码"),
            注册邮箱验证码("RegistEmail", "注册邮箱验证码"),
            找回密码邮箱验证码("RetrievePasswordEmail", "找回密码邮箱验证码"),
            ;
    
            VerifyCodeTypeEnum(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
    
            public String code;
            public String desc;
    
            public static VerifyCodeTypeEnum toEnum(String code) { 
                for (VerifyCodeTypeEnum item : VerifyCodeTypeEnum.values()) { 
                    if (item.code.equals(code)) { 
                        return item;
                    }
                }
                return null;
            }
        }
    
    
        /** * 模板类型 */
        enum TemplateTypeEnum { 
    
            邮件("Email", "邮件"),
            ;
            public String code;
            public String desc;
    
            TemplateTypeEnum(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
    
        }
    
    
    
        /** * 模板名字 */
        enum TempleNameEnum  { 
            邮箱验证("VerifyEmail", "邮箱验证"),
            找回密码邮箱验证("PasswordVerifyEmail", "找回密码邮箱验证"),
            手机号验证("VerifyPhone", "手机号验证"),
            ;
            TempleNameEnum(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
    
            public String code;
            public String desc;
    
    
            public static TempleNameEnum toEnum(String code) { 
                for (TempleNameEnum item : TempleNameEnum.values()) { 
                    if (item.code.equals(code)) { 
                        return item;
                    }
                }
                return null;
            }
        }
    
    
        /** * 菜单类型 */
        enum MenuTypeEnum { 
    
            后端菜单("0", "后端菜单"),
            前端菜单("1", "前端菜单");
    
            MenuTypeEnum(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
    
            public String code;
            public String desc;
    
    
            public static MenuTypeEnum toEnum(String code) { 
                for (MenuTypeEnum value : MenuTypeEnum.values()) { 
                    if (value.code .equals( code)) { 
                        return value;
                    }
                }
                return null;
            }
        }
    
    
    
        /** * 用户类型 */
        enum UserTypeEnum { 
    
            管理人员("manager", "管理人员"),
            网站用户("webuser", "网站用户");
    
            UserTypeEnum(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
    
            public String code;
            public String desc;
    
    
            public static MenuTypeEnum toEnum(String code) { 
                for (MenuTypeEnum value : MenuTypeEnum.values()) { 
                    if (value.code .equals( code)) { 
                        return value;
                    }
                }
                return null;
            }
        }
    
    
    }

#### 1.2.3、状态枚举 ####

package com.healerjean.proj.enums;
    
    /** * @Description * @Author HealerJean * @Date 2019-06-16 01:58. */
    public enum  StatusEnum { 
    
        生效("10", "生效"),
        废弃("99", "废弃");
    
        StatusEnum(String code, String desc) { 
            this.code = code;
            this.desc = desc;
        }
    
        public String code;
        public String desc;
    
    
    }

#### 1.2.4、下拉菜单枚举 ####

package com.duodian.admore.data;
    
    import java.io.Serializable;
    
    /** * 下拉列表用 */
    public class LabelValueBean implements Serializable{ 
        private static final long serialVersionUID = -1211726511402154326L;
    
        private String label;
        private String value;
    
        private Boolean checked = false;
    
        public LabelValueBean() { 
        }
    
        public LabelValueBean(String label, String value) { 
            this.label = label;
            this.value = value;
        }
    
        public String getValue() { 
            return value;
        }
    
        public void setValue(String value) { 
            this.value = value;
        }
    
        public String getLabel() { 
            return label;
        }
    
        public void setLabel(String label) { 
            this.label = label;
        }
    
        public Boolean getChecked() { 
            return checked;
        }
    
        public void setChecked(Boolean checked) { 
            this.checked = checked;
        }
    }

### 1.3、响应Bean ###

package com.healerjean.proj.dto;
    
    
    import com.healerjean.proj.enums.ResponseEnum;
    import com.healerjean.proj.utils.JsonUtils;
    
    /** * 返回对象 */
    public class ResponseBean { 
    
        private ResponseBean() { 
        }
    
        public static ResponseBean buildSuccess() { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(true);
            responseBean.setCode(ResponseEnum.正常.code);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static ResponseBean buildSuccess(String msg) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(true);
            responseBean.setCode(ResponseEnum.正常.code);
            responseBean.setResult(msg);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static ResponseBean buildSuccess(Object result) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(true);
            responseBean.setCode(ResponseEnum.正常.code);
            responseBean.setResult(result);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static ResponseBean buildSuccess(String msg, Object result) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(true);
            responseBean.setCode(ResponseEnum.正常.code);
            responseBean.setMsg(msg);
            responseBean.setResult(result);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static String buildSensitivitySuccess(String msg, Object result) { 
            return JsonUtils.toJsonStringWithSensitivity(buildSuccess(msg, result));
        }
    
        public static String buildSensitivitySuccess(Object result) { 
            return JsonUtils.toJsonStringWithSensitivity(buildSuccess(result));
        }
    
    
        public static ResponseBean buildFailure() { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(false);
            responseBean.setCode(ResponseEnum.系统错误.code);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static ResponseBean buildFailure(String msg) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(false);
            responseBean.setCode(ResponseEnum.系统错误.code);
            responseBean.setMsg(msg);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
        public static ResponseBean buildFailure(ResponseEnum responseEnum) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(false);
            responseBean.setCode(responseEnum.code);
            responseBean.setMsg(responseEnum.msg);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
    
        public static ResponseBean buildFailure(int code, String msg) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(false);
            responseBean.setCode(code);
            responseBean.setMsg(msg);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
    
        public static ResponseBean buildFailure(ResponseEnum responseEnum, String msg) { 
            ResponseBean responseBean = new ResponseBean();
            responseBean.setSuccess(false);
            responseBean.setCode(responseEnum.code);
            responseBean.setMsg(msg);
            responseBean.setDate(System.currentTimeMillis() + "");
            return responseBean;
        }
    
    
        private boolean success;
        private Object result = "{}";
        private String msg = "";
        private int code;
        private String date;
    
        public boolean isSuccess() { 
            return success;
        }
    
        public void setSuccess(boolean success) { 
            this.success = success;
        }
    
        public Object getResult() { 
            return result;
        }
    
        public void setResult(Object result) { 
            this.result = result;
        }
    
        public String getMsg() { 
            return msg;
        }
    
        public void setMsg(String msg) { 
            this.msg = msg;
        }
    
        public int getCode() { 
            return code;
        }
    
        public void setCode(int code) { 
            this.code = code;
        }
    
        public String getDate() { 
            return date;
        }
    
        public void setDate(String date) { 
            this.date = date;
        }
    }

## 2、代码规范 ##

### 2.1、方法、实体名字： ###

小米
    
    manager dao 层
    
    queryBeanSingle
    queryBeanPage
    queryBeanList
    queryBeanPageLike
    queryBeanListLike

#### 2.1.1、查询 ####

*  单个记录查询

根据某几个简单属性查询
    查询数据库  findBeanNameBy
    不查询数据库 getBeanNameBy
    
    
    查询数据库  findBeanName
    不查询数据库 getBeanName

*  多个记录查询

根据某几个简单属性查询
    查询数据库  qureyBeanNameBy
    不查询数据库 dataBeanNameBy
    
    
    查询数据库分页  qureyBeanNamePage
    查询数据库集合  qureyBeanNameList
    不查询数据库分页 dataBeanNamePage
    不查询数据库集合  dataBeanNameList

#### 2.1.2、删除 ####

更新status字段
    deleteBean 
    
    直接删除库里的数据
    deleteDBeanName

#### 2.1.4、接口请求 rquest/response ####

请求data
    请求参数的data为		ReqRecordData
    
    返回单个实体
    返回结果的data为		RspRecordModel
    
    返回集合
    返回结果的data为		RspRecordList

![WX20190213-180740][]

### 2.2、注释、日志规范 ###

#### 2.2.1、controller日志 ####

*  **-------8个-**
 *  **头部是controller说明，日志内容写上头部以及功能日志说明**

/** * @author HealerJean * @ClassName UserController * @date 2019/10/18 14:10. * @Description 用户管理 */
    public class UserController extends BaseController { 
       
    public ResponseBean register(@RequestBody UserDTO userDTO) { 
       log.info("用户管理---------用户注册---------请求参数：{}", userDTO);
         
       log.info("用户管理---------用户注册---------请求参数：{},响应结果：{}",userDTO, userDTO);
    
         }
         
         
    /** * @author HealerJean * @ClassName UserController * @date 2019/10/18 14:10. * @Description 系统管理-字典管理 */ 
    
    public ResponseBean getDictType(@PathVariable Long id) { 
      log.info("系统管理-字典管理--------字典类型查询--------字典类型Id：{}", id);
    
      log.info("系统管理-字典管理--------字典类型查询--------字典类型Id:{}，响应结果：{}", id，dict);
    }

#### 2.2.2、 方法注释和日志 ####

/** * 根据合同模板生成合同初始pdf文件，讲合同状态设置为待确认状态 * 1、数据校验 * 1.1、基本数据校验 * 1.2、校验合同模板是否存在 * 1.3、校验签署人是否完整 * 1.4、校验签署方是否真实有效 * 2、把合同签署各方的信息和模板取出，将变量更替，生成word和pdf * 4、保存签署人信息 * 5、合同初始化日志保存 * 6、删除临时文件 */
        void createContractByTeamplate(ContractDTO contractDTO) ；

### 2.3、异常问题 ###

#### 2.3.1 、工具类异常问题 ####

public class UrlEncodeUtil { 
    
        public String encode(String text){ 
            try { 
                return URLEncoder.encode(text,"gbk" );
            }catch (UnsupportedEncodingException e) { 
                throw new RuntimeException("{}加密失败", text,e);
            }catch (Exception e){ 
                throw new RuntimeException("{ }加密失败”,text, e);
            }
        }
    }

## 3、数据库规范 ##

### 3.1、demo ###

#### 3.1.1、建表语句 ####

*  **是否 nuLl 必须not null** ，这样不方便建立索引，为了防止为null，我们可以给赋予初始值，今后建议 default ‘’,给一个空串，空串不占内存空间，NULL是占内存空间的

create table test
    (
        `id`        bigint(20) unsigned not null auto_increment comment '主键',
        uk_name     bigint(20) unsigned not null comment 'uk',
        idx_name    bigint(20) unsigned not null comment 'idx',
        ref_item_id  bigint(20) unsigned not null comment 'item表主键',
        status      varchar(32)         not null comment '产品状态 字典表 productstatus',
        create_user bigint(20) unsigned null     default 0 comment '创建人',
        create_name varchar(64)         null     default '' comment '创建人名称',
        create_time datetime            not null default current_timestamp comment '创建时间',
        update_user bigint(20) unsigned null     default 0 comment '更新人',
        update_name varchar(64)         null     default '' comment '更新人名称',
        update_time datetime            not null default current_timestamp on update current_timestamp comment '更新时间',
        unique index uk_name (uk_name) using btree comment '唯一索引',
        index idx_name (idx_name) using btree comment '索引',
        primary key (`id`) using btree
    ) engine = innodb comment '测试表'

#### 3.1.2、建表说明 ####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>名称</th> 
   <th>长度</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>bigint</td> 
   <td>主键</td> 
   <td>bigint(20)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>地址</td> 
   <td>varchar(128)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>状态</td> 
   <td>varchar(8)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>附件，逗号相隔</td> 
   <td>varchar(128)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>备注、描述</td> 
   <td>varchar(128/256)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>手机号</td> 
   <td>varchar(20)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>名字</td> 
   <td>varchar(64)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>邮件</td> 
   <td>varchar(64)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>decimal</td> 
   <td>金额</td> 
   <td>decimal(20,0)</td> 
   <td>以分为单位</td> 
  </tr> 
  <tr> 
   <td>decimal</td> 
   <td>百分比</td> 
   <td>decimal(7,6)</td> 
   <td>80% 0.800000</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>数字</td> 
   <td>int(10)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>tinyint</td> 
   <td>布尔</td> 
   <td>tinyint(1)</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

### 3.2、基础规范 ###

#### 3.2.1、统一说明 ####

*  MySQL字符集统一使用utf8，默认排序规则：utf8\_general\_ci
 *  使用InnoDB存储引擎，默认事务隔离级别REPEATABLE-READ(可重复读)
 *  不要使用MySQL存储过程，视图，触发器，Event, InnoDB外键约束
 *  每个数据表都添加注释 comment, 每个字段也添加comment
 *  不要在数据库中存储大图片或大文件，尽量使用简单的数据类型，避免使用blob和text类型
 *  单表数据量控制在1000W行以内 ，采用合适的分库分表策略，例如十库百表

#### 3.2.2、字段设计 ####

*  表示状态字段（0-255）的使用TINYINT UNSINGED ; 0避免成为有效状态值，非负的数字类型字段，都添加上UNSINGED,
 *  时间字段使用时间日期类型，避免使用字符串类型存储，日期使用DATE类型，年使用YEAR类型，日期时间可使用DATETIME和TIMESTAMP
 *  字符串VARCHAR(N), 其中N表示字符个数，请尽量减少N的大小
 *  字段都设置为NOT NULL， 为字段提供默认值，如’’和’0’ ;
 *  主键尽量保持增长趋势，建议使用id的生成器，避免使用表的自增列

#### 3.2.3、sql使用规范 ####

*  避免使用join，子查询等SQL

1.对于mysql，不推荐使用子查询和join是因为本身join的效率就是硬伤，一旦数据量很大效率就很难保证，强烈推荐分别根据索引单表取数据，然后在程序里面做join，merge数据，导致性能下降
    
    2.子查询就更别用了，效率太差，执行子查询时，MYSQL需要创建临时表，查询完毕后再删除这些临时表，所以，子查询的速度会受到一定的影响，这里多了一个创建和销毁临时表的过程。
    
    3.如果是JOIN的话，它是走嵌套查询的。小表驱动大表，且通过索引字段进行关联。如果表记录比较少的话，还是OK的。大的话业务逻辑中可以控制处理

*  在线业务的update和delete的where中是唯一索引或者主键，避免一次修改多条语句的情况，而且这样锁住的是一行数据
 *  避免在MySQL数据库中进行计算操作，尽量由业务来处理运算，数据库，就应该让它做存储数据，查询数据的事情，
 *  避免使用select \* , 只返回自己需要的字段，枚举出要返回的字段名称
 *  SQL过滤的where条件尽量不使用OR, NOT IN , NOT EXIST
 *  使用where IN()过滤时，IN集合个数必须小于500，因为in的数据少的时候，mysql优化器会可能会使用索引，但是当数据太多以后就不一定了，可以让MySQL按照ID顺序进行查询，这可能比随机的关联要更高效

### 3.3、表名设计 ###

尽量使用 `项目名(scf)_模块名_表名`

项目名，因为我们可能一个数据库对应多个项目，这样容易区分

模块名，能够清晰明了的知道是哪个模块的表

### 3.4、字段设计 ###

**使用下划线，不要使用大小写组合，原因自己理解吧，兄弟**

#### 3.4.1、长度说明 ####

##### 3.4.1.1、数字型 #####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>范围（有符号）</th> 
   <th>范围（无符号）</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>tintint</td> 
   <td>1</td> 
   <td>(-128，127)</td> 
   <td>(0，255)</td> 
   <td>小整数值</td> 
  </tr> 
  <tr> 
   <td>smallint</td> 
   <td>2</td> 
   <td>(-32 768，32 767)</td> 
   <td>(0，65 535)</td> 
   <td>大整数值</td> 
  </tr> 
  <tr> 
   <td>mediumint</td> 
   <td>3</td> 
   <td>(-8 388 608，8 388 607)</td> 
   <td>(0，16 777 215)</td> 
   <td>大整数值</td> 
  </tr> 
  <tr> 
   <td>int/integer</td> 
   <td>4</td> 
   <td>(-2 147 483 648，2 147 483 647)</td> 
   <td>(0，4 294 967 295)</td> 
   <td>大整数值</td> 
  </tr> 
  <tr> 
   <td>bigint</td> 
   <td>8</td> 
   <td>(-9 233 372 036 854 775 808，9 223 372 036 854 775 807)</td> 
   <td>(0，18 446 744 073 709 551 615)</td> 
   <td>极大整数值</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>4</td> 
   <td>(-3.402 823 466 E+38，1.175 494 351 E-38)，0，(1.175 494 351 E-38，3.402 823 466 351 E+38)</td> 
   <td>0，(1.175 494 351 E-38，3.402 823 466 E+38)</td> 
   <td>单精度/浮点数值</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>8</td> 
   <td>(1.797 693 134 862 315 7 E+308，2.225 073 858 507 201 4 E-308)，0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)</td> 
   <td>0，(2.225 073 858 507 201 4 E-308，1.797 693 134 862 315 7 E+308)</td> 
   <td>双精度/浮点数值</td> 
  </tr> 
  <tr> 
   <td>decimal</td> 
   <td>M&gt;D，为M+2否则为D+2</td> 
   <td>decimal(M,D)依赖于M和D的值</td> 
   <td>依赖于M和D的值</td> 
   <td>小数值</td> 
  </tr> 
 </tbody> 
</table>

##### 3.4.1.2、字符类型 #####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>char</td> 
   <td>0-255字节</td> 
   <td>变长字符串</td> 
  </tr> 
  <tr> 
   <td>varchar</td> 
   <td>0-255字节</td> 
   <td>变长字符串</td> 
  </tr> 
  <tr> 
   <td>tinyblog</td> 
   <td>0-255字节</td> 
   <td>不超过 255 个字符的二进制字符串</td> 
  </tr> 
  <tr> 
   <td>tinytext</td> 
   <td>0-255字节</td> 
   <td>短文本字符串</td> 
  </tr> 
  <tr> 
   <td>blog</td> 
   <td>0-65 535字节</td> 
   <td>二进制形式的长文本数据</td> 
  </tr> 
  <tr> 
   <td>text</td> 
   <td>0-65 535字节</td> 
   <td>长文本数据</td> 
  </tr> 
  <tr> 
   <td>mediumblog</td> 
   <td>0-16 777 215字节 16M</td> 
   <td>二进制形式的中等长度文本数据</td> 
  </tr> 
  <tr> 
   <td>mediumtext</td> 
   <td>0-16 777 215字节 16M</td> 
   <td>中等长度文本数据</td> 
  </tr> 
  <tr> 
   <td>longblog</td> 
   <td>0-4 294 967 295字节 4G</td> 
   <td>二进制形式的极大文本数据</td> 
  </tr> 
  <tr> 
   <td>longtext</td> 
   <td>0-4 294 967 295字节 4G</td> 
   <td>极大文本数据</td> 
  </tr> 
 </tbody> 
</table>

##### 3.4.1.3、时间类型 #####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>取值范围</th> 
   <th></th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>year</td> 
   <td>1</td> 
   <td>1901——2155</td> 
   <td>YYYY</td> 
   <td>日期值</td> 
  </tr> 
  <tr> 
   <td>date</td> 
   <td>4</td> 
   <td>1000-01-01——9999-12-31</td> 
   <td>YYYY-MM-DD</td> 
   <td>时间值或持续时间</td> 
  </tr> 
  <tr> 
   <td>time</td> 
   <td>3</td> 
   <td>-838:59:59——838:59:59</td> 
   <td>HH:MM:SS</td> 
   <td>年份值</td> 
  </tr> 
  <tr> 
   <td>datetime</td> 
   <td>8</td> 
   <td>1000-01-01 00:00:00——9999-12-31 23:59:59</td> 
   <td>YYYY-MM-DD HH:MM:SS</td> 
   <td>混合日期和时间值</td> 
  </tr> 
  <tr> 
   <td>timestamp</td> 
   <td>4</td> 
   <td>19700101080001——20380119111407</td> 
   <td>YYYYMMDD HHMMSSsss</td> 
   <td>混合日期和时间值，时间戳</td> 
  </tr> 
 </tbody> 
</table>

#### 3.4.2、字段详解 ####

##### 3.4.2.1、字符 char(M),varcahr(M) #####

char是一种固定长度的类型，varchar则是一种可变长度的类型，它们的区别是：

*  char(M)类型的数据列里，每个值都占用M个字节，如果某个长度小于M，`MySQL就会在它的右边用空格字符补足`．（在检索操作中那些填补出来的空格字符将被去掉）
 *  varchar(M)类型的数据列里，每个值只占用刚好够用的字节再加上一个用来记录其长度的字节（**即总长度为L+1字节**）

**注意：一般千万不要使用text ，这样从mybatis取出来看似是String类型的，但是在实际使用中却或出现字符问题**

##### 3.4.2.3、日期 #####

###### 1、Local类型的日期 ######

**LocalTime** 对应 \*\*time \*\*只包括时间

**LocalDate** 对应 \*\*date \*\* 只包括日期

**LocalDateTime** 对应 \*\*timestamp datetime \*\*包括日期和时间

###### 2、timestamp ######

timestamp 多个日期，如果可能为空，则建议使用datetime（默认值建议设置为）  
0001-01-01 00:00:00，因为0000-00-00 00:00:00mysql不能保存，而且会报错，

普通字段不要设置为timestamp，timestamp列必须有默认值，默认值可以为“0000-00-00 00:00:00”，但不能为null。如果我们在save实体的时候，没有给相关timestamp设置值，那么他就会自动由mysql将当前时间设置进去

###### 3、注解使用 ######

@Column(insertable = true,updatable = false)
    @ApiModelProperty(hidden = true)
    private Date cdate;
    
    @UpdateTimestamp
    @ApiModelProperty(hidden = true)
    private Date udate;

##### 3.4.2.3、小数设计 decimal #####

**mysql中的decimal字段，声明语法为DECIMAL(M,D)** **D是小数点右侧数位0-30，M最大精度数位，1-65**

*  D：是小数部分的位数，若插入的值未指定小数部分或者小数部分不足D位则会自动补到D位小数，若插入的值小数部分超过了D为则会发生截断，截取前D位小数(四舍五入截取)。
 *  M：**是整数部分+小数部分=总长度**，也即插入的数字整数部分不能超过M-D位，否则不能成功插入，会报超出范围的错误。

规则：先保证小数点，再保证整数，  
    
    举例说明，11615.23653234568这个数存你说的三个格式
    decimal：11615
    decimal(3)：999
    decimal(3,2)：9.99
    decimal(10,5)11615.23653
    超出精度范围的数会被强制进位并只显示数据类型定义的格式

##### 3.4.2.4、数字 #####

###### 1、mysql 类型有符号范围和无符号范围 ######

> 带符号和无符号,顾名思义,就是是否有正负之分:
> 
> 比如8位的二进制,
> 
> 如果带符号,需要用1位表示符号(1表示负数,0表示正),剩下7位表示数据.  
> 那么表示范围是-128—127(包括-0和+0).
> 
> 如果不带符号,8位全部表示数据,  
> 那么表示范围是 0–256
> 
> 最小负数二进制是1000 0000 → 减一： 0111 1111 取反： 1000 0000 = 128 所以应该为 - 128  
> 最大负数二进制是1111 1111 → 减一： 1111 1110 取反： 0000 0001 = 1 所以应该为 - 1  
> 如果带符号,需要用1位表示符号(1表示负数,0表示正),剩下7位表示数据. 那么表示范围是-128—127(包括-0和+0).
> 
> 理解下了的话，就是无符号都是正数 ，所以主键自增Id我们一般都设计为无符号的
> 
>     `id` bigint(16) unsigned NOT NULL AUTO_INCREMENT,

###### 2、各个数据类型的长度以及默认 ######

> 整型的每一种都分无符号（unsigned）和有符号（signed）两种类型，在默认情况整型变量都是有符号的类型

![1556179030028][]

###### 3、int(M) (用于提示开发者长度) ######

这个长度`M`并不代表允许存储的宽度,`int（M）`,也就是`int（3`）和`int（11）`能够存储的数据是一样的

只有联合zerofill参数才能有意义，否则`int（3）`和`int（11）`没有任何区别。

*  **不加zeroffill没有区别**

create table test_int
        (
          id   int(3)  unsigned  not null,
          uid  int(11) unsigned  not null,
          uuid int     unsigned  not null
        );
    #插入数据 
    insert into test_int
    values (4294967295, 4294967295, 4294967295);
    
    #查询数据，发现没有什么区别
    select * from test_int;
    +------------+------------+------------+
    | id         | uid        | uuid       |
    +------------+------------+------------+
    | 4294967295 | 4294967295 | 4294967295 |
    +------------+------------+------------+
    1 row in set (0.00 sec)

*  **有了zeroffill 不足会自动补0**

create table test_int1
    (
          id   int(3) unsigned zerofill  not null,
          uid  int(11) unsigned zerofill not null,
          uuid int unsigned zerofill     not null
    );
    #插入数据
    insert into test_int1
    values (4294967295, 4294967295, 4294967295);
    
    insert into test_int1
    values (1, 4294967295, 110000);
    
    #查询数据 发现前面的不足长度的右0了，当然不能使用idea测试，idea没有显示0
    mysql> select * from test_int1;
    +------------+-------------+------------+
    | id         | uid         | uuid       |
    +------------+-------------+------------+
    | 4294967295 | 04294967295 | 4294967295 |
    |        001 | 04294967295 | 0000110000 |
    +------------+-------------+------------+
    2 rows in set (0.02 sec)

*  **当使用zerofill 时，默认会自动加unsigned（无符号），zerofill默认为int(10)**

create table test_int2
    (
          id   int(3) unsigned zerofill  not null,
          uid  int  zerofill not null,
          uuid int unsigned zerofill     not null
    );
    
    # 下面的不能执行成功，以为无符号的都是正数
    insert into test_int2
    values (1, -4294967295, 110000);
    
    insert into test_int2
    values (1, 12345678, 110000);
    
    mysql> select * from test_int2;
    +-----+------------+------------+
    | id  | uid        | uuid       |
    +-----+------------+------------+
    | 001 | 0012345678 | 0000110000 |
    +-----+------------+------------+

##### 3.4.2.5、boolean #####

boolean值用1代表TRUE，0代表FALSE。boolean在mysql里的类型为tinyint(1)。mysql里有四个常量：true,false,TRUE,FALSE分别代表1,0,1,0。

private Boolean loan;
    	
    tinyint(1) NOT NULL COMMENT '是否借款 true/false 1/0',

### 3.5、索引设计 ###

*  普通索引前缀：idx\_索引字段名，唯一索引前缀：uk\_索引字段名
 *  每个表必须显示指定主键，主键尽量为一个字段，且为数字类型,避免使用字符串
 *  主键尽量保持增长趋势，建议使用id的生成器，而不使用数据库自增（这个很难，我这里还是自增的）
 *  重要的SQL或调用频率高的SQL

update/select/delete的where条件列字段都要添加索引
    order by , group by, distinct的字段都要添加索引

*  组合索引创建时，把区分度(选择性)高的字段放在前面；根据SQL的特性，调整组合索引的顺序
 *  禁止对索引列进行函数运算和数学运算
 *  每个表的索引个数尽量少于5个，避免创建重复冗余索引；每个组合索引尽量避免超过3个字段

\*\*唯一索引添加之后，如果是逻辑删除的，如果有可能恢复，记得还原id，没有添加唯一索引，则按照正常的删除即可 \*\*

\*\*不过一般情况下，我们这种下面这种没有业务的是可以恢复的，如果是设计到用户名，一般情况下我个人的理解是注销的用户，数据进行迁移，当前数据库中没有，然后就可以恢复了 \*\*

##### 1、没有索引删除的 #####

/** * 添加字典类型 * * @return */
        @Override
        public void addDictType(DictionaryTypeDTO typeDTO, LoginUserDTO loginUserDTO) { 
            SysDictionaryTypeQuery query = new SysDictionaryTypeQuery();
            query.setTypeKey(typeDTO.getTypeKey());
            query.setStatus(StatusEnum.生效.code);
            SysDictionaryType type = sysDictionaryTypeManager.findByQueryContion(query);
            if (type != null) { 
                throw new BusinessException(ResponseEnum.字典类型已存在);
            }
            type = new SysDictionaryType();
            type.setCreateUser(loginUserDTO.getUserId());
            type.setCreateName(loginUserDTO.getRealName());
            type.setTypeKey(typeDTO.getTypeKey());
            type.setTypeDesc(typeDTO.getTypeDesc());
            type.setStatus(StatusEnum.生效.code);
            type.setUpdateUser(loginUserDTO.getUserId());
            type.setUpdateName(loginUserDTO.getRealName());
            sysDictionaryTypeManager.insertSelective(type);
        }
    
        /** * 删除字典类型 */
        @Override
        public void deleteDictType(Long id, LoginUserDTO loginUserDTO) { 
            SysDictionaryType type = sysDictionaryTypeManager.findById(id);
            if (type == null) { 
                throw new BusinessException(ResponseEnum.字典类型不存在);
            }
            type.setStatus(StatusEnum.废弃.code);
            type.setUpdateUser(loginUserDTO.getUserId());
            type.setUpdateName(loginUserDTO.getRealName());
            sysDictionaryTypeManager.updateSelective(type);
        }
    
    
        /** * 修改字典类型 */
        @Override
        public void updateDictType(DictionaryTypeDTO typeDTO, LoginUserDTO loginUserDTO) { 
    
            SysDictionaryTypeQuery query = new SysDictionaryTypeQuery();
            query.setTypeKey(typeDTO.getTypeKey());
            query.setStatus(StatusEnum.生效.code);
            SysDictionaryType typeExist = sysDictionaryTypeManager.findByQueryContion(query);
            //判断是是否已经存在数据
            if (typeExist != null && !typeExist.getId().equals(typeDTO.getId())  ) { 
                throw new BusinessException(ResponseEnum.字典类型已存在);
            }
            SysDictionaryType type = BeanUtils.dtoToDictionaryType(typeDTO);
            type.setUpdateUser(loginUserDTO.getUserId());
            type.setUpdateName(loginUserDTO.getRealName());
            sysDictionaryTypeManager.updateSelective(type);
        }

##### 2、**有索引删除的代码** #####

/** * 添加域名 */
        @Override
        public DomainDTO addDomain(DomainDTO domainDTO, LoginUserDTO loginUserDTO) { 
            AlimamaInfoDTO alimamaInfoDTO = loginUserDTO.getAlimamaInfo();
            SysDomainQuery domainQuery = new SysDomainQuery();
            domainQuery.setRefAlimamaInfoId(alimamaInfoDTO.getAlimamaInfoId());
            domainQuery.setType(domainDTO.getType());
            SysDomain domain = sysDomainManager.findByQueryContion(domainQuery);
            if (domain != null) { 
                if (domain.getStatus().equals(StatusEnum.生效.code)) { 
                    throw new BusinessException(ResponseEnum.域名已存在);
                } else { 
                    domain.setRefAlimamaInfoId(alimamaInfoDTO.getAlimamaInfoId());
                    domain.setStatus(StatusEnum.生效.code);
                    domain.setValue(domainDTO.getValue());
                    domain.setCreateUser(loginUserDTO.getUserId());
                    domain.setCreateName(loginUserDTO.getRealName());
                    domain.setUpdateUser(loginUserDTO.getUserId());
                    domain.setUpdateName(loginUserDTO.getRealName());
                    sysDomainManager.updateSelective(domain);
                }
            } else { 
                domain = new SysDomain();
                domain.setRefAlimamaInfoId(alimamaInfoDTO.getAlimamaInfoId());
                domain.setType(domainDTO.getType());
                domain.setValue(domainDTO.getValue());
                domain.setStatus(StatusEnum.生效.code);
                domain.setCreateUser(loginUserDTO.getUserId());
                domain.setCreateName(loginUserDTO.getRealName());
                domain.setUpdateUser(loginUserDTO.getUserId());
                domain.setUpdateName(loginUserDTO.getRealName());
                sysDomainManager.save(domain);
            }
            domainDTO.setDomainId(domain.getId());
            return domainDTO;
        }
    
        /** * 修改域名 */
        @Override
        public void updateDomain(DomainDTO domainDTO, LoginUserDTO loginUserDTO) { 
            AlimamaInfoDTO alimamaInfoDTO = loginUserDTO.getAlimamaInfo();
            SysDomainQuery domainQuery = new SysDomainQuery();
            domainQuery.setRefAlimamaInfoId(alimamaInfoDTO.getAlimamaInfoId());
            domainQuery.setType(domainDTO.getType());
            SysDomain domain = sysDomainManager.findByQueryContion(domainQuery);
            if(domain != null ){ 
                if(!domain.getId().equals(domainDTO.getDomainId())){ 
                    if(domain.getStatus().equals(StatusEnum.生效.code)){ 
                        throw new BusinessException(ResponseEnum.域名已存在);
                    }else { //前提必须是status，否则会出问题
                        domain.setStatus(StatusEnum.生效.code);
                        domain.setValue(domainDTO.getValue());
                        domain.setUpdateUser(loginUserDTO.getUserId());
                        domain.setUpdateName(loginUserDTO.getRealName());
                        sysDomainManager.updateSelective(domain);
                    }
                }else { 
                    domain.setValue(domainDTO.getValue());
                    domain.setUpdateUser(loginUserDTO.getUserId());
                    domain.setUpdateName(loginUserDTO.getRealName());
                    sysDomainManager.updateSelective(domain);
                }
            }else { 
                throw new BusinessException(ResponseEnum.域名不存在);
            }
        }
    
    
    
        /** * 删除域名 */
        @Override
        public void deleteDomain(DomainDTO domainDTO, LoginUserDTO loginUserDTO) { 
            AlimamaInfoDTO alimamaInfoDTO = loginUserDTO.getAlimamaInfo();
            SysDomain domain = sysDomainManager.findByIdAndAlimamaId(domainDTO.getDomainId(), alimamaInfoDTO.getAlimamaInfoId());
            if(domain == null ){ 
                throw new BusinessException(ResponseEnum.域名不存在);
            }
            if(domain.getStatus().equals(StatusEnum.废弃.code)){ 
                throw new BusinessException(ResponseEnum.重复操作);
            }
            domain.setStatus(StatusEnum.废弃.code);
            domain.setUpdateUser(loginUserDTO.getUserId());
            domain.setUpdateName(loginUserDTO.getRealName());
            sysDomainManager.updateSelective(domain);
        }

### 3.5、sql规范 ###

select o.createTime,
           o.clickTime,
           c.itemTitle,
           o.itemId,
           o.orderNo,
           c.shopTitle,
           o.estimateAmount,
           o.payAmount,
           c.commissionRatio,
           o.orderStatus
    from user_order o left  join
         coupon_taoke_data c on c.id = o.taokeId
    where 1=1

### 4、接口文档规范 ###

#### 4.1、多点 ####

##### 4.1.1、 查询排重接口 #####

<table> 
 <thead> 
  <tr> 
   <th>接口详情</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>地址</td> 
   <td>http://www.baidu.com （正式环境）</td> 
  </tr> 
  <tr> 
   <td>请求方式</td> 
   <td>GET</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>是否必填</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>idfa</td> 
   <td>是</td> 
   <td>广告标识符，只支持单个查询</td> 
  </tr> 
  <tr> 
   <td>source</td> 
   <td>是</td> 
   <td>渠道来源，具体值在接入时再进行分配</td> 
  </tr> 
 </tbody> 
</table>

--------------------

<table> 
 <thead> 
  <tr> 
   <th>返回结果</th> 
   <th>格式</th> 
   <th>JSON</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>状态码</td> 
   <td>10000</td> 
   <td>success（调用成功）</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>10001</td> 
   <td>param error(参数错误)</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>10002</td> 
   <td>query failed（查询失败）</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>10010</td> 
   <td>access prohibited(访问拒绝)</td> 
  </tr> 
 </tbody> 
</table>

--------------------

具体返回结果举例：

1、查询成功

{ 
      "state": 10000,
      "message": "success",
      "data": { 
        "BD239708-2874-417C-8292-7E335A537FAD": 1 //已经存在
      }
    }
    
    { 
      "state": 10000,
      "message": "success",
      "data": { 
        "BD239708-2874-417C-8292-7E335A537FAD": 0 //不存在
      }
    }

1.  接口调用失败

{ 
      "state": 10010,
      "message": "access prohibited",
      "data": [
        
      ]
    }

### 4.2、小米 ###

##### 4.2.1、角色列表查询 #####

> **说明**

*  测试调用地址：/api/roles
 *  调用方式：***GET***

> **请求参数**

<table> 
 <thead> 
  <tr> 
   <th align="center">参数名称</th> 
   <th align="center">参数类型</th> 
   <th align="center">参数长度</th> 
   <th align="center">是否必需</th> 
   <th align="center">说明</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">pageSize</td> 
   <td align="center">整数</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">每页显示数量</td> 
   <td align="center">默认10</td> 
  </tr> 
  <tr> 
   <td align="center">pageNo</td> 
   <td align="center">整数</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">当前查看页码</td> 
   <td align="center">默认1</td> 
  </tr> 
  <tr> 
   <td align="center">roleName</td> 
   <td align="center">字符串</td> 
   <td align="center">64</td> 
   <td align="center">否</td> 
   <td align="center">角色名称</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">systemCode</td> 
   <td align="center">字符串</td> 
   <td align="center">32</td> 
   <td align="center">否</td> 
   <td align="center">系统CODE</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">isPage</td> 
   <td align="center">布尔</td> 
   <td align="center">4</td> 
   <td align="center">否</td> 
   <td align="center">是否分页</td> 
   <td align="center">true/false</td> 
  </tr> 
 </tbody> 
</table>

> **请求报文样例**

{ 
        "pageSize": 1,
        "pageNo": 1,
        "roleName": "",
        "systemCode": "scf-manager",
        "isPage": true
    }

> **响应参数**

<table> 
 <thead> 
  <tr> 
   <th align="center">参数名称</th> 
   <th align="center">参数类型</th> 
   <th align="center">参数长度</th> 
   <th align="center">是否必需</th> 
   <th align="center">说明</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">msg</td> 
   <td align="center">字符串</td> 
   <td align="center">255</td> 
   <td align="center">是</td> 
   <td align="center">返回结果</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">total</td> 
   <td align="center">数字</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">总数</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">pageNo</td> 
   <td align="center">数字</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">页数</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">totalPage</td> 
   <td align="center">数字</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">总页数</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">pageSize</td> 
   <td align="center">数字</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">每页数量</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">datas</td> 
   <td align="center">Role数组</td> 
   <td align="center"></td> 
   <td align="center">否</td> 
   <td align="center">返回的数据信息</td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

***Role 数据结构***

<table> 
 <thead> 
  <tr> 
   <th align="center">参数名称</th> 
   <th align="center">参数类型</th> 
   <th align="center">参数长度</th> 
   <th align="center">是否必需</th> 
   <th align="center">说明</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">id</td> 
   <td align="center">数字</td> 
   <td align="center">16</td> 
   <td align="center">是</td> 
   <td align="center">id</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">roleName</td> 
   <td align="center">字符串</td> 
   <td align="center">64</td> 
   <td align="center">是</td> 
   <td align="center">角色名称</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">systemCode</td> 
   <td align="center">字符串</td> 
   <td align="center">64</td> 
   <td align="center">是</td> 
   <td align="center">系统CODE</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">status</td> 
   <td align="center">字符串</td> 
   <td align="center">8</td> 
   <td align="center">是</td> 
   <td align="center">状态</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">desc</td> 
   <td align="center">字符串</td> 
   <td align="center">255</td> 
   <td align="center">否</td> 
   <td align="center">描述</td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

> **响应报文样例**

{ 
        "msg": "角色列表查询成功",
        "total": 2,
        "pageNo": 1,
        "totalPage": 1,
        "datas": [
            { 
                "id": 1,
                "roleName": "后台管理员",
                "systemCode": "scf-manager",
                "status": "10"
            },
            { 
                "id": 4,
                "roleName": "测试角色哦",
                "systemCode": "scf-manager",
                "status": "10",
                "desc": "真的是测试"
            }
        ],
        "pageSize": 10
    }

> **返回码解析**

![ContactAuthor][]

[WX20190213-180740]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0hlYWxlckplYW4vSGVhbGVySmVhbi5naXRodWIuaW8vbWFzdGVyL2Jsb2dJbWFnZXMvV1gyMDE5MDIxMy0xODA3NDAucG5n?x-oss-process=image/format,png
[1556179030028]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0hlYWxlckplYW4vSGVhbGVySmVhbi5naXRodWIuaW8vbWFzdGVyL2Jsb2dJbWFnZXMvMTU1NjE3OTAzMDAyOC5wbmc?x-oss-process=image/format,png
[ContactAuthor]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL0hlYWxlckplYW4vSGVhbGVySmVhbi5naXRodWIuaW8vbWFzdGVyL2Fzc2V0cy9pbWcvYXJ0aWNhbF9ib3R0b20uanBn?x-oss-process=image/format,png