一段代码讲透Java所有编程规范（精华版）-转载

转载链接：https://blog.csdn.net/qq_35859844/article/details/88412611?from=timeline&isappinstalled=0

 

本文参考了《代码整洁之道》，《阿里巴巴编程规范》，《华为编程规范》以及大量优秀的源码总结而来。简洁，优雅的代码根本不需要一行注释。

这是一段根据条件查询订单列表的代码，咋一看好像没有什么问题。但是，一个个来讲其中的问题。

/**
 * @Author: guandezhi
 * @Date: 2019/3/11 22:30
 */
@Service
public class OrderServiceImpl implements OrderService {
 
    public static final String ORDER_LIST_KEY = "orderList";
 
    private Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
 
    @Autowired
    private OrderMapper orderMapper;
 
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
 
    /**
     * 根据查询条件，
     * 查询订单列表，
     * 获取所需字段
     *
     * @param orderNo
     * @param orderStatus
     * @param payStatus
     * @param createTime
     * @return
     */
    @Override
    public ResultVo<List<Order>> query(String orderNo, Integer orderStatus, Integer payStatus, Date createTime) {
        ResultVo resultVo = new ResultVo();
        List<OrderVo> orderVos = null;
        //查询缓存
        String orderListStr = redisTemplate.opsForValue().get(ORDER_LIST_KEY);
        if (StringUtils.isNotEmpty(orderListStr)) {
            List<Order> orderList = JSONObject.parseArray(orderListStr, Order.class);
            if (CollectionUtils.isNotEmpty(orderList)) {
                resultVo.setResultCode(200);
                resultVo.setResultMsg("查询缓存成功");
                resultVo.setDate(orderList);
                return resultVo;
            }
        }
        try {
            //设置查询条件
            OrderExample example = new OrderExample();
            OrderExample.Criteria criteria = example.createCriteria();
            if (StringUtils.isNotEmpty(orderNo)) {
                criteria.andOrderNoEqualTo(orderNo);
            }
            if (orderStatus != null) {
                if (orderStatus == 10) {
                    criteria.andOrderStatusNotEqualTo(orderStatus);
                } else if (orderStatus == 20) {
                    criteria.andOrderStatusEqualTo(orderStatus);
                }
            }
            if (payStatus != null) {
                criteria.andPayStatusGreaterThan(payStatus);
            }
            if (createTime != null) {
                criteria.andCreateTimeEqualTo(createTime);
            }
            //查询数据库
            List<Order> orderList = orderMapper.selectByExample(example);
            if (CollectionUtils.isNotEmpty(orderList)) {
                orderVos = new ArrayList<>();
                for (Order order : orderList) {
                    OrderVo orderVo = new OrderVo();
                    BeanUtils.copyProperties(order, orderVo);
                    orderVos.add(orderVo);
                }
            }
 
            String orderListJson = JSONObject.toJSONString(orderList);
            if (CollectionUtils.isNotEmpty(orderVos)) {
                redisTemplate.opsForValue().set(ORDER_LIST_KEY, orderListJson);
            }
            resultVo.setResultCode(200);
            resultVo.setDate(orderList);
        } catch (Exception e) {
            logger.error("查询订单数据异常, {}", e.getMessage());
            resultVo.setResultCode(500);
            resultVo.setResultMsg("查询订单数据异常");
        }
        return resultVo;
    }

问题1.日志可以简化，方法名应该见名知意，方法参数超过2个应该封装。

问题2.去掉多余的行注释，让代码解释代码，增强代码可读性，利用枚举封装魔数。

问题3.try catch非常影响代码的美观，变量声明应该最靠近变量使用的地方。

问题4.删除多余临时变量

问题5.一个方法代码有点过长，封装性不够好，影响代码的阅读。

开始重构

    a.重构之后的代码简直溜达飞起，简洁，清晰

/**
 * @Author: guandezhi
 * @Date: 2019/3/11 22:30
 */
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
 
    public static final String ORDER_LIST_KEY = "orderList";
 
 
    @Autowired
    private OrderMapper orderMapper;
 
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
 
    /**
     * 根据查询条件，
     * 查询订单列表，
     * 获取所需字段
     *
     * @param param
     * @return
     */
    @Override
    public ResultVo<List<Order>> queryOrderList(QueryOrderListParam param) {
        ResultVo resultVo = new ResultVo();
        List<OrderVo> orderVos = queryOrderListFromCache();
        if (CollectionUtils.isNotEmpty(orderVos)) {
            resultVo.setDate(orderVos);
            resultVo.setResultCode(MsgCodeEnum.SUCCESS.getCode());
            resultVo.setResultMsg(MsgCodeEnum.SUCCESS.getMsg());
            return resultVo;
        }
 
        List<Order> orders = null;
        try {
            orders = queryOrderListFromMysql(param);
        } catch (Exception e) {
            setErrorMsg(resultVo, e);
            return resultVo;
        }
 
        if (CollectionUtils.isEmpty(orders)) {
            resultVo.setResultCode(MsgCodeEnum.FAIL.getCode());
            resultVo.setResultMsg(MsgCodeEnum.FAIL.getMsg());
            return resultVo;
        }
 
        OrderVo orderVo = null;
        for (Order order : orders) {
            orderVo = new OrderVo();
            BeanUtils.copyProperties(order, orderVo);
            orderVos.add(orderVo);
        }
 
        if (CollectionUtils.isEmpty(orderVos)) {
            resultVo.setResultCode(MsgCodeEnum.FAIL.getCode());
            resultVo.setResultMsg(MsgCodeEnum.FAIL.getMsg());
            return resultVo;
        }
        redisTemplate.opsForValue().set(ORDER_LIST_KEY, JSONObject.toJSONString(orderVos));
        resultVo.setResultCode(MsgCodeEnum.SUCCESS.getCode());
        resultVo.setDate(orderVos);
        return resultVo;
    }
 
    private void setErrorMsg(ResultVo resultVo, Exception e) {
        log.error("查询订单数据异常, {}", e.getMessage());
        resultVo.setResultCode(MsgCodeEnum.ERROR.getCode());
        resultVo.setResultMsg(MsgCodeEnum.ERROR.getMsg());
    }
 
    private List<Order> queryOrderListFromMysql(QueryOrderListParam param) {
        List<Order> orderList = orderMapper.selectByExample(getQueryCondition(param));
        return orderList;
    }
 
    private OrderExample getQueryCondition(QueryOrderListParam param) {
        OrderExample example = new OrderExample();
        OrderExample.Criteria criteria = example.createCriteria();
        if (StringUtils.isNotEmpty(param.getOrderNo())) {
            criteria.andOrderNoEqualTo(param.getOrderNo());
        }
        if (param.getOrderStatus() != null) {
            if (OrderStatusEnum.CANCLE_ORDER.getOrderStatus().equals(param.getOrderStatus())) {
                criteria.andOrderStatusNotEqualTo(param.getOrderStatus());
            } else if (OrderStatusEnum.FINISH_ORDER.getOrderStatus().equals(param.getOrderStatus())) {
                criteria.andOrderStatusEqualTo(param.getOrderStatus());
            }
        }
        if (param.getPayStatus() != null) {
            criteria.andPayStatusGreaterThan(param.getPayStatus());
        }
        if (param.getCreateTime() != null) {
            criteria.andCreateTimeEqualTo(param.getCreateTime());
        }
        return example;
    }
 
    private List<OrderVo> queryOrderListFromCache() {
        String orderListStr = redisTemplate.opsForValue().get(ORDER_LIST_KEY);
        if (StringUtils.isNotEmpty(orderListStr)) {
            return JSONObject.parseArray(orderListStr, OrderVo.class);
        }
        return null;
    }

b.重构之后的主方法，逻辑非常清晰，根本不需要一行注释