Java編程技巧之樣板代碼

時間  2021-06-10
標籤 java 數據庫 編程 設計模式 數組 app 框架 工具 學習 開發工具 欄目 Java 简体版
原文   原文鏈接

簡介： 在平常編碼的過程當中，能夠總結出不少「樣板代碼」，就像」活字印刷術中的「活字」同樣。當咱們編寫新的代碼時，須要用到這些「活字」，就把「樣板代碼」拷貝過來，修改替換一下就能夠了，寫起代碼來「極爲神速」。「樣板代碼」其實就是一種樣例、一種模式、一種經驗……總結的「樣板代碼」越多，編寫代碼的格式越規範、質量越高、速度越快。
image.pngjava

做者 | 常意
來源 | 阿里技術公衆號數據庫

前言

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

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

在平常編碼的過程當中，咱們能夠總結出不少"樣板代碼"，就像"活字印刷術"中的"活字"同樣。當咱們編寫新的代碼時，須要用到這些"活字"，就把"樣板代碼"拷貝過來，修改替換一下就能夠了，寫起代碼來"極爲神速"。"樣板代碼"其實就是一種樣例、一種模式、一種經驗……總結的"樣板代碼"越多，編寫代碼的格式越規範、質量越高、速度越快。數組

這裏，做者總結了幾種常見Java的"樣板代碼"，但願起到拋磚引玉的做用，但願你們不斷總結和完善，造成本身的樣板代碼庫。app

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）指能夠做爲一種解決方案。當遇到相似的案例時，就把樣板代碼拷貝過去，根據實際狀況進行修改，該案例就被輕鬆解決了。學習

樣板代碼的主要做用：開發工具

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

1.3. 如何編寫樣板代碼？

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

複製粘貼生成代碼

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

用文本替換生成代碼

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

用Excel公式生成代碼

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

用工具或插件生成代碼

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

用代碼生成代碼

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

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插件掃描，會出現如下問題：

image.png

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插件掃描，會出現如下問題：

image.png

根據建議，應該刪除構造方法前多餘的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類，它一般具備以下特色：

  • 必須具備一個無參的構造方法；
  • 全部屬性字段必須是私有的；
  • 全部屬性字段必須經過遵循一種命名規範的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);

主要優勢：

代碼很是簡單，只有私有屬性字段及其公有Getter/Setter方法；
賦值對象代碼可讀性較強，明確地知道哪一個屬性字段對應哪一個值；
很是簡單實用，被普遍地用於HSF、Dubbo、MyBatis等中間件。
主要缺點：

因爲能夠經過Setter方法設置屬性字段，因此不能定義爲不可變類；
因爲每一個字段分別設置，因此不能保證字段必填，必須設置完畢後進行統一驗證。

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");

主要優勢：

  • 初始化對象代碼簡潔，只有簡單的一行代碼；
  • 能夠定義爲不可變類，初始化後屬性字段值不可變動；
  • 能夠在構造方法內進行不可空驗證。

主要缺點：

  • 重載構造方法數量過多，沒法覆蓋必填字段和非必填字段的全部組合；
  • 初始化對象代碼可讀性差，沒法看出哪一個屬性字段對應哪一個值；
  • 若是刪除某個字段，初始化對象代碼可能不會報錯，致使出現賦值錯誤問題。

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();

主要優勢：

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

主要缺點：

  • 代碼量較大，多定義了一個Builder類，多定義了一套屬性字段，多實現了一套賦值方法；
  • 運行效率低，須要先建立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插件掃描，會出現如下問題：

image.png

因爲普通的集合對象（如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個問題：

image.png

其中，圈複雜度（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個問題：

image.png

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

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;
}

適用條件：

  • 適合於&&（或||）鏈接大量條件表達式的狀況；
  • 適合於每一個條件表達式都須要傳入相同參數的狀況，若是每一個條件表達式傳入參數不一樣，只能使用動態無參數Lambda表達式列表方法；
  • 若是須要傳入兩個參數，可使用BiPredicate類型來接收Lambda表達式；若是須要傳入多個參數，則須要自定義方法接口。

原文連接本文爲阿里雲原創內容，未經容許不得轉載。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程