Java編程技巧之樣板代碼

作者 | 常意
來源 | 阿里技術公眾號

前言

北宋科學家沈括在《夢溪筆談》第十八卷《技藝》中這樣描述"活字印刷術"：

慶曆中，有布衣畢昇，又為活版。其法用膠泥刻字，薄如錢脣，每字為一印，火燒令堅……若止印三、二本，未為簡易；若印數十百千本，則極為神速。

在日常編碼的過程中，我們可以總結出很多"樣板代碼"，就像"活字印刷術"中的"活字"一樣。當我們編寫新的代碼時，需要用到這些"活字"，就把"樣板代碼"拷貝過來，修改替換一下就可以了，寫起代碼來"極為神速"。"樣板代碼"其實就是一種樣例、一種模式、一種經驗……總結的"樣板代碼"越多，編寫代碼的格式越規範、質量越高、速度越快。

這裡，作者總結了幾種常見Java的"樣板代碼"，希望起到拋磚引玉的作用，希望大家不斷總結和完善，形成自己的樣板代碼庫。

1. 樣板代碼簡介

1.1. 什麼是樣板代碼？

樣板代碼（Boilerplate Code），通常是指一堆具有固定模式的代碼塊，可以被廣泛地應用到各個程序模塊。

例如，讀取文件就是典型的樣板代碼：

try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
    String line;
    while (Objects.nonNull(line = reader.readLine())) {
        // 處理一行
        ...
    }
} catch (IOException e) {
    String message = String.format("讀取文件(%s)異常", fileName);
    log.error(message, e);
    throw new ExampleException(message, e);
}

1.2. 樣板代碼有什麼用？

樣板（Boilerplate ），可以拆分為樣例（Example）和模式（Pattern）兩個單詞進行理解——樣例（Example）指可以當成一種標準範例，模式（Pattern）指可以作為一種解決方案。當遇到類似的案例時，就把樣板代碼拷貝過去，根據實際情況進行修改，該案例就被輕鬆解決了。

樣板代碼的主要作用：

1. 提供一種標準樣例：可以用於新人學習，能夠快速上手並使用；
2. 提供一種解決方案：遇到類似案例時，可以快速利用該方案進行解決；
3. 有助於不斷積累經驗：當發現一種樣例代碼時，都會不斷地進行優化，力求達到最佳樣例；
4. 有助於提高代碼質量：樣板代碼必然通過了時間考驗，存在BUG和出錯的機率相對比較低；
5. 有助於提高編碼速度：利用樣板代碼編碼，只是複製粘貼修改代碼，編碼速度大幅提高；
6. 有助於統一代碼樣式：心中有了樣板代碼，就能保證每次都寫出統一樣式的代碼。

1.3. 如何編寫樣板代碼？

在作者以前的文章《編碼方法論，賦能你我他》中，有詳細的說明和舉例，這裡不再累述。其中，適合於樣板代碼的編寫方法有：

1. 複製粘貼生成代碼

   利用複製粘貼樣板代碼，用好了編碼會事半功倍。

2. 用文本替換生成代碼

   利用文本替換生成代碼，可以很快生成一段新代碼。

3. 用Excel公式生成代碼

   把樣板代碼先公式化，傳入不同的參數，生成不同的代碼。

4. 用工具或插件生成代碼

   很多開發工具或插件都提供一些工具生成代碼，比如：生成構造方法、重載基類/接口方法、生成Getter/Setter方法、生成toString方法、生成數據庫訪問方法……能夠避免很多手敲代碼。

5. 用代碼生成代碼

   用代碼生成代碼，就是自己編寫代碼，按照自己的樣板代碼格式生成代碼。

1.4. 如何減少樣板代碼？

樣板代碼(Boilerplate Code)具有很大的重複性，通常被認為是一種冗餘而又不得不寫的代碼。其實不然，有些樣板代碼不能減少，只是我們還沒有遇到合適的解決方案而已。通常情況下，我們可以通過以下幾種方式減少樣板代碼：

1.4.1. 利用註解減少樣板代碼

比如，JavaBean模型類中的Getter/Setter就是樣板代碼，我們可以通過Lombok的@Getter/@Setter註解來減少這樣的樣板代碼。

原始代碼：

public class User {
    private Long id;
    ...
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    ...
}

優化代碼：

@Getter
@Setter
public class User {
    private Long id;
    ...
}

1.4.2. 利用框架減少樣板代碼

比如，MyBatis 是一款優秀的持久層框架，封裝了獲取數據庫連接和聲明、設置參數、獲取結果集等所有JDBC操作。MyBatis 可以通過簡單的 XML 或註解來配置和映射原始類型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 對象）為數據庫中的記錄。

原始代碼：

/** 查詢公司員工 */
public List< EmployeeDO> queryEmployee(Long companyId) {
    try (Connection connection = tddlDataSource.getConnection();
        PreparedStatement statement = connection.prepareStatement(QUERY_EMPLOYEE_SQL)) {
        statement.setLong(1, companyId);
        try (ResultSet result = statement.executeQuery()) {
            List< EmployeeDO> employeeList = new ArrayList<>();
            while (result.next()) {
                EmployeeDO employee = new EmployeeDO();
                employee.setId(result.getLong(1));
                employee.setName(result.getString(2));
                ...
                employeeList.add(employee);
            }
            return employeeList;
        }
    } catch (SQLException e) {
        String message = String.format("查詢公司(%s)用戶異常", companyId);
        log.error(message, e);
        throw new ExampleException(message, e);
    }
}

優化代碼：

UserDAO.java：

@Mapper
public interface UserDAO {
    List< EmployeeDO> queryEmployee(@Param("companyId") Long companyId);
}

UserDAO.xml：

< mapper namespace="com.example.repository.UserDAO">
    < select id="queryEmployee" resultType="com.example.repository.UserDO">
        select id
        , name
        ...
        from t_user
        where company_id = #{companyId}
    < /select>
< /mapper>

1.4.3. 利用設計模式減少樣板代碼

利用設計模式，可以把一些重複性代碼進行封裝。比如，上面的讀取文件行模式代碼，就可以用模板方法進行封裝。

原始代碼：

try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
    String line;
    while (Objects.nonNull(line = reader.readLine())) {
        // 處理一行
        ...
    }
} catch (IOException e) {
    String message = String.format("讀取文件(%s)異常", fileName);
    log.error(message, e);
    throw new ExampleException(message, e);
}

優化代碼：

/** 定義方法 */
public static void readLine(String fileName, Consumer< String> lineConsumer) {
    try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
        String line;
        while (Objects.nonNull(line = reader.readLine())) {
            lineConsumer.accept(line);
        }
    } catch (IOException e) {
        String message = String.format("讀取文件(%s)異常", fileName);
        log.error(message, e);
        throw new ExampleException(message, e);
    }
}

// 使用代碼
readLine("example.txt", line -> {
    // 處理一行
    ...
});

1.5. 消滅不了的樣板代碼

如果樣板代碼可以被消滅，那麼世界上就不存在樣板代碼了。即便是上一節提供的減少樣板代碼方法，也不能完全的消滅樣板代碼，因為這些樣板代碼依舊存在於框架和模式的實現中。所以，樣板代碼是消滅不了的。

既然不能消滅樣板代碼，那就應該合理地利用樣板代碼。提煉一段樣板代碼，若只用二三次，未為簡便；若用數十百千次，則極為神速。下面，列舉了幾種常見Java的樣板代碼，描述了樣板代碼在日常編程中如何提煉和使用。

2. 定義工具類

2.1. 常用定義方式

通常，我們會如下定義工具類：

/** 例子工具類 */
public class ExampleHelper {
    /** 常量值 */
    public final static int CONST_VALUE = 123;
    /** 求和方法 */
    public static int sum(int a, int b) {
        return a + b;
    }
}

2.2. 存在一些問題

2.2.1. 修飾符順序不規範

通過SonarLint插件掃描，會出現以下問題：

Rule key	Rule name	Description
java:S1124	Modifiers should be declared in the correct order（修飾符應該以正確的順序聲明）	Reorder the modifiers to comply with the Java Language Specification.（重新排序修飾符以符合Java語言規範。）

Java語言規範建議使用"static final"，而不是"final static"。請記住這麼一條規則：靜態常量，靜態（static）在前，常量（final）在後。

2.2.2. 工具類可以被繼承覆蓋

如果我們定義一個MyExampleHelper來繼承ExampleHelper：

public class MyExampleHelper extends ExampleHelper {
    /** 常量值 */
    public static final int CONST_VALUE = 321;

    /** 求和方法 */
    public static int sum(int a, int b) {
        return a * b;
    }
}

會發現，MyExampleHelper會對ExampleHelper中的常量和方法進行覆蓋，導致我們不知道是不是使用了ExampleHelper中的常量和方法。

對於Apache提供的工具類，很多同學都喜歡定義相同名稱的工具類，並讓這個工具類繼承Apache的工具類，並在這個類中添加自己的實現方法。其實，我是非常不推薦這種做法的，因為你不知道——你調用的是Apache工具類提供的常量和方法，還是被覆蓋的常量和方法。最好的辦法，就是對工具類添加final關鍵字，讓這個工具類不能被繼承和覆蓋。

2.2.3. 工具類可以被實例化

對於ExampleHelper工具類，我們可以這樣使用：

int value = ExampleHelper.CONST_VALUE;
int sum = ExampleHelper.sum(1, 2);

也可以被這樣使用：

ExampleHelper exampleHelper = new ExampleHelper();
int value = exampleHelper.CONST_VALUE;
int sum = exampleHelper.sum(1, 2);

對於工具類來說，沒有必要進行實例化。所以，我們建議添加私有構造方法，並在方法中拋出UnsupportedOperationException（不支持的操作異常）。

2.3. 最佳定義方式

根據以上存在問題及其解決方法，最佳定義的ExampleHelper工具類如下：

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值 */
    public static final int CONST_VALUE = 123;

    /** 構造方法 */
    private ExampleHelper() {
        throw new UnsupportedOperationException();
    }

    /** 求和方法 */
    public static int sum(int a, int b) {
        return a + b;
    }
}

3. 定義枚舉類

3.1. 常用定義方式

通常，我們會如下定義枚舉類：

/** 例子枚舉類 */
public enum ExampleEnum {
    /** 枚舉相關 */
    ONE(1, "one(1)"),
    TWO(2, "two(2)"),
    THREE(3, "two(3)");

    /** 屬性相關 */
    private Integer value;
    private String desc;

    /** 構造方法 */
    private ExampleEnum(Integer value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    /** 獲取取值 */
    public Integer getValue() {
        return value;
    }

    /** 獲取描述 */
    public String getDesc() {
        return desc;
    }
}

3.2. 一些優化建議

3.2.1. 修飾符private可缺省

通過SonarLint插件掃描，會出現以下問題：

Rule key	Rule name	Description
java:S2333	Redundant modifiers should not be used（不應該使用多餘的修飾符）	"private" is redundant in this context.（private在上下文中是多餘的。）

根據建議，應該刪除構造方法前多餘的private修飾符。

3.2.2. 建議使用基礎類型

用包裝類型Integer保存枚舉取值，本身並沒有什麼問題。但是，本著能用基礎類型就用基礎類型的規則，所以建議使用基礎類型int。

3.2.3. 建議使用final字段

假設，我們要實現一個靜態方法，可能一不小心就把枚舉值給修改了：

/** 修改取值 */
public static void modifyValue() {
    for (ExampleEnum value : values()) {
        value.value++;
    }
}

如果調用了modifyValue方法，就會把枚舉值修改，導致應用程序出錯。為了避免這樣的情況出現，我們建議對字段添加final修飾符，從而避免字段值被惡意篡改。

3.3. 最佳定義方式

/** 例子枚舉類 */
public enum ExampleEnum {
    /** 枚舉相關 */
    ONE(1, "one(1)"),
    TWO(2, "two(2)"),
    THREE(3, "two(3)");

    /** 字段相關 */
    private final int value;
    private final String desc;

    /** 構造方法 */
    ExampleEnum(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    /** 獲取取值 */
    public int getValue() {
        return value;
    }

    /** 獲取描述 */
    public String getDesc() {
        return desc;
    }
}

4. 定義模型類

下面，以定義User（用戶）模型類為例，從JavaBean模式、重載構造方法、Builder模式3種方式，來說明模型類的定義方法以及優缺點。

假設：User（用戶）模型類共有4個屬性——id（標識）、name（名稱）、age（年齡）、desc（描述），其中必填屬性為——id（標識）、name（名稱），可填屬性為——age（年齡）、desc（描述）。

4.1. JavaBean模式

JavaBean是一個遵循特定寫法的Java類，它通常具有如下特點：

1. 必須具有一個無參的構造方法；
2. 所有屬性字段必須是私有的；
3. 所有屬性字段必須通過遵循一種命名規範的Getter/Setter方法開放出來。

通過JavaBean模式定義的User（用戶）模型類如下：

/** 用戶類 */
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String desc;

    public Long getId() {return id;}
    public void setId(Long id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Integer getAge() {return age;}
    public vid setAge(Integer age) {this.age = age;}
    public String getDesc() {return desc;}
    public void setDesc(String desc) {this.desc = desc;}
}

注意：也可以通過Lombok的@Getter/@Setter註解生成對應個Getter/Setter方法。

使用代碼：

User user = new User();
user.setId(1L);
user.setName("alibaba");
user.setAge(102);
user.setDesc("test");
verifyUser(user);

主要優點：

1. 代碼非常簡單，只有私有屬性字段及其公有Getter/Setter方法；
2. 賦值對象代碼可讀性較強，明確地知道哪個屬性字段對應哪個值；
3. 非常簡單實用，被廣泛地用於HSF、Dubbo、MyBatis等中間件。

主要缺點：

1. 由於可以通過Setter方法設置屬性字段，所以不能定義為不可變類；
2. 由於每個字段分別設置，所以不能保證字段必填，必須設置完畢後進行統一驗證。

4.2. 重載構造方法

通過"重載構造方法"定義User（用戶）模型類如下：

/** 用戶類 */
public final class User {
    private Long id;
    private String name;
    private Integer age;
    private String desc;

    public User(Long id, String name) {
        this(id, name, null);
    }
    public User(Long id, String name, Integer age) {
        this(id, name, age, null);
    }
    public User(Long id, String name, Integer age, String desc) {
        Assert.notNull(id, "標識不能為空");
        Assert.notNull(name, "名稱不能為空");
        this.id = id;
        this.name = name;
        this.age = age;
        this.desc = desc;
    }

    public Long getId() {return id;}
    public String getName() {return name;}
    public Integer getAge() {return age;}
    public String getDesc() {return desc;}
}

使用代碼：

User user1 = new User(1L, "alibaba");
User user2 = new User(1L, "alibaba", 102, "test");

主要優點：

1. 初始化對象代碼簡潔，只有簡單的一行代碼；
2. 可以定義為不可變類，初始化後屬性字段值不可變更；
3. 可以在構造方法內進行不可空驗證。

主要缺點：

1. 重載構造方法數量過多，無法覆蓋必填字段和非必填字段的所有組合；
2. 初始化對象代碼可讀性差，無法看出哪個屬性字段對應哪個值；
3. 如果刪除某個字段，初始化對象代碼可能不會報錯，導致出現賦值錯誤問題。

4.3. Builder模式

/** 用戶類 */
public final class User {
    private Long id;
    private String name;
    private Integer age;
    private String desc;

    private User(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.age = builder.age;
        this.desc = builder.desc;
    }
    public static Builder newBuilder(Long id, String name) {
        return new Builder(id, name);
    }

    public Long getId() {return id;}
    public String getName() {return name;}
    public Integer getAge() {return age;}
    public String getDesc() {return desc;}

    public static class Builder {
        private Long id;
        private String name;
        private Integer age;
        private String desc;

        private Builder(Long id, String name) {
            Assert.notNull(id, "標識不能為空");
            Assert.notNull(name, "名稱不能為空");
            this.id = id;
            this.name = name;
        }
        public Builder age(Integer age) {
            this.age = age;
            return this;
        }
        public Builder desc(String desc) {
            this.desc = desc;
            return this;
        }
        public User build() {
            return new User(this);
        }
    }
}

注意：可以採用Lombok的@Builder註解簡化代碼。

使用代碼：

User user = User.newBuilder(1L, "alibaba").age(102).desc("test").build();

主要優點：

1. 明確了必填參數和可選參數，在構造方法中進行驗證；
2. 可以定義為不可變類，初始化後屬性字段值不可變更；
3. 賦值代碼可讀性較好，明確知道哪個屬性字段對應哪個值；
4. 支持鏈式方法調用，相比於調用Setter方法，代碼更簡潔。

主要缺點：

1. 代碼量較大，多定義了一個Builder類，多定義了一套屬性字段，多實現了一套賦值方法；
2. 運行效率低，需要先創建Builder實例，再賦值屬性字段，再創建目標實例，最後拷貝屬性字段。

5. 定義集合常量

在編碼中，經常使用到各種集合常量，比如List(列表)常量、Set(集合)常量、Map(映射)常量等。

5.1. 普通定義方式

定義代碼：

最簡單的方法，就是直接定義一個普通的集合常量。

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值列表 */
    public static final List< Integer> CONST_VALUE_LIST = Arrays.asList(1, 2, 3);
    /** 常量值集合 */
    public static final Set< Integer> CONST_VALUE_SET = new HashSet<>(Arrays.asList(1, 2, 3));
    /** 常量值映射 */
    public static final Map< Integer, String> CONST_VALUE_MAP;
    static {
        CONST_VALUE_MAP = new HashMap<>(MapHelper.DEFAULT);
        CONST_VALUE_MAP.put(1, "value1");
        CONST_VALUE_MAP.put(2, "value2");
        CONST_VALUE_MAP.put(3, "value3");
    }
    ...
}

使用代碼：

使用也很方便，直接通過"類名.常量名"使用。

// 使用常量值集合
List< Integer> constValueList = ExampleHelper.CONST_VALUE_LIST;
Set< Integer> constValueSet = ExampleHelper.CONST_VALUE_SET;
Map< Integer, String> constValueMap = ExampleHelper.CONST_VALUE_MAP;

5.2. 存在主要問題

通過SonarLint插件掃描，會出現以下問題：

Rule key	Rule name	Description
java:S2386	Mutable fields should not be "public static"（可變字段不應為“公共靜態”）	Make this member "protected".（將此成員設為“protected”。）

由於普通的集合對象（如ArrayList、HashMap、HashSet等）都是可變集合對象，即便是定義為靜態常量，也可以通過操作方法進行修改。所以，上面方法定義的集合常量，並不是真正意義上的集合常量。其中，Arrays.asList方法生成的內部ArrayList不能執行add/remove/clear方法，但是可以set方法，也屬於可變集合對象。

// 操作常量列表
ExampleHelper.CONST_VALUE_LIST.remove(3); // UnsupportedOperationException
ExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationException
ExampleHelper.CONST_VALUE_LIST.set(1, 20); // [1,20,3]
ExampleHelper.CONST_VALUE_LIST.clear(); // UnsupportedOperationException

// 操作常量集合
ExampleHelper.CONST_VALUE_SET.remove(3); // [1,2]
ExampleHelper.CONST_VALUE_SET.add(3); // [1,2,3]
ExampleHelper.CONST_VALUE_SET.clear(); // []

// 操作常量映射
ExampleHelper.CONST_VALUE_MAP.remove(3); // {1:"value1",2:"value2"}
ExampleHelper.CONST_VALUE_MAP.put(3, "value3"); // {1:"value1",2:"value2",3:"value3"}
ExampleHelper.CONST_VALUE_MAP.clear(); // []

5.3. 最佳定義方式

在JDK中，Collections工具類中提供一套方法，用於把可變集合對象變為不可變（不可修改，修改時會拋出UnsupportedOperationException異常）集合對象。所以，可以利用這套方法定義集合靜態常量。

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值列表 */
    public static final List< Integer> CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3));
    /** 常量值集合 */
    public static final Set< Integer> CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3)));
    /** 常量值映射 */
    public static final Map< Integer, String> CONST_VALUE_MAP;
    static {
        Map< Integer, String> valueMap = new HashMap<>(MapHelper.DEFAULT);
        valueMap.put(1, "value1");
        valueMap.put(2, "value2");
        valueMap.put(3, "value3");
        CONST_VALUE_MAP = Collections.unmodifiableMap(valueMap);
    }
    ...
}

6. 定義數組常量

上一章介紹瞭如何定義集合常量，這一章就來介紹一下如何定義數組常量。

6.1. 定義公有數組常量

定義代碼：

一般人定義數組常量，就會像下面代碼一樣，定義一個公有數組常量。

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值數組 */
    public static final int[] CONST_VALUES = new int[] {1, 2, 3};
    ...
}

使用代碼：

使用也很方便，直接通過"類名.常量名"使用。

// 使用常量值數組
int[] constValues = ExampleHelper.CONST_VALUES;

存在問題：

但是，可以通過下標修改數組值，導致數組常量的值可變。所以，這種方法定義的數組常量，並不是一個真正意義上的數組常量。

// 修改常量值數組
ExampleHelper.CONST_VALUES[1] = 20; // [1, 20, 3]

6.2. 定義公有集合常量

定義代碼：

可以通過上一章定義集合常量的方法，返回一個公有集合常量。

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值列表 */
    public static final List< Integer> CONST_VALUE_LIST =
        Collections.unmodifiableList(Arrays.asList(1, 2, 3));
    ...
}

使用代碼：

要想得到數組常量，就把集合常量轉化為數組常量。

// 使用常量值列表
int[] constValues = ExampleHelper.CONST_VALUE_LIST.stream()
    .mapToInt(Integer::intValue).toArray();

存在問題：

每一次都會把集合常量轉化為數組常量，導致程序運行效率降低。

6.3. 最佳定義方式

最佳法"私有數組常量+公有克隆方法"的解決方案。如下代碼所示：先定義一個私有數組常量，保證不會被外部類使用；在定義一個獲取數組常量方法，並返回一個數組常量的克隆值。

定義代碼：

這裡，提供一個"私有數組常量+公有克隆方法"的解決方案。如下代碼所示：先定義一個私有數組常量，保證不會被外部類使用；在定義一個獲取數組常量方法，並返回一個數組常量的克隆值。

/** 例子工具類 */
public final class ExampleHelper {
    /** 常量值數組 */
    private static final int[] CONST_VALUES = new int[] {1, 2, 3};
    /** 獲取常量值數組方法 */
    public static int[] getConstValues() {
        return CONST_VALUES.clone();
    }
    ...
}

使用代碼：

由於每次返回的是一個克隆數組，即便修改了克隆數組的常量值，也不會導致原始數組常量值的修改。

// 使用常量值方法
int[] constValues = ExampleHelper.getConstValues(); // [1, 2, 3]
constValues[1] = 20; // [1, 20, 3]
constValues = ExampleHelper.getConstValues(); // [1, 2, 3]

7. 定義多條件表達式

7.1. 利用運算符&&（或||）直接拼接

定義代碼：

有時候，我們會判斷很多條件，需求用&&（或||）連接多個條件表達式。

/** 獲取審核結果方法 */
private static Integer getAuditResult(AuditDataVO data) {
    if (isPassed(data.getAuditItem1())
        && isPassed(data.getAuditItem2())
        ...
        && isPassed(data.getAuditItem11())) {
        return AuditResult.PASSED;
    }
    return AuditResult.REJECTED;
}

存在問題：

通過SonarLint插件掃描，會存在2個問題：

Rule key	Rule name	Description
java:S1067	Expressions should not be too complex（表達式不能太複雜）	Reduce the number of conditional operators (11) used in the expression (maximum allowed 3).（減少表達式中使用的條件運算符（11個）的數量（最多允許3個）。）
java:S1541	Methods should not be too complex（方法不能太複雜）	The Cyclomatic Complexity of this method "getAuditResult" is 13 which is greater than 10 authorized.（方法“getAuditResult”的圈複雜度為13，大於10。）

其中，圈複雜度（Cyclomatic complexity，CC）也稱為條件複雜度，是一種衡量代碼複雜度的標準，其符號為V(G)。

麥凱布最早提出一種稱為“基礎路徑測試”（Basis Path Testing）的軟件測試方式，測試程序中的每一線性獨立路徑，所需的測試用例個數即為程序的圈複雜度。

圈複雜度可以用來衡量一個模塊判定結構的複雜程度，其數量上表現為獨立路徑的條數，也可理解為覆蓋所有的可能情況最少使用的測試用例個數。

7.2. 利用運算符=和&&（或||）級聯拼接

定義代碼：

那麼，就把&&（或||）連接符拆開，利用運算符=和&&（或||）級聯進行拼接。

/** 獲取審核結果方法 */
private static AuditResult getAuditResult(AuditDataVO data) {
    boolean isPassed = isPassed(data.getAuditItem1());
    isPassed = isPassed && isPassed(data.getAuditItem2());
    ...
    isPassed = isPassed && isPassed(data.getAuditItem11());
    if (isPassed) {
        return AuditResult.PASSED;
    }
    return AuditResult.REJECTED;
}

存在問題：

通過SonarLint插件掃描，還存在1個問題：

Rule key	Rule name	Description
java:S1541	Methods should not be too complex（方法不能太複雜）	The Cyclomatic Complexity of this method "getAuditResult" is 13 which is greater than 10 authorized.（方法“getAuditResult”的圈複雜度為13，大於10。）

也就是，利用運算符=和&&（或||）級聯進行拼接，並不能減少方法的圈複雜度。

7.3. 利用動態無參數Lambda表達式列表

定義代碼：

下面，利用動態無參數Lambda表達式列表優化，即把每個條件表達式作為BooleanSupplier對象存在列表中，然後依次執行條件表達式得出最後結果。

/** 獲取審核結果方法 */
private static AuditResult getAuditResult(AuditDataVO data) {
    List< BooleanSupplier> supplierList = new ArrayList<>();
    supplierList.add(() -> isPassed(data.getAuditItem1()));
    supplierList.add(() -> isPassed(data.getAuditItem2()));
    ...
    supplierList.add(() -> isPassed(data.getAuditItem11()));
    for (BooleanSupplier supplier : supplierList) {
        if (!supplier.getAsBoolean()) {
            return AuditResult.REJECTED;
        }
    }
    return AuditResult.PASSED;
}

存在問題：

通過SonarLint插件掃描，沒有提示任何問題。但是，每次都動態添加Lambda表達式，就會導致程序效率低下。那麼，有沒有把Lambda表達式靜態化的方法呢？

7.4. 利用靜態有參數Lambda表達式列表

定義代碼：

要想固化Lambda表達式，就必須動態傳入AuditDataVO對象。這裡，採用Predicate<AuditDataVO>來接收Lambda表達式，在Lambda表達式中指定AuditDataVO對象data。然後，在for循環中，依次指定AuditDataVO對象data，並計算表達式的值。

/** 審核結果斷言列表 */
private static final List< Predicate<AuditDataVO>> AUDIT_RESULT_PREDICATE_LIST =
    Collections.unmodifiableList(Arrays.asList(
        data -> isPassed(data.getAuditItem1()),
        data -> isPassed(data.getAuditItem2()),
        ...
        data -> isPassed(data.getAuditItem11())));

/** 獲取審核結果方法 */
private static AuditResult getAuditResult(AuditDataVO data) {
    for (Predicate< AuditDataVO> predicate : AUDIT_RESULT_PREDICATE_LIST) {
        if (!predicate.test(data)) {
            return AuditResult.REJECTED;
        }
    }
    return AuditResult.PASSED;
}

適用條件：

1. 適合於&&（或||）連接大量條件表達式的情況；
2. 適合於每個條件表達式都需要傳入相同參數的情況，如果每個條件表達式傳入參數不同，只能使用動態無參數Lambda表達式列表方法；
3. 如果需要傳入兩個參數，可以使用BiPredicate類型來接收Lambda表達式；如果需要傳入多個參數，則需要自定義方法接口。

後記

明代思想家王陽明在《傳習錄》中說道：

初種根時，只管栽培灌溉，勿作枝想，勿作葉想，勿作花想，勿作實想。懸想何益？但不忘栽培之功，怕沒有枝葉花實？

這也是我們高德研發團隊的人才宗旨——不論學歷、不論經歷、不論年齡、不論性別，只要有緣來到我們的團隊，我們都將一視同仁地“栽培灌溉”；力求讓每一個新人都能夠茁壯成長，綻放出最完美的“枝葉花實”。
我們誠聘各類優秀人才：Java工程師、C++工程師、算法工程師、前端工程師、客戶端工程師。歡迎大家投簡歷到[email protected]，郵件標題格式為“姓名-技術方向-來自阿里技術”。

---

免費領取電子書

《高德技術2020年刊合輯》

高德技術重磅發佈《高德技術2020年刊合輯》電子書，覆蓋了大前端、算法、架構、汽車工程、質量等多個領域，以及數篇高德入選頂會論文的解讀，分享高德在智慧出行上的最佳技術實踐和總結。

掃碼加阿里妹好友，回覆“高德”獲取吧~(若掃碼無效，可直接添加alimei4、alimei5、alimei6、alimei7)