编程规约

1. POJO 类中的任何布尔类型的变量，都不要加 is 前缀，否则部分框架解析会引起序列 化错误。

说明：在本文 MySQL 规约中的建表约定第一条，表达是与否的变量采用 is_xxx 的命名方式，所以，需要 在设置从 is_xxx 到 xxx 的映射关系。
反例：定义为基本数据类型 Boolean isDeleted 的属性，它的方法也是 isDeleted()，框架在反向解析的时 候，“误以为”对应的属性名称是 deleted，导致属性获取不到，进而抛出异常。

2. 避免在子父类的成员变量之间、或者不同代码块的局部变量之间采用完全相同的命名， 使可理解性降低。 说明：子类、父类成员变量名相同，即使是 public 类型的变量也能够通过编译，另外，局部变量在同一方 法内的不同代码块中同名也是合法的，这些情况都要避免。对于非 setter/getter 的参数名称也要避免与成 员变量名称相同。

public class ConfusingName {
    public int stock;
    // 非 setter/getter 的参数名称，不允许与本类成员变量同名
    public void get(String alibaba) {
        if (condition) {
            final int money = 666;
            // ...
        }
        for (int i = 0; i < 10; i++) {
            // 在同一方法体中，不允许与其它代码块中的 money 命名相同
            final int money = 15978;
            // ...
        }
    }
}
class Son extends ConfusingName {
    // 不允许与父类的成员变量名称相同
    public int stock;
}

3. 接口和实现类的命名有两套规则：

1. 【强制】对于 Service 和 DAO 类，基于 SOA 的理念，暴露出来的服务一定是接口，内部的实现类用 Impl 的后缀与接口区别。 正例：CacheServiceImpl 实现 CacheService 接口。

2. 【推荐】如果是形容能力的接口名称，取对应的形容词为接口名（通常是–able 的形容词）。 正例：AbstractTranslator 实现 Translatable 接口。
   

   4. 各层命名规约参考：

3. Service/DAO 层方法命名规约

   1. 获取单个对象的方法用 get 做前缀。
   2. 获取多个对象的方法用 list 做前缀，复数结尾，如：listObjects。
   3. 获取统计值的方法用 count 做前缀
   4. 插入的方法用 save/insert 做前缀。
   5. 删除的方法用 remove/delete 做前缀。
   6. 修改的方法用 update 做前缀。

4. 领域模型命名规约

   1. 数据对象：xxxDO，xxx 即为数据表名。
   2. 数据传输对象：xxxDTO，xxx 为业务领域相关的名称。
   3. 展示对象：xxxVO，xxx 一般为网页名称。
   4. POJO 是 DO/DTO/BO/VO 的统称，禁止命名成 xxxPOJO。
      

      5. 常量的复用层次有五层：跨应用共享常量、应用内共享常量、子工程内共享常量、包 内共享常量、类内共享常量。

5. 跨应用共享常量：放置在二方库中，通常是 client.jar 中的 constant 目录下。

6. 应用内共享常量：放置在一方库中，通常是子模块中的 constant 目录下。

反例：易懂变量也要统一定义成应用内共享常量，两位工程师在两个类中分别定义了“YES”的变量：
类 A 中：public static final String YES = “yes”;
类 B 中：public static final String YES = “y”;
A.YES.equals(B.YES)，预期是 true，但实际返回为 false，导致线上问题。

1. 子工程内部共享常量：即在当前子工程的 constant 目录下。
2. 包内共享常量：即在当前包下单独的 constant 目录下。

3. 类内共享常量：直接在类内部 private static final 定义。

   6. 采用 4 个空格缩进，禁止使用 Tab 字符。 说明：如果使用 Tab 缩进，必须设置 1 个 Tab 为 4 个空格。IDEA 设置 Tab 为 4 个空格时，请勿勾选 Use tab character；而在 Eclipse 中，必须勾选 insert spaces for tabs。

   public static void main(String[] args) {
    // 缩进 4 个空格
    String say = "hello";
    // 运算符的左右必须有一个空格
    int flag = 0;
    // 关键词 if 与括号之间必须有一个空格，括号内的 f 与左括号，0 与右括号不需要空格
    if (flag == 0) {
        System.out.println(say);
    }
    // 左大括号前加空格且不换行；左大括号后换行
    if (flag == 1) {
        System.out.println("world");
        // 右大括号前换行，右大括号后有 else，不用换行
    } else {
        System.out.println("ok");
        // 在右大括号后直接结束，则必须换行
    }
   }

   7. 单行字符数限制不超过 120 个，超出需要换行，换行时遵循如下原则：

4. 第二行相对第一行缩进 4 个空格，从第三行开始，不再继续缩进。

5. 运算符与下文一起换行。
6. 方法调用的点符号与下文一起换行。
7. 方法调用中的多个参数需要换行时，在逗号后进行。
8. 在括号前不要换行，见反例。

   StringBuilder sb = new StringBuilder(); 
   // 超过 120 个字符的情况下，换行缩进 4 个空格，并且方法前的点号一起换行 
   sb.append("yang").append("hao")... 
   .append("chen")... 
   .append("chen")... 
   .append("chen");

   StringBuilder sb = new StringBuilder(); 
   // 超过 120 个字符的情况下，不要在括号前换行 sb.append("you").append("are")...append 
   ("lucky"); 
   // 参数很多的方法调用可能超过 120 个字符，逗号后才是换行处 
   method(args1, args2, args3, ... 
    , argsX);

   8. 单个方法的总行数不超过 80 行。 【推荐】

   说明：除注释之外的方法签名、左右大括号、方法内代码、空行、回车及任何不可见字符的总行数不超过 80 行。
   正例：代码逻辑分清红花和绿叶，个性和共性，绿叶逻辑单独出来成为额外方法，使主干代码更加清晰；共 性逻辑抽取成为共性方法，便于复用和维护。
   

   9. 相同参数类型，相同业务含义，才可以使用 Java 的可变参数，避免使用 Object。

   说明：可变参数必须放置在参数列表的最后。（建议开发者尽量不用可变参数编程）
   正例：public List listUsers(String type, Long… ids) {…}

   10. 外部正在调用或者二方库依赖的接口，不允许修改方法签名，避免对接口调用方产生 影响。接口过时必须加@Deprecated 注解，并清晰地说明采用的新接口或者新服务是什么。

   11. Object 的 equals 方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals。

   正例：”test”.equals(object);
   反例：object.equals(“test”);
   说明：推荐使用 JDK7 引入的工具类 java.util.Objects#equals(Object a, Object b)
   

   12. 所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

   说明：对于 Integer var = ? 在-128 至 127 之间的赋值，Integer 对象是在IntegerCache.cache 产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行判断，但是这个区间之外的所有数据，都会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用 equals 方法进行判断。
   

   13. 浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。

   说明：浮点数采用“尾数+阶码”的编码方式，类似于科学计数法的“有效数字+指数”的表示方式。二进制无法精确表示大部分的十进制小数。

   float a = 1.0F - 0.9F;
   float b = 0.9F - 0.8F;
   if (a == b) {
   // 预期进入此代码块，执行其它业务逻辑
   // 但事实上 a==b 的结果为 false
   }
   Float x = Float.valueOf(a);
   Float y = Float.valueOf(b);
   if (x.equals(y)) {
   // 预期进入此代码块，执行其它业务逻辑
   // 但事实上 equals 的结果为 false
   }

   ```java //(1) 指定一个误差范围，两个浮点数的差值在此范围之内，则认为是相等的。 float a = 1.0F - 0.9F; float b = 0.9F - 0.8F; float diff = 1e-6F; if (Math.abs(a - b) < diff) { System.out.println(“true”); } //(2) 使用 BigDecimal 来定义值，再进行浮点数的运算操作。 BigDecimal a = new BigDecimal(“1.0”); BigDecimal b = new BigDecimal(“0.9”); BigDecimal c = new BigDecimal(“0.8”); BigDecimal x = a.subtract(b); BigDecimal y = b.subtract(c); if (x.compareTo(y) == 0) { System.out.println(“true”); }

<a name="n64wY"></a>
####  14. BigDecimal 的等值比较应使用 compareTo()方法，而不是 equals()方法。 
说明：equals()方法会比较值和精度（1.0 与 1.00 返回结果为 false），而 compareTo()则会忽略精度。  
<a name="XOhtL"></a>
#### 15.  定义数据对象 DO 类时，属性类型要与数据库字段类型相匹配。 
正例：数据库字段的 bigint 必须与类属性的 Long 类型相对应。 <br />反例：某个案例的数据库表 id 字段定义类型 bigint unsigned，实际类对象属性为 Integer，随着 id 越来 越大，超过 Integer 的表示范围而溢出成为负数。  
<a name="idtvQ"></a>
####  16. 禁止使用构造方法 BigDecimal(double)的方式把 double 值转化为 BigDecimal 对象。 
说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。 <br />如：BigDecimal g = new BigDecimal(0.1F); 实际的存储值为：0.10000000149 <br />正例：优先推荐入参为 String 的构造方法，或使用 BigDecimal 的 valueOf 方法，此方法内部其实执行了 Double 的 toString，而 Double 的 toString 按 double 的实际能表达的精度对尾数进行了截断。 <br />BigDecimal recommend1 = new BigDecimal("0.1"); <br />BigDecimal recommend2 = BigDecimal.valueOf(0.1)  
<a name="k1dDa"></a>
####  17. 关于基本数据类型与包装数据类型的使用标准如下：
   1. 【强制】所有的 POJO 类属性必须使用包装数据类型。
   1. 【强制】RPC 方法的返回值和参数必须使用包装数据类型。
   1. 【推荐】所有的局部变量使用基本数据类型。 
说明：POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何 NPE 问题，或 者入库检查，都由使用者来保证。 <br />正例：数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。 <br />反例：某业务的交易报表上显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调 用不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线-。所以包装数据类型 的 null 值，能够表示额外的信息，如：远程调用失败，异常退出。  
<a name="eB8DN"></a>
#### 18.  定义 DO/DTO/VO 等 POJO 类时，不要设定任何属性默认值。 
反例：POJO 类的 createTime 默认值为 new Date()，但是这个属性在数据提取时并没有置入具体值，在更新其它字段时又附带更新了此字段，导致创建时间被修改成当前时间。 
<a name="HJcl3"></a>
####  19. 序列化类新增属性时，请不要修改 serialVersionUID 字段，避免反序列失败；
如果 完全不兼容升级，避免反序列化混乱，那么请修改 serialVersionUID 值。 <br />说明：注意 serialVersionUID 不一致会抛出序列化运行时异常。   
<a name="lxNzN"></a>
####  20. POJO 类必须写 toString 方法。
使用 IDE 中的工具：source> generate toString 时，如果继承了另一个 POJO 类，注意在前面加一下 super.toString。 <br />说明：在方法执行抛出异常时，可以直接调用 POJO 的 toString()方法打印其属性值，便于排查问题。  
<a name="zZGTQ"></a>
####  21. 禁止在 POJO 类中，同时存在对应属性 xxx 的 isXxx()和 getXxx()方法。
 说明：框架在调用属性 xxx 的提取方法时，并不能确定哪个方法一定是被优先调用到的。  
<a name="ddWdv"></a>
#### 22.  setter 方法中，参数名称与类成员变量名称一致，this.成员名 = 参数名。【推荐】
在 getter/setter 方法中，不要增加业务逻辑，增加排查问题的难度。  
```java
public Integer getData () {
 if (condition) {
 return this.data + 100;
 } else {
 return this.data - 100;
 }
}

23. 循环体内，字符串的连接方式，使用 StringBuilder 的 append 方法进行扩展。

说明：下例中，反编译出的字节码文件显示每次循环都会 new 出一个 StringBuilder 对象，然后进行 append 操作，最后通过 toString 方法返回 String 对象，造成内存资源浪费。

String str = "start";
for (int i = 0; i < 100; i++) {
 str = str + "hello";
}

24. 慎用 Object 的 clone 方法来拷贝对象。

说明：对象 clone 方法默认是浅拷贝，若想实现深拷贝，需覆写 clone 方法实现域对象的深度遍历式拷贝。

25. 日期格式化时，传入 pattern 中表示年份统一使用小写的 y。

说明：日期格式化时，yyyy 表示当天所在的年，而大写的 YYYY 代表是 week in which year（JDK7 之后 引入的概念），意思是当天所在的周属于的年份，一周从周日开始，周六结束，只要本周跨年，返回的 YYYY 就是下一年。

//表示日期和时间的格式如下所示： 
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

26. 在日期格式中分清楚大写的 M 和小写的 m，大写的 H 和小写的 h 分别指代的意义。

说明：日期格式中的这两对字母表意如下：

1. 表示月份是大写的 M；
2. 表示分钟则是小写的 m；
3. 24 小时制的是大写的 H；
4. 12 小时制的则是小写的 h。
   

   27. 不允许在程序任何地方中使用：1）java.sql.Date。 2）java.sql.Time。 3）java.sql.Timestamp。

   说明：第 1 个不记录时间，getHours()抛出异常；第 2 个不记录日期，getYear()抛出异常；第 3 个在构造方法 super((time/1000)*1000)，在 Timestamp 属性 fastTime 和 nanos 分别存储秒和纳秒信息。
   反例：java.util.Date.after(Date)进行时间比较时，当入参是 java.sql.Timestamp 时，会触发 JDK BUG(JDK9 已修复)，可能导致比较时的意外结果。
   

   28. 不要在程序中写死一年为 365 天，避免在公历闰年时出现日期转换错误或程序逻辑 错误。

   // 获取今年的天数
   int daysOfThisYear = LocalDate.now().lengthOfYear();
   // 获取指定某年的天数
   LocalDate.of(2011, 1, 1).lengthOfYear();

   // 第一种情况：在闰年 366 天时，出现数组越界异常
   int[] dayArray = new int[365];
   // 第二种情况：一年有效期的会员制，今年 1 月 26 日注册，硬编码 365 返回的却是 1 月 25 日
   Calendar calendar = Calendar.getInstance();
   calendar.set(2020, 1, 26);
   calendar.add(Calendar.DATE, 365);

   29. 避免公历闰年 2 月问题。闰年的 2 月份有 29 天，一年后的那一天不可能是 2 月 29 日。

   30. 使用枚举值来指代月份。如果使用数字，注意 Date，Calendar 等日期相关类的月份 month 取值在 0-11 之间。

   说明：参考 JDK 原生注释，Month value is 0-based. e.g., 0 for January.
   正例： Calendar.JANUARY，Calendar.FEBRUARY，Calendar.MARCH 等来指代相应月份来进行传参或 比较。
   

   31. 判断所有集合内部的元素是否为空，使用 isEmpty()方法，而不是 size()==0 的方式。 说明：在某些集合中，前者的时间复杂度为 O(1)，而且可读性更好。

   ```java Map map = new HashMap<>(16); if(map.isEmpty()) { System.out.println(“no element in this map.”); }

<a name="xZZpW"></a>
#### 32. 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时，一定要使 用含有参数类型为 BinaryOperator，参数名为 mergeFunction 的方法，否则当出现相同 key 值时会抛出 IllegalStateException 异常。  
 说明：参数 mergeFunction 的作用是当出现 key 重复时，自定义对 value 的处理策略。  
```java
List<Pair<String, Double>> pairArrayList = new ArrayList<>(3);
        pairArrayList.add(new Pair<>("version", 12.10));
        pairArrayList.add(new Pair<>("version", 12.19));
        pairArrayList.add(new Pair<>("version", 6.28));
        Map<String, Double> map = pairArrayList.stream().collect(
                // 生成的 map 集合中只有一个键值对：{version=6.28}
                Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v2));
        map.forEach((k, v) -> System.out.println(k + "," + v));

String[] departments = new String[] {"iERP", "iERP", "EIBU"};
// 抛出 IllegalStateException 异常
Map<Integer, String> map = Arrays.stream(departments)
 .collect(Collectors.toMap(String::hashCode, str -> str))

33. 在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map 集合时，一定要注 意当 value 为 null 时会抛 NPE 异常。

说明：在 java.util.HashMap 的 merge 方法里会进行如下的判断：

//toMap方法
public static <T, K, U, M extends Map<K, U>>
    Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
                                Function<? super T, ? extends U> valueMapper,
                                BinaryOperator<U> mergeFunction,
                                Supplier<M> mapSupplier) {
        BiConsumer<M, T> accumulator
                = (map, element) -> map.merge(keyMapper.apply(element),
                                              valueMapper.apply(element), mergeFunction);
        return new CollectorImpl<>(mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
    }
//调用的merge方法
default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }

List<Pair<String, Double>> pairArrayList = new ArrayList<>(2);
pairArrayList.add(new Pair<>("version1", 8.3));
pairArrayList.add(new Pair<>("version2", null));
Map<String, Double> map = pairArrayList.stream().collect(
// 抛出 NullPointerException 异常
Collectors.toMap(Pair::getKey, Pair::getValue, (v1, v2) -> v2))

34. ArrayList 的 subList 结果不可强转成 ArrayList，否则会抛出 ClassCastException 异 常：java.util.RandomAccessSubList cannot be cast to java.util.ArrayList。

说明：subList()返回的是 ArrayList 的内部类 SubList，并不是 ArrayList 本身，而是 ArrayList 的一个视 图，对于 SubList 的所有操作最终会反映到原列表上。

35. 使用 Map 的方法 keySet()/values()/entrySet()返回集合对象时，不可以对其进行添加元素操作，否则会抛出 UnsupportedOperationException 异常。

36. Collections 类返回的对象，如：emptyList()/singletonList()等都是 immutable list， 不可对其进行添加或者删除元素的操作。

反例：如果查询无结果，返回 Collections.emptyList()空集合对象，调用方一旦进行了添加元素的操作，就 会触发 UnsupportedOperationException 异常

37. 在 subList 场景中，高度注意对父集合元素的增加或删除，均会导致子列表的遍历、 增加、删除产生 ConcurrentModificationException 异常。

38. 使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全一 致、长度为 0 的空数组。

反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[]类，若强转其它类型数组将出现 ClassCastException 错误。

List<String> list = new ArrayList<>(2);
list.add("guan");
list.add("bao");
String[] array = list.toArray(new String[0]);

 说明：使用 toArray 带参方法，数组空间大小的 length： 

1. 等于 0，动态创建与 size 相同的数组，性能最好。
2. 大于 0 但小于 size，重新创建大小等于 size 的数组，增加 GC 负担。
3. 等于 size，在高并发情况下，数组创建完成之后，size 正在变大的情况下，负面影响与 2 相同。
4. 大于 size，空间浪费，且在 size 处插入 null 值，存在 NPE 隐患。
   

   39. 在使用 Collection 接口任何实现类的 addAll()方法时，都要对输入的集合参数进行 NPE 判断。

   说明：在 ArrayList#addAll 方法的第一行代码即 Object[] a = c.toArray(); 其中 c 为输入集合参数，如果 为 null，则直接抛出异常。
   

   40. 使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方法， 它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。

   说明：asList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。Arrays.asList 体现的是适配器模式，只是转换接口，后台的数据仍是数组。
   String[] str = new String[] { “chen”, “yang”, “hao” };
   List list = Arrays.asList(str);
   第一种情况：list.add(“yangguanbao”); 运行时异常。
   第二种情况：str[0] = “change”; 也会随之修改，反之亦然。