编码规范 | Java函数优雅之道(上)
导读
随着软件项目代码的日积月累,系统维护成本变得越来越高,是所有软件团队面临的共同问题。持续地优化代码,提高代码的质量,是提升系统生命力的有效手段之一。软件系统思维有句话“Less coding, more thinking(少编码、多思考)”,也有这么一句俚语“Think more, code less(思考越多,编码越少)”。所以,我们在编码中多思考多总结,努力提升自己的编码水平,才能编写出更优雅、更高质、更高效的代码。
本文总结了一套与Java函数相关的编码规则,旨在给广大Java程序员一些编码建议,有助于大家编写出更优雅、更高质、更高效的代码。这套编码规则,通过在高德采集部门的实践,已经取得了不错的成效。
使用通用工具函数
案例一
现象描述:
不完善的写法:
thisName != null && thisName.equals(name);
更完善的写法:
(thisName == name) || (thisName != null && thisName.equals(name));
建议方案:
Objects.equals(name, thisName);
案例二
现象描述:
!(list == null || list.isEmpty());
建议方案:
import org.apache.commons.collections4.CollectionUtils; CollectionUtils.isNotEmpty(list);
主要收益
-
函数式编程,业务代码减少,逻辑一目了然;
-
通用工具函数,逻辑考虑周全,出问题概率低。
拆分超大函数
当一个函数超过80行后,就属于超大函数,需要进行拆分。
案例一:每一个代码块都可以封装为一个函
每一个代码块必然有一个注释,用于解释这个代码块的功能。
如果代码块前方有一行注释,就是在提醒你——可以将这段代码替换成一个函数,而且可以在注释的基础上给这个函数命名。如果函数有一个描述恰当的名字,就不需要去看内部代码究竟是如何实现的。
现象描述:
// 每日生活函数 public void liveDaily() { // 吃饭 // 吃饭相关代码几十行 // 编码 // 编码相关代码几十行 // 睡觉 // 睡觉相关代码几十行 }
建议方案:
// 每日生活函数 public void liveDaily() { // 吃饭 eat(); // 编码 code(); // 睡觉 sleep(); } // 吃饭函数 private void eat() { // 吃饭相关代码 } // 编码函数 private void code() { // 编码相关代码 } // 睡觉函数 private void sleep() { // 睡觉相关代码 }
案例二:每一个循环体都可以封装为一个函
现象描述:
// 生活函数 public void live() { while (isAlive) { // 吃饭 eat(); // 编码 code(); // 睡觉 sleep(); } }
建议方案:
// 生活函数 public void live() { while (isAlive) { // 每日生活 liveDaily(); } } // 每日生活函数 private void liveDaily() { // 吃饭 eat(); // 编码 code(); // 睡觉 sleep(); }
案例三:每一个条件体都可以封装为一个函
现象描述:
// 外出函数 public void goOut() { // 判断是否周末 // 判断是否周末: 是周末则游玩 if (isWeekday()) { // 游玩代码几十行 } // 判断是否周末: 非周末则工作 else { // 工作代码几十行 } }
建议方案:
// 外出函数 public void goOut() { // 判断是否周末 // 判断是否周末: 是周末则游玩 if (isWeekday()) { play(); } // 判断是否周末: 非周末则工作 else { work(); } } // 游玩函数 private void play() { // 游玩代码几十行 } // 工作函数 private void work() { // 工作代码几十行 }
主要收益
-
函数越短小精悍,功能就越单一,往往生命周期较长;
-
一个函数越长,就越不容易理解和维护,维护人员不敢轻易修改;
-
在过长函数中,往往含有难以发现的重复代码。
同一函数内代码块级别尽量一致
案例一
现象描述:
// 每日生活函数 public void liveDaily() { // 吃饭 eat(); // 编码 code(); // 睡觉 // 睡觉相关代码几十行 }
很明显,睡觉这块代码块,跟eat(吃饭)和code(编码)不在同一级别上,显得比较突兀。如果把写代码比作写文章,eat(吃饭)和code(编码)是段落大意,而睡觉这块代码块属于一个详细段落。而在liveDaily(每日生活)这个函数上,只需要写出主要流程(段落大意)即可。
建议方案:
public void liveDaily() { // 吃饭 eat(); // 编码 code(); // 睡觉 sleep(); } // 睡觉 private void sleep() { // 睡觉相关代码 }
主要收益
-
函数调用表明用途,函数实现表达逻辑,层次分明便于理解;
-
不用层次的代码块放在一个函数中,容易让人觉得代码头重脚轻。
封装相同功能代码为函数
案例一:封装相同代码为函数
现象描述:
// 禁用用户函数 public void disableUser() { // 禁用黑名单用户 List<Long> userIdList = queryBlackUser(); for (Long userId : userIdList) { User userUpdate = new User(); userUpdate.setId(userId); userUpdate.setEnable(Boolean.FALSE); userDAO.update(userUpdate); } // 禁用过期用户 userIdList = queryExpiredUser(); for (Long userId : userIdList) { User userUpdate = new User(); userUpdate.setId(userId); userUpdate.setEnable(Boolean.FALSE); userDAO.update(userUpdate); } }
建议方案:
// 禁用用户函数 public void disableUser() { // 禁用黑名单用户 List<Long> userIdList = queryBlackUser(); for (Long userId : userIdList) { disableUser(userId); } // 禁用过期用户 userIdList = queryExpiredUser(); for (Long userId : userIdList) { disableUser(userId); } } // 禁用用户函数 private void disableUser(Long userId) { User userUpdate = new User(); userUpdate.setId(userId); userUpdate.setEnable(Boolean.FALSE); userDAO.update(userUpdate); }
案例二:封装相似代码为函数
封装相似代码为函数,差异性通过函数参数控制。
现象描述:
// 通过工单函数 public void adoptOrder(Long orderId) { Order orderUpdate = new Order(); orderUpdate.setId(orderId); orderUpdate.setStatus(OrderStatus.ADOPTED); orderUpdate.setAuditTime(new Date()); orderDAO.update(orderUpdate); } // 驳回工单函数 public void rejectOrder(Long orderId) { Order orderUpdate = new Order(); orderUpdate.setId(orderId); orderUpdate.setStatus(OrderStatus.REJECTED); orderUpdate.setAuditTime(new Date()); orderDAO.update(orderUpdate); }
建议方案:
// 通过工单函数 public void adoptOrder(Long orderId) { auditOrder(orderId, OrderStatus.ADOPTED); } // 驳回工单函数 public void rejectOrder(Long orderId) { auditOrder(orderId, OrderStatus.REJECTED); } // 审核工单函数 private void auditOrder(Long orderId, OrderStatus orderStatus) { Order orderUpdate = new Order(); orderUpdate.setId(orderId); orderUpdate.setStatus(orderStatus); orderUpdate.setAuditTime(new Date()); orderDAO.update(orderUpdate); }
主要收益
-
封装公共函数,减少代码行数,提高代码质量;
-
封装公共函数,使业务代码更精炼,可读性可维护性更强。
封装获取参数值函数
案例一
现象描述:
// 是否通过函数 public boolean isPassed(Long userId) { // 获取通过阈值 double thisPassThreshold = PASS_THRESHOLD; if (Objects.nonNull(passThreshold)) { thisPassThreshold = passThreshold; } // 获取通过率 double passRate = getPassRate(userId); // 判读是否通过 return passRate >= thisPassThreshold; }
建议方案:
// 是否通过函数 public boolean isPassed(Long userId) { // 获取通过阈值 double thisPassThreshold = getPassThreshold(); // 获取通过率 double passRate = getPassRate(userId); // 判读是否通过 return passRate >= thisPassThreshold; } // 获取通过阈值函数 private double getPassThreshold() { if (Objects.nonNull(passThreshold)) { return passThreshold; } return PASS_THRESHOLD; }
主要收益
-
把获取参数值从业务函数中独立,使业务逻辑更清晰;
-
封装的获取参数值为独立函数,可以在代码中重复使用。
通过接口参数化封装相同逻辑
案例一
现象描述:
// 发送审核员结算数据函数 public void sendAuditorSettleData() { List<WorkerSettleData> settleDataList = auditTaskDAO.statAuditorSettleData(); for (WorkerSettleData settleData : settleDataList) { WorkerPushData pushData = new WorkerPushData(); pushData.setId(settleData.getWorkerId()); pushData.setType(WorkerPushDataType.AUDITOR); pushData.setData(settleData); pushService.push(pushData); } } // 发送验收员结算数据函数 public void sendCheckerSettleData() { List<WorkerSettleData> settleDataList = auditTaskDAO.statCheckerSettleData(); for (WorkerSettleData settleData : settleDataList) { WorkerPushData pushData = new WorkerPushData(); pushData.setId(settleData.getWorkerId()); pushData.setType(WorkerPushDataType.CHECKER); pushData.setData(settleData); pushService.push(pushData); }
建议方案:
// 发送审核员结算数据函数 public void sendAuditorSettleData() { sendWorkerSettleData(WorkerPushDataType.AUDITOR, () -> auditTaskDAO.statAuditorSettleData()); } // 发送验收员结算数据函数 public void sendCheckerSettleData() { sendWorkerSettleData(WorkerPushDataType.CHECKER, () -> auditTaskDAO.statCheckerSettleData()); } // 发送作业员结算数据函数 public void sendWorkerSettleData(WorkerPushDataType dataType, WorkerSettleDataProvider dataProvider) { List<WorkerSettleData> settleDataList = dataProvider.statWorkerSettleData(); for (WorkerSettleData settleData : settleDataList) { WorkerPushData pushData = new WorkerPushData(); pushData.setId(settleData.getWorkerId()); pushData.setType(dataType); pushData.setData(settleData); pushService.push(pushData); } } // 作业员结算数据提供者接口 private interface WorkerSettleDataProvider { // 统计作业员结算数据 public List<WorkerSettleData> statWorkerSettleData(); }
主要收益
-
把核心逻辑从各个业务函数中抽析,使业务代码更清晰更易维护;
-
避免重复性代码多次编写,精简重复函数越多收益越大。
减少函数代码层级
如果要使函数优美,建议函数代码层级在1-4之间,过多的缩进会让函数难以阅读。
案例一:利用return提前返回函数
现象描述:
// 获取用户余额函数 public Double getUserBalance(Long userId) { User user = getUser(userId); if (Objects.nonNull(user)) { UserAccount account = user.getAccount(); if (Objects.nonNull(account)) { return account.getBalance(); } } return null; }
建议方案:
// 获取用户余额函数 public Double getUserBalance(Long userId) { // 获取用户信息 User user = getUser(userId); if (Objects.isNull(user)) { return null; } // 获取用户账户 UserAccount account = user.getAccount(); if (Objects.isNull(account)) { return null; } // 返回账户余额 return account.getBalance(); }
案例二:利用continue提前结束循环
现象描述:
// 获取合计余额函数 public double getTotalBalance(List<User> userList) { // 初始合计余额 double totalBalance = 0.0D; // 依次累加余额 for (User user : userList) { // 获取用户账户 UserAccount account = user.getAccount(); if (Objects.nonNull(account)) { // 累加用户余额 Double balance = account.getBalance(); if (Objects.nonNull(balance)) { totalBalance += balance; } } } // 返回合计余额 return totalBalance; }
建议方案:
// 获取合计余额函数 public double getTotalBalance(List<User> userList) { // 初始合计余额 double totalBalance = 0.0D; // 依次累加余额 for (User user : userList) { // 获取用户账户 UserAccount account = user.getAccount(); if (Objects.isNull(account)) { continue; } // 累加用户余额 Double balance = account.getBalance(); if (Objects.nonNull(balance)) { totalBalance += balance; } } // 返回合计余额 return totalBalance; }
特殊说明
其它方式:在循环体中,先调用案例1的函数getUserBalance(获取用户余额),再进行对余额进行累加。
在循环体中,建议最多使用一次continue。如果需要有使用多次continue的需求,建议把循环体封装为一个函数。
案例三:利用条件表达式函数减少层级
请参考下一章的"案例2: 把复杂条件表达式封装为函数"
主要收益
-
代码层级减少,代码缩进减少;
-
模块划分清晰,方便阅读维护。
封装条件表达式函数
案例一:把简单条件表达式封装为函数
现象描述:
// 获取门票价格函数 public double getTicketPrice(Date currDate) { if (Objects.nonNull(currDate) && currDate.after(DISCOUNT_BEGIN_DATE) && currDate.before(DISCOUNT_END_DATE)) { return TICKET_PRICE * DISCOUNT_RATE; } return TICKET_PRICE; }
建议方案:
// 获取门票价格函数 public double getTicketPrice(Date currDate) { if (isDiscountDate(currDate)) { return TICKET_PRICE * DISCOUNT_RATE; } return TICKET_PRICE; } // 是否折扣日期函数 private static boolean isDiscountDate(Date currDate) { return Objects.nonNull(currDate) && currDate.after(DISCOUNT_BEGIN_DATE) && currDate.before(DISCOUNT_END_DATE); }
案例二:把复杂条件表达式封装为函数
现象描述:
// 获取土豪用户列表 public List<User> getRichUserList(List<User> userList) { // 初始土豪用户列表 List<User> richUserList = new ArrayList<>(); // 依次查找土豪用户 for (User user : userList) { // 获取用户账户 UserAccount account = user.getAccount(); if (Objects.nonNull(account)) { // 判断用户余额 Double balance = account.getBalance(); if (Objects.nonNull(balance) && balance.compareTo(RICH_THRESHOLD) >= 0) { // 添加土豪用户 richUserList.add(user); } } } // 返回土豪用户列表 return richUserList; }
建议方案:
// 获取土豪用户列表 public List<User> getRichUserList(List<User> userList) { // 初始土豪用户列表 List<User> richUserList = new ArrayList<>(); // 依次查找土豪用户 for (User user : userList) { // 判断土豪用户 if (isRichUser(user)) { // 添加土豪用户 richUserList.add(user); } } // 返回土豪用户列表 return richUserList; } // 是否土豪用户 private boolean isRichUser(User user) { // 获取用户账户 UserAccount account = user.getAccount(); if (Objects.isNull(account)) { return false; } // 获取用户余额 Double balance = account.getBalance(); if (Objects.isNull(balance)) { return false; } // 比较用户余额 return balance.compareTo(RICH_THRESHOLD) >= 0; }
以上代码也可以用采用流式(Stream)编程的过滤来实现。
主要收益
-
把条件表达式从业务函数中独立,使业务逻辑更清晰;
-
封装的条件表达式为独立函数,可以在代码中重复使用。
尽量避免不必要的空指针判断
本章只适用于项目内部代码,并且是自己了解的代码,才能够尽量避免不必要的空指针判断。对于第三方中间件和系统接口,必须做好空指针判断,以保证代码的健壮性。
案例一:调用函数保证参数不为空,被调用函数尽量避免不必要的空指针判断
现象描述:
// 创建用户信息 User user = new User(); ... // 赋值用户相关信息 createUser(user); // 创建用户函数 private void createUser(User user){ // 判断用户为空 if(Objects.isNull(user)) { return; } // 创建用户信息 userDAO.insert(user); userRedis.save(user); }
建议方案:
// 创建用户信息 User user = new User(); ... // 赋值用户相关信息 createUser(user); // 创建用户函数 private void createUser(User user){ // 创建用户信息 userDAO.insert(user); userRedis.save(user); }
案例二:被调用函数保证返回不为空,调用函数尽量避免不必要的空指针判断
现象描述:
// 保存用户函数 public void saveUser(Long id, String name) { // 构建用户信息 User user = buildUser(id, name); if (Objects.isNull(user)) { throw new BizRuntimeException("构建用户信息为空"); } // 保存用户信息 userDAO.insert(user); userRedis.save(user); } // 构建用户函数 private User buildUser(Long id, String name) { User user = new User(); user.setId(id); user.setName(name); return user; }
建议方案:
// 保存用户函数 public void saveUser(Long id, String name) { // 构建用户信息 User user = buildUser(id, name); // 保存用户信息 userDAO.insert(user); userRedis.save(user); } // 构建用户函数 private User buildUser(Long id, String name) { User user = new User(); user.setId(id); user.setName(name); return user; }
案例三:赋值逻辑保证列表数据项不为空,处理逻辑尽量避免不必要的空指针判断
现象描述:
// 查询用户列表 List<UserDO> userList = userDAO.queryAll(); if (CollectionUtils.isEmpty(userList)) { return; } // 转化用户列表 List<UserVO> userVoList = new ArrayList<>(userList.size()); for (UserDO user : userList) { UserVO userVo = new UserVO(); userVo.setId(user.getId()); userVo.setName(user.getName()); userVoList.add(userVo); } // 依次处理用户 for (UserVO userVo : userVoList) { // 判断用户为空 if (Objects.isNull(userVo)) { continue; } // 处理相关逻辑 ... }
建议方案:
// 查询用户列表 List<UserDO> userList = userDAO.queryAll(); if (CollectionUtils.isEmpty(userList)) { return; } // 转化用户列表 List<UserVO> userVoList = new ArrayList<>(userList.size()); for (UserDO user : userList) { UserVO userVo = new UserVO(); userVo.setId(user.getId()); userVo.setName(user.getName()); userVoList.add(userVo); } // 依次处理用户 for (UserVO userVo : userVoList) { // 处理相关逻辑 ... }
案例四:MyBatis查询函数返回列表和数据项不为空,可以不用空指针判断
MyBatis是一款优秀的持久层框架,是在项目中使用的最广泛的数据库中间件之一。通过对MyBatis源码进行分析,查询函数返回的列表和数据项都不为空,在代码中可以不用进行空指针判断。
现象描述:
这种写法没有问题,只是过于保守了。
// 查询用户函数 public List<UserVO> queryUser(Long id, String name) { // 查询用户列表 List<UserDO> userList = userDAO.query(id, name); if (Objects.isNull(userList)) { return Collections.emptyList(); } // 转化用户列表 List<UserVO> voList = new ArrayList<>(userList.size()); for (UserDO user : userList) { // 判断对象为空 if (Objects.isNull(user)) { continue; } // 添加用户信息 UserVO vo = new UserVO(); BeanUtils.copyProperties(user, vo); voList.add(vo); } // 返回用户列表 return voList; }
建议方案:
// 查询用户函数 public List<UserVO> queryUser(Long id, String name) { // 查询用户列表 List<UserDO> userList = userDAO.query(id, name); // 转化用户列表 List<UserVO> voList = new ArrayList<>(userList.size()); for (UserDO user : userList) { UserVO vo = new UserVO(); BeanUtils.copyProperties(user, vo); voList.add(vo); } // 返回用户列表 return voList; }
主要收益
-
避免不必要的空指针判断,精简业务代码处理逻辑,提高业务代码运行效率;
-
这些不必要的空指针判断,基本属于永远不执行的Death代码,删除有助于代码维护。
关注高德技术,找到更多出行技术领域专业内容
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。
持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。
- 上一篇
一次难得的分库分表实践
背景 前不久发过两篇关于分表的文章: 一次分表踩坑实践的探讨 分表后需要注意的二三事 从标题可以看得出来,当时我们只做了分表;还是由于业务发展,截止到现在也做了分库,目前看来都还比较顺利,所以借着脑子还记得清楚来一次复盘。 <!--more--> 先来回顾下整个分库分表的流程如下: 整个过程也很好理解,基本符合大部分公司的一个发展方向。 很少会有业务一开始就会设计为分库分表,虽说这样会减少后续的坑,但部分公司刚开始都是以业务为主。 直到业务发展到单表无法支撑时,自然而然会考虑分表甚至分库的事情。 于是本篇会作一次总结,之前提过的内容可能会再重复一次。 分表 首先讨论下什么样的情况下适合分表? 根据我的经验来看,当某张表的数据量已经达到千万甚至上亿,同时日增数据量在 2% 以上。 当然这些数字并不是绝对的,最重要的还是对这张表的写入和查询都已经影响到正常业务执行,比如查询速度明显下降,数据库整体 IO 居高不下等。 而谈到分表时我们着重讨论的还是水平分表; 也就是将一张大表数据通过某种路由算法将数据尽可能的均匀分配到 N 张小表中。 Range 而分表策略也有好几种,分别适用...
- 下一篇
四要素落地持续交付
本文通过持续集成、自动化测试、流水线以及自动化部署几个要素介绍宜信的持续交付平台及实践。 一、什么是持续交付 持续交付(Continuous delivery,缩写为 CD),是一种软件工程方法,让软件产品的产出过程在一个短周期内完成,以保证软件可以稳定、持续的保持在随时可以发布的状况。它的目标在于让软件的编译、测试与发布变得更快更频繁。这种方式可以减少软件开发的成本与时间,减少风险。 而我对持续交付的一个较为抽象的理解是“一套软件工程方法论和许多最佳实践的集合”。方法论和实践都需要人去总结落地,所以,要想体会到持续交付的真正含义,就要在实际工作中贯彻和使用实践工具。 二、持续交付的价值 其最大的显性价值是,在实施持续交付后,能够做到在保证交付质量的前提下,加快交付速度,从而更快地得到市场反馈,推动产品的商业价值的实现。在互联网应用盛行、速度为王的今天,持续交付的价值更被突显出来。持续交付的能力,已成为评定一家互联网公司研发能力的重要指标。除显性价值外,如果站在不同角度看持续交付后的变化,我们还会发现一些隐性价值,而其中有一些影响甚至远远超过我们的预期。 1、通过快速灵活统一的环境构建...
相关文章
文章评论
共有0条评论来说两句吧...
文章二维码
点击排行
推荐阅读
最新文章
- Docker安装Oracle12C,快速搭建Oracle学习环境
- CentOS8编译安装MySQL8.0.19
- SpringBoot2整合MyBatis,连接MySql数据库做增删改查操作
- Springboot2将连接池hikari替换为druid,体验最强大的数据库连接池
- CentOS6,CentOS7官方镜像安装Oracle11G
- Jdk安装(Linux,MacOS,Windows),包含三大操作系统的最全安装
- SpringBoot2更换Tomcat为Jetty,小型站点的福音
- CentOS8安装Docker,最新的服务器搭配容器使用
- CentOS8,CentOS7,CentOS6编译安装Redis5.0.7
- 设置Eclipse缩进为4个空格,增强代码规范