后端开发规范

绝地灬酷狼 2022-12-07 11:40 200阅读 0赞

java开发规范

### 循环 ###

使用了while类的循环操作时，要求必须增加一个最大阈值控制器，如果超过该阈值则中断while操作，避免死循环和cpu使用率飙升的问题。

如：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>        // 最大循环次数需要契合于业务
        int maxCycleNum = 10000;
        int cycleNum = 0;
        while(cycleNum ++ &lt; maxCycleNum &amp;&amp;  业务循环条件 ){
            // 主逻辑
            System.out.println(cycleNum);
        }</pre> </td> 
  </tr> 
 </tbody> 
</table>

命名规范  
【强制】避免在子父类的成员变量之间、或者不同代码块的局部变量之间采用完全相同的命名，  
使可理解性降低。  
【强制】杜绝完全不规范的缩写，避免望文不知义。为了达到代码自解释的目标，任何自定义编程元素在命名时，使用尽量完整的单词组合来表达；如果实在过长需采用缩写需要注释其含义。  
反例：AbstractClass“缩写”成 AbsClass；condition“缩写”成  condi；Function 缩写”成 Fu，此类  
随意缩写严重降低了代码的可阅读性。

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

【推荐】接口类中的方法和属性不要加任何修饰符号（public  也不要加），保持代码的简洁  
性，并加上有效的 Javadoc  注释。尽量不要在接口里定义变量，如果一定要定义变量，确定  
与接口方法相关，并且是整个应用的基础常量。  
正例：接口方法签名  void commit();  
接口基础常量  String COMPANY = "alibaba";  
反例：接口方法定义  public abstract void f();  
说明：JDK8 中接口允许有默认实现，那么这个 default  方法，是对所有实现类都有价值的默认实现。

【参考】各层命名规约：  
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。

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

【推荐】不要使用一个常量类维护所有常量，要按常量功能进行归类，分开维护。  
说明：大而全的常量类，杂乱无章，使用查找功能才能定位到修改的常量，不利于理解，也不利于维护。  
正例：缓存相关常量放在类 CacheConsts 下；系统配置相关常量放在类 SystemConfigConsts  下。

【强制】在进行类型强制转换时，右括号与强制转换值之间不需要任何空格隔开。  
正例：  
double first =  3.2d;  
int second = (int)first +  2;

OOP  规约  
【强制】避免通过一个类的对象引用访问此类的静态变量或静态方法，无谓增加编译器解析成本，直接用类名来访问即可。  
【强制】所有的覆写方法，必须加@Override  注解。  
说明：getObject()与 get0bject()的问题。一个是字母的 O，一个是数字的 0，加@Override  可以准确判  
断是否覆盖成功。另外，如果在抽象类中对方法签名进行修改，其实现类会马上编译报错。

【强制】任何货币金额，均以最小货币单位且整型类型来进行存储。

【强制】浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 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  
\}  
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");  
\}  
【强制】如上所示 BigDecimal 的等值比较应使用 compareTo()方法，而不是 equals()方法。  
说明：equals()方法会比较值和精度（1.0 与 1.00 返回结果为 false），而 compareTo()则会忽略精度。

【强制】定义数据对象 DO  类时，属性类型要与数据库字段类型相匹配。  
正例：数据库字段的 bigint 必须与类属性的 Long  类型相对应。  
反例：某个案例的数据库表 id 字段定义类型 bigint unsigned，实际类对象属性为 Integer，随着 id  越来  
越大，超过 Integer  的表示范围而溢出成为负数。

【强制】禁止使用构造方法BigDecimal(double)的方式把double值转化为 BigDecimal  对象。  
说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。  
如：BigDecimal g = 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);

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

【强制】定义 DO/DTO/VO 等 POJO  类时，不要设定任何属性默认值。  
反例：POJO 类的 createTime 默认值为 new Date()，但是这个属性在数据提取时并没有置入具体值，在  
更新其它字段时又附带更新了此字段，导致创建时间被修改成当前时间。

日期时间  
1.  【强制】日期格式化时，传入 pattern 中表示年份统一使用小写的 y。  
说明：日期格式化时，yyyy 表示当天所在的年，而大写的 YYYY 代表是 week in which year（JDK7  之后  
引入的概念），意思是当天所在的周属于的年份，一周从周日开始，周六结束，只要本周跨年，返回的 YYYY  
就是下一年。  
正例：表示日期和时间的格式如下所示：  
new DateTimeFormatter("yyyy-MM-dd HH:mm:ss")

【推荐】涉及到日期处理的场景推荐使用joda包下的DateTime,功能十分丰富，如：  
import org.joda.time.DateTime;  
// 获取6个月后的时间  
Date endDate = DateTime.now().plusMonths(6).toDate();

【强制】在日期格式中分清楚大写的M和小写的m，大写的 H 和小写的 h  分别指代的意义。  
说明：日期格式中的这两对字母表意如下：  
1）  表示月份是大写的 M；  
2）  表示分钟则是小写的 m；  
3）  24 小时制的是大写的 H；  
4）  12 小时制的则是小写的 h。

集合  
【强制】判断所有集合内部的元素是否为空，使用 isEmpty()方法，而不是 size()==0  的方式。  
说明：在某些集合中，前者的时间复杂度为 O(1)，而且可读性更好。而size在集合不为空的场景下是需要获取具体size()的  
正例：  
Map<String, Object> map = new  HashMap<>(16);  
if(map.isEmpty())  \{  
System.out.println("no element in this map.");  
\}

【强制】在使用 java.util.stream.Collectors 类的 toMap()方法转为 Map  集合时，一定要使用含有参数类型为 BinaryOperator，参数名为 mergeFunction 的方法，否则当出现相同key值时会抛出 IllegalStateException  异常。  
说明：参数 mergeFunction 的作用是当出现 key 重复时，自定义对 value 的处理策略。  
正例：  
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));  
反例：  
String\[\] departments = new String\[\] \{"iERP", "iERP", "EIBU"\};  
//  抛出 IllegalStateException  异常  
Map<Integer, String> map =  Arrays.stream(departments)  
.collect(Collectors.toMap(String::hashCode, str ->  str));  
【强制】在使用 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 = 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));

【强制】ArrayList 的 subList 结果不可强转成 ArrayList，否则会抛出  ClassCastException  异  
常：java.util.RandomAccessSubList cannot be cast to java.util.ArrayList。  
说明：subList()返回的是 ArrayList 的内部类 SubList，并不是 ArrayList 本身，而是 ArrayList  的一个视  
图，对于 SubList  的所有操作最终会反映到原列表上。  
【强制】使用 Map 的方法keySet()/values()/entrySet()返回集合对象时，不可以对其进行添  
加元素操作，否则会抛出 UnsupportedOperationException  异常。

【强制】Collections 类返回的对象，如：emptyList()/singletonList()等都是 immutable list，  
不可对其进行添加或者删除元素的操作。  
反例：如果查询无结果，返回 Collections.emptyList()空集合对象，调用方一旦进行了添加元素的操作，就  
会触发 UnsupportedOperationException 异常。

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

【强制】使用集合转数组的方法，必须使用集合的 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  隐患。

【强制】在使用Collection接口任何实现类的addAll()方法时，都要对输入的集合参数进行NPE判断。  
说明：在 ArrayList\#addAll 方法的第一行代码即 Object\[\] a = c.toArray(); 其中 c  为输入集合参数，如果  
为 null，则直接抛出异常。

【强制】使用工具类 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";  也会随之修改，反之亦然。  
【强制】泛型通配符<? extends T>来接收返回的数据，此写法的泛型集合不能使用 add  方法，  
而<? super T>不能使用 get  方法，两者在接口调用赋值的场景中容易出错。  
说明：扩展说一下 PECS(Producer Extends Consumer Super)原则：第一、频繁往外读取内容的，适合用  
<? extends T>。第二、经常往里插入的，适合用<? super T>

【强制】在无泛型限制定义的集合赋值给泛型限制的集合时，在使用集合元素时，需要进行  
instanceof 判断，避免抛出 ClassCastException  异常。  
说明：毕竟泛型是在 JDK5  后才出现，考虑到向前兼容，编译器是允许非泛型集合与泛型集合互相赋值。  
反例：  
List<String> generics =  null;  
List notGenerics = new  ArrayList(10);  
notGenerics.add(new Object());  
notGenerics.add(new Integer(1));  
generics =  notGenerics;  
//  此处抛出 ClassCastException  异常  
String string =  generics.get(0);

【强制】不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用  Iterator  
方式，如果并发操作，需要对 Iterator  对象加锁。  
正例：  
List<String> list = new  ArrayList<>();  
list.add("1");  
list.add("2");  
Iterator<String> iterator =  list.iterator();  
while (iterator.hasNext()) \{  
String item =  iterator.next();  
if (删除元素的条件) \{  
iterator.remove();  
\}  
\}  
反例：  
for (String item : list)  \{  
if ("1".equals(item)) \{  
list.remove(item);  
\}  
\}  
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的结果吗？

【强制】在 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  比较结果相同。  
反例：下例中没有处理相等的情况，交换两个对象判断结果并不互反，不符合第一个条件，在实际使用中  
可能会出现异常。  
new Comparator<Student>()  \{  
@Override  
public int compare(Student o1, Student o2)  \{  
return o1.getId() > o2.getId() ? 1 : -1;  
\}  
\};

【推荐】使用 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  值组合集合。

并发  
【强制】获取单例对象需要保证线程安全，其中的方法也要保证线程安全。  
说明：资源驱动类、工具类、单例工厂类都需要注意。

【强制】创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。  
正例：自定义线程工厂，并且根据外部特征进行分组，比如，来自同一机房的调用，把机房编号赋值给  
whatFeatureOfGroup  
public class UserThreadFactory implements ThreadFactory  \{  
private final String namePrefix;  
private final AtomicInteger nextId = new  AtomicInteger(1);  
//  定义线程组名称，在利用 jstack  来排查问题时，非常有帮助  
UserThreadFactory(String whatFeatureOfGroup)  \{  
namePrefix = "From UserThreadFactory's " + whatFeatureOfGroup +  "-Worker-";  
\}  
@Override  
public Thread newThread(Runnable task)  \{  
String name = namePrefix +  nextId.getAndIncrement();  
Thread thread = new Thread(null, task, name, 0,  false);  
System.out.println(thread.getName());  
return  thread;  
\}  
\}

【强制】SimpleDateFormat  是线程不安全的类，一般不要定义为 static 变量，如果定义为 static，  
必须加锁，或者使用 DateUtils  工具类。  
正例：注意线程安全，使用 DateUtils。亦推荐如下处理：  
private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>()  \{  
@Override  
protected DateFormat initialValue()  \{  
return new  SimpleDateFormat("yyyy-MM-dd");  
\}  
\};  
说明：如果是 JDK8 的应用，可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，  
DateTimeFormatter 代替 SimpleDateFormat，官方给出的解释：simple beautiful strong immutable  
thread-safe。

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

强制】在使用阻塞等待获取锁的方式中，必须在 try 代码块之外，并且在加锁方法与 try  代  
码块之间没有任何可能抛出异常的方法调用，避免加锁成功后，在 finally  中无法解锁。  
说明一：如果在 lock 方法与 try  代码块之间的方法调用抛出异常，那么无法解锁，造成其它线程无法成功  
获取锁。  
说明二：如果 lock 方法在 try 代码块之内，可能由于其它方法抛出异常，导致在 finally 代码块中，unlock  
对未加锁的对象解锁，它会调用 AQS 的 tryRelease  方法（取决于具体实现类），抛出  
IllegalMonitorStateException  异常。  
说明三：在 Lock 对象的 lock 方法实现中可能抛出 unchecked  异常，产生的后果与说明二相同。  
正例：  
Lock lock = new  XxxLock();  
// ...  
lock.lock();  
try  \{  
doSomething();  
doOthers();  
\} finally  \{  
lock.unlock();  
\}  
反例：  
Lock lock = new  XxxLock();  
// ...  
18/59  
   
   
Java开发手册  
try  \{  
//  如果此处抛出异常，则直接执行 finally  代码块  
doSomething();  
//  无论加锁是否成功，finally  代码块都会执行  
lock.lock();  
doOthers();  
\} finally  \{  
lock.unlock();  
\}

强制】并发修改同一记录时，避免更新丢失，需要加锁。要么在应用层加锁，要么在缓存加  
锁，要么在数据库层使用乐观锁，使用 version  作为更新依据。  
说明：如果每次访问冲突概率小于 20%，推荐使用乐观锁，否则使用悲观锁。乐观锁的重试次数不得小于  
3  次。  
12.【强制】多线程并行处理定时任务时，Timer 运行多个 TimeTask  时，只要其中之一没有捕获抛  
出的异常，其它任务便会自动终止运行，使用 ScheduledExecutorService  则没有这个问题。

【推荐】避免 Random 实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一  seed  
导致的性能下降。  
说明：Random 实例包括 java.util.Random 的实例或者  Math.random()的方式。  
正例：在 JDK7 之后，可以直接使用 API ThreadLocalRandom，而在 JDK7  之前，需要编码保证每个线  
程持有一个单独的 Random  实例。

控制语句  
【强制】在一个 switch 块内，每个 case 要么通过 continue/break/return  等来终止，要么  
注释说明程序将继续执行到哪一个 case 为止；在一个 switch 块内，都必须包含一个  default  
语句并且放在最后，即使它什么代码也没有。  
说明：注意 break 是退出 switch 语句块，而 return  是退出方法体。

【强制】当 switch 括号内的变量类型为 String 并且此变量为外部参数时，必须先进行  null  
判断。  
反例：如下的代码输出是什么？  
public class SwitchString  \{  
public static void main(String\[\] args)  \{  
method(null);  
\}  
public static void method(String param)  \{  
switch (param) \{  
//  肯定不是进入这里  
case  "sth":  
System.out.println("it's  sth");  
break;  
//  也不是进入这里  
case  "null":  
System.out.println("it's  null");  
break;  
//  也不是进入这里  
default:  
System.out.println("default");  
\}  
\}  
\}

【强制】在高并发场景中，避免使用”等于”判断作为中断或退出的条件。  
说明：如果并发控制没有处理好，容易产生等值判断被“击穿”的情况，使用大于或小于的区间判断条件  
来代替。  
反例：判断剩余奖品数量等于 0  时，终止发放奖品，但因为并发处理错误导致奖品数量瞬间变成了负数，  
这样的话，活动无法终止。

异常处理  
【强制】异常捕获后不要用来做流程控制，条件控制。  
说明：异常设计的初衷是解决程序运行中的各种意外情况，且异常的处理效率比条件判断方式要低很多。  
【强制】catch  时请分清稳定代码和非稳定代码，稳定代码指的是无论如何不会出错的代码。  
对于非稳定代码的 catch  尽可能进行区分异常类型，再做对应的异常处理。  
说明：对大段代码进行 try-catch，使程序无法根据不同的异常做出正确的应激反应，也不利于定位问题，  
这是一种不负责任的表现。  
正例：用户注册的场景中，如果用户输入非法字符，或用户名称已存在，或用户输入密码过于简单，在程  
序上作出分门别类的判断，并提示给用户。  
【强制】事务场景中，抛出异常被 catch  后，如果需要回滚，一定要注意手动回滚事务。

【强制】finally 块必须对资源对象、流对象进行关闭，有异常也要做 try-catch。  
说明：如果 JDK7 及以上，可以使用 try-with-resources  方式。  
public static void copy(String src, String dst) \{  
    try (InputStream in = new FileInputStream(src);  
         OutputStream out = new FileOutputStream(dst)) \{  
        byte\[\] buff = new byte\[1024\];  
        int n;  
        while ((n = in.read(buff)) >= 0) \{  
            out.write(buff, 0, n);  
        \}  
    \} catch (IOException e) \{  
        e.printStackTrace();  
    \}  
\}  
 【强制】不要在 finally 块中使用 return。  
说明：try 块中的 return 语句执行成功后，并不马上返回，而是继续执行 finally  块中的语句，如果此处存  
在 return 语句，则在此直接返回，无情丢弃掉 try  块中的返回点。  
反例：  
private int x =  0;  
public int checkReturn()  \{  
try  \{  
// x 等于 1，此处不返回  
return  ++x;  
\} finally  \{  
//  返回的结果是  2  
return  ++x;  
\}  
\}

【推荐】涉及到日期处理的场景推荐使用joda包下的DateTime,功能十分丰富，如：

import org.joda.time.DateTime;  
// 获取6个月后的时间  
Date endDate = DateTime.now().plusMonths(6).toDate();

争议：  
4. 【强制】类名使用UpperCamelCase风格，但以下情形例外:DO/BO/DTO/VO/AO/ PO / UID 等。  
正例:ForceCode / UserDO / HtmlDTO / XmlService / TcpUdpDeal / TaPromotion 反例:forcecode / UserDo / HTMLDto / XMLService / TCPUDPDeal / TAPromotion

9. 【强制】POJO类中的任何布尔类型的变量，都不要加is前缀，否则部分框架解析会引起序列化错误。  
说明：在本文 MySQL 规约中的建表约定第一条，表达是与否的变量采用 is\_xxx  的命名方式，所以，需要  
在<resultMap>设置从 is\_xxx 到 xxx  的映射关系。  
反例：定义为基本数据类型 Boolean isDeleted 的属性，它的方法也是 isDeleted()，框架在反向解析的时  
候，“误以为”对应的属性名称是 deleted，导致属性获取不到，进而抛出异常。  
【强制】判断所有集合内部的元素是否为空，使用isEmpty()方法，而不是size()==0的方式。

说明:在某些集合中，前者的时间复杂度为 O(1)，而且可读性更好。