SpringBoot项目标准化代码编写

作者: 一击必中 | 来源:发表于2021-04-15 12:00 被阅读0次

一、认识项目结构

1、项目基本结构

基础功能结构

entitys // 存放实体类
enums // 存放枚举类
dto  // 存放入参结构
vo   // 存放出参结构
utils // 存放相关工具类

核心逻辑功能结构

-controller  // 基本参数校验
--service    // 存放服务接口
---impl       // 存放服务接口实现类(核心业务逻辑功能开发)
----dao      // 持久层，数据增删改查
-----provider // 动态sql拼接层，编写动态的sql

2、统一消息返回

ErrorCodeEnum.java（存放各类错误码）

public enum ErrorCodeEnum {
    /**
     * 错误码
     */
    ERROR(9999, "系统异常"),
    HTTP_CONNECTION_OVERTIME(9998, "连接超时"),
    FREQUENTLY_REQUEST(9003, "操作频繁"),
    INVALID_RSA_KEY(9002, "超时失效"),
    TOKEN_TIMEOUT(9005, "token失效"),
    INVALID_PARAMS(9001, "非法参数"),
    SIGN_ERROR(9000, "签名错误"),
    INVALID_STATUS(9004, "状态不符"),

    OK(200, "请求通过"),
    NO(201, "请求不通过"),
    TIP(202, "提示"),

    private Integer code;

    private String message;

    ErrorCodeEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

ErrorCodeException.java 统一异常结构

@ToString
public class ErrorCodeException extends RuntimeException {

    private static final long serialVersionUID = -7638041501183925225L;

    private Integer code;

    public ErrorCodeException(ErrorCodeEnum errorCode, String msg) {
        super(msg);
        this.code = errorCode.getCode();
    }

    public ErrorCodeException(ErrorCodeEnum errorCode) {
        super(errorCode.getMessage());
        this.code = errorCode.getCode();
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

}

SimpleMessage.java (简易信息返回)

@Data
public class SimpleMessage implements Serializable {
    private static final long serialVersionUID = -2957516153008725933L;
    private Integer errorCode;
    private String errorMsg;

    public SimpleMessage(ErrorCodeEnum errorCode, String errorMsg) {
        this.errorCode = errorCode.getCode();
        this.errorMsg = errorMsg;
    }
}

MessageBean.java (丰富信息返回)

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MessageBean implements Serializable {
    private static final long serialVersionUID = 7192766535561421181L;
    private String errorMsg;
    private Object data;
    private Integer errorCode;
}

AppResponseBodyAdvice.java 处理统一返回

@Slf4j
@ControllerAdvice
public class AppResponseBodyAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return MappingJackson2HttpMessageConverter.class.isAssignableFrom(converterType);
    }

    @SuppressWarnings("Duplicates")
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                  ServerHttpRequest request,
                                  ServerHttpResponse response) {
       // 特殊返回类型处理
        if (body instanceof SimpleMessage || body instanceof MessageBean) {
            return body;
        }
        MessageBean messageBean = new MessageBean();
        messageBean.setErrorCode(ErrorCodeEnum.OK.getCode());
        messageBean.setErrorMsg(ErrorCodeEnum.OK.getMessage());
        messageBean.setData(body);
        return messageBean;
    }
}

· ManagerExceptionHandler.java (全局异常处理)

@Slf4j
@ControllerAdvice
public class ManagerExceptionHandler {

    @ExceptionHandler(value = ErrorCodeException.class)
    @ResponseBody
    public SimpleMessage myErrorHandler(ErrorCodeException e) {
        SimpleMessage message = new SimpleMessage();
        message.setErrorCode(e.getCode());
        message.setErrorMsg(e.getMessage());
        return message;
    }

    @ExceptionHandler(value = DuplicateKeyException.class)
    @ResponseBody
    public SimpleMessage duplicateKeyErrorHandler() {
        SimpleMessage message = new SimpleMessage();
        message.setErrorCode(ErrorCodeEnum.NO.getCode());
        message.setErrorMsg("数据重复");
        return message;
    }

    @ExceptionHandler(value = MaxUploadSizeExceededException.class)
    @ResponseBody
    public SimpleMessage fileSizeLimitErrorHandler() {
        SimpleMessage message = new SimpleMessage();
        message.setErrorCode(ErrorCodeEnum.NO.getCode());
        message.setErrorMsg("图片过大");
        return message;
    }

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public SimpleMessage errorHandler(Exception e, HttpServletRequest request) {
        SimpleMessage message = new SimpleMessage();
        message.setErrorCode(ErrorCodeEnum.ERROR.getCode());
        message.setErrorMsg(ErrorCodeEnum.ERROR.getMessage());
        log.error("url [{}] params [{}] error", request.getRequestURI(), JSON.toJSONString(request.getParameterMap()), e);
        return message;
    }
}

二、了解常用规范

1.实体类（以设备表功能为例）

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class DeviceInfo implements Serializable {
    private static final long serialVersionUID = -4951578247348538266L;
    /**
     * 自增ID
     */
    @NotNull(message = "设备ID不能为空", groups = {Update.class})
    private Integer id;
    /**
     * 设备名称
     */
    @NotBlank(message = "设备名称不能为空", groups = {Insert.class, Update.class})
    private String deviceName;
    /**
     * 设备码
     */
    @NotNull(message = "设备码不能为空", groups = {Insert.class, Update.class})
    private DeviceTypeEnum deviceCode;
    /**
     * 二级分类ID
     */
    @NotNull(message = "二级分类ID", groups = {Insert.class, Update.class})
    private Integer parentId;
    /**
     * 图标地址
     */
    @NotBlank(message = "图标地址不能为空", groups = {Insert.class, Update.class})
    private String iconUrl;
    /**
     * 排序
     */
    @NotNull(message = "排序不能为空", groups = {Insert.class, Update.class})
    private Integer sort;
    /**
     * 创建人
     */
    private String createNo;
    /**
     * 更新人
     */
    private String updateNo;
    /**
     * 创建时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    /**
     * 更新时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime;

}

讲解点

1、 Lomok 注解
2、@Valid 注解【@NotNull 、@NotBlank、@NotEmpty、@JsonFormat、@DateTimeFormat】
3、自定义接口【Insert.class、Update.class】
4、javadoc 注释
5、@Valid延伸、多级结构校验

注意点

【强制】1、实体类必须与表结构完全对应一致
【强制】2、实体类必须实现序列化接口
【强制】3、增、删、改、查的接口，必须使用公共接口
【强制】4、java类、各参数值必须使用 javadoc 注释（具体注释情况，需按照alibaba编程规范执行）
【推荐】5、添加@JsonInclude(JsonInclude.Include.NON_NULL) 和 @Builder

2.DTO类

@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class DeviceInfoDTO extends DeviceInfo implements Serializable {
    private static final long serialVersionUID = 7535820681677648701L;

    /**
     * 当前页
     */
    @NotNull(message = "当前页不能为空", groups = {PageQuery.class})
    private Integer pageNumber;
    /**
     * 每页的数量
     */
    @NotNull(message = "每页显示数量不能为空", groups = {PageQuery.class})
    private Integer pageSize;

}

讲解点

1、extend 继承的好处
2、PageQuery.class 接口

注意点

【强制】DTO 类必须继承至实体类
【强制】DTO 类型实现后必须实现序列化接口
【强制】DTO 类的命名，必须最后的DTO 为大写
【建议】在需要分页功能中，pageNumber和pageSzie必传

2.VO类

@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class DeviceInfoVO extends DeviceInfo implements Serializable {
    private static final long serialVersionUID = -5721621832940504628L;
    /**
     * 二级分类
     */
    private String secondaryCategoryName;
    /**
     * 一级分类
     */
    private String primaryCategoryName;

}

讲解点

用法与DTO保持一致

注意点

【强制】VO 类必须继承至实体类
【强制】VO 类型实现后必须实现序列化接口
【强制】VO 类的命名，必须最后的DTO 为大写

3.枚举类

public enum DeviceTypeEnum {

    /**
     * 智能插座
     */
    SOCKET("智能插座"),
    /**
     * 通断器
     */
    ON_OFF("通断器")
    ;

    private final String str;

    DeviceTypeEnum(String str) {
        this.str = str;
    }

    /**
     * 获取key，value值
     *
     * @return List<CodeValuePair>
     */
    public static List<CodeValuePair> getStatusMap() {
        List<CodeValuePair> list = new ArrayList<>();
        for (DeviceTypeEnum balanceTypeEnum : DeviceTypeEnum.values()) {
            list.add(CodeValuePair.builder().code(balanceTypeEnum.name()).value(balanceTypeEnum.getStr()).build());
        }
        return list;
    }

    public String getStr() {
        return str;
    }
}

讲解点

1、使用类型枚举的好处
2、使用枚举的注意点（保持枚举更新的一致性）
3、字符串枚举的好处（简述间隙锁）

注意点

【强制】涉及到类型的必须使用枚举

三、增删改查标准化写法

1、controller 层级

/**
 * @author tangn
 * @date 2021/1/9 9:46
 */
@RestController
@RequestMapping("/device")
public class DeviceController {

    @Resource
    private DeviceService deviceService;


    /**
     * 创建设备
     *
     * @param deviceInfo 设备信息
     * @param result     校验结果
     * @return SimpleMessage
     */
    @RequestMapping("/createDevice")
    public SimpleMessage createDevice(@Validated({Insert.class}) DeviceInfo deviceInfo,
                                      BindingResult result) throws Exception {
        if (result.hasErrors()) {
            return new SimpleMessage(ErrorCodeEnum.INVALID_PARAMS, result.getAllErrors().get(0).getDefaultMessage());
        }
        return deviceService.createDevice(deviceInfo);
    }

    /**
     * 获取设备列表
     *
     * @param deviceInfoDTO 查询参数
     * @param result        校验结果
     * @return List<DeviceInfoVO>
     */
    @RequestMapping("/getDeviceList")
    public Page<DeviceInfoVO> getDeviceList(@Validated({PageQuery.class}) DeviceInfoDTO deviceInfoDTO,
                                            BindingResult result) {
        if (result.hasErrors()) {
            throw new ErrorCodeException(ErrorCodeEnum.INVALID_PARAMS, result.getAllErrors().get(0).getDefaultMessage());
        }
        return new Page<>(deviceService.getDeviceList(deviceInfoDTO));
    }

    /**
     * 更新设备信息
     *
     * @param deviceInfo 设备信息
     * @param result     校验结果
     * @return SimpleMessage
     */
    @RequestMapping("/updateDevice")
    public SimpleMessage updateDevice(@Validated({Update.class}) DeviceInfo deviceInfo,
                                      BindingResult result) throws Exception {
        if (result.hasErrors()) {
         return new SimpleMessage(ErrorCodeEnum.INVALID_PARAMS, result.getAllErrors().get(0).getDefaultMessage());
        }
        return deviceService.updateDevice(deviceInfo);
    }

    /**
     * 删除设备信息
     *
     * @param deviceId 设备ID
     * @return SimpleMessage
     */
    @RequestMapping("/delDevice")
    public SimpleMessage updateDevice(Integer deviceId) {
        if (Objects.isNull(deviceId)) {
            return new SimpleMessage(ErrorCodeEnum.INVALID_PARAMS);
        }
        return deviceService.delDevice(deviceId);
    }

}

讲解点

1、头部类的 @RequestMapping
2、@Validated({Update.class}) 根据接口标识类型进行参数校验的规范
3、return 和 throw 的用法
4、controller层的使用规范
5、分页查询的使用方法（搭配DTO、VO 使用）
6、注释的使用
7、@Resource 和 @Autowired 的区别（自行理解）(https://blog.csdn.net/magi1201/article/details/82590106)

注意点

【强制】基本参数校验必须使用@Validated校验方式
【强制】必须用对return 和 throw ，不允许满足return情况的使用throw
【强制】注释必须完善，不允许图省事不写参数的意义
【强制】controller 层级不允许出现 Dao层的注入，只能注入 Service 层
【强制】无特殊用途，必须使用@Resuorce注解，不能使用@Autowired注解
【建议】操作类型的返回，使用SimpleMessage

2、service 层级

/**
 * @author tangn
 * @date 2021/1/9 9:47
 */
public interface DeviceService {

    /**
     * 创建设备
     *
     * @param deviceInfo 设备信息
     * @return SimpleMessage
     * @throws Exception
     */
    SimpleMessage createDevice(DeviceInfo deviceInfo) throws Exception;

    /**
     * 获取设备列表
     *
     * @param deviceInfoDTO 查询参数
     * @return List<DeviceInfoVO>
     */
    List<DeviceInfoVO> getDeviceList(DeviceInfoDTO deviceInfoDTO);

    /**
     * 更新设备信息
     *
     * @param deviceInfo 设备信息
     * @return SimpleMessage
     * @throws Exception
     */
    SimpleMessage updateDevice(DeviceInfo deviceInfo) throws Exception;

    /**
     * 删除设备
     *
     * @param deviceId 设备ID
     * @return SimpleMessage
     * @throws Exception
     */
    SimpleMessage delDevice(Integer deviceId);

}

讲解点

为什么要通过接口形式进行service层编写？

2、impl 层级

/**
 * @author tangn
 * @date 2021/1/9 9:48
 */
@Service
@Slf4j
public class DeviceServiceImpl implements DeviceService {

    @Resource
    private CategoryDao categoryDao;
    @Resource
    private DeviceDao deviceDao;
    @Resource
    private StoreDevicesDao storeDevicesDao;
    @Resource
    private AdminService adminService;

    /**
     * 创建设备
     *
     * @param deviceInfo 设备信息
     * @return SimpleMessage
     */
    @Override
    public SimpleMessage createDevice(DeviceInfo deviceInfo) throws Exception {
        AccountVO currentAccount = adminService.getCurrentAdmin();
        // 二级分类检测
        if (categoryDao.checkSecondaryCategoryExistById(deviceInfo.getParentId()) == 0) {
            return new SimpleMessage(ErrorCodeEnum.NO, "查询不到二级分类");
        }
        // 设置账户
        deviceInfo.setCreateNo(currentAccount.getPhoneNo());
        // 创建商品
        deviceDao.createDeviceInfo(deviceInfo);
        return new SimpleMessage(ErrorCodeEnum.OK, "创建设备成功");
    }

    /**
     * 获取设备列表
     *
     * @param deviceInfoDTO 查询参数
     * @return List<DeviceInfo>
     */
    @Override
    public List<DeviceInfoVO> getDeviceList(DeviceInfoDTO deviceInfoDTO) {
        PageHelper.startPage(deviceInfoDTO.getPageNumber(), deviceInfoDTO.getPageSize());
        return deviceDao.getDeviceList(deviceInfoDTO);
    }

    /**
     * 更新设备信息
     *
     * @param deviceInfo 设备信息
     * @return SimpleMessage
     */
    @Override
    public SimpleMessage updateDevice(DeviceInfo deviceInfo) throws Exception {
        AccountVO currentAccount = adminService.getCurrentAdmin();
        // 设备检测
        if (deviceDao.checkDeviceById(deviceInfo.getId()) == 0) {
            return new SimpleMessage(ErrorCodeEnum.NO, "查询不到该设备");
        }
        // 二级分类检测
        if (categoryDao.checkSecondaryCategoryExistById(deviceInfo.getParentId()) == 0) {
            return new SimpleMessage(ErrorCodeEnum.NO, "查询不到二级分类");
        }
        deviceInfo.setUpdateNo(currentAccount.getPhoneNo());
        // 更新设备
        deviceDao.updateDeviceInfo(deviceInfo);
        return new SimpleMessage(ErrorCodeEnum.OK, "更新成功");
    }

    /**
     * 删除设备
     *
     * @param deviceId 设备ID
     * @return SimpleMessage
     */
    @Override
    public SimpleMessage delDevice(Integer deviceId) {
        // 设备检测
        if (deviceDao.checkDeviceById(deviceId) == 0) {
            return new SimpleMessage(ErrorCodeEnum.NO, "查询不到该设备");
        }
        // 检查设备是否被门店绑定
        if (storeDevicesDao.checkDeviceBinded(deviceId) > 0) {
            return new SimpleMessage(ErrorCodeEnum.NO, "该设备已经被门店绑定，请先移除");
        }
        deviceDao.delDeviceInfo(deviceId);
        return new SimpleMessage(ErrorCodeEnum.OK, "删除成功");
    }
}

讲解点

1、@Slf4j 日志打印注解
2、数据是否存在校验（count）
3、PageHelper 使用
4、注释的使用

注意点

【强制】参数的真实性校验一定要做，不要相信任何传过来的值
【强制】编写每句代码时，操作每个数据时，一定要确定该值是否为空，禁止出现空指针异常
【强制】return 和 throw 一定要使用正确（再次强调！！）
【强制】数据库返回的值，一定要做期望值校验（后面会讲解期望值校验注解）
【强制】方法中定义的变量要使用非包装类型接受，（例：使用int 不用 Integer ）

3、dao层级

/**
 * @author tangn
 * @date 2021/1/19 17:00
 */
@Mapper
public interface DeviceDao {

    /**
     * 根据二级分类ID检查设备是否存在
     *
     * @param parentId 分类ID
     * @return int
     */
    @Select("SELECT COUNT(*) FROM device_info WHERE parent_id = #{parentId}")
    int checkDeviceByParentId(@Param("parentId") Integer parentId);

    /**
     * 检查设备信息
     *
     * @param id 设备ID
     * @return int
     */
    @Select("SELECT COUNT(*) FROM device_info WHERE id = #{id}")
    int checkDeviceById(@Param("id") Integer id);

    /**
     * 创建设备信息
     *
     * @param deviceInfo 设备信息
     * @return int
     */
    @Insert("INSERT INTO device_info (" +
            "device_name," +
            "device_code," +
            "parent_id," +
            "icon_url," +
            "sort," +
            "create_time," +
            "create_no) VALUES (" +
            "#{dto.deviceName}," +
            "#{dto.deviceCode}," +
            "#{dto.parentId}," +
            "#{dto.iconUrl}," +
            "#{dto.sort}," +
            "now()," +
            "#{dto.createNo})")
    @ReturnCheck(info = "创建设备信息失败")
    int createDeviceInfo(@Param("dto") DeviceInfo deviceInfo);

    /**
     * 获取设备信息
     *
     * @param deviceInfoDTO 查询参数
     * @return List<DeviceInfoVO>
     */
    @SelectProvider(type = DeviceDaoProvider.class, method = "getDeviceList")
    List<DeviceInfoVO> getDeviceList(@Param("dto") DeviceInfoDTO deviceInfoDTO);

    /**
     * 更新设备信息
     *
     * @param deviceInfo 设备信息
     * @return int
     */
    @Update("UPDATE device_info set " +
            "device_name = #{dto.deviceName}," +
            "device_code = #{dto.deviceCode}," +
            "parent_id = #{dto.parentId}," +
            "icon_url = #{dto.iconUrl}," +
            "sort = #{dto.sort}," +
            "update_no = #{dto.updateNo}," +
            "update_time = now() " +
            "WHERE id = #{dto.id} ")
    @ReturnCheck(info = "更新设备信息失败")
    int updateDeviceInfo(@Param("dto") DeviceInfo deviceInfo);

    /**
     * 删除设备信息
     *
     * @param id 设备ID
     * @return int
     */
    @Delete("DELETE FROM device_info WHERE id = #{id}")
    @ReturnCheck(info = "删除设备失败")
    int delDeviceInfo(@Param("id") Integer id);

    /**
     * 获取设备信息
     *
     * @param id 设备ID
     * @return DeviceInfo
     */
    @Select("SELECT id,device_name FROM device_info WHERE id = #{id}")
    DeviceInfo getDeviceInfo(@Param("id") Integer id);

}

讲解点

1.使用count(*)校验数据真实性
2.@ReturnCheck 注解使用
3.@Select 、@Update 、@Delete 的使用（尤其注意@Update 和 @Delete ）
3.@SelectProvider 使用 type 和 method
4.利用映射转VO
5.无特殊需求返回值无须添加 as （mybatis配置）

注意点

【强制】插入及更新时不能忘记创建时间(人)、更新时间(人)
【强制】无特殊需求，不允许创建时插入更新时间
【强制】影响行数必须使用非包装类型接受（使用 int 而非 Integer ）
【建议】更新时，更新依据字段尽可能落在主键或唯一索引上
【建议】增加@ReturnCheck 注解和 @ReturnListCheck 注解减少serivce层判断

3、provider层级

/**
 * @author tangn
 * @date 2021/1/20 17:29
 */
public class DeviceDaoProvider {

    /**
     * 获取设备列表
     *
     * @param map 查询参数
     * @return String
     */
    public String getDeviceList(HashMap<String, DeviceInfoDTO> map) {
        StringBuilder sql = new StringBuilder();
        DeviceInfoDTO deviceInfoDTO = map.get("dto");
        sql.append("SELECT " +
                " a.id," +
                " a.device_name," +
                " a.device_code," +
                " a.parent_id," +
                " a.icon_url," +
                " a.sort," +
                " d.name as 'createNo'," +
                " e.name as 'updateNo'," +
                " a.create_time," +
                " a.update_time, " +
                " b.category_name AS 'secondaryCategoryName', " +
                " c.category_name AS 'primaryCategoryName'  " +
                "FROM " +
                " `device_info` a " +
                " JOIN device_secondary_category b ON a.parent_id = b.id " +
                " JOIN device_primary_category c ON b.parent_id = c.id  " +
                " LEFT JOIN shiro_account d ON a.create_no = d.phone_no and d.plat_type = 0 " +
                " LEFT JOIN shiro_account e ON a.update_no = e.phone_no and e.plat_type = 0  " +
                "WHERE " +
                " 1 = 1 ");
        // 设备名称
        if (StringUtils.isNotBlank(deviceInfoDTO.getDeviceName())) {
            sql.append(" AND INSTR(a.device_name,#{dto.deviceName}) > 0 ");
        }
        // 二级分类
        if (Objects.nonNull(deviceInfoDTO.getParentId())) {
            sql.append(" AND a.parent_id = #{dto.parentId} ");
        }
        sql.append(" ORDER BY a.create_time DESC ");
        return sql.toString();
    }

}

讲解点

1.DTO 内取值的好处
2.WHERE 1 = 1 的妙处
3.使用工具类进行参数值的判断
4.使用 INSTR 进行模糊查询

规范点

【强制】使用工具类对参数进行判别
【建议】使用DTO 作为参数的携带体

四、来点干的？

1、事务的使用

    /**
     * 确认发放
     *
     * @param shopOrderDTO 参数
     * @return : com.orangeconvenient.common.entity.MessageBean<java.time.LocalDateTime>
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public MessageBean<String> confirmRelease(ShopOrderDTO shopOrderDTO) {
        ShopOrder shopOrder = Optional.ofNullable(storeOrderDao.getByIdAndStore(shopOrderDTO.getId(), shopOrderDTO.getStoreNo()))
                .orElseThrow(() -> new ErrorCodeException(ErrorCodeEnum.NO, "订单不存在"));
        if (ShopOrderStatusEnum.RECEIVED.equals(shopOrder.getOrderStatus())) {
            return new MessageBean<>(ErrorCodeEnum.EXT_ASSEMBLE_ORDER_CONSUMED, Objects.nonNull(shopOrder.getSuccessTime()) ? LocalDateTimeUtil.formatDateTime(shopOrder.getSuccessTime()) : null, "此订单顾客已取货,请不要重复发放!");
        }
        if (ShopOrderStatusEnum.MEMBER_CANCEL.equals(shopOrder.getOrderStatus()) ||
                ShopOrderStatusEnum.STORE_CANCEL.equals(shopOrder.getOrderStatus()) ||
                ShopOrderStatusEnum.RAISE_OVER_CANCEL.equals(shopOrder.getOrderStatus())) {
            return new MessageBean<>(ErrorCodeEnum.NO, "此订单已被取消,请不要发放商品!");
        }
        if (!ShopOrderStatusEnum.PENDING.equals(shopOrder.getOrderStatus())) {
            return new MessageBean<>(ErrorCodeEnum.NO, "订单状态不正确");
        }
        shopOrder.setSuccessTime(LocalDateTime.now());
        // 设置出库商品的数量
        shopOrder.setOutGoodsNum(orderDao.getGoodsNumByOrderNo(shopOrder.getOrderNo(), ShopOrderInfoStatusEnum.PENDING));
        orderDao.updateOrderStatus(shopOrder, ShopOrderStatusEnum.RECEIVED);
        List<ShopOrderInfoVO> shopOrderInfoList = orderDao.getCanRefundOrderInfoList(shopOrder.getId(), ShopOrderInfoStatusEnum.PENDING);
        if (CollectionUtils.isEmpty(shopOrderInfoList)) {
            return new MessageBean<>(ErrorCodeEnum.NO, "没有待自提的订单明细");
        }
        if (orderDao.updateInfoStatusByOrderId(shopOrder.getId(), ShopOrderInfoStatusEnum.RECEIVED, ShopOrderInfoStatusEnum.PENDING, null) != shopOrderInfoList.size()) {
            throw new ErrorCodeException(ErrorCodeEnum.NO, "订单明细状态修改失败");
        }
        // 更新实际出库的订单详情
        storeOrderDao.updateInfoOutStatusByIds(shopOrderInfoList.size(), shopOrderInfoList.stream().map(ShopOrderInfo::getId).collect(Collectors.toList()), true);
        User user = Optional.ofNullable(userDao.queryUserById(shopOrder.getUserId())).orElseThrow(() -> new ErrorCodeException(ErrorCodeEnum.NO, "会员不存在"));
        //初始化评价
        memberCardOrderDao.insertEvaluateRecord(EvaluateRecord.builder()
                .orderNo(shopOrder.getOrderNo())
                .unionId(user.getUnionId())
                .userId(shopOrder.getUserId())
                .consumeTime(shopOrder.getSuccessTime())
                .merchantNo(shopOrder.getStoreNo())
                .totalAmount(shopOrderInfoList.stream().map(ShopOrderInfo::getActualPrice).reduce(BigDecimal.ZERO, BigDecimal::add))
                .evaluateRecordType(EvaluateRecordTypeEnum.MALL_ORDER).build());
        // 获取门店信息
        Store store = storeDao.getByStoreNo(shopOrder.getStoreNo());
        //初始化售后信息
        ShopOrderAfterSale shopOrderAfterSale = ShopOrderAfterSale.builder()
                .orderId(shopOrder.getId())
                .userId(shopOrder.getUserId())
                .afterSaleOrderNo(Constant.SHOP_ORDER_AFTER_SALE_PREFIX + CheckUtil.fillZero(user.getId().longValue(), 5) + System.nanoTime()).build();
        afterSaleOrderDao.insertAfterSaleOrder(shopOrderAfterSale);
        // 初始化模板消息备注信息
        StringBuilder remark = new StringBuilder(200);
        givenUserIntegral(user, shopOrderInfoList, shopOrder.getStoreNo(), shopOrder.getOrderNo(), shopOrder, remark);
        // 消费返券
        consumeReturnCoupon(shopOrder.getId(), user, remark, shopOrderDTO.getStoreNo());
        vitalityChangeService.doVitality(shopOrder.getUserId(), ShopCouponWeeklyContentTypeEnum.SHOP_CONSUME, null);
        //发送新版评价
        accessTokenComponent.sendCommonEvaluateMessage(user.getOpenId(),
                user.getUnionId(), shopOrder.getOrderNo(), Objects.nonNull(store) ? store.getBusinessName() : "",
                LocalDateTime.now(), remark);
        return new MessageBean<>(ErrorCodeEnum.OK, "取货成功,请将商品发放给顾客");
    }

讲解点

1.事务的使用场景
2.为什么我的事务不生效？
3.@Builder使用

注意点

【强制】不要使用编程式事务
【建议】开启事务后，要考虑在合适的时机抛出事务，让其回滚
【建议】多层事务嵌套，要考虑回滚情况

2、for update 使用（悲观锁）

    /**
     * 获取最后一条会员积分记录
     *
     * @param userId 会员id
     * @return 积分
     */
    @Select("select integral from tbl_user_integral where user_id=#{userId} for update")
    @Options(timeout = 3)
    Long getLastIntegralByUserId(@Param("userId") Long userId);

讲解点

当涉及到金额、库存等需要保持一致性的操作时，可采用悲观锁进行相应的查询并执行更新

注意点

@Options(timeout = 3) 一定要加，且不能锁数据时间过长

3、update 更新状态

    /**
     * 更新闲鱼订单状态
     * @param outOrderStatus 订单状态
     * @param orderId 订单ID
     * @param oldStatus 旧状态
     * @return int
     */
    @Update("UPDATE xy_receive_order SET " +
            "out_order_status = #{outOrderStatus}," +
            "update_time = now() " +
            "WHERE id = #{orderId} AND " +
            "out_order_status = #{oldStatus} ")
    @ReturnCheck(info = "更新闲鱼订单状态失败")
    int updateOutOrderStatus(@Param("outOrderStatus") Integer outOrderStatus,
                             @Param("orderId") Long orderId,
                             @Param("oldStatus") Integer oldStatus);

讲解点

当对状态相关数据进行更新时，需要知道数据的原状态

注意点

【强制】更新状态时，必须限定原状态

4、update 更新数值

    /**
     * 扣款
     *
     * @param id          代金券接收ID
     * @param orderAmount 订单金额
     * @return int
     */
    @Update("UPDATE cash_voucher_receiver  " +
            "SET left_amount = ( left_amount - #{orderAmount} ), " +
            "update_time = now( ) " +
            "WHERE " +
            " id = #{id}  " +
            " AND (left_amount - #{orderAmount}) >= 0 ")
    @ReturnCheck(info = "核销失败")
    int consumeVoucher(@Param("id") Long id, @Param("orderAmount") BigDecimal orderAmount);

讲解点

WHERE 前使用数据库增减余额(库存)
2.WHERE 后使用计算结果>0 进行校验，防止多扣（允许负库存例外）

注意点

【强制】禁止在service层级计算好结果直接更新到库

5、批量操作 in 的使用方法

    /**
     * 批量插入用户信息
     *
     * @param userInfoList 用户信息列表
     * @return 影响的行数
     */
    @Insert("<script>" +
            " insert into tbl_user_info " +
            " (user_id, recent_consume_date, store_consume_time, " +
            " shop_consume_time, assemble_consume_time, " +
            " store_consume_date_collect, shop_consume_date_collect, " +
            " assemble_consume_date_collect, create_time) " +
            " values " +
            "  <foreach collection=\"list\" index=\"index\" item=\"info\" open=\"\" separator=\",\" close=\"\"> " +
            "  ( " +
            "      #{info.userId}, " +
            "      #{info.recentConsumeDate}, " +
            "      #{info.storeConsumeTime}, " +
            "      #{info.shopConsumeTime}, " +
            "      #{info.assembleConsumeTime}, " +
            "      #{info.storeConsumeDateCollect}, " +
            "      #{info.shopConsumeDateCollect}, " +
            "      #{info.assembleConsumeDateCollect}, " +
            "      NOW() " +
            "    )" +
            "  </foreach>" +
            "</script>")
    int insertUserInfo(@Param("list") List<UserInfo> userInfoList);

讲解点

1.<script> 标签替代 xml 文件
2.<foreach> 标签的使用
3.使用批量插入的好处
4.使用批量插入的风险点

注意点

【强制】在使用in进行动态sql拼接时，一定要考虑应用场景插入的条数，必要时，需要在sevice层做分割。

SpringBoot项目标准化代码编写

一、认识项目结构

1、项目基本结构

2、统一消息返回

二、了解常用规范

1.实体类（以设备表功能为例）

2.DTO类

2.VO类

3.枚举类

三、增删改查标准化写法

1、controller 层级

2、service 层级

2、impl 层级

3、dao层级

3、provider层级

四、来点干的？

1、事务的使用

2、for update 使用（悲观锁）

3、update 更新状态

4、update 更新数值

5、批量操作 in 的使用方法

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Spring Boot