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

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

前言

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

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

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

這里，作者總結了幾種常見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）指可以作為一種解決方案。當遇到類似的案例時，就把樣板代碼拷貝過去，根據實際情況進行修改，該案例就被輕松解決了。

樣板代碼的主要作用：

提供一種標準樣例：可以用于新人學習，能夠快速上手并使用；

提供一種解決方案：遇到類似案例時，可以快速利用該方案進行解決；

有助于不斷積累經驗：當發現一種樣例代碼時，都會不斷地進行優化，力求達到最佳樣例；

有助于提高代碼質量：樣板代碼必然通過了時間考驗，存在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_userwhere 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 keyRule nameDescription

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 keyRule nameDescription

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類，它通常具有如下特點：

必須具有一個無參的構造方法；

所有屬性字段必須是私有的；

所有屬性字段必須通過遵循一種命名規范的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插件掃描，會出現以下問題：

Rule keyRule nameDescription

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 keyRule nameDescription

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 keyRule nameDescription

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

適用條件：

適合于&&（或||）連接大量條件表達式的情況；

適合于每個條件表達式都需要傳入相同參數的情況，如果每個條件表達式傳入參數不同，只能使用動態無參數Lambda表達式列表方法；

如果需要傳入兩個參數，可以使用BiPredicate類型來接收Lambda表達式；如果需要傳入多個參數，則需要自定義方法接口。

原文鏈接
本文為阿里云原創內容，未經允許不得轉載。

總結

以上是生活随笔為你收集整理的Java编程技巧之样板代码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。