发布于2021-06-14 10:33 阅读(567) 评论(0) 点赞(23) 收藏(2)
简介: 在日常编码的过程中,可以总结出很多“样板代码”,就像”活字印刷术中的“活字”一样。当我们编写新的代码时,需要用到这些“活字”,就把“样板代码”拷贝过来,修改替换一下就可以了,写起代码来“极为神速”。“样板代码”其实就是一种样例、一种模式、一种经验……总结的“样板代码”越多,编写代码的格式越规范、质量越高、速度越快。
作者 | 常意
来源 | 阿里技术公众号
北宋科学家沈括在《梦溪笔谈》第十八卷《技艺》中这样描述"活字印刷术":
庆历中,有布衣毕昇,又为活版。其法用胶泥刻字,薄如钱唇,每字为一印,火烧令坚……若止印三、二本,未为简易;若印数十百千本,则极为神速。
在日常编码的过程中,我们可以总结出很多"样板代码",就像"活字印刷术"中的"活字"一样。当我们编写新的代码时,需要用到这些"活字",就把"样板代码"拷贝过来,修改替换一下就可以了,写起代码来"极为神速"。"样板代码"其实就是一种样例、一种模式、一种经验……总结的"样板代码"越多,编写代码的格式越规范、质量越高、速度越快。
这里,作者总结了几种常见Java的"样板代码",希望起到抛砖引玉的作用,希望大家不断总结和完善,形成自己的样板代码库。
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.3. 如何编写样板代码?
在作者以前的文章《编码方法论,赋能你我他》中,有详细的说明和举例,这里不再累述。其中,适合于样板代码的编写方法有:
利用复制粘贴样板代码,用好了编码会事半功倍。
利用文本替换生成代码,可以很快生成一段新代码。
把样板代码先公式化,传入不同的参数,生成不同的代码。
很多开发工具或插件都提供一些工具生成代码,比如:生成构造方法、重载基类/接口方法、生成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.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.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;
- }
- }
下面,以定义User(用户)模型类为例,从JavaBean模式、重载构造方法、Builder模式3种方式,来说明模型类的定义方法以及优缺点。
假设:User(用户)模型类共有4个属性——id(标识)、name(名称)、age(年龄)、desc(描述),其中必填属性为——id(标识)、name(名称),可填属性为——age(年龄)、desc(描述)。
4.1. JavaBean模式
JavaBean是一个遵循特定写法的Java类,它通常具有如下特点:
通过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);
主要优点:
主要缺点:
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();
主要优点:
主要缺点:
在编码中,经常使用到各种集合常量,比如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.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.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;
- }
适用条件:
原文链接
本文为阿里云原创内容,未经允许不得转载。
原文链接:https://blog.csdn.net/yunqiinsight/article/details/117732155
作者:想要飞翔的天使
链接:http://www.javaheidong.com/blog/article/222764/45fd3a72a24a8a485472/
来源:java黑洞网
任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任
昵称:
评论内容:(最多支持255个字符)
---无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事,而不是让内心的烦躁、焦虑,坏掉你本来就不多的热情和定力
Copyright © 2018-2021 java黑洞网 All Rights Reserved 版权所有,并保留所有权利。京ICP备18063182号-2
投诉与举报,广告合作请联系vgs_info@163.com或QQ3083709327
免责声明:网站文章均由用户上传,仅供读者学习交流使用,禁止用做商业用途。若文章涉及色情,反动,侵权等违法信息,请向我们举报,一经核实我们会立即删除!