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

绝地灬酷狼 2022-03-09 01:38 276阅读 0赞

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

*  **先看一下重构之前和之后的代码对比：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70][]

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

/**
     * @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：**

*  应该用lombok简化代码量
 *  方法名应该见名知意
 *  方法参数超过2个，应该用实体来封装

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 1][] ##

**图2：**

*  响应码应该用更有意义的变量来封装
 *  行注释应该代码的阅读与简洁，除非逻辑特别复杂，否则没有必要。
 *  魔数应该用枚举来封装更容易阅读

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 2][] ##

**图3：**

*  try catch 非常影响代码的优雅与简洁，应该抽离其中的代码封装成函数调用。
 *  变量的声明应该在离使用变量最近的地方
 *  引用变量的循环创建，容易导致垃圾回收频繁，从而影响到java的性能。

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 3][] ##

**图4：**

*  一个方法中的代码不宜过长，否则不易阅读，需要加注释才好理解。应该封装成小而精的代码块，比较简洁。

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70][] ##

**开始重构**

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

/**
     * @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.setResultVo(MsgCode.SUCCESS);
                return resultVo;
            }
            List<Order> orders = null;
            try {
                orders = queryOrderListFromMysql(param);
            } catch (Exception e) {
                setErrorMsg(resultVo, e);
                return resultVo;
            }
            if (CollectionUtils.isEmpty(orders)) {
                resultVo.setResultVo(MsgCode.QUERY_ORDER_FAIL);
                return resultVo;
            }
            if (CollectionUtils.isEmpty(getOrderVos(orders))) {
                resultVo.setResultVo(MsgCode.QUERY_ORDER_FAIL);
                return resultVo;
            }
            redisTemplate.opsForValue().set(ORDER_LIST_KEY, JSONObject.toJSONString(getOrderVos(orders)));
            resultVo.setDate(orderVos);
            return resultVo;
        }
    
    
        private List<OrderVo> getOrderVos(List<Order> orders) {
            List<OrderVo> orderVos = new ArrayList<>();
            OrderVo orderVo = null;
            for (Order order : orders) {
                orderVo = new OrderVo();
                BeanUtils.copyProperties(order, orderVo);
                orderVos.add(orderVo);
            }
            return orderVos;
        }
    
        private void setErrorMsg(ResultVo resultVo, Exception e) {
            log.error("查询订单数据异常, {}", e.getMessage());
            resultVo.setResultVo(MsgCode.ERROR);
        }
    
        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;
        }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 4][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70]: /images/20220309/cecc7897a883425292fca4a8050d9139.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 1]: /images/20220309/84a42c5a321d428895031c90061ace40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 2]: /images/20220309/2a59a03b46e64969aca61220014be043.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 3]: /images/20220309/ccfb906716ed4446a625fa757062a0ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODU5ODQ0_size_16_color_FFFFFF_t_70 4]: /images/20220309/32aa22c7b4d34fd0a7fbe0440688c635.png