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教程