|
|
|
|
公众号矩阵
创建专栏

Java编程技巧之样板代码

在日常编码的过程中,我们可以总结出很多“样板代码”,就像”活字印刷术中的“活字”一样。当我们编写新的代码时,需要用到这些“活字”,就把“样板代码”拷贝过来,修改替换一下就可以了,写起代码来“极为神速”。

作者:阿里技术|2021-06-10 11:05

前言

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

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

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

这里,作者总结了几种常见Java的“样板代码”,希望起到抛砖引玉的作用,希望大家不断总结和完善,形成自己的样板代码库。

一 样板代码简介

1 什么是样板代码?

样板代码(Boilerplate Code),通常是指一堆具有固定模式的代码块,可以被广泛地应用到各个程序模块。

例如,读取文件就是典型的样板代码:

  1. try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) { 
  2.     String line; 
  3.     while (Objects.nonNull(line = reader.readLine())) { 
  4.         // 处理一行 
  5.         ... 
  6.     } 
  7. } catch (IOException e) { 
  8.     String message = String.format("读取文件(%s)异常", fileName); 
  9.     log.error(message, e); 
  10.     throw new ExampleException(message, e); 

2 样板代码有什么用?

样板(Boilerplate ),可以拆分为样例(Example)和模式(Pattern)两个单词进行理解——样例(Example)指可以当成一种标准范例,模式(Pattern)指可以作为一种解决方案。当遇到类似的案例时,就把样板代码拷贝过去,根据实际情况进行修改,该案例就被轻松解决了。

样板代码的主要作用:

  1. 提供一种标准样例:可以用于新人学习,能够快速上手并使用;
  2. 提供一种解决方案:遇到类似案例时,可以快速利用该方案进行解决;
  3. 有助于不断积累经验:当发现一种样例代码时,都会不断地进行优化,力求达到最佳样例;
  4. 有助于提高代码质量:样板代码必然通过了时间考验,存在BUG和出错的几率相对比较低;
  5. 有助于提高编码速度:利用样板代码编码,只是复制粘贴修改代码,编码速度大幅提高;
  6. 有助于统一代码样式:心中有了样板代码,就能保证每次都写出统一样式的代码。

3 如何编写样板代码?

在作者以前的文章《这6种编码方法,你掌握了几个?》中,有详细的说明和举例,这里不再累述。其中,适合于样板代码的编写方法有:

复制粘贴生成代码:利用复制粘贴样板代码,用好了编码会事半功倍。

用文本替换生成代码:利用文本替换生成代码,可以很快生成一段新代码。

用Excel公式生成代码:把样板代码先公式化,传入不同的参数,生成不同的代码。

用工具或插件生成代码:很多开发工具或插件都提供一些工具生成代码,比如:生成构造方法、重载基类/接口方法、生成Getter/Setter方法、生成toString方法、生成数据库访问方法……能够避免很多手敲代码。

用代码生成代码:用代码生成代码,就是自己编写代码,按照自己的样板代码格式生成代码。

4 如何减少样板代码?

样板代码(Boilerplate Code)具有很大的重复性,通常被认为是一种冗余而又不得不写的代码。其实不然,有些样板代码不能减少,只是我们还没有遇到合适的解决方案而已。通常情况下,我们可以通过以下几种方式减少样板代码:

利用注解减少样板代码

比如,JavaBean模型类中的Getter/Setter就是样板代码,我们可以通过Lombok的@Getter/@Setter注解来减少这样的样板代码。

原始代码:

  1. public class User { 
  2.     private Long id; 
  3.     ... 
  4.     public Long getId() { 
  5.         return id; 
  6.     } 
  7.     public void setId(Long id) { 
  8.         this.id = id; 
  9.     } 
  10.     ... 

优化代码:

  1. @Getter 
  2. @Setter 
  3. public class User { 
  4.     private Long id; 
  5.     ... 

利用框架减少样板代码

比如,MyBatis 是一款优秀的持久层框架,封装了获取数据库连接和声明、设置参数、获取结果集等所有JDBC操作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

原始代码:

  1. /** 查询公司员工 */ 
  2. public List<EmployeeDO> queryEmployee(Long companyId) { 
  3.     try (Connection connection = tddlDataSource.getConnection(); 
  4.         PreparedStatement statement = connection.prepareStatement(QUERY_EMPLOYEE_SQL)) { 
  5.         statement.setLong(1, companyId); 
  6.         try (ResultSet result = statement.executeQuery()) { 
  7.             List<EmployeeDO> employeeList = new ArrayList<>(); 
  8.             while (result.next()) { 
  9.                 EmployeeDO employee = new EmployeeDO(); 
  10.                 employee.setId(result.getLong(1)); 
  11.                 employee.setName(result.getString(2)); 
  12.                 ... 
  13.                 employeeList.add(employee); 
  14.             } 
  15.             return employeeList; 
  16.         } 
  17.     } catch (SQLException e) { 
  18.         String message = String.format("查询公司(%s)用户异常", companyId); 
  19.         log.error(message, e); 
  20.         throw new ExampleException(message, e); 
  21.     } 

优化代码:

1)UserDAO.java

  1. @Mapper 
  2. public interface UserDAO { 
  3.     List<EmployeeDO> queryEmployee(@Param("companyId") Long companyId); 

2)UserDAO.xml

  1. <mapper namespace="com.example.repository.UserDAO"
  2.     <select id="queryEmployee" resultType="com.example.repository.UserDO"
  3.         select id 
  4.         , name 
  5.         ... 
  6.         from t_user 
  7.         where company_id = #{companyId} 
  8.     </select
  9. </mapper> 

利用设计模式减少样板代码

利用设计模式,可以把一些重复性代码进行封装。比如,上面的读取文件行模式代码,就可以用模板方法进行封装。

原始代码:

  1. try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) { 
  2.     String line; 
  3.     while (Objects.nonNull(line = reader.readLine())) { 
  4.         // 处理一行 
  5.         ... 
  6.     } 
  7. } catch (IOException e) { 
  8.     String message = String.format("读取文件(%s)异常", fileName); 
  9.     log.error(message, e); 
  10.     throw new ExampleException(message, e); 

优化代码:

  1. /** 定义方法 */ 
  2. public static void readLine(String fileName, Consumer<String> lineConsumer) { 
  3.     try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) { 
  4.         String line; 
  5.         while (Objects.nonNull(line = reader.readLine())) { 
  6.             lineConsumer.accept(line); 
  7.         } 
  8.     } catch (IOException e) { 
  9.         String message = String.format("读取文件(%s)异常", fileName); 
  10.         log.error(message, e); 
  11.         throw new ExampleException(message, e); 
  12.     } 
  13.  
  14. // 使用代码 
  15. readLine("example.txt", line -> { 
  16.     // 处理一行 
  17.     ... 
  18. }); 

5 消灭不了的样板代码

如果样板代码可以被消灭,那么世界上就不存在样板代码了。即便是上一节提供的减少样板代码方法,也不能完全的消灭样板代码,因为这些样板代码依旧存在于框架和模式的实现中。所以,样板代码是消灭不了的。

既然不能消灭样板代码,那就应该合理地利用样板代码。提炼一段样板代码,若只用二三次,未为简便;若用数十百千次,则极为神速。下面,列举了几种常见Java的样板代码,描述了样板代码在日常编程中如何提炼和使用。

二 定义工具类

1 常用定义方式

通常,我们会如下定义工具类:

  1. /** 例子工具类 */ 
  2. public class ExampleHelper { 
  3.     /** 常量值 */ 
  4.     public final static int CONST_VALUE = 123; 
  5.     /** 求和方法 */ 
  6.     public static int sum(int a, int b) { 
  7.         return a + b; 
  8.     } 

2 存在一些问题

修饰符顺序不规范

通过SonarLint插件扫描,会出现以下问题:

Java语言规范建议使用”static final”,而不是”final static”。请记住这么一条规则:静态常量,静态(static)在前,常量(final)在后。

工具类可以被继承覆盖

如果我们定义一个MyExampleHelper来继承ExampleHelper:

  1. public class MyExampleHelper extends ExampleHelper { 
  2.     /** 常量值 */ 
  3.     public static final int CONST_VALUE = 321; 
  4.  
  5.     /** 求和方法 */ 
  6.     public static int sum(int a, int b) { 
  7.         return a * b; 
  8.     } 

会发现,MyExampleHelper会对ExampleHelper中的常量和方法进行覆盖,导致我们不知道是不是使用了ExampleHelper中的常量和方法。

对于Apache提供的工具类,很多同学都喜欢定义相同名称的工具类,并让这个工具类继承Apache的工具类,并在这个类中添加自己的实现方法。其实,我是非常不推荐这种做法的,因为你不知道——你调用的是Apache工具类提供的常量和方法,还是被覆盖的常量和方法。最好的办法,就是对工具类添加final关键字,让这个工具类不能被继承和覆盖。

工具类可以被实例化

对于ExampleHelper工具类,我们可以这样使用:

  1. int value = ExampleHelper.CONST_VALUE; 
  2. int sum = ExampleHelper.sum(1, 2); 

也可以被这样使用:

  1. ExampleHelper exampleHelper = new ExampleHelper(); 
  2. int value = exampleHelper.CONST_VALUE; 
  3. int sum = exampleHelper.sum(1, 2); 

对于工具类来说,没有必要进行实例化。所以,我们建议添加私有构造方法,并在方法中抛出UnsupportedOperationException(不支持的操作异常)。

3 最佳定义方式

根据以上存在问题及其解决方法,最佳定义的ExampleHelper工具类如下:

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值 */ 
  4.     public static final int CONST_VALUE = 123; 
  5.  
  6.     /** 构造方法 */ 
  7.     private ExampleHelper() { 
  8.         throw new UnsupportedOperationException(); 
  9.     } 
  10.  
  11.     /** 求和方法 */ 
  12.     public static int sum(int a, int b) { 
  13.         return a + b; 
  14.     } 

三 定义枚举类

1 常用定义方式

通常,我们会如下定义枚举类:

  1. /** 例子枚举类 */ 
  2. public enum ExampleEnum { 
  3.     /** 枚举相关 */ 
  4.     ONE(1, "one(1)"), 
  5.     TWO(2, "two(2)"), 
  6.     THREE(3, "two(3)"); 
  7.  
  8.     /** 属性相关 */ 
  9.     private Integer value; 
  10.     private String desc
  11.  
  12.     /** 构造方法 */ 
  13.     private ExampleEnum(Integer value, String desc) { 
  14.         this.value = value; 
  15.         this.desc = desc
  16.     } 
  17.  
  18.     /** 获取取值 */ 
  19.     public Integer getValue() { 
  20.         return value; 
  21.     } 
  22.  
  23.     /** 获取描述 */ 
  24.     public String getDesc() { 
  25.         return desc
  26.     } 

2 一些优化建议

修饰符private可缺省

通过SonarLint插件扫描,会出现以下问题:

根据建议,应该删除构造方法前多余的private修饰符。

建议使用基础类型

用包装类型Integer保存枚举取值,本身并没有什么问题。但是,本着能用基础类型就用基础类型的规则,所以建议使用基础类型int。

建议使用final字段

假设,我们要实现一个静态方法,可能一不小心就把枚举值给修改了:

  1. /** 修改取值 */ 
  2. public static void modifyValue() { 
  3.     for (ExampleEnum value : values()) { 
  4.         value.value++; 
  5.     } 

如果调用了modifyValue方法,就会把枚举值修改,导致应用程序出错。为了避免这样的情况出现,我们建议对字段添加final修饰符,从而避免字段值被恶意篡改。

3 最佳定义方式

  1. /** 例子枚举类 */ 
  2. public enum ExampleEnum { 
  3.     /** 枚举相关 */ 
  4.     ONE(1, "one(1)"), 
  5.     TWO(2, "two(2)"), 
  6.     THREE(3, "two(3)"); 
  7.  
  8.     /** 字段相关 */ 
  9.     private final int value; 
  10.     private final String desc
  11.  
  12.     /** 构造方法 */ 
  13.     ExampleEnum(int value, String desc) { 
  14.         this.value = value; 
  15.         this.desc = desc
  16.     } 
  17.  
  18.     /** 获取取值 */ 
  19.     public int getValue() { 
  20.         return value; 
  21.     } 
  22.  
  23.     /** 获取描述 */ 
  24.     public String getDesc() { 
  25.         return desc
  26.     } 

四 定义模型类

下面,以定义User(用户)模型类为例,从JavaBean模式、重载构造方法、Builder模式3种方式,来说明模型类的定义方法以及优缺点。

假设:User(用户)模型类共有4个属性——id(标识)、name(名称)、age(年龄)、desc(描述),其中必填属性为——id(标识)、name(名称),可填属性为——age(年龄)、desc(描述)。

1 JavaBean模式

JavaBean是一个遵循特定写法的Java类,它通常具有如下特点:

  1. 必须具有一个无参的构造方法;
  2. 所有属性字段必须是私有的;
  3. 所有属性字段必须通过遵循一种命名规范的Getter/Setter方法开放出来。

通过JavaBean模式定义的User(用户)模型类如下:

  1. /** 用户类 */ 
  2. public class User { 
  3.     private Long id; 
  4.     private String name
  5.     private Integer age; 
  6.     private String desc
  7.  
  8.     public Long getId() {return id;} 
  9.     public void setId(Long id) {this.id = id;} 
  10.     public String getName() {return name;} 
  11.     public void setName(String name) {this.name = name;} 
  12.     public Integer getAge() {return age;} 
  13.     public vid setAge(Integer age) {this.age = age;} 
  14.     public String getDesc() {return desc;} 
  15.     public void setDesc(String desc) {this.desc = desc;} 

注意:也可以通过Lombok的@Getter/@Setter注解生成对应个Getter/Setter方法。

使用代码:

  1. User user = new User(); 
  2. user.setId(1L); 
  3. user.setName("alibaba"); 
  4. user.setAge(102); 
  5. user.setDesc("test"); 
  6. verifyUser(user); 

主要优点:

  1. 代码非常简单,只有私有属性字段及其公有Getter/Setter方法;
  2. 赋值对象代码可读性较强,明确地知道哪个属性字段对应哪个值;
  3. 非常简单实用,被广泛地用于HSF、Dubbo、MyBatis等中间件。

主要缺点:

  • 由于可以通过Setter方法设置属性字段,所以不能定义为不可变类;
  • 由于每个字段分别设置,所以不能保证字段必填,必须设置完毕后进行统一验证。

2 重载构造方法

通过”重载构造方法”定义User(用户)模型类如下:

  1. /** 用户类 */ 
  2. public final class User { 
  3.     private Long id; 
  4.     private String name
  5.     private Integer age; 
  6.     private String desc
  7.  
  8.     public User(Long id, String name) { 
  9.         this(id, namenull); 
  10.     } 
  11.     public User(Long id, String nameInteger age) { 
  12.         this(id, name, age, null); 
  13.     } 
  14.     public User(Long id, String nameInteger age, String desc) { 
  15.         Assert.notNull(id, "标识不能为空"); 
  16.         Assert.notNull(name"名称不能为空"); 
  17.         this.id = id; 
  18.         this.name = name
  19.         this.age = age; 
  20.         this.desc = desc
  21.     } 
  22.  
  23.     public Long getId() {return id;} 
  24.     public String getName() {return name;} 
  25.     public Integer getAge() {return age;} 
  26.     public String getDesc() {return desc;} 

使用代码:

  1. User user1 = new User(1L, "alibaba"); 
  2.  
  3. User user2 = new User(1L, "alibaba", 102, "test"); 

主要优点:

  1. 初始化对象代码简洁,只有简单的一行代码;
  2. 可以定义为不可变类,初始化后属性字段值不可变更;
  3. 可以在构造方法内进行不可空验证。

主要缺点:

  1. 重载构造方法数量过多,无法覆盖必填字段和非必填字段的所有组合;
  2. 初始化对象代码可读性差,无法看出哪个属性字段对应哪个值;
  3. 如果删除某个字段,初始化对象代码可能不会报错,导致出现赋值错误问题。

3 Builder模式

  1. /** 用户类 */ 
  2. public final class User { 
  3.     private Long id; 
  4.     private String name
  5.     private Integer age; 
  6.     private String desc
  7.  
  8.     private User(Builder builder) { 
  9.         this.id = builder.id; 
  10.         this.name = builder.name
  11.         this.age = builder.age; 
  12.         this.desc = builder.desc
  13.     } 
  14.     public static Builder newBuilder(Long id, String name) { 
  15.         return new Builder(id, name); 
  16.     } 
  17.  
  18.     public Long getId() {return id;} 
  19.     public String getName() {return name;} 
  20.     public Integer getAge() {return age;} 
  21.     public String getDesc() {return desc;} 
  22.  
  23.     public static class Builder { 
  24.         private Long id; 
  25.         private String name
  26.         private Integer age; 
  27.         private String desc
  28.  
  29.         private Builder(Long id, String name) { 
  30.             Assert.notNull(id, "标识不能为空"); 
  31.             Assert.notNull(name"名称不能为空"); 
  32.             this.id = id; 
  33.             this.name = name
  34.         } 
  35.         public Builder age(Integer age) { 
  36.             this.age = age; 
  37.             return this; 
  38.         } 
  39.         public Builder desc(String desc) { 
  40.             this.desc = desc
  41.             return this; 
  42.         } 
  43.         public User build() { 
  44.             return new User(this); 
  45.         } 
  46.     } 

注意:可以采用Lombok的@Builder注解简化代码。

使用代码:

  1. User user = User.newBuilder(1L, "alibaba").age(102).desc("test").build(); 

主要优点:

  1. 明确了必填参数和可选参数,在构造方法中进行验证;
  2. 可以定义为不可变类,初始化后属性字段值不可变更;
  3. 赋值代码可读性较好,明确知道哪个属性字段对应哪个值;
  4. 支持链式方法调用,相比于调用Setter方法,代码更简洁。

主要缺点:

  1. 代码量较大,多定义了一个Builder类,多定义了一套属性字段,多实现了一套赋值方法;
  2. 运行效率低,需要先创建Builder实例,再赋值属性字段,再创建目标实例,最后拷贝属性字段。

五 定义集合常量

在编码中,经常使用到各种集合常量,比如List(列表)常量、Set(集合)常量、Map(映射)常量等。

1 普通定义方式

定义代码:

最简单的方法,就是直接定义一个普通的集合常量。

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值列表 */ 
  4.     public static final List<Integer> CONST_VALUE_LIST = Arrays.asList(1, 2, 3); 
  5.     /** 常量值集合 */ 
  6.     public static final Set<Integer> CONST_VALUE_SET = new HashSet<>(Arrays.asList(1, 2, 3)); 
  7.     /** 常量值映射 */ 
  8.     public static final Map<Integer, String> CONST_VALUE_MAP; 
  9.     static { 
  10.         CONST_VALUE_MAP = new HashMap<>(MapHelper.DEFAULT); 
  11.         CONST_VALUE_MAP.put(1, "value1"); 
  12.         CONST_VALUE_MAP.put(2, "value2"); 
  13.         CONST_VALUE_MAP.put(3, "value3"); 
  14.     } 
  15.     ... 

使用代码:

使用也很方便,直接通过”类名.常量名”使用。

  1. // 使用常量值集合 
  2. List<Integer> constValueList = ExampleHelper.CONST_VALUE_LIST; 
  3. Set<Integer> constValueSet = ExampleHelper.CONST_VALUE_SET; 
  4. Map<Integer, String> constValueMap = ExampleHelper.CONST_VALUE_MAP 

2 存在主要问题

通过SonarLint插件扫描,会出现以下问题:

由于普通的集合对象(如ArrayList、HashMap、HashSet等)都是可变集合对象,即便是定义为静态常量,也可以通过操作方法进行修改。所以,上面方法定义的集合常量,并不是真正意义上的集合常量。其中,Arrays.asList方法生成的内部ArrayList不能执行add/remove/clear方法,但是可以set方法,也属于可变集合对象。

  1. // 操作常量列表 
  2. ExampleHelper.CONST_VALUE_LIST.remove(3); // UnsupportedOperationException 
  3. ExampleHelper.CONST_VALUE_LIST.add(4); // UnsupportedOperationException 
  4. ExampleHelper.CONST_VALUE_LIST.set(1, 20); // [1,20,3] 
  5. ExampleHelper.CONST_VALUE_LIST.clear(); // UnsupportedOperationException 
  6.  
  7. // 操作常量集合 
  8. ExampleHelper.CONST_VALUE_SET.remove(3); // [1,2] 
  9. ExampleHelper.CONST_VALUE_SET.add(3); // [1,2,3] 
  10. ExampleHelper.CONST_VALUE_SET.clear(); // [] 
  11.  
  12. // 操作常量映射 
  13. ExampleHelper.CONST_VALUE_MAP.remove(3); // {1:"value1",2:"value2"
  14. ExampleHelper.CONST_VALUE_MAP.put(3, "value3"); // {1:"value1",2:"value2",3:"value3"
  15. ExampleHelper.CONST_VALUE_MAP.clear(); // [] 

3 最佳定义方式

在JDK中,Collections工具类中提供一套方法,用于把可变集合对象变为不可变(不可修改,修改时会抛出UnsupportedOperationException异常)集合对象。所以,可以利用这套方法定义集合静态常量。

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值列表 */ 
  4.     public static final List<Integer> CONST_VALUE_LIST = Collections.unmodifiableList(Arrays.asList(1, 2, 3)); 
  5.     /** 常量值集合 */ 
  6.     public static final Set<Integer> CONST_VALUE_SET = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(1, 2, 3))); 
  7.     /** 常量值映射 */ 
  8.     public static final Map<Integer, String> CONST_VALUE_MAP; 
  9.     static { 
  10.         Map<Integer, String> valueMap = new HashMap<>(MapHelper.DEFAULT); 
  11.         valueMap.put(1, "value1"); 
  12.         valueMap.put(2, "value2"); 
  13.         valueMap.put(3, "value3"); 
  14.         CONST_VALUE_MAP = Collections.unmodifiableMap(valueMap); 
  15.     } 
  16.     ... 

六 定义数组常量

上一章介绍了如何定义集合常量,这一章就来介绍一下如何定义数组常量。

1 定义公有数组常量

定义代码:

一般人定义数组常量,就会像下面代码一样,定义一个公有数组常量。

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值数组 */ 
  4.     public static final int[] CONST_VALUES = new int[] {1, 2, 3}; 
  5.     ... 

使用代码:

使用也很方便,直接通过”类名.常量名”使用。

  1. // 使用常量值数组 
  2. int[] constValues = ExampleHelper.CONST_VALUES; 

存在问题:

但是,可以通过下标修改数组值,导致数组常量的值可变。所以,这种方法定义的数组常量,并不是一个真正意义上的数组常量。

  1. // 修改常量值数组 
  2. ExampleHelper.CONST_VALUES[1] = 20; // [1, 20, 3] 

2 定义公有集合常量

定义代码:

可以通过上一章定义集合常量的方法,返回一个公有集合常量。

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值列表 */ 
  4.     public static final List<Integer> CONST_VALUE_LIST = 
  5.         Collections.unmodifiableList(Arrays.asList(1, 2, 3)); 
  6.     ... 

使用代码:

要想得到数组常量,就把集合常量转化为数组常量。

  1. // 使用常量值列表 
  2. int[] constValues = ExampleHelper.CONST_VALUE_LIST.stream() 
  3.     .mapToInt(Integer::intValue).toArray(); 

存在问题:

每一次都会把集合常量转化为数组常量,导致程序运行效率降低。

3 最佳定义方式

最佳法”私有数组常量+公有克隆方法”的解决方案。如下代码所示:先定义一个私有数组常量,保证不会被外部类使用;在定义一个获取数组常量方法,并返回一个数组常量的克隆值。

定义代码:

这里,提供一个”私有数组常量+公有克隆方法”的解决方案。如下代码所示:先定义一个私有数组常量,保证不会被外部类使用;在定义一个获取数组常量方法,并返回一个数组常量的克隆值。

  1. /** 例子工具类 */ 
  2. public final class ExampleHelper { 
  3.     /** 常量值数组 */ 
  4.     private static final int[] CONST_VALUES = new int[] {1, 2, 3}; 
  5.     /** 获取常量值数组方法 */ 
  6.     public static int[] getConstValues() { 
  7.         return CONST_VALUES.clone(); 
  8.     } 
  9.     ... 

使用代码:

由于每次返回的是一个克隆数组,即便修改了克隆数组的常量值,也不会导致原始数组常量值的修改。

  1. // 使用常量值方法 
  2. int[] constValues = ExampleHelper.getConstValues(); // [1, 2, 3] 
  3. constValues[1] = 20; // [1, 20, 3] 
  4. constValues = ExampleHelper.getConstValues(); // [1, 2, 3] 

七 定义多条件表达式

1 利用运算符&&(或||)直接拼接

定义代码:

有时候,我们会判断很多条件,需求用&&(或||)连接多个条件表达式。

  1. /** 获取审核结果方法 */ 
  2. private static Integer getAuditResult(AuditDataVO data) { 
  3.     if (isPassed(data.getAuditItem1()) 
  4.         && isPassed(data.getAuditItem2()) 
  5.         ... 
  6.         && isPassed(data.getAuditItem11())) { 
  7.         return AuditResult.PASSED; 
  8.     } 
  9.     return AuditResult.REJECTED; 

存在问题:

通过SonarLint插件扫描,会存在2个问题:

其中,圈复杂度(Cyclomatic complexity,CC)也称为条件复杂度,是一种衡量代码复杂度的标准,其符号为V(G)。

麦凯布最早提出一种称为“基础路径测试”(Basis Path Testing)的软件测试方式,测试程序中的每一线性独立路径,所需的测试用例个数即为程序的圈复杂度。

圈复杂度可以用来衡量一个模块判定结构的复杂程度,其数量上表现为独立路径的条数,也可理解为覆盖所有的可能情况最少使用的测试用例个数。

2 利用运算符=和&&(或||)级联拼接

定义代码:

那么,就把&&(或||)连接符拆开,利用运算符=和&&(或||)级联进行拼接。

  1. /** 获取审核结果方法 */ 
  2. private static AuditResult getAuditResult(AuditDataVO data) { 
  3.     boolean isPassed = isPassed(data.getAuditItem1()); 
  4.     isPassed = isPassed && isPassed(data.getAuditItem2()); 
  5.     ... 
  6.     isPassed = isPassed && isPassed(data.getAuditItem11()); 
  7.     if (isPassed) { 
  8.         return AuditResult.PASSED; 
  9.     } 
  10.     return AuditResult.REJECTED; 

存在问题:

通过SonarLint插件扫描,还存在1个问题:

也就是,利用运算符=和&&(或||)级联进行拼接,并不能减少方法的圈复杂度。

3 利用动态无参数Lambda表达式列表

定义代码:

下面,利用动态无参数Lambda表达式列表优化,即把每个条件表达式作为BooleanSupplier对象存在列表中,然后依次执行条件表达式得出最后结果。

  1. /** 获取审核结果方法 */ 
  2. private static AuditResult getAuditResult(AuditDataVO data) { 
  3.     List<BooleanSupplier> supplierList = new ArrayList<>(); 
  4.     supplierList.add(() -> isPassed(data.getAuditItem1())); 
  5.     supplierList.add(() -> isPassed(data.getAuditItem2())); 
  6.     ... 
  7.     supplierList.add(() -> isPassed(data.getAuditItem11())); 
  8.     for (BooleanSupplier supplier : supplierList) { 
  9.         if (!supplier.getAsBoolean()) { 
  10.             return AuditResult.REJECTED; 
  11.         } 
  12.     } 
  13.     return AuditResult.PASSED; 

存在问题:

通过SonarLint插件扫描,没有提示任何问题。但是,每次都动态添加Lambda表达式,就会导致程序效率低下。那么,有没有把Lambda表达式静态化的方法呢?

4 利用静态有参数Lambda表达式列表

定义代码:

要想固化Lambda表达式,就必须动态传入AuditDataVO对象。这里,采用Predicate来接收Lambda表达式,在Lambda表达式中指定AuditDataVO对象data。然后,在for循环中,依次指定AuditDataVO对象data,并计算表达式的值。

  1. /** 审核结果断言列表 */ 
  2. private static final List<Predicate<AuditDataVO>> AUDIT_RESULT_PREDICATE_LIST = 
  3.     Collections.unmodifiableList(Arrays.asList( 
  4.         data -> isPassed(data.getAuditItem1()), 
  5.         data -> isPassed(data.getAuditItem2()), 
  6.         ... 
  7.         data -> isPassed(data.getAuditItem11()))); 
  8.  
  9. /** 获取审核结果方法 */ 
  10. private static AuditResult getAuditResult(AuditDataVO data) { 
  11.     for (Predicate<AuditDataVO> predicate : AUDIT_RESULT_PREDICATE_LIST) { 
  12.         if (!predicate.test(data)) { 
  13.             return AuditResult.REJECTED; 
  14.         } 
  15.     } 
  16.     return AuditResult.PASSED; 

适用条件:

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

后记

明代思想家王阳明在《传习录》中说道:

初种根时,只管栽培灌溉,勿作枝想,勿作叶想,勿作花想,勿作实想。悬想何益?但不忘栽培之功,怕没有枝叶花实?

【编辑推荐】

  1. 基于JavaMail的复杂邮件发送视频课程
  2. 2021年6月编程语言排行榜:Python或将超越C语言,迎来巅峰时刻
  3. Java项目实战—打造一款股票区间交易盯盘系统
  4. 2021年6月编程语言排行榜:Python或将超越C语言,迎来巅峰时刻
  5. 一小段Python代码,破解加密zip文件的密码
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢