編碼規範 | Java函式優雅之道（上）

amap_tech發表於2019-08-08
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程式碼，刪除有助於程式碼維護。

編碼規範 | Java函式優雅之道（上）

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

相關文章