#序言
依照阿里巴巴JAVA开发手册+供应链技术团队实际开发情况形成此规范，目的旨在规范代码、提高代码质量、提高代码可读性可维护性。
泰山版java开发规范.pdf

1、编程规约

1.1命名风格

1.【强制】类名使⽤用UpperCamelCase风格，必须遵从驼峰形式。
正例: MarcoPolo / UserDo / XmlService / TcpUdpDeal / TaPromotion
反例: macroPolo / UserDO / XMLService / TCPUDPDeal / TAPromotion

2.【强制】⽅法名、参数名、成员变量、局部变量都统一使⽤用lowerCamelCase风格，必须遵从驼峰形式。

正例：localValue / getHttpMessage() / inputUserId

3.【强制】常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长。

4.【强制】抽象类命名使用Abstract或Base开头；异常类命名使用Exception结尾；测试类命名以它要测试的类的名称开始，以Test结尾。

5.【强制】类型与中括号紧挨相连来表示数组。

正例：定义整形数组int[] arrayDemo;

反例：在main参数中，使用String args[]来定义。

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

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

7.【强制】包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式。

正例：应用工具类包名为com.alibaba.ei.kunlun.aap.util、类名为MessageUtils（此规则参考spring的框架结构）

8.【强制】避免在子父类的成员变量之间、或者不同代码块的局部变量之间采用完全相同的命名，使可读性降低。

说明：子类、父类成员变量名相同，即使是public类型的变量也是能够通过编译，而局部变量在同一方法内的不同代码块中同名也是合法的，但是要避免使用。对于非setter/getter的参数名称也要避免与成员变量名称相同。

9.【强制】杜绝完全不规范的缩写，避免望文不知义。

反例：AbstractClass“缩写”命名成AbsClass；condition“缩写”命名成condi，此类随意缩写严重降低了代码的可阅读性。

12.【推荐】为了达到代码自解释的目标，任何自定义编程元素在命名时，使用尽量完整的单词组合来表达。

正例：在JDK中，对某个对象引用的volatile字段进行原子更新的类名为：AtomicReferenceFieldUpdater。

10.【推荐】在常量与变量的命名时，表示类型的名词放在词尾，以提升辨识度。

正例：startTime / workQueue / nameList / TERMINATED_THREAD_COUNT

反例：startedAt / QueueOfWork / listName / COUNT_TERMINATED_THREAD

11.【推荐】如果模块、接口、类、方法使用了设计模式，在命名时需体现出具体模式。说明：将设计模式体现在名字中，有利于阅读者快速理解架构设计理念。
正例：

public class OrderFactory;

public class LoginProxy;

publicc lass ResourceObserver;

12.【推荐】枚举类名带上Enum后缀，枚举成员名称需要全大写，单词间用下划线隔开。说明：枚举其实就是特殊的常量类，且构造方法被默认强制是私有。

正例：枚举名字为ProcessStatusEnum的成员名称：SUCCESS/UNKNOWN_REASON。

13.【推荐】各层命名规约：
A)Service/DAO层方法命名规约
1）获取单个对象的方法用get做前缀。
2）获取多个对象的方法用list做前缀，复数结尾，如：listObjects。
3）获取统计值的方法用count做前缀。
4）插入的方法用save/insert做前缀。
5）删除的方法用remove/delete做前缀。
6）修改的方法用update做前缀。
B)领域模型命名规约
1）数据对象：xxxDO，xxx即为数据表名。
2）数据传输对象：xxxDTO，xxx为业务领域相关的名称。
3）展示对象：xxxVO，xxx一般为网页名称。
4）POJO是DO / DTO / BO / VO的统称，禁止命名成xxxPOJO。

1.2 常量定义

1.【强制】不允许任何魔法值（即未经预先定义的常量）直接出现在代码中。

2.【强制】在long或者Long赋值时，数值后使用大写的L，不能是小写的l，小写容易跟数字混淆，造成误解。
说明：Long a = 2l; 写的是数字的21，还是Long型的2。

3.【推荐】不要使用一个常量类维护所有常量，要按常量功能进行归类，分开维护。

说明：大而全的常量类，杂乱无章，使用查找功能才能定位到修改的常量，不利于理解，也不利于维护。
正例：缓存相关常量放在类CacheConsts下；系统配置相关常量放在类ConfigConsts下。

4.【推荐】常量的复用层次有五层：跨应用共享常量、应用内共享常量、子工程内共享常量、包内共享常量、类内共享常量。

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

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

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

3）子工程内部共享常量：即在当前子工程的constant目录下。

4）包内共享常量：即在当前包下单独的constant目录下。

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

5.【推荐】如果变量值仅在一个固定范围内变化用enum类型来定义
正例
表示一年中的第几个季节。

public enum SeasonEnum{
SPRING(1),SUMMER(2),AUTUMN(3),WINTER(4);

private int seq;
SeasonEnum(int seq)
{
	this.seq=seq;
}
public int getSeq(){
	returnseq;
 }
}

1.3 代码格式

1.【强制】如果是大括号内为空，则简洁地写成{}即可，大括号中间无需换行和空格；如果是非空代码块则：
1）左大括号前不换行。

2）左大括号后换行。

3）右大括号前换行。

4）右大括号后还有else等代码则不换行；表示终止的右大括号后必须换行。

2.【强制】左小括号和右边相邻字符之间不出现空格；右小括号和左边相邻字符之间也不出现空格；而左大括号前需要加空格。
反例：if(空格a==b空格)

3.【强制】if/for/while/switch/do等保留字与括号之间都必须加空格。

4.【强制】任何二目、三目运算符的左右两边都需要加一个空格。说明：包括赋值运算符=、逻辑运算符&&、加减乘除符号等。

5.【强制】采用4个空格缩进，禁止使用tab字符。

说明：如果使用tab缩进，必须设置1个tab为4个空格。IDEA设置tab为4个空格时，请勿勾选Use tab character；
正例：（涉及1-5点）

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");
 // 在右大括号后直接结束，则必须换行
 }
}

6.【强制】注释的双斜线与注释内容之间有且仅有一个空格。
正例：
//这是示例注释，请注意在双斜线之后有一个空格
String comment String = new String();

7.【强制】单行字符数限制不超过120个，超出需要换行，换行时遵循如下原则：
1）第二行相对第一行缩进4个空格，从第三行开始，不再继续缩进，参考示例。
2）运算符与下文一起换行。
3）方法调用的点符号与下文一起换行。
4）方法调用中的多个参数需要换行时，在逗号后进行。
5）在括号前不要换行。
正例：

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

反例：

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

9.【强制】方法参数在定义和传入时，多个参数逗号后边必须加空格。

正例：下例中实参的args1，后边必须要有一个空格。
method(args1, args2, args3);

10.【强制】IDE的textfileencoding设置为UTF-8;IDE中文件的换行符使用Unix格式，不要使用Windows格式。

11.【推荐】单个方法的总行数不超过80行。
说明：除注释之外的方法签名、左右大括号、方法内代码、空行、回车及任何不可见字符的总行数不超过80行。

正例：代码逻辑分清红花和绿叶，个性和共性，绿叶逻辑单独出来成为额外方法，使主干代码更加清晰；共性逻辑抽取成为共性方法，便于复用和维护。

1.4 OOP规约

1.【强制】避免通过一个类的对象引用访问此类的静态变量或静态方法，无谓增加编译器解析成本，直接用类名来访问即可。

2.【强制】所有的覆写方法，必须加@Override注解。
说明：getObject()与get0bject()的问题。一个是字母的O，一个是数字的0，加@Override可以准确判断是否覆盖成功。另外，如果在抽象类中对方法签名进行修改，其实现类会马上编译报错。

3.【强制】相同参数类型，相同业务含义，才可以使用Java的可变参数，避免使用Object。
说明：可变参数必须放置在参数列表的最后。（提倡同学们尽量不用可变参数编程）
正例：
public List listUsers(String type, Long... ids) {...}

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

正例："test".equals(object);

反例：object.equals("test");

说明：推荐使用java.util.Objects#equals（JDK7引入的工具类）。

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

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

Integer i1 = Integer.valueOf(1);
Integer i2 = new Integer(1);
Integer i3 = 1;
System.out.println(i1 == i2);  //false
System.out.println(i1 == i3);  //true

6.【强制】浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用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
}

正例：

(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.equals(y)) {
 System.out.println("true");
}

11.【强制】禁止使用构造方法BigDecimal(double)的方式把double值转化为BigDecimal对象。

说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。如：BigDecima lg = new BigDecimal(0.1f); 实际的存储值为：0.10000000149
正例：优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。

BigDecimal recommend1 = new BigDecimal("0.1");
BigDecimal recommend2 = BigDecimal.valueOf(0.1);

12.关于基本数据类型与包装数据类型的使用标准如下：

1）【强制】所有的POJO类属性必须使用包装数据类型。

2）【强制】RPC方法的返回值和参数必须使用包装数据类型。

3）【推荐】所有的局部变量使用基本数据类型。

说明：POJO类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何NPE问题，或者入库检查，都由使用者来保证。
正例：数据库的查询结果可能是null，因为自动拆箱，用基本数据类型接收有NPE风险。
反例：某业务的交易报表上显示成交总额涨跌情况，即正负x%，x为基本数据类型，调用的RPC服务，调用不成功时，返回的是默认值，页面显示为0%，这是不合理的，应该显示成中划线-。所以包装数据类型的null值，能够表示额外的信息，如：远程调用失败，异常退出。

15.【强制】构造方法里面禁止加入任何业务逻辑，如果有初始化逻辑，请放在init方法中。

16.【强制】POJO类必须写toString方法。使用IDE中的工具：source>generatetoString时，如果继承了另一个POJO类，注意在前面加一下super.toString。说明：在方法执行抛出异常时，可以直接调用POJO的toString()方法打印其属性值，便于排查问题。

18.【推荐】使用索引访问用String的split方法得到的数组时，需做最后一个分隔符后有无内容的检查，否则会有抛IndexOutOfBoundsException的风险。说明：

Stringstr="a,b,c,,";
String[]ary=str.split(",");
//预期大于3，结果是3
System.out.println(ary.length);

21.【推荐】setter方法中，参数名称与类成员变量名称一致，this.成员名=参数名。在getter/setter方法中，不要增加业务逻辑，增加排查问题的难度。反例：

public Integer getData () {
 if (condition) {
 return this.data + 100;
 } else {
 return this.data - 100;
 }
}

22.【推荐】循环体内，字符串的连接方式，使用StringBuilder的append方法进行扩展。说明：下例中，反编译出的字节码文件显示每次循环都会new出一个StringBuilder对象，然后进行append操作，最后通过toString方法返回String对象，造成内存资源浪费。
反例：

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

23.【推荐】final可以声明类、成员变量、方法、以及本地变量，下列情况使用final关键字：

1）不允许被继承的类，如：String类。

2）不允许修改引用的域对象，如：POJO类的域变量。

3）不允许被覆写的方法，如：POJO类的setter方法。

4）不允许运行过程中重新赋值的局部变量。

5）避免上下文重复使用一个变量，使用final可以强制重新定义一个变量，方便更好地进行重构。

24.【推荐】慎用Object的clone方法来拷贝对象。说明：对象clone方法默认是浅拷贝，若想实现深拷贝需覆写clone方法实现域对象的深度遍历式拷贝。

25.【推荐】类成员与方法访问控制从严：
1）如果不允许外部直接通过new来创建对象，那么构造方法必须是private。

2）工具类不允许有public或default构造方法。

3）类非static成员变量并且与子类共享，必须是protected。

4）类非static成员变量并且仅在本类使用，必须是private。

5）类static成员变量如果仅在本类使用，必须是private。

6）若是static成员变量，考虑是否为final。

7）类成员方法只供类内部调用，必须是private。

8）类成员方法只对继承类公开，那么限制为protected。

说明：任何类、方法、参数、变量，严控访问范围。过于宽泛的访问范围，不利于模块解耦。思考：如果是一个private的方法，想删除就删除，可是一个public的service成员方法或成员变量，删除一下，不得手心冒点汗吗？变量像自己的小孩，尽量在自己的视线内，变量作用域太大，无限制的到处跑，那么你会担心的。

1.5 日期时间

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

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

new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

2.【强制】在日期格式中分清楚大写的M和小写的m，大写的H和小写的h分别指代的意义。说明：日期格式中的这两对字母表意如下：

1）表示月份是大写的M；

2）表示分钟则是小写的m；

3）24小时制的是大写的H；

4）12小时制的则是小写的h。

3.【强制】获取当前毫秒数：System.currentTimeMillis(); 而不是newDate().getTime()。说明：如果想获取更加精确的纳秒级时间值，使用System.nanoTime的方式。在JDK8中，针对统计时间等场景，推荐使用Instant类。

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

正例：
//获取今年的天数

intdaysOfThisYear=LocalDate.now().lengthOfYear();

//获取指定某年的天数

LocalDate.of(2011,1,1).lengthOfYear();

反例：
//第一种情况：在闰年366天时，出现数组越界异常

int[] dayArray=new int[365];

//第二种情况：一年有效期的会员制，今年1月26日注册，硬编码365返回的却是1月25日

Calendarcalendar=Calendar.getInstance();calendar.set(2020,1,26);calendar.add(Calendar.DATE,365);

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

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

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

1.6 集合处理

1.【强制】关于hashCode和equals的处理，遵循如下规则：

1）只要重写equals，就必须重写hashCode。

2）因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的对象必须重写这两个方法。

3）如果自定义对象作为Map的键，那么必须覆写hashCode和equals。

说明：String因为重写了hashCode和equals方法，所以我们可以愉快地使用String对象作为key来使用。

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

正例：

Map<String,Object> map = new HashMap<>();
	if(map.isEmpty()) {
		System.out.println("no element in this map.");
}

【说明】ConcurrentLinkedQueue时间复杂度为O(N)，是基于链表节点的无界，线程安全队列。

3.【强制】在使用java.util.stream.Collectors类的toMap()方法转为Map集合时，一定要使用含有参数类型为BinaryOperator，参数名为mergeFunction的方法，否则当出现相同key值时会抛出IllegalStateException异常。说明：参数mergeFunction的作用是当出现key重复时，自定义对value的处理策略。

正例：

List<Pair<String,Double>> pairArrayList = new ArrayList<>(3);

pairArrayList.add(newPair<>("version",6.19));
pairArrayList.add(newPair<>("version",10.24));
pairArrayList.add(newPair<>("version",13.14));

Map<String,Double> map = pairArrayList.stream().collect(

	//生成的map集合中只有一个键值对：{version=13.14}
	Collectors.toMap(Pair::getKey,Pair::getValue,(v1,v2)->v2));
	
	//反例:
	String[]departments=newString[]{"iERP","iERP","EIBU"};
	
	//抛出IllegalStateException异常
	Map<Integer,String> ma p= Arrays.stream(departments)
	
.collect(Collectors.toMap(String::hashCode,str->str));

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

说明：在java.util.HashMap的merge方法里会进行如下的判断：
if(value == null || remappingFunction==null)
throw new NullPointerException();
反例：

List<Pair<String,Double>>pairArrayList=newArrayList<>(2);

pairArrayList.add(newPair<>("version1",4.22));
pairArrayList.add(newPair<>("version2",null));

Map<String,Double>map=pairArrayList.stream().collect(

	//抛出NullPointerException异常
	Collectors.toMap(Pair::getKey,Pair::getValue,(v1,v2)->v2));

5.【强制】ArrayList的subList结果不可强转成ArrayList，否则会抛出ClassCastException异常：

java.util.RandomAccessSubListcannotbecasttojava.util.ArrayList。

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

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

7.【强制】Collections类返回的对象，如：emptyList()/singletonList()等都是immutablelist，不可对其进行添加或者删除元素的操作。

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

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

9.【强制】使用集合转数组的方法，必须使用集合的toArray(T[]array)，传入的是类型完全一致、长度为0的空数组。
反例：直接使用toArray无参方法存在问题，此方法返回值只能是Object[]类，若强转其它类型数组将出现
ClassCastException错误。
正例：

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

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

1）等于0，动态创建与size相同的数组，性能最好。

2）大于0但小于size，重新创建大小等于size的数组，增加GC负担。

3）等于size，在高并发情况下，数组创建完成之后，size正在变大的情况下，负面影响与2相同。

4）大于size，空间浪费，且在size处插入null值，存在NPE隐患。

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

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

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

说明：asList的返回对象是一个Arrays内部类，并没有实现集合的修改方法。Arrays.asList体现的是适配器模式，只是转换接口，后台的数据仍是数组。

String[]str=newString[]{"yang","hao"};
Listlist=Arrays.asList(str);

第一种情况：list.add("yangguanbao");运行时异常。

第二种情况：str[0]="changed";也会随之修改，反之亦然。

12.【强制】泛型通配符<?extendsT>来接收返回的数据，此写法的泛型集合不能使用add方法，而<?superT>不能使用get方法，两者在接口调用赋值的场景中容易出错。

说明：扩展说一下PECS(ProducerExtendsConsumerSuper)原则：

第一、频繁往外读取内容的，适合用<?extendsT>。

第二、经常往里插入的，适合用<?superT>

13.【强制】在无泛型限制定义的集合赋值给泛型限制的集合时，在使用集合元素时，需要进行instanceof判断，避免抛出ClassCastException异常。

说明：毕竟泛型是在JDK5后才出现，考虑到向前兼容，编译器是允许非泛型集合与泛型集合互相赋值。

反例：

List<String>generics=null;

ListnotGenerics=newArrayList(10);

notGenerics.add(newObject());
notGenerics.add(newInteger(1));

generics=notGenerics;

//此处抛出ClassCastException异常
Stringstring=generics.get(0);

14.【强制】不要在foreach循环里进行元素的remove/add操作。remove元素请使用Iterator方式，如果并发操作，需要对Iterator对象加锁。

正例：

List<String>list=newArrayList<>();

list.add("1");
list.add("2");

Iterator<String>iterator=list.iterator();

while(iterator.hasNext()) {
	Stringitem=iterator.next();
	if(删除元素的条件) {
		iterator.remove();
	}
}

反例：

for(Stringitem:list) {
	if("1".equals(item)) {
	list.remove(item);
	}
}

说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的结果吗？

15.【强制】在JDK7版本及以上，Comparator实现类要满足如下三个条件，不然Arrays.sort，
Collections.sort会抛IllegalArgumentException异常。

说明：三个条件如下
1）x，y的比较结果和y，x的比较结果相反。

2）x>y，y>z，则x>z。

3）x=y，则x，z比较结果和y，z比较结果相同。

反例：下例中没有处理相等的情况，交换两个对象判断结果并不互反，不符合第一个条件，在实际使用中可能会出现异常。

newComparator<Student>() {
	@Override
	publicintcompare(Studento1,Studento2) {
		returno1.getId()>o2.getId()?1:-1;
	}
};

16.【推荐】集合泛型定义时，在JDK7及以上，使用diamond语法或全省略。说明：菱形泛型，即diamond，直接使用<>来指代前边已经指定的类型。

正例：

//diamond方式，即<>
HashMap<String,String>userCache=newHashMap<>(16);

//全省略方式
ArrayList<User>users=newArrayList(10);

17.【推荐】集合初始化时，指定集合初始值大小。

说明：HashMap使用HashMap(intinitialCapacity)初始化，如果暂时无法确定集合大小，那么指定默认值（16）即可。
正例：initialCapacity=(需要存储的元素个数/负载因子)+1。注意负载因子（即loaderfactor）默认为0.75，如果暂时无法确定初始值大小，请设置为16（即默认值）。
反例：HashMap需要放置1024个元素，由于没有设置容量初始大小，随着元素不断增加，容量7次被迫扩大，resize需要重建hash表。当放置的集合元素个数达千万级别时，不断扩容会严重影响性能。

18.【推荐】使用entrySet遍历Map类集合KV，而不是keySet方式进行遍历。说明：keySet其实是遍历了2次，一次是转为Iterator对象，另一次是从hashMap中取出key所对应的value。而entrySet只是遍历了一次就把key和value都放到了entry中，效率更高。如果是JDK8，使用Map.forEach方法。
正例：values()返回的是V值集合，是一个list集合对象；keySet()返回的是K值集合，是一个Set集合对象；entrySet()返回的是K-V值组合集合。

19.【推荐】高度注意Map类集合K/V能不能存储null值的情况，如下表格：

集合类KeyValueSuper说明
Hashtable不允许为null不允许为nullDictionary线程安全
ConcurrentHashMap不允许为null不允许为nullAbstractMap锁分段技术（JDK8:CAS）
TreeMap不允许为null允许为nullAbstractMap线程不安全
HashMap允许为null允许为nullAbstractMap线程不安全
反例：由于HashMap的干扰，很多人认为ConcurrentHashMap是可以置入null值，而事实上，存储null值时会抛出NPE异常。

20.【推荐】合理利用好集合的有序性(sort)和稳定性(order)，避免集合的无序性(unsort)和不稳定性(unorder)带来的负面影响。

说明：有序性是指遍历的结果是按某种比较规则依次排列的。稳定性指集合每次遍历的元素次序是一定的。如：ArrayList是order/unsort；HashMap是unorder/unsort；TreeSet是order/sort。

21.【推荐】利用Set元素唯一的特性，可以快速对一个集合进行去重操作，避免使用List的contains()进行遍历去重或者判断包含操作。

1.7 并发处理

1.【强制】获取单例对象需要保证线程安全，其中的方法也要保证线程安全。

说明：资源驱动类、工具类、单例工厂类都需要注意。

2.【强制】创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。
正例：

//自定义线程工厂，并且根据外部特征进行分组，比如，来自同一机房的调用，把机房编号赋值给whatFeaturOfGroup
	public class UserThreadFactory implements ThreadFactory {
		privatefinalStringnamePrefix;
		privatefinalAtomicIntegernextId=newAtomicInteger(1);

		//定义线程组名称，在jstack问题排查时，非常有帮助
		UserThreadFactory(StringwhatFeaturOfGroup) {
			namePrefix="FromUserThreadFactory's"+whatFeaturOfGroup+"-Worker-";
			}

		@Override
		publicThreadnewThread(Runnabletask) {

			Stringname=namePrefix+nextId.getAndIncrement();
			
			Threadthread=newThread(null,task,name,0,false);
			
			System.out.println(thread.getName());
			
			return thread;
		
		}
}

3.【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

说明：线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

4.【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors返回的线程池对象的弊端如下：

1）FixedThreadPool和SingleThreadPool：
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

2）CachedThreadPool：
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

5.【强制】SimpleDateFormat是线程不安全的类，一般不要定义为static变量，如果定义为static，必须加锁，或者使用DateUtils工具类。

正例：注意线程安全，使用DateUtils。亦推荐如下处理：

privatestaticfinalThreadLocal<DateFormat>df=newThreadLocal<DateFormat>() {

	@Override
	protectedDateFormatinitialValue() {
		return newSimpleDateFormat("yyyy-MM-dd");
	}
};

说明：如果是JDK8的应用，可以使用Instant代替Date，LocalDateTime代替Calendar，

DateTimeFormatter代替SimpleDateFormat，官方给出的解释：simplebeautifulstrongimmutablethread-safe。

6.【强制】必须回收自定义的ThreadLocal变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的ThreadLocal变量，可能会影响后续业务逻辑和造成内存泄露等问题。尽量在代理中使用try-finally块进行回收。

正例：

objectThreadLocal.set(userInfo);

try {
	//...
}finally {
	objectThreadLocal.remove();
}

7.【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。说明：尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用RPC方法。

8.【强制】对多个资源、数据库表、对象同时加锁时，需要保持一致的加锁顺序，否则可能会造成死锁。说明：线程一需要对表A、B、C依次全部加锁后才可以进行更新操作，那么线程二的加锁顺序也必须是A、B、C，否则可能出现死锁。

9.【强制】在使用阻塞等待获取锁的方式中，必须在try代码块之外，并且在加锁方法与try代码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在finally中无法解锁。

说明一：如果在lock方法与try代码块之间的方法调用抛出异常，那么无法解锁，造成其它线程无法成功获取锁。

说明二：如果lock方法在try代码块之内，可能由于其它方法抛出异常，导致在finally代码块中，unlock对未加锁的对象解锁，它会调用AQS的tryRelease方法（取决于具体实现类），抛出IllegalMonitorStateException异常。

说明三：在Lock对象的lock方法实现中可能抛出unchecked异常，产生的后果与说明二相同。

正例：

Locklock=newXxxLock();
//...
lock.lock();

try{
	doSomething();
	doOthers();
}finally {
lock.unlock();
}

反例：

Locklock=newXxxLock();
//...
try{
	//如果此处抛出异常，则直接执行finally代码块
	doSomething();
	//无论加锁是否成功，finally代码块都会执行lock.lock();doOthers();
}finally {
	lock.unlock();
}

10.【强制】在使用尝试机制来获取锁的方式中，进入业务代码块之前，必须先判断当前线程是否持有锁。锁的释放规则与锁的阻塞等待方式相同。

说明：Lock对象的unlock方法在执行时，它会调用AQS的tryRelease方法（取决于具体实现类），如果
当前线程不持有锁，则抛出IllegalMonitorStateException异常。

正例：

Locklock=newXxxLock();

booleanisLocked=lock.tryLock();
	if(isLocked) {
		try {
			doSomething();
			doOthers();
		}finally {
		lock.unlock();
		}
	}

11.【强制】并发修改同一记录时，避免更新丢失，需要加锁。要么在应用层加锁，要么在缓存加锁，要么在数据库层使用乐观锁，使用version作为更新依据。说明：如果每次访问冲突概率小于20%，推荐使用乐观锁，否则使用悲观锁。乐观锁的重试次数不得小于3次。

12.【强制】多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。

13.【推荐】资金相关的金融敏感信息，使用悲观锁策略。

说明：乐观锁在获得锁的同时已经完成了更新操作，校验逻辑容易出现漏洞，另外，乐观锁对冲突的解决策略有较复杂的要求，处理不当容易造成系统压力或数据异常，所以资金相关的金融敏感信息不建议使用乐观锁更新。

正例：悲观锁遵循一锁二判三更新四释放的原则

14.【推荐】使用CountDownLatch进行异步转同步操作，每个线程退出前必须调用countDown方法，线程执行代码注意catch异常，确保countDown方法被执行到，避免主线程无法执行至await方法，直到超时才返回结果。

说明：注意，子线程抛出异常堆栈，不能在主线程try-catch到。

15.【推荐】避免Random实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一seed导致的性能下降。

说明：Random实例包括java.util.Random的实例或者Math.random()的方式。

正例：在JDK7之后，可以直接使用APIThreadLocalRandom，而在JDK7之前，需要编码保证每个线程持有一个单独的Random实例。

16.【推荐】通过双重检查锁（double-checkedlocking）（在并发场景下）实现延迟初始化的优化问题隐患(可参考The"Double-CheckedLockingisBroken"Declaration)，推荐解决方案中较为简单一种（适用于JDK5及以上版本），将目标属性声明为volatile型（比如修改helper的属性声明为privatevolatileHelperhelper=null;）。
反例：

publicclassLazyInitDemo {

	privateHelperhelper=null;

	publicHelpergetHelper() {
		if(helper==null) {
			synchronized(this) {
				if(helper==null) {
					helper=newHelper();
					}
				}
			}
				return helper;
	}
//othermethodsandfields...
}

17.【推荐】volatile解决多线程内存不可见问题。对于一写多读，是可以解决变量同步问题，但是如果多写，同样无法解决线程安全问题。

说明：如果是count++操作，使用如下类实现：AtomicIntegercount=newAtomicInteger();count.addAndGet(1);如果是JDK8，推荐使用LongAdder对象，比AtomicLong性能更好（减少乐观锁的重试次数）。

18.【推荐】HashMap在容量不够进行resize时由于高并发可能出现死链，导致CPU飙升，在开发过程中注意规避此风险。

19.【推荐】ThreadLocal对象使用static修饰，ThreadLocal无法解决共享对象的更新问题。

说明：这个变量是针对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享此静态变量，也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象(只要是这个线程内定义的)都可以操控这个变量。

1.8 注释规约

1.【强制】类、类属性、类方法的注释必须使用Javadoc规范，使用/**内容*/格式，不得使用 //xxx方式。

说明：在IDE编辑窗口中，Javadoc方式会提示相关注释，生成Javadoc可以正确输出相应注释；在IDE中，工程调用方法时，不进入方法即可悬浮提示方法、参数、返回值的意义，提高阅读效率。

2.【强制】所有的抽象方法（包括接口中的方法）必须要用Javadoc注释、除了返回值、参数、异常说明外，还必须指出该方法做什么事情，实现什么功能。说明：对子类的实现要求，或者调用注意事项，请一并说明。

3.【强制】所有的类都必须添加创建者和创建日期。
说明：在设置模板时，注意IDEA的@author为${USER}，大小写有区别，而日期的设置统一为yyyy/MM/dd的格式。

4.【强制】方法内部单行注释，在被注释语句上方另起一行，使用//注释。方法内部多行注释使用/**/注释，注意与代码对齐。

5.【推荐】代码修改的同时，注释也要进行相应的修改，尤其是参数、返回值、异常、核心逻辑等的修改。

6.【推荐】删除未使用的任何字段和方法；在方法中删除未使用的任何参数声明与内部变量。

7.【推荐】谨慎注释掉代码。在上方详细说明，而不是简单地注释掉。如果无用，则删除。

8.【推荐】对于注释的要求：第一、能够准确反映设计思想和代码逻辑；第二、能够描述业务含义，使别的程序员能够迅速了解到代码背后的信息。完全没有注释的大段代码对于阅读者形同天书，注释是给自己看的，即使隔很长时间，也能清晰理解当时的思路；注释也是给继任者看的，使其能够快速接替自己的工作。

9.【推荐】好的命名、代码结构是自解释的，注释力求精简准确、表达到位。避免出现注释的一个极端：过多过滥的注释，代码的逻辑一旦修改，修改注释是相当大的负担。

10.【推荐】特殊注释标记，请注明标记人与标记时间。注意及时处理这些标记，通过标记扫描，经常清理此类标记。线上故障有时候就是来源于这些标记处的代码。
1）待办事宜（TODO）:（标记人，标记时间，[预计处理时间]）
2）错误，不能工作（FIXME）:（标记人，标记时间，[预计处理时间]）在注释中用FIXME标记某代码是错误的，而且不能工作，需要及时纠正的情况。

2、异常日志

2.1 错误码

1.【强制】错误码的制定原则：快速溯源、简单易记、沟通标准化。

不要所有错误信息直接抛出（或者抛出系统异常）

1）下游系统可根据错误码能对上游服务逻辑初步认识；

2）正常业务逻辑上的校验，根据交易码可输出解决办法。

3）系统异常，可快速定位问题

2.【强制】错误码使用者避免随意定义新的错误码。说明：尽可能在原有错误码附表中找到语义相同或者相近的错误码在代码中使用即可。

3.【强制】错误码不能直接输出给用户作为提示信息使用。
说明：堆栈（stack_trace）、错误信息(error_message)、错误码（error_code）、提示信息（user_tip）是一个有效关联并互相转义的和谐整体，但是请勿互相越俎代庖。

4.【推荐】错误码之外的业务独特信息由error_message来承载，而不是让错误码本身涵盖过多具体业务属性。

5.【推荐】在获取第三方服务错误码时，向上抛出允许本系统转义，由C转为B，并且在错误信息上带上原有的第三方错误码。

6.【推荐】错误码分为一级宏观错误码、二级宏观错误码、三级宏观错误码。说明：在无法更加具体确定的错误场景中，可以直接使用一级宏观错误码，分别是：A0001（用户端错误）、B0001（系统执行出错）、C0001（调用第三方服务出错）。
正例：调用第三方服务出错是一级，中间件错误是二级，消息服务出错是三级。

2.2 异常处理

1.【强制】Java类库中定义的可以通过预检查方式规避的RuntimeException异常不应该通过
catch的方式来处理，比如：NullPointerException，IndexOutOfBoundsException等等。
说明：无法通过预检查的异常除外，比如，在解析字符串形式的数字时，可能存在数字格式错误，不得不通过catchNumberFormatException来实现。
正例：if(obj!=null){...}
反例：try{obj.method();}catch(NullPointerExceptione){…}
2.【强制】异常不要用来做流程控制，条件控制。说明：异常设计的初衷是解决程序运行中的各种意外情况，且异常的处理效率比条件判断方式要低很多。
3.【强制】catch时请分清稳定代码和非稳定代码，稳定代码指的是无论如何不会出错的代码。对于非稳定代码的catch尽可能进行区分异常类型，再做对应的异常处理。说明：对大段代码进行try-catch，使程序无法根据不同的异常做出正确的应激反应，也不利于定位问题，这是一种不负责任的表现。
正例：用户注册的场景中，如果用户输入非法字符，或用户名称已存在，或用户输入密码过于简单，在程序上作出分门别类的判断，并提示给用户。
4.【强制】捕获异常是为了处理它，不要捕获了却什么都不处理而抛弃之，如果不想处理它，请将该异常抛给它的调用者。最外层的业务使用者，必须处理异常，将其转化为用户可以理解的内容。
5.【强制】事务场景中，抛出异常被catch后，如果需要回滚，一定要注意手动回滚事务。
6.【强制】finally块必须对资源对象、流对象进行关闭，有异常也要做try-catch。
说明：如果JDK7及以上，可以使用try-with-resources方式。
7.【强制】不要在finally块中使用return。说明：try块中的return语句执行成功后，并不马上返回，而是继续执行finally块中的语句，如果此处存在return语句，则在此直接返回，无情丢弃掉try块中的返回点。反例：
privateintx=0;

publicintcheckReturn(){try{
//x等于1，此处不返回
return++x;
}finally{
//返回的结果是2
return++x;}
}
8.【强制】捕获异常与抛异常，必须是完全匹配，或者捕获异常是抛异常的父类。说明：如果预期对方抛的是绣球，实际接到的是铅球，就会产生意外情况。
9.【强制】在调用RPC、二方包、或动态生成类的相关方法时，捕捉异常必须使用Throwable类来进行拦截。
说明：通过反射机制来调用方法，如果找不到方法，抛出NoSuchMethodException。什么情况会抛出NoSuchMethodError呢？二方包在类冲突时，仲裁机制可能导致引入非预期的版本使类的方法签名不匹配，或者在字节码修改框架（比如：ASM）动态创建或修改类时，修改了相应的方法签名。这些情况，即使代码编译期是正确的，但在代码运行期时，会抛出NoSuchMethodError。
10.【推荐】方法的返回值可以为null，不强制返回空集合，或者空对象等，必须添加注释充分说明什么情况下会返回null值。说明：本手册明确防止NPE是调用者的责任。即使被调用方法返回空集合或者空对象，对调用者来说，也并非高枕无忧，必须考虑到远程调用失败、序列化失败、运行时异常等场景返回null的情况。
11.【推荐】防止NPE，是程序员的基本修养，注意NPE产生的场景：
1）返回类型为基本数据类型，return包装数据类型的对象时，自动拆箱有可能产生NPE。
反例：publicintf(){returnInteger对象}，如果为null，自动解箱抛NPE。
2）数据库的查询结果可能为null。
3）集合里的元素即使isNotEmpty，取出的数据元素也可能为null。
4）远程调用返回对象时，一律要求进行空指针判断，防止NPE。
5）对于Session中获取的数据，建议进行NPE检查，避免空指针。
6）级联调用obj.getA().getB().getC()；一连串调用，易产生NPE。正例：使用JDK8的Optional类来防止NPE问题。
12.【推荐】定义时区分unchecked/checked异常，避免直接抛出newRuntimeException()，更不允许抛出Exception或者Throwable，应使用有业务含义的自定义异常。推荐业界已定
义过的自定义异常，如：DAOException/ServiceException等。
13.【推荐】对于公司外的http/api开放接口必须使用“错误码”；而应用内部推荐异常抛出；跨应用间RPC调用优先考虑使用Result方式，封装isSuccess()方法、“错误码”、“错误简短信息”；而应用内部推荐异常抛出。
说明：关于RPC方法返回方式使用Result方式的理由：
1）使用抛异常返回方式，调用方如果没有捕获到就会产生运行时错误。
2）如果不加栈信息，只是new自定义异常，加入自己的理解的errormessage，对于调用端解决问题的帮助不会太多。如果加了栈信息，在频繁调用出错的情况下，数据序列化和传输的性能损耗也是问题。
14.【推荐】避免出现重复的代码（Don'tRepeatYourself），即DRY原则。
说明：随意复制和粘贴代码，必然会导致代码的重复，在以后需要修改时，需要修改所有的副本，容易遗漏。必要时抽取共性方法，或者抽象公共类，甚至是组件化。
正例：一个类中有多个public方法，都需要进行数行相同的参数校验操作，这个时候请抽取：
privatebooleancheckParam(DTOdto){...}

2.3 日志规约

1.【强制】应用中不可直接使用日志系统（Log4j、Logback）中的API，而应依赖使用日志框架
（SLF4J、JCL--JakartaCommonsLogging）中的API，使用门面模式的日志框架，有利于维护和
各个类的日志处理方式统一。
说明：日志框架（SLF4J、JCL--JakartaCommonsLogging）的使用方式（推荐使用SLF4J）
使用SLF4J：
importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;
privatestaticfinalLoggerlogger=LoggerFactory.getLogger(Test.class);使用JCL：
importorg.apache.commons.logging.Log;importorg.apache.commons.logging.LogFactory;privatestaticfinalLoglog=LogFactory.getLog(Test.class);
2.【强制】所有日志文件至少保存15天，因为有些异常具备以“周”为频次发生的特点。对于当天日志，以“应用名.log”来保存，保存在/home/app/应用名/logs/目录下，过往日志格式为:{logname}.log.{保存日期}，日期格式：yyyy-MM-dd说明：以mppserver应用为例，日志保存在/home/app/mppserver/logs/mppserver.log，历史日志名称为mppserver.log.2016-08-01
3.【强制】应用中的扩展日志（如打点、临时监控、访问日志等）命名方式：
appName_logType_logName.log。logType:日志类型，如stats/monitor/access等；logName:日志描述。这种命名的好处：通过文件名就可知道日志文件属于什么应用，什么类型，什么目的，也有利于归类查找。
说明：推荐对日志进行分类，如将错误日志和业务日志分开存放，便于开发人员查看，也便于通过日志对系统进行及时监控。
正例：mppserver应用中单独监控时区转换异常，如：mppserver_monitor_timeZoneConvert.log
4.【强制】在日志输出时，字符串变量之间的拼接使用占位符的方式。
说明：因为String字符串的拼接会使用StringBuilder的append()方式，有一定的性能损耗。使用占位符仅是替换动作，可以有效提升性能。
正例：logger.debug("Processingtradewithid:{}andsymbol:{}",id,symbol);
5.【强制】对于trace/debug/info级别的日志输出，必须进行日志级别的开关判断。
说明：虽然在debug(参数)的方法体内第一行代码isDisabled(Level.DEBUG_INT)为真时（Slf4j的常见实现Log4j和Logback），就直接return，但是参数可能会进行字符串拼接运算。此外，如果debug(getName())这种参数内有getName()方法调用，无谓浪费方法调用的开销。正例：
//如果判断为真，那么可以输出trace和debug级别的日志
if(logger.isDebugEnabled()){logger.debug("CurrentIDis:{}andnameis:{}",id,getName());
}
6.【强制】避免重复打印日志，浪费磁盘空间，务必在log4j.xml中设置additivity=false。
正例：<loggername="com.taobao.dubbo.config"additivity="false">
7.【强制】生产环境禁止直接使用System.out或System.err输出日志或使用
e.printStackTrace()打印异常堆栈。
说明：标准日志输出与标准错误输出文件每次Jboss重启时才滚动，如果大量输出送往这两个文件，容易造成文件大小超过操作系统大小限制。
8.【强制】异常信息应该包括两类信息：案发现场信息和异常堆栈信息。如果不处理，那么通过关键字throws往上抛出。
正例：logger.error(各类参数或者对象toString()+"_"+e.getMessage(),e);
9.【强制】日志打印时禁止直接用JSON工具将对象转换成String。说明：如果对象里某些get方法被重写，存在抛出异常的情况，则可能会因为打印日志而影响正常业务流程的执行。
正例：打印日志时仅打印出业务相关属性值或者调用其对象的toString()方法。
10.【推荐】谨慎地记录日志。生产环境禁止输出debug日志；有选择地输出info日志；如果使用warn来记录刚上线时的业务行为信息，一定要注意日志输出量的问题，避免把服务器磁盘撑爆，并记得及时删除这些观察日志。
说明：大量地输出无效日志，不利于系统性能提升，也不利于快速定位错误点。记录日志时请思考：这些日志真的有人看吗？看到这条日志你能做什么？能不能给问题排查带来好处？
11.【推荐】可以使用warn日志级别来记录用户输入参数错误的情况，避免用户投诉时，无所适从。如非必要，请不要在此场景打出error级别，避免频繁报警。说明：注意日志输出的级别，error级别只记录系统逻辑出错、异常或者重要的错误信息。
12.【推荐】尽量用英文来描述日志错误信息，如果日志中的错误信息用英文描述不清楚的话使用中文描述即可，否则容易产生歧义。说明：国际化团队或海外部署的服务器由于字符集问题，使用全英文来注释和描述日志错误信息。

薛定谔的猿