《阿里巴巴 Java开发手册》读后感

时间 2019-11-08

标签阿里巴巴 Java开发手册读后感栏目阿里巴巴繁體版

原文原文链接

前言

只有光头才能变强java

前一阵子一直在学Redis，结果在黄金段位被虐了，暂时升不了段位了，天天都拿不到首胜(好烦)。git

趁着学校校运会，合理地给本身放了一个小长假，而后就回家了。回到家才发现当时618买了一堆书，这堆书还有没撕包装的呢....因而我翻出了最薄的一本《阿里巴巴 Java开发手册》程序员

这本书一共就90多页，一天就能够通读完了，看完以后我又来水博文了。github

注意：算法

书上不少的规范是能够用IDE来避免的，也有不少以前已经知道的了。
因此，这篇文章只记录我认为比较重要，或者说是我以前开发时没有注意到的一些规范(知识点)。
该文章的内容确定没有书上写得那么全的，若是感兴趣的同窗能够去买一原本读一下~

PDF官方地址：sql

github.com/alibaba/p3c

1、Java相关

POJO是DO/DTO/BO/VO的统称，禁止命名为xxxPOJO
获取多个对象的方法中list做为前缀
获取统计值的方法用count做为前缀
POJO类中的布尔类型(Boolean)的变量都不要加is前缀，不然部分框架解析会引发序列化错误
- 若是你的变量名带is的话，好比isActive，框架解析的时候可能就当成active了。
若是是形容能力的接口名称，取对应的形容词为接口名(一般是-able的形式)
不容许任何魔法值(未经预先定义的常量)直接出如今代码中
Object的euqals方法容易抛出空指针异常，应使用常量或者有值的对象来调用equals。推荐使用java.util.Object#equals工具类
全部POJO类的属性所有使用包装数据类型，RPC的返回值和参数必须使用包装数据类型，全部的局部变量都使用基本数据类型。定义VO/DTO/DO等POJO类时，不要设定任何属性的默认值
- 若是你的类属性使用int这样的基本数据类型，默认值是0。通常状况下该变量没有赋值，通常想表达的是不存在(null)，而不是0。
构造方法禁止加入任何的业务逻辑，若是初始化逻辑能够放在init方法中。set/get方法也不要增长业务逻辑。
- 若是set/get方法放入业务逻辑，有时候排查问题就变得很麻烦了
工具类Arrays.asList()把数组转成List时，不能使用其修改集合的相关方法。好比说add、clear、remove
在JDK7以及以上版本中，Comparator要知足三个条件，否则调用Arrays.sort()或者Collections.sort()会报异常。
- x，y 的比较结果和 y，x 的比较结果相反
- 传递性：x>y而且y>z，那么x必定大于z
- 对称性：x=y,则 x,z 比较结果和y，z比较结果相同
使用entrySet遍历Map类集合K/V，而不是用keySet方式遍历
- keySet遍历了两次，一次是转成Iterator对象，一次是从hashMap中取出key所对应的value，若是JDK8可使用Map.foreach方法
线程资源必须由线程池提供，不容许在应用中自行显示建立线程。线程池不容许用Executors建立，经过ThreadPoolExecutor的方式建立，这样的处理方式可以让编写代码的工程师更加明确线程池的运行规则，规避资源耗尽的风险。
SimpleDateFormat是线程不安全的类，通常不要定义为static变量，若是定义为static，必须加锁，或者使用DateUtils工具类
- 若是是JDK8应用，可使用Instant(针对时间统计等场景)代替Date，LocalDateTime代替Calendar，DateTimeFormatter代替SimpleDateFormat
避免Random实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一seed致使性能降低
- 在JDK7以后，能够直接使用API ThreadLocalRandom，而在JDK7 以前，须要编码保证每一个线程持有一个实例。
类、类属性、类方法的注释必须使用 Javadoc 规范，使用 /**内容*/ 格式，不得使用 //xxx 方式
全部的抽象方法（包括接口中的方法）必需要用 Javadoc 注释，除了返回值、参数、异常说明外，还必须指出该方法作什么事情，实现什么功能。全部的类都必须添加建立者和建立日期。
对于暂时被注释掉，后续可能恢复使用的代码片段，在注释代码的上方，使用三个斜杠///来讲明注释代码的理由
保证单元测试的独立性。为了保证单元测试稳定可靠且便于维护，单元测试之间不能互相调用，也不能依赖执行的前后顺序。
高并发服务器建议调小TCP协议的time_await超时时间，调大最大事件句柄数(fd)，

1.1值得说明的点

1、不容许任何魔法值(未经预先定义的常量)直接出如今代码中数据库

例子：编程

Negative example:
    //Magic values, except for predefined, are forbidden in coding.
    if (key.equals("关注公众号：Java3y")) {
        //...
    }

    Positive example:
    String KEY_PRE = "关注公众号：Java3y";
    if (KEY_PRE.equals(key)) {
        //...
    }

复制代码

ps:我猜是把先常量定义出来，后续引用/修改的时候就很方便了。数组

2、Object的euqals方法容易抛出空指针异常，应使用常量或者有值的对象来调用equals。推荐使用java.util.Object#equals工具类安全

java.util.Object#equals的源码(已经判断null的状况了)

public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }
复制代码

3、工具类Arrays.asList()把数组转成List时，不能使用其修改集合的相关方法。

由于返回的ArrayList是一个内部类，并无实现集合的修改方法。后台的数据还是数组，这里体现的是适配器模式。

4、在JDK7以及以上版本中，Comparator要知足自反性，传递性，对称性，否则调用Arrays.sort()或者Collections.sort()会报异常。

The implementor must ensure that sgn(compare(x, y)) == -sgn(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

Finally, the implementor must ensure that compare(x, y)==0 implies that sgn(compare(x, z))==sgn(compare(y, z)) for all z.

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类集合K/V，而不是用keySet方式遍历

首先咱们来看一下使用keySet是如何遍历HashMap的：

public static void main(String[] args) throws InterruptedException {

        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("关注公众号:", "Java3y");
        hashMap.put("坚持原创", "Java3y");
        hashMap.put("点赞", "关注，转发，分享");


        // 获得keySet，遍历keySet获得全部的key
        Set<String> strings = hashMap.keySet();
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()) {

            // HashMap的每一个key
            String key = iterator.next();

			// 经过key能够得到对应的value，若是有看过HashMap的同窗知道get方法的时间复杂度是O(1)
            System.out.println("key = " + key + ", value = " + hashMap.get(key));
        }

    }



复制代码

再来看一下源码：

// 1. 获得keySet，若是不存在，则建立
public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new KeySet();
        keySet = ks;
    }
    return ks;
}

// 2.初始化ks (实际上就是Set集合[HashMap的内部类]，在初始化时须要顺便初始化iterator)
ks = new AbstractSet<K>() {
    public Iterator<K> iterator() {
        return new Iterator<K>() {
            private Iterator<Entry<K,V>> i = entrySet().iterator();

            public boolean hasNext() {
                return i.hasNext();
            }

            public K next() {
                return i.next().getKey();
            }

            public void remove() {
                i.remove();
            }
        };
    }

};




复制代码

再来看一下entrySet，能够直接拿到key和value，不用再使用get方法来获得value，因此比keySet更加推荐使用！

public static void main(String[] args) throws InterruptedException {

        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("关注公众号:", "Java3y");
        hashMap.put("坚持原创", "Java3y");
        hashMap.put("点赞", "关注，转发，分享");


        // 获得entrySet，遍历entrySet获得结果
        Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
        }
    }
复制代码

若是是JDK8的话，推荐直接使用Map.forEach()就行了，咱们也来看看用法：

public static void main(String[] args) throws InterruptedException {

    HashMap<String, String> hashMap = new HashMap<>();
    hashMap.put("关注公众号:", "Java3y");
    hashMap.put("坚持原创", "Java3y");
    hashMap.put("点赞", "关注，转发，分享");

    
    // forEach用法
    hashMap.forEach((key, value) -> System.out.println("key = " + key + ", value = " + value));
}

复制代码

其实在源码里边咱们能够发现，forEach实际上就是封装了entrySet，提供forEach给咱们能够更加方便地遍历Map集合

// forEach源码
    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }
复制代码

5、SimpleDateFormat是线程不安全的类，通常不要定义为static变量，若是定义为static，必须加锁，或者使用DateUtils工具类。

有如下的例子能够正确使用SimpleDateFormat：

// 1. 在方法内部使用，没有线程安全问题
private static final String FORMAT = "yyyy-MM-dd HH:mm:ss";
public String getFormat(Date date){
    SimpleDateFormat dateFormat = new SimpleDateFormat(FORMAT);
    return dateFormat.format(date);
}


// 2. 每次使用的时候加锁 
private static final SimpleDateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public void getFormat(){
    synchronized (SIMPLE_DATE_FORMAT){
    SIMPLE_DATE_FORMAT.format(new Date());
    ….;
}
        
// 3. 使用ThreadLocal，每一个线程都有本身的SimpleDateFormat对象，互不干扰
private static final ThreadLocal<DateFormat> DATE_FORMATTER = new ThreadLocal<DateFormat>() {
    @Override
    protected DateFormat initialValue() {
        return new SimpleDateFormat("yyyy-MM-dd");
    }
};

// 4. 使用DateTimeFormatter(This class is immutable and thread-safe.)

    DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    System.out.println(timeFormatter.format(LocalDateTime.now()));

复制代码

若是是JDK8应用，可使用Instant代替Date，LocalDateTime代替Calendar，DateTimeFormatter代替SimpleDateFormat。

2、数据库相关

表达是否概念的字段，必须使用isxxx的方式命名，数据类型是unsigned tinyint(1表示是，0表示否)
小数类型用decimal，禁止使用float和double。
varchar是可变字符串，不预选分配存储空间的话，长度不要超过5000个字符。若是超过则用text，独立一张表，用主键对应，避免影响到其余字段的索引效率。
表必备的三个字段：id(类型是unsigned bigint)，gmt_create(建立时间)，gme_modified(修改时间)
字段容许适当冗余，以提升查询性能，但必须考虑数据一致性。冗余的字段必须不是频繁修改的字段，不是varhar超长字段(更不能是text字段)。
单表行数超过500万行或者单表容量超过2GB才推荐进行分库分表(若是预计三年都达不到这个数据量，不要在建立表的时候就分库分表!)
超过三个表禁止使用join，须要join的字段，数据类型必须保持一致，当多表关联查询时，保证被关联的字段须要有索引！
在varchar字段上创建索引时，必须指定索引长度，不必对全字段创建索引，页面搜索严禁左模糊或者全模糊，若是须要则经过搜索引擎来解决。
- 充分利用好最左前缀匹配特性！
利用延迟关联或者子查询优化超多也分场景。
若是有全球化须要，均以utf-8编码。若是须要存储表情，选择utf8mb4进行存储。

2.1值得说明的点

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

MySQL并非跳过 offset行，而是取 offset+N行，而后返回放弃前offset行，返回N行，那当 offset特别大的时候，效率就很是的低下，要么控制返回的总页数，要么对超过特定阈值的页数进行SQL改写。

例子：

// 优化前

SELECT id, cu_id, name, info, biz_type
	, gmt_create, gmt_modified, start_time, end_time, market_type
	, back_leaf_category, item_status, picuture_url
FROM relation
WHERE biz_type = '0'
	AND end_time >= '2014-05-29'
ORDER BY id ASC
LIMIT 149420, 20;


// 优化后

SELECT a.*
FROM relation a, (
		SELECT id
		FROM relation
		WHERE biz_type = '0'
			AND end_time >= '2014-05-29'
		ORDER BY id ASC
		LIMIT 149420, 20
	) b
WHERE a.id = b.id

复制代码

解释：其实这里就是经过使用覆盖索引查询返回须要的主键,再根据主键关联原表得到须要的数据。这样就是充分利用了索引！

3、未解决的问题

在看《手册》的时候还有一些知识点没看过、没实践过、涉及到的知识点比较多的，在这里先mark一下，后续再遇到或者有空的时候再回来补坑~

使用CountDownLatch进行异步转同步操做，每一个线程退出前必须调用 countDown方法，线程执行代码注意 catch 异常，确保 countDown 方法被执行到，避免主线程没法执行至 await 方法，直到超时才返回结果。说明：注意，子线程抛出异常堆栈，不能在主线程 try-catch 到。
对于一写多读，是能够解决变量同步问题，可是若是多写，一样没法解决线程安全问题。若是是 count++操做，使用以下类实现: AtomicInteger count = new AtomicInteger(); count.addAndGet(1);若是是 JDK8，推荐使用 LongAdder 对象，比 AtomicLong 性能更好(减小乐观锁的重试次数)。
使用JDK8的Optional类来防止NPE问题。

固然了，若是你有比较好的资料阅读，也能够在评论区告诉我。我也会mark住好好看看。

好比说：“3y，我发现Optional类有篇文章写得很不错，url是xxxx(书籍的名称是xxx)

因为如今没有必定的经验积累，因此如下的章节得回头看：

《手册》中的“日志规约”，“工程结构”、“设计规范”

最后

看我上面写的内容就知道，除了一些规范外，还有不少实用的小技巧，这些对咱们开发是有帮助的。我这个阶段也有一些没怎么接触过的("日志","设计","二方库")，这些都须要我在成长中不断的回看才行。

ps:我会回来补坑的。

引用书上的一句话：

不少编程方式客观上没有对错之分，一致性很重要，可读性很重要，团队沟通效率很重要。程序员天生须要团队协做，而协做的正能量要放在问题的有效沟通上。个性化应尽可能表如今系统架构和算法效率的提高上，而不是在合做规范上进行纠缠不休的讨论、争论，最后没有结论。

做者(孤尽)在知乎回答的一句话：

翻完了不表明记住了，记住了不表明理解了，理解了不表明可以应用上去，真正的知识是实践，实践，实践。

若是你以为我写得还不错，了解一下：

坚持原创的技术公众号：Java3y
文章的目录导航(精美脑图+海量视频资源)：github.com/ZhongFuChen…