編碼規范 | 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代碼，刪除有助于代碼維護。

關注高德技術，找到更多出行技術領域專業內容