下载地址：https://github.com/alibaba/p3c/tree/master

编程规约

命名风格

所有编程相关的命名均不能以下划线或美元符号开始，也不能以下划线或美元符号结束。

如:_name / __name / $Object / name_ / name$ / Object$

类名使用 UpperCamelCase 风格。

• 以下情形例外：DO / PO / DTO / BO / VO / UID 等。

正例:

• ForceCode / UserDO / HtmlDTO / XmlService / TcpUdpDeal / TaPromotion。

反例:

• forcecode / UserDo / HTMLDto / XMLService / TCPUDPDeal / TAPromotion。

方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格。

正例:

• localValue / getHttpMessage() / inputUserId

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

正例:

• MAX_STOCK_COUNT / CACHE_EXPIRED_TIME

反例:

• MAX_COUNT / EXPIRED_TIME

抽象类命名使用 Abstract 或 Base 开头。

异常类命名使用 Exception 结尾。

测试类命名以它要 测试的类的名称开始，以 Test 结尾。

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

定义为布尔类型 Boolean isDeleted 的字段，它的 getter 方法也是 isDeleted()，部分框架在反向解析时，误以为 对应的字段名称是 deleted，导致字段获取不到，得到意料之外的结果或抛出异常。

包名统一使用小写，点分隔符之间有且仅有一个自然语义的英语单词。

包名统一使用单数形式，但是类名如果有复数含义，类名可以使用复数形式。

正例：

• 应用工具类包名为 com.alibaba.ei.kunlun.aap.util。
• 类名为 MessageUtils(此规则参考 spring 的框架结构)。

杜绝完全不规范的英文缩写，避免望文不知义。

反例:

• AbstractClass 缩写 成 AbsClass。
• condition 缩写 成 condi。
• Function 缩写 成 Fu，此类随意缩写 严重降低了代码的可阅读性。

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

正例:

• startTime / workQueue / nameList / TERMINATED_THREAD_COUNT

反例:

• startedAt / QueueOfWork / listName / COUNT_TERMINATED_THREAD

如果模块、接口、类、方法使用了设计模式，在命名时要体现出具体模式。

正例:

• public class OrderFactory;
• public class LoginProxy;
• public class ResourceObserver;

对于 Service 和 DAO 类，基于 SOA 的理念，暴露出来的服务一定是接口，内部的实现类用 Impl 的后缀 与接口区别。

正例:

• CacheServiceImpl 实现 CacheService 接口。

如果是形容能力的接口名称，取对应的形容词为接口名(通常是 –able 结尾的形容词)。

正例:

• AbstractTranslator 实现 Translatable。

枚举类名带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开。

• 枚举其实就是特殊的常量类，且构造方法被默认强制是私有。

正例:

• 枚举名字为 ProcessStatusEnum 的成员名称：SUCCESS / UNKNOWN_REASON

Service / DAO 层方法命名规约:

• 获取单个对象的方法用 get 做前缀。

• 获取多个对象的方法用 list 做前缀，复数结尾，如:listObjects

• 获取统计值的方法用 count 做前缀。

• 插入的方法用 save / insert 做前缀。

• 删除的方法用 remove / delete 做前缀。

• 修改的方法用 update 做前缀。

领域模型命名规约:

• 数据对象：xxxDO，xxx 即为数据表名。

• 数据传输对象：xxxDTO，xxx 为业务领域相关的名称。

• 展示对象：xxxVO，xxx 一般为网页名称。

POJO 是 DO / DTO / BO / VO 的统称，禁止命名成 xxxPOJO。

常量定义

不允许任何魔法值(即未经预先定义的常量)直接出现在代码中。

long 或 Long 赋值时，数值后使用大写 L，不能是小写 l，小写容易跟数字混淆，造成误解。

比如：public static final Long NUM = 2l; 写的是数字的 21，还是 Long 型的 2?

浮点数类型的数值后缀统一为大写的 D 或 F。

正例：

• public static final double HEIGHT = 175.5D;

• public static final float WEIGHT = 150.3F;

不要使用一个常量类维护所有常量，要按常量功能进行归类，分开维护。

正例:

• 缓存相关常量放在类 CacheConsts 下。
• 系统配置相关常量放在类 SystemConfigConsts 下。

如果变量值仅在一个固定范围内变化用 enum 类型来定义。

OOP规约

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

• 可变参数必须放置在参数列表的最后。

• 建议开发者尽量不用可变参数编程。

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

正例:

• "test".equals(param);

反例:

• param.equals("test");

推荐使用 JDK7 引入的工具类 java.util.Objects#equals(Object a, Object b)

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

任何货币金额，均以最小货币单位且为整型类型进行存储。

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

使用 BigDecimal 来定义值，再进行浮点数的运算操作。

BigDecimal 的等值比较应使用 compareTo() 方法，而不是 equals() 方法。

• equals() 方法会比较值和精度(1.0 与 1.00 返回结果为 false)，而 compareTo() 则会忽略精度。

定义数据对象 DO 类时，属性类型要与数据库字段类型相匹配。

正例:

• 数据库字段的 bigint 必须与类属性的 Long 类型相对应。

禁止使用构造方法 BigDecimal(double) 的方式把 double 值转化为 BigDecimal 对象。

BigDecimal(double) 存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。

如: BigDecimal g = new BigDecimal(0.1F);

• 实际的存储值为:0.100000001490116119384765625

优先推荐入参为 String 的构造方法，或使用 BigDecimal 的 valueOf 方法，此方法内部其实执行了 Double 的 toString，而 Double 的 toString 按 double 的实际能表达的精度对尾数进行了截断。

1
2

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

基本数据类型与包装数据类型的使用标准:

• 所有的 POJO 类属性必须使用包装数据类型。

• RPC 方法的返回值和参数必须使用包装数据类型。

• 所有的局部变量使用基本数据类型。

POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何 NPE 问题，或者入库检查， 都由使用者来保证。

正例:

• 数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。

反例:

• 某业务的交易报表上显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调用不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线-。

• 所以包装数据类型的 null 值，能够表示额外的信息，如：远程调用失败，异常退出。

定义 DO / PO / DTO / VO 等 POJO 类时，不要设定任何属性默认值。

反例:

• 某业务的 DO 的 createTime 默认值为 new Date();

• 但是这个属性在数据提取时并没有置入具体值，在更新其它字段时又附带更新了此字段，导致创建时间被修改成当前时间。

序列化类新增属性时，不要修改 serialVersionUID 字段，避免反序列失败。

如果完全不兼容升级，避免反序列化混乱，需要修改 serialVersionUID 值。

• serialVersionUID 不一致会抛出序列化运行时异常。

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

POJO 类必须写 toString 方法。

使用 IDE 中的工具 source > generate toString 时，如果继 承了另一个 POJO 类，注意在前面加一下super.toString()。

• 在方法执行抛出异常时，可以直接调用 POJO 的 toString() 方法打印其属性值，便于排查问题。

禁止在 POJO 类中，同时存在对应属性 xxx 的 isXxx() 和 getXxx() 方法。

• 框架在调用属性 xxx 的提取方法时，并不能确定哪个方法一定是被优先调用到。

使用索引访问用 String 的 split 方法得到的数组时，需做最后一个分隔符后有无内容的检查，

否则会有抛 IndexOutOfBoundsException 的风险。

• 由于String.Split()的特性，忽略了空值，导致异常。

1
2
3
4

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

当一个类有多个构造方法，或者多个同名方法，这些方法应该按顺序放置在一起，便于阅读。

类内方法定义的顺序依次是：公有方法或保护方法 > 私有方法 > getter / setter 方法。

setter 方法中，参数名称与类成员变量名称一致，this.成员名=参数名。

在 getter/setter 方 法中，不要增加业务逻辑，增加排查问题的难度。

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

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

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

集合处理

hashCode 和 equals 的处理，遵循如下规则:

• 只要覆写 equals，就必须覆写 hashCode。
  • 因为 Set 存储的是不重复的对象，依据 hashCode 和 equals 进行判断，所以 Set 存储的对象必须覆写这两种方法。

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

判断所有集合内部的元素是否为空，使用 isEmpty() 方法，而不是 size() == 0 的方式。

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

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

ArrayList 的 subList 结果不可强转成 ArrayList，否则会抛出 ClassCastException 异常。

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

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

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

一旦集合中进行了添加元素的操作，就会触发 UnsupportedOperationException 异常。

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

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

1
2
3
4

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

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

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

泛型通配符<? extends T>来接收返回的数据，此写法的泛型集合不能使用 add 方法。

<? super T>不能使用 get 方法，两者在接口调用赋值的场景中容易出错。

不要在 foreach 循环里进行元素的 remove/add 操作。

remove 元素使用 iterator 方式。

• 如果并发操作，需要对 iterator 对象加锁。

集合初始化时，指定集合初始值大小。

使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历。

注意 Map 类集合 K/V 能不能存储 null 值的情况。

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

并发处理

获取单例对象需要保证线程安全，其中的方法也要保证线程安全。

创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。

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

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

SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量。

如果定义为 static，必须 加锁，或者使用 DateUtils 工具类。

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

DateTimeFormatter 代替 SimpleDateFormat。

1
2
3
4
5
6

private static final ThreadLocal<DateFormat> dateStyle = new ThreadLocal<DateFormat>() {
	@Override
	protected DateFormat initialValue() {
		return new SimpleDateFormat("yyyy-MM-dd"); 
	}
};

必须回收自定义的 ThreadLocal 变量记录的当前线程的值，尤其在线程池场景下，线程经常会被复用。

如果不清理自定义的 ThreadLocal 变量，可能会影响后续业务逻辑和造成内存泄露等问题。

尽量在代码中使用 try-finally 块进行回收。

1
2
3
4
5
6

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

高并发时，同步调用应该去考量锁的性能损耗。

能用无锁数据结构，就不要用锁。

能锁区块，就不要锁整个方法体，能用对象锁，就不要用类锁。

尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用 RPC 方法。

对多个资源、数据库表、对象同时加锁时，需要保持一致的加锁顺序，否则可能会造成死锁。

线程一需要对表 A、B、C 依次全部加锁后才可以进行更新操作，那么线程二的加锁顺序也必须是 A、B、C，否则可能出现死锁。

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

• 在 lock 方法与 try 代码块之间的方法调用抛出异常，无法解锁，造成其它线程无法成功获取锁。
• 如果 lock 方法在 try 代码块之内，可能由于其它方法抛出异常，导致在 finally 代码块中，unlock 对未加锁的对象解锁，它会调用 AQS 的 tryRelease 方法(取决于具体实现类)，抛出 IllegalMonitorStateException 异常。
• 在 Lock 对象的 lock 方法实现中可能抛出 unchecked 异常，产生的后果与二相同。

正例：

1
2
3
4
5
6
7
8
9

Lock lock = new XxxLock();
// ...
lock.lock();
try {
    doSomething();
    doOthers();
} finally {
    lock.unlock();
}

反例：

1
2
3
4
5
6
7
8
9
10
11
12

Lock lock = new XxxLock();
// ...
try {
    // 如果在此抛出异常，会直接执行 finally 块的代码
    doSomething();
    // 不管锁是否成功，finally 块都会执行
    lock.lock();
    doOthers();

} finally {
    lock.unlock();
}

在使用尝试机制来获取锁的方式中，进入业务代码块之前，必须先判断当前线程是否持有锁。

• 锁的释放规则与锁的阻塞等待方式相同。

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

1
2
3
4
5
6
7
8
9
10
11

Lock lock = new XxxLock();
// ...
boolean isLocked = lock.tryLock();
	if (isLocked) {
 		try {
 			doSomething();
 			doOthers();
	 	} finally {
		 	lock.unlock();
 		}
}

并发修改同一记录时，避免更新丢失，需要加锁。

要么在应用层加锁，要么在缓存加锁，要么在数据库层使用乐观锁，使用 version 作为更新依据。

• 如果每次访问冲突概率小于 20%，推荐使用乐观锁，否则使用悲观锁。
• 乐观锁的重试次数不得小于 3 次。

资金相关的金融敏感信息，使用悲观锁策略。

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

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

通过双重检查锁(double-checked locking)，实现延迟初始化需要将目标属性声明为 volatile 型，(比如修改 helper 的属性声明为 private volatile Helper helper = null;)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class LazyInitDemo {
    private volatile Helper helper = null;
    public Helper getHelper() {
    if (helper == null) {    
        synchronized(this) {  
            if (helper == null) {   
                helper = new Helper();   
            }    
        }   
    }   
    return helper;   
}    
// other methods and fields...   
}

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

如果是 count++ 操作，使用如下类实现:

• 如果是 JDK8，推荐使用 LongAdder 对象，比 AtomicLong 性能更好(减少乐观锁的重试次数)。

1
2

AtomicInteger count = new AtomicInteger();
count.addAndGet(1);

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

ThreadLocal 对象使用 static 修饰，ThreadLocal 无法解决共享对象的更新问题。

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

控制语句

当 switch 括号内的变量类型为 String 并且此变量为外部参数时，必须先进行 null 判断。

三目运算符 condition ? 表达式 1:表达式 2 中，高度注意表达式 1 和 2 在类型对齐时，可能抛出因自动拆箱导致的 NPE 异常。

以下两种场景会触发类型对齐的拆箱操作:

• 表达式 1 或 表达式 2 的值只要有一个是原始类型。
• 表达式 1 或 表达式 2 的值的类型不一致，会强制拆箱升级成表示范围更大的那个类型。

1
2
3
4
5
6

Integer a = 1;
Integer b = 2;
Integer c = null;
Boolean flag = false;
// a*b的结果是int类型，那么c会强制拆箱成int类型，抛出NPE异常 
Integer result = (flag ? a * b : c);

在高并发场景中，避免使用 等于 判断作为中断或退出的条件。

如果并发控制没有处理好，容易产生等值判断被 击穿 的情况，使用大于或小于的区间判断条件来代替。

如：判断剩余奖品数量等于 0 时，终止发放奖品，但因为并发处理错误导致奖品数量瞬间变成了负数，这样的话，活动无法终止。

循环体中的语句要考量性能，以下操作尽量移至循环体外处理：

• 如定义对象、变量、获取数据库连接，进行不必要的 try-catch 操作(这个 try-catch 是否可以移至循环体外)。

数据库

建表规约

表达是与否概念的字段，必须使用 is_xxx 的方式命名，数据类型是 unsigned tinyint(1 表示是，0 表示否)。

• 任何字段如果为非负数，必须是 unsigned。
• 表达逻辑删除的字段名 is_deleted，1 表示删除，0 表示未删除。

表名、字段名必须使用小写字母或数字，禁止出现数字开头禁止两个下划线中间只出现数字。

正例:

• aliyun_admin，rdc_config，level3_name

反例:

• AliyunAdmin，rdcConfig，level_3_name

表名不使用复数名词。

表名应该仅仅表示表里面的实体内容，不应该表示实体数量，对应于 DO 类名也是单数形式，符合表达习惯。

主键索引名为 pk_字段名。

唯一索引名为 uk_字段名。

普通索引名为 idx_字段名。

小数类型为 decimal，禁止使用 float 和 double。

在存储的时候，float 和 double 都存在精度损失的问题，很可能在比较值的时候，得到不正确的结果。

如果存储的数据范围超过 decimal 的范围，建议将数据拆成整数和小数并分开存储。

如果存储的字符串长度几乎相等，使用 char 定长字符串类型。

varchar 是可变长字符串，不预先分配存储空间，长度不要超过 5000，如果存储长度大于此值，定义字段类型为 text，独立出来一张表，用主键来对应，避免影响其它字段索引率。

表必备三字段:id，create_time，update_time。

其中 id 必为主键，类型为 bigint unsigned、单表时自增、步长为 1。

create_time，update_time 的类型均为 datetime 类型，如果要记录时区信息，那么类型设置为 timestamp。

在数据库中不能使用物理删除操作，要使用逻辑删除。

逻辑删除在数据删除后可以追溯到行为操作。

不过会使得一些情况下的唯一主键变得不唯一，需要根据情况来酌情解决。

表的命名最好是遵循 业务名称_表的作用。

正例:

• alipay_task / force_project / trade_config / tes_question

库名与应用名称尽量一致。

单表行数超过 500 万行或者单表容量超过 2GB，才推荐进行分库分表。

• 如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。

合适的字符存储长度，不但节约数据库表空间、节约索引存储，更重要的是提升检索速度。

• 无符号值可以避免误存负数，且扩大了表示范围。

索引规约

业务上具有唯一特性的字段，即使是组合字段，也必须建成唯一索引。

不要以为唯一索引影响了 insert 速度，这个速度损耗可以忽略，但提高查找速度是明显的。

另外，即使在应用层做了非常完善的校验控制，只要没有唯一索引，根据墨菲定律，必然有脏数据产生。

超过三个表禁止 join。

需要 join 的字段，数据类型保持绝对一致。

多表关联查询时，保证被关联的字段需要有索引。

• 即使双表 join 也要注意表索引、SQL 性能。

在 varchar 字段上建立索引时，必须指定索引长度，没必要对全字段建立索引，根据实际文本区分度决定索引长度。

索引的长度与区分度是一对矛盾体，一般对字符串类型数据，长度为 20 的索引，区分度会高达 90% 以上，可以使用 count(distinct left(列名，索引长度)) / count(*) 的区分度来确定。

页面搜索严禁左模糊或者全模糊，如果需要走搜索引擎来解决。

• 索引文件具有 B-Tree 的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。

如果有 order by 的场景，请注意利用索引的有序性。

order by 最后的字段是组合索引的一部分，并且放在索引组合顺序的最后，避免出现 filesort 的情况，影响查询性能。

正例:

• where a = ? and b = ? order by c;索引:a_b_c

反例:

• 索引如果存在范围查询，那么索引有序性无法利用，如:WHERE a > 10 ORDER BY b;索引 a_b 无法排序。

利用覆盖索引来进行查询操作，避免回表。

用 explain 的结果，extra 列会出现:using index。

利用延迟关联或者子查询优化超多分页场景。

先快速定位需要获取的 id 段，然后再关联:

SELECT t1.* FROM 表 1 as t1 , (select id from 表 1 where 条件 LIMIT 100000 , 20) as t2 where t1.id = t2.id

SQL 性能优化的目标:至少要达到 range 级别，要求是 ref 级别，如果可以是 const 最好。

• consts 单表中最多只有一个匹配行(主键或者唯一索引)，在优化阶段即可读取到数据。
• ref 指的是使用普通的索引(normal index)。
• range 对索引进行范围检索。

explain 表的结果，type = index，索引物理文件全扫描，速度非常慢。

这个 index 级别比较 range 还低，与全表扫描是小巫见大巫。

建组合索引的时候，区分度最高的在最左边。

正例:

• 如果 where a = ? and b = ?，a 列的几乎接近于唯一值，那么只需要单建 idx_a 索引即可。

存在非等号和等号混合判断条件时，在建索引时，请把等号条件的列前置。

如:where c > ? and d = ? 那么即使 c 的区分度更高，也必须把 d 放在索引的最前列，即建立组合索引 idx_d_c。

防止因字段类型不同造成的隐式转换，导致索引失效。

SQL语句

不要使用 count(列名) 或 count(常量) 来替代 count(*)，count(*) 是 SQL92 定义的标准统计行数的语法，跟数据库无关，跟 NULL 和非 NULL 无关。

• count(*) 会统计值为 NULL 的行，而 count(列名) 不会统计此列为 NULL 值的行。

count(distinct col) 计算该列除 NULL 之外的不重复行数。

注意 count(distinct col1 , col2) 如果其中一列全为 NULL，那么即使另一列有不同的值，也返回为 0。

当某一列的值全是 NULL 时，count(col) 的返回结果为 0。

但 sum(col) 的返回结果为 NULL，因此使用 sum() 时需注意 NPE 问题。

可以使用如下方式来避免 sum 的 NPE 问题:

• SELECT IFNULL(SUM(column) , 0) FROM table;

SQL 语句中表的别名前加 as，并且以 t1、t2、t3、…的顺序依次命名。

别名可以是表的简称，或者是依照表在 SQL 语句中出现的顺序，以 t1、t2、t3 的方式命名。

别名前加 as 使别名更容易识别。

正例:

• select t1.name from first_table as t1 , second_table as t2 where t1.id = t2.id;

in 操作能避免则避免，若实在避免不了，需要仔细评估 in 后边的集合元素数量，控制在 1000 个之内。

因国际化需要，所有的字符存储与表示，均采用 utf8mb4 字符集，字符计数方法需要注意。

说明:

• SELECT LENGTH("轻松工作");--返回为 12

• SELECT CHARACTER_LENGTH("轻松工作");--返回为 4

表情需要用 utf8mb4 来进行存储，注意它与 utf8 编码的区别。

TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少，但 TRUNCATE 无事务且不触发 trigger，有可能造成事故，故不建议在开发代码中使用此语句。

TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同。