zoukankan      html  css  js  c++  java

  • Java编程技巧之样板代码

    简介： 在日常编码的过程中，可以总结出很多“样板代码”，就像”活字印刷术中的“活字”一样。当我们编写新的代码时，需要用到这些“活字”，就把“样板代码”拷贝过来，修改替换一下就可以了，写起代码来“极为神速”。“样板代码”其实就是一种样例、一种模式、一种经验……总结的“样板代码”越多，编写代码的格式越规范、质量越高、速度越快。

    image.png

    作者 | 常意
    来源 | 阿里技术公众号

    前言

    北宋科学家沈括在《梦溪笔谈》第十八卷《技艺》中这样描述"活字印刷术"：

    庆历中，有布衣毕昇，又为活版。其法用胶泥刻字，薄如钱唇，每字为一印，火烧令坚……若止印三、二本，未为简易；若印数十百千本，则极为神速。

    在日常编码的过程中，我们可以总结出很多"样板代码"，就像"活字印刷术"中的"活字"一样。当我们编写新的代码时，需要用到这些"活字"，就把"样板代码"拷贝过来，修改替换一下就可以了，写起代码来"极为神速"。"样板代码"其实就是一种样例、一种模式、一种经验……总结的"样板代码"越多，编写代码的格式越规范、质量越高、速度越快。

    这里，作者总结了几种常见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 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类，它通常具有如下特点：

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

    适用条件：

    1. 适合于&&（或||）连接大量条件表达式的情况；
    2. 适合于每个条件表达式都需要传入相同参数的情况，如果每个条件表达式传入参数不同，只能使用动态无参数Lambda表达式列表方法；
    3. 如果需要传入两个参数，可以使用BiPredicate类型来接收Lambda表达式；如果需要传入多个参数，则需要自定义方法接口。

    原文链接
    本文为阿里云原创内容，未经允许不得转载。
  • 相关阅读:
    [BJOI2019] 光线
    C# 从零开始写 SharpDx 应用 笔刷
    BAT 脚本判断当前系统是 x86 还是 x64 系统
    BAT 脚本判断当前系统是 x86 还是 x64 系统
    win2d 通过 CanvasActiveLayer 画出透明度和裁剪
    win2d 通过 CanvasActiveLayer 画出透明度和裁剪
    PowerShell 拿到显卡信息
    PowerShell 拿到显卡信息
    win10 uwp 如何使用DataTemplate
    win10 uwp 如何使用DataTemplate
  • 原文地址：https://www.cnblogs.com/yunqishequ/p/14865772.html
Copyright © 2011-2022 走看看