Merge pull request #1 from hollischuang/master

从hollischuang/toBeTopJavaer这里同步更新别人的提交

.gitignore

@@ -12,6 +12,7 @@
 .idea/**/common_info.xml
 .idea/**
 
+
 # Sensitive or high-churn files
 .idea/**/dataSources/
 .idea/**/dataSources.ids

README.md

@@ -171,13 +171,15 @@ apache集合处理工具类的使用、
 
 #### 序列化
 
-什么是序列化与反序列化、为什么序列化、序列化底层原理、序列化与单例模式、protobuf、为什么说序列化并不安全
+[什么是序列化与反序列化](/basics/java-basic/serialize.md)、为什么序列化、[序列化底层原理](/basics/java-basic/serialize-principle.md)、[序列化与单例模式](/basics/java-basic/serialize-singleton.md)、protobuf、为什么说序列化并不安全
 
 #### 注解
 
-元注解、自定义注解、Java中常用注解使用、注解与反射的结合
+[元注解](/basics/java-basic/meta-annotation.md)、[自定义注解](/basics/java-basic/custom-annotation.md)、Java中常用注解使用、注解与反射的结合
 
-Spring常用注解
+[如何自定义一个注解？](/basics/java-basic/create-annotation.md)
+
+[Spring常用注解](/basics/java-basic/annotation-in-spring.md)
 
 #### JMS
 
@@ -189,13 +191,13 @@ Spring常用注解
 
 #### 泛型
 
-泛型与继承、类型擦除、泛型中K T V E ？ [object等的含义](/basics/java-basic/k-t-v-e.md)、泛型各种用法
+泛型与继承、类型擦除、[泛型中K T V E ？ object等的含义](/basics/java-basic/k-t-v-e.md)、泛型各种用法
 
 限定通配符和非限定通配符、上下界限定符extends 和 super
 
-List<Object>和原始类型List之间的区别? 
+[List<Object>和原始类型List之间的区别?](/basics/java-basic/genericity-list.md)
 
-List<?>和List<Object>之间的区别是什么?
+[List<?>和List<Object>之间的区别是什么?](/basics/java-basic/genericity-list-wildcard.md)
 
 #### 单元测试
 
@@ -211,9 +213,9 @@ junit、mock、mockito、内存数据库（h2）
 
 #### API&SPI
 
-API、API和SPI的关系和区别
+API、[API和SPI的关系和区别](/basics/java-basic/api-vs-spi.md)
 
-如何定义SPI、SPI的实现原理
+[如何定义SPI](/basics/java-basic/create-spi.md)、[SPI的实现原理](/basics/java-basic/spi-principle.md)
 
 #### 异常
 
@@ -307,7 +309,7 @@ synchronized和原子性、可见性和有序性之间的关系
 
 #### volatile
 
-happens-before、内存屏障、编译器指令重排和CPU指令重
+happens-before、内存屏障、编译器指令重排和CPU指令重排
 
 volatile的实现原理
 

basics/java-basic/annotation-in-spring.md

+@Configuration把一个类作为一个IoC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean。
+
+@Scope注解 作用域
+
+@Lazy(true) 表示延迟初始化
+
+@Service用于标注业务层组件、 
+
+@Controller用于标注控制层组件@Repository用于标注数据访问组件，即DAO组件。
+
+@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
+
+@Scope用于指定scope作用域的（用在类上）
+
+@PostConstruct用于指定初始化方法（用在方法上）
+
+@PreDestory用于指定销毁方法（用在方法上）
+
+@DependsOn：定义Bean初始化及销毁时的顺序
+
+@Primary：自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
+
+@Autowired 默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
+
+@Autowired @Qualifier("personDaoBean") 存在多个实例配合使用
+
+@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。
+
+@PostConstruct 初始化注解
+
+@PreDestroy 摧毁注解 默认 单例  启动就加载
+
+
+### Spring中的这几个注解有什么区别：@Component 、@Repository、@Service、@Controller
+
+
+1. @Component指的是组件，
+
+@Controller，@Repository和@Service 注解都被@Component修饰，用于代码中区分表现层，持久层和业务层的组件，代码中组件不好归类时可以使用@Component来标注
+
+2. 当前版本只有区分的作用，未来版本可能会添加更丰富的功能
+

basics/java-basic/api-vs-spi.md

+Java 中区分 API 和 SPI，通俗的讲：API 和 SPI 都是相对的概念，他们的差别只在语义上，API 直接被应用开发人员使用，SPI 被框架扩展人员使用
+
+
+API  Application Programming Interface
+
+大多数情况下，都是实现方来制定接口并完成对接口的不同实现，调用方仅仅依赖却无权选择不同实现。
+
+SPI Service Provider Interface
+
+而如果是调用方来制定接口，实现方来针对接口来实现不同的实现。调用方来选择自己需要的实现方。
\ No newline at end of file

basics/java-basic/create-annotation.md

+在Java中，类使用class定义，接口使用interface定义，注解和接口的定义差不多，增加了一个@符号，即@interface，代码如下：
+
+    public @interface EnableAuth {
+    
+    }
+
+注解中可以定义成员变量，用于信息的描述，跟接口中方法的定义类似，代码如下：
+    
+    public @interface EnableAuth {
+        String name();
+    }
+
+还可以添加默认值：
+
+    public @interface EnableAuth {
+        String name() default "猿天地";
+    }
+
+上面的介绍只是完成了自定义注解的第一步，开发中日常使用注解大部分是用在类上，方法上，字段上，示列代码如下：
+
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.RUNTIME)
+    @Documented
+    public @interface EnableAuth {
+    
+    }
+
+Target 
+
+用于指定被修饰的注解修饰哪些程序单元，也就是上面说的类，方法，字段
+
+Retention 
+
+用于指定被修饰的注解被保留多长时间，分别SOURCE（注解仅存在于源码中，在class字节码文件中不包含）,CLASS（默认的保留策略，注解会在class字节码文件中存在，但运行时无法获取）,RUNTIME（注解会在class字节码文件中存在，在运行时可以通过反射获取到）三种类型，如果想要在程序运行过程中通过反射来获取注解的信息需要将Retention设置为RUNTIME
+
+Documented 
+
+用于指定被修饰的注解类将被javadoc工具提取成文档
+
+Inherited 
+
+用于指定被修饰的注解类将具有继承性
\ No newline at end of file

basics/java-basic/create-spi.md

+步骤1、定义一组接口 (假设是org.foo.demo.IShout)，并写出接口的一个或多个实现，(假设是org.foo.demo.animal.Dog、org.foo.demo.animal.Cat)。
+
+    public interface IShout {
+        void shout();
+    }
+    public class Cat implements IShout {
+        @Override
+        public void shout() {
+            System.out.println("miao miao");
+        }
+    }
+    public class Dog implements IShout {
+        @Override
+        public void shout() {
+            System.out.println("wang wang");
+        }
+    }
+
+步骤2、在 src/main/resources/ 下建立 /META-INF/services 目录， 新增一个以接口命名的文件 (org.foo.demo.IShout文件)，内容是要应用的实现类（这里是org.foo.demo.animal.Dog和org.foo.demo.animal.Cat，每行一个类）。
+
+    org.foo.demo.animal.Dog
+    org.foo.demo.animal.Cat
+
+步骤3、使用 ServiceLoader 来加载配置文件中指定的实现。
+
+    public class SPIMain {
+        public static void main(String[] args) {
+            ServiceLoader<IShout> shouts = ServiceLoader.load(IShout.class);
+            for (IShout s : shouts) {
+                s.shout();
+            }
+        }
+    }
+
+代码输出：
+
+    wang wang
+    miao miao
\ No newline at end of file

basics/java-basic/custom-annotation.md

+除了元注解，都是自定义注解。通过元注解定义出来的注解。
+如我们常用的Override 、Autowire等。
+日常开发中也可以自定义一个注解，这些都是自定义注解。
\ No newline at end of file

basics/java-basic/genericity-list-wildcard.md

+List<?> 是一个未知类型的List，而List<Object> 其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给 List<Object>。

basics/java-basic/genericity-list.md

+原始类型List和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查。
+
+通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。
+
+它们之间的第二点区别是，你可以把任何带参数的类型传递给原始类型List，但却不能把List<String>传递给接受 List<Object>的方法，因为会产生编译错误。
\ No newline at end of file

basics/java-basic/meta-annotation.md

+说简单点，就是  定义其他注解的注解 。
+比如Override这个注解，就不是一个元注解。而是通过元注解定义出来的。
+
+    @Target(ElementType.METHOD)
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Override {
+    }
+
+这里面的
+@Target
+@Retention
+就是元注解。
+
+元注解有四个:@Target（表示该注解可以用于什么地方）、@Retention（表示再什么级别保存该注解信息）、@Documented（将此注解包含再javadoc中）、@Inherited（允许子类继承父类中的注解）。
\ No newline at end of file

basics/java-basic/object-oriented-vs-procedure-oriented.md

 ### 什么是面向过程？
 
+####概述: 自顶而下的编程模式.
+
 把问题分解成一个一个步骤，每个步骤用函数实现，依次调用即可。
 
 就是说，在进行面向过程编程的时候，不需要考虑那么多，上来先定义一个函数，然后使用各种诸如if-else、for-each等方式进行代码执行。
@@ -8,8 +10,28 @@
 
 
 ### 什么是面向对象？
+
+####概述: 将事务高度抽象化的编程模式.
+
 将问题分解成一个一个步骤，对每个步骤进行相应的抽象，形成对象，通过不同对象之间的调用，组合解决问题。
 
 就是说，在进行面向对象进行编程的时候，要把属性、行为等封装成对象，然后基于这些对象及对象的能力进行业务逻辑的实现。
 
-比如想要造一辆车，上来要先把车的各种属性定义出来，然后抽象成一个Car类。
\ No newline at end of file
+比如:想要造一辆车，上来要先把车的各种属性定义出来，然后抽象成一个Car类。
+
+#### 举例说明区别
+
+同样一个象棋设计.
+
+面向对象:创建黑白双方的对象负责演算,棋盘的对象负责画布,规则的对象负责判断，例子可以看出,面向对象更重视不重复造轮子,即创建一次,重复使用.
+
+面向过程:开始—黑走—棋盘—判断—白走—棋盘—判断—循环。只需要关注每一步怎么实现即可.
+
+#### 优劣对比
+
+面向对象:占用资源相对高,速度相对慢
+
+面向过程:占用资源相对低,速度相对快
+
+
+

basics/java-basic/platform-independent.md

@@ -46,7 +46,7 @@
 
 **Java虚拟机**
 
-所谓平台无关性，就是说要能够做到可以在多个平台上都能无缝对接。但是，对于不通的平台，硬件和操作系统肯定都是不一样的。
+所谓平台无关性，就是说要能够做到可以在多个平台上都能无缝对接。但是，对于不同的平台，硬件和操作系统肯定都是不一样的。
 
 对于不同的硬件和操作系统，最主要的区别就是指令不同。比如同样执行a+b，A操作系统对应的二进制指令可能是10001000，而B操作系统对应的指令可能是11101110。那么，想要做到跨平台，最重要的就是可以根据对应的硬件和操作系统生成对应的二进制指令。
 
@@ -64,7 +64,7 @@
 
 **字节码**
 
-各种不同的平台的虚拟机都使用统一的程序存储格式——字节码（ByteCode）是构成平台无关性的另一个基石。Java虚拟机只与由自己码组成的Class文件进行交互。
+各种不同的平台的虚拟机都使用统一的程序存储格式——字节码（ByteCode）是构成平台无关性的另一个基石。Java虚拟机只与由字节码组成的Class文件进行交互。
 
 我们说Java语言可以Write Once ,Run Anywhere。这里的Write其实指的就是生成Class文件的过程。
 
@@ -88,7 +88,7 @@
 
 ### 小结
 
-对于Java的平台无关性的支持是分布在整个Java体系结构中的。其中扮演者重要的角色的有Java语言规范、Class文件、Java虚拟机等。
+对于Java的平台无关性的支持是分布在整个Java体系结构中的。其中扮演着重要角色的有Java语言规范、Class文件、Java虚拟机等。
 
 *   Java语言规范 
     *   通过规定Java语言中基本数据类型的取值范围和行为
@@ -119,4 +119,4 @@ Java的平台无关性是建立在Java虚拟机的平台有关性基础之上的
  [6]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539297082025.jpg
  [7]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539303829914.jpg
  [8]: https://www.hollischuang.com/wp-content/uploads/2019/03/15539319645205.jpg
- [9]: https://www.hollischuang.com/archives/2938
\ No newline at end of file
+ [9]: https://www.hollischuang.com/archives/2938

basics/java-basic/polymorphism.md

-###什么是多态，多态有什么好处，多态的必要条件是什么、Java中多态的实现方式
+### 什么是多态，多态有什么好处，多态的必要条件是什么、Java中多态的实现方式
 
 多态的概念呢比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
 
@@ -41,7 +41,7 @@
 比如Spring 中的IOC出来的对象，你在使用的时候就不知道他是谁，或者说你可以不用关心他是谁。根据具体情况而定。
 
 
-另外，还有一种说法，包括维基百科也说明，动态还分为动态多态和静态多态。
+另外，还有一种说法，包括维基百科也说明，多态还分为动态多态和静态多态。
 上面提到的那种动态绑定认为是动态多态，因为只有在运行期才能知道真正调用的是哪个类的方法。
 
 还有一种静态多态，一般认为Java中的函数重载是一种静态多态，因为他需要在编译期决定具体调用哪个方法、

basics/java-basic/principle.md

@@ -11,7 +11,7 @@
 “需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。
 
 
-### Liskov替换原则（Liskov-Substituion Principle）
+### Liskov替换原则（Liskov-Substitution Principle）
 
 其核心思想是：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。同时，这一约束反过来则是不成立的，子类可以替换基类，但是基类不一定能替换子类。
 Liskov替换原则，主要着眼于对抽象和多态建立在继承的基础上，因此只有遵循了Liskov替换原则，才能保证继承复用是可靠地。实现的方法是面向接口编程：将公共部分抽象为基类接口或抽象类，通过Extract Abstract Class，在子类中通过覆写父类的方法实现新的方式支持同样的职责。
@@ -34,4 +34,4 @@ Liskov替换原则能够保证系统具有良好的拓展性，同时实现基
 接口有效地将细节和抽象隔离，体现了对抽象编程的一切好处，接口隔离强调接口的单一性。而胖接口存在明显的弊端，会导致实现的类型必须完全实现接口的所有方法、属性等；而某些时候，实现类型并非需要所有的接口定义，在设计上这是“浪费”，而且在实施上这会带来潜在的问题，对胖接口的修改将导致一连串的客户端程序需要修改，有时候这是一种灾难。在这种情况下，将胖接口分解为多个特点的定制化方法，使得客户端仅仅依赖于它们的实际调用的方法，从而解除了客户端不会依赖于它们不用的方法。
 分离的手段主要有以下两种：1、委托分离，通过增加一个新的类型来委托客户的请求，隔离客户和接口的直接依赖，但是会增加系统的开销。2、多重继承分离，通过接口多继承来实现客户的需求，这种方式是较好的。
 
-以上就是5个基本的面向对象设计原则，它们就像面向对象程序设计中的金科玉律，遵守它们可以使我们的代码更加鲜活，易于复用，易于拓展，灵活优雅。不同的设计模式对应不同的需求，而设计原则则代表永恒的灵魂，需要在实践中时时刻刻地遵守。就如ARTHUR J.RIEL在那边《OOD启示录》中所说的：“你并不必严格遵守这些原则，违背它们也不会被处以宗教刑罚。但你应当把这些原则看做警铃，若违背了其中的一条，那么警铃就会响起。”
\ No newline at end of file
+以上就是5个基本的面向对象设计原则，它们就像面向对象程序设计中的金科玉律，遵守它们可以使我们的代码更加鲜活，易于复用，易于拓展，灵活优雅。不同的设计模式对应不同的需求，而设计原则则代表永恒的灵魂，需要在实践中时时刻刻地遵守。就如ARTHUR J.RIEL在那边《OOD启示录》中所说的：“你并不必严格遵守这些原则，违背它们也不会被处以宗教刑罚。但你应当把这些原则看做警铃，若违背了其中的一条，那么警铃就会响起。”

basics/java-basic/serialize-principle.md

+## 序列化与反序列化
+
+序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介，例如档案或是记亿体缓冲等。在网络传输过程中，可以是字节或是XML等格式。而字节的或XML编码格式可以还原完全相等的对象。这个相反的过程又称为反序列化。
+
+## Java对象的序列化与反序列化
+
+在Java中，我们可以通过多种方式来创建对象，并且只要对象没有被回收我们都可以复用该对象。但是，我们创建出来的这些Java对象都是存在于JVM的堆内存中的。只有JVM处于运行状态的时候，这些对象才可能存在。一旦JVM停止运行，这些对象的状态也就随之而丢失了。
+
+但是在真实的应用场景中，我们需要将这些对象持久化下来，并且能够在需要的时候把对象重新读取出来。Java的对象序列化可以帮助我们实现该功能。
+
+对象序列化机制（object serialization）是Java语言内建的一种对象持久化方式，通过对象序列化，可以把对象的状态保存为字节数组，并且可以在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。对象序列化可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。
+
+在Java中，对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中。
+
+## 相关接口及类
+
+Java为了方便开发人员将Java对象进行序列化及反序列化提供了一套方便的API来支持。其中包括以下接口和类：
+
+> java.io.Serializable
+> 
+> java.io.Externalizable
+> 
+> ObjectOutput
+> 
+> ObjectInput
+> 
+> ObjectOutputStream
+> 
+> ObjectInputStream
+
+## Serializable 接口
+
+类通过实现 `java.io.Serializable` 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。**序列化接口没有方法或字段，仅用于标识可序列化的语义。** ([该接口并没有方法和字段，为什么只有实现了该接口的类的对象才能被序列化呢？][1])
+
+当试图对一个对象进行序列化的时候，如果遇到不支持 Serializable 接口的对象。在此情况下，将抛出 `NotSerializableException`。
+
+如果要序列化的类有父类，要想同时将在父类中定义过的变量持久化下来，那么父类也应该集成`java.io.Serializable`接口。
+
+下面是一个实现了`java.io.Serializable`接口的类
+
+    package com.hollischaung.serialization.SerializableDemos;
+    import java.io.Serializable;
+    /**
+     * Created by hollis on 16/2/17.
+     * 实现Serializable接口
+     */
+    public class User1 implements Serializable {
+    
+        private String name;
+        private int age;
+    
+        public String getName() {
+            return name;
+        }
+    
+        public void setName(String name) {
+            this.name = name;
+        }
+    
+        public int getAge() {
+            return age;
+        }
+    
+        public void setAge(int age) {
+            this.age = age;
+        }
+    
+        @Override
+        public String toString() {
+            return "User{" +
+                    "name='" + name + '\'' +
+                    ", age=" + age +
+                    '}';
+        }
+    }
+    
+
+通过下面的代码进行序列化及反序列化
+
+    package com.hollischaung.serialization.SerializableDemos;
+    
+    import org.apache.commons.io.FileUtils;
+    import org.apache.commons.io.IOUtils;
+    
+    import java.io.*;
+    /**
+     * Created by hollis on 16/2/17.
+     * SerializableDemo1 结合SerializableDemo2说明 一个类要想被序列化必须实现Serializable接口
+     */
+    public class SerializableDemo1 {
+    
+        public static void main(String[] args) {
+            //Initializes The Object
+            User1 user = new User1();
+            user.setName("hollis");
+            user.setAge(23);
+            System.out.println(user);
+    
+            //Write Obj to File
+            ObjectOutputStream oos = null;
+            try {
+                oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
+                oos.writeObject(user);
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                IOUtils.closeQuietly(oos);
+            }
+    
+            //Read Obj from File
+            File file = new File("tempFile");
+            ObjectInputStream ois = null;
+            try {
+                ois = new ObjectInputStream(new FileInputStream(file));
+                User1 newUser = (User1) ois.readObject();
+                System.out.println(newUser);
+            } catch (IOException e) {
+                e.printStackTrace();
+            } catch (ClassNotFoundException e) {
+                e.printStackTrace();
+            } finally {
+                IOUtils.closeQuietly(ois);
+                try {
+                    FileUtils.forceDelete(file);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+    
+        }
+    }
+    
+    //OutPut:
+    //User{name='hollis', age=23}
+    //User{name='hollis', age=23}
+    
+
+更多关于Serializable的使用，请参考[代码实例][2]
+
+## Externalizable接口
+
+除了Serializable 之外，java中还提供了另一个序列化接口`Externalizable`
+
+为了了解Externalizable接口和Serializable接口的区别，先来看代码，我们把上面的代码改成使用Externalizable的形式。
+
+    package com.hollischaung.serialization.ExternalizableDemos;
+    
+    import java.io.Externalizable;
+    import java.io.IOException;
+    import java.io.ObjectInput;
+    import java.io.ObjectOutput;
+    
+    /**
+     * Created by hollis on 16/2/17.
+     * 实现Externalizable接口
+     */
+    public class User1 implements Externalizable {
+    
+        private String name;
+        private int age;
+    
+        public String getName() {
+            return name;
+        }
+    
+        public void setName(String name) {
+            this.name = name;
+        }
+    
+        public int getAge() {
+            return age;
+        }
+    
+        public void setAge(int age) {
+            this.age = age;
+        }
+    
+        public void writeExternal(ObjectOutput out) throws IOException {
+    
+        }
+    
+        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+    
+        }
+    
+        @Override
+        public String toString() {
+            return "User{" +
+                    "name='" + name + '\'' +
+                    ", age=" + age +
+                    '}';
+        }
+    }
+    
+
+ 
+
+    package com.hollischaung.serialization.ExternalizableDemos;
+    
+    import java.io.*;
+    
+    /**
+     * Created by hollis on 16/2/17.
+     */
+    public class ExternalizableDemo1 {
+    
+        //为了便于理解和节省篇幅，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
+        //IOException直接抛出
+        public static void main(String[] args) throws IOException, ClassNotFoundException {
+            //Write Obj to file
+            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
+            User1 user = new User1();
+            user.setName("hollis");
+            user.setAge(23);
+            oos.writeObject(user);
+            //Read Obj from file
+            File file = new File("tempFile");
+            ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
+            User1 newInstance = (User1) ois.readObject();
+            //output
+            System.out.println(newInstance);
+        }
+    }
+    //OutPut:
+    //User{name='null', age=0}
+    
+
+通过上面的实例可以发现，对User1类进行序列化及反序列化之后得到的对象的所有属性的值都变成了默认值。也就是说，之前的那个对象的状态并没有被持久化下来。这就是Externalizable接口和Serializable接口的区别：
+
+Externalizable继承了Serializable，该接口中定义了两个抽象方法：`writeExternal()`与`readExternal()`。当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写`writeExternal()`与`readExternal()`方法。由于上面的代码中，并没有在这两个方法中定义序列化实现细节，所以输出的内容为空。还有一点值得注意：在使用Externalizable进行序列化的时候，在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。所以，实现Externalizable接口的类必须要提供一个public的无参的构造器。
+
+按照要求修改之后代码如下：
+
+    package com.hollischaung.serialization.ExternalizableDemos;
+    
+    import java.io.Externalizable;
+    import java.io.IOException;
+    import java.io.ObjectInput;
+    import java.io.ObjectOutput;
+    
+    /**
+     * Created by hollis on 16/2/17.
+     * 实现Externalizable接口,并实现writeExternal和readExternal方法
+     */
+    public class User2 implements Externalizable {
+    
+        private String name;
+        private int age;
+    
+        public String getName() {
+            return name;
+        }
+    
+        public void setName(String name) {
+            this.name = name;
+        }
+    
+        public int getAge() {
+            return age;
+        }
+    
+        public void setAge(int age) {
+            this.age = age;
+        }
+    
+        public void writeExternal(ObjectOutput out) throws IOException {
+            out.writeObject(name);
+            out.writeInt(age);
+        }
+    
+        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+            name = (String) in.readObject();
+            age = in.readInt();
+        }
+    
+        @Override
+        public String toString() {
+            return "User{" +
+                    "name='" + name + '\'' +
+                    ", age=" + age +
+                    '}';
+        }
+    }
+    
+
+ 
+
+    package com.hollischaung.serialization.ExternalizableDemos;
+    
+    import java.io.*;
+    
+    /**
+     * Created by hollis on 16/2/17.
+     */
+    public class ExternalizableDemo2 {
+    
+        //为了便于理解和节省篇幅，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
+        //IOException直接抛出
+        public static void main(String[] args) throws IOException, ClassNotFoundException {
+            //Write Obj to file
+            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
+            User2 user = new User2();
+            user.setName("hollis");
+            user.setAge(23);
+            oos.writeObject(user);
+            //Read Obj from file
+            File file = new File("tempFile");
+            ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
+            User2 newInstance = (User2) ois.readObject();
+            //output
+            System.out.println(newInstance);
+        }
+    }
+    //OutPut:
+    //User{name='hollis', age=23}
+    
+
+这次，就可以把之前的对象状态持久化下来了。
+
+> 如果User类中没有无参数的构造函数，在运行时会抛出异常：`java.io.InvalidClassException`
+
+更多Externalizable接口使用实例请参考[代码实例][3]
+
+## ObjectOutput和ObjectInput 接口
+
+ObjectInput接口 扩展自 DataInput 接口以包含对象的读操作。
+
+> DataInput 接口用于从二进制流中读取字节，并根据所有 Java 基本类型数据进行重构。同时还提供根据 UTF-8 修改版格式的数据重构 String 的工具。
+> 
+> 对于此接口中的所有数据读取例程来说，如果在读取所需字节数之前已经到达文件末尾 (end of file)，则将抛出 EOFException（IOException 的一种）。如果因为到达文件末尾以外的其他原因无法读取字节，则将抛出 IOException 而不是 EOFException。尤其是，在输入流已关闭的情况下，将抛出 IOException。
+
+ObjectOutput 扩展 DataOutput 接口以包含对象的写入操作。
+
+> DataOutput 接口用于将数据从任意 Java 基本类型转换为一系列字节，并将这些字节写入二进制流。同时还提供了一个将 String 转换成 UTF-8 修改版格式并写入所得到的系列字节的工具。
+> 
+> 对于此接口中写入字节的所有方法，如果由于某种原因无法写入某个字节，则抛出 IOException。
+
+## ObjectOutputStream类和ObjectInputStream类
+
+通过前面的代码片段中我们也能知道，我们一般使用ObjectOutputStream的`writeObject`方法把一个对象进行持久化。再使用ObjectInputStream的`readObject`从持久化存储中把对象读取出来。
+
+更多关于ObjectInputStream和ObjectOutputStream的相关知识欢迎阅读我的另外两篇博文：[深入分析Java的序列化与反序列化][4]、[单例与序列化的那些事儿][5]
+
+## Transient 关键字
+
+Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。关于Transient 关键字的拓展知识欢迎阅读[深入分析Java的序列化与反序列化][4]
+
+## 序列化ID
+
+虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 `private static final long serialVersionUID`)
+
+序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。
+
+## 参考资料
+
+[维基百科][6]
+
+[理解Java对象序列化][7]
+
+[Java 序列化的高级认识][8]
+
+## 推荐阅读
+
+[深入分析Java的序列化与反序列化][4]
+
+[单例与序列化的那些事儿][5]
+
+ [1]: http://www.hollischuang.com/archives/1140#What%20Serializable%20Did
+ [2]: https://github.com/hollischuang/java-demo/tree/master/src/main/java/com/hollischaung/serialization/SerializableDemos
+ [3]: https://github.com/hollischuang/java-demo/tree/master/src/main/java/com/hollischaung/serialization/ExternalizableDemos
+ [4]: http://www.hollischuang.com/archives/1140
+ [5]: http://www.hollischuang.com/archives/1144
+ [6]: https://zh.wikipedia.org/wiki/序列化
+ [7]: http://www.blogjava.net/jiangshachina/archive/2012/02/13/369898.html
+ [8]: https://www.ibm.com/developerworks/cn/java/j-lo-serial/
\ No newline at end of file

basics/java-basic/serialize-singleton.md

+本文将通过实例+阅读Java源码的方式介绍序列化是如何破坏单例模式的，以及如何避免序列化对单例的破坏。
+
+> 单例模式，是设计模式中最简单的一种。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。关于单例模式的使用方式，可以阅读[单例模式的七种写法][1]
+
+但是，单例模式真的能够实现实例的唯一性吗？
+
+答案是否定的，很多人都知道使用反射可以破坏单例模式，除了反射以外，使用序列化与反序列化也同样会破坏单例。
+
+## 序列化对单例的破坏
+
+首先来写一个单例的类：
+
+code 1
+
+    package com.hollis;
+    import java.io.Serializable;
+    /**
+     * Created by hollis on 16/2/5.
+     * 使用双重校验锁方式实现单例
+     */
+    public class Singleton implements Serializable{
+        private volatile static Singleton singleton;
+        private Singleton (){}
+        public static Singleton getSingleton() {
+            if (singleton == null) {
+                synchronized (Singleton.class) {
+                    if (singleton == null) {
+                        singleton = new Singleton();
+                    }
+                }
+            }
+            return singleton;
+        }
+    }
+    
+
+接下来是一个测试类：
+
+code 2
+
+    package com.hollis;
+    import java.io.*;
+    /**
+     * Created by hollis on 16/2/5.
+     */
+    public class SerializableDemo1 {
+        //为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
+        //Exception直接抛出
+        public static void main(String[] args) throws IOException, ClassNotFoundException {
+            //Write Obj to file
+            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
+            oos.writeObject(Singleton.getSingleton());
+            //Read Obj from file
+            File file = new File("tempFile");
+            ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
+            Singleton newInstance = (Singleton) ois.readObject();
+            //判断是否是同一个对象
+            System.out.println(newInstance == Singleton.getSingleton());
+        }
+    }
+    //false
+    
+
+输出结构为false，说明：
+
+> 通过对Singleton的序列化与反序列化得到的对象是一个新的对象，这就破坏了Singleton的单例性。
+
+这里，在介绍如何解决这个问题之前，我们先来深入分析一下，为什么会这样？在反序列化的过程中到底发生了什么。
+
+## ObjectInputStream
+
+对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的，那么带着刚刚的问题，分析一下ObjectInputputStream 的`readObject` 方法执行情况到底是怎样的。
+
+为了节省篇幅，这里给出ObjectInputStream的`readObject`的调用栈：
+
+<img src="https://www.hollischuang.com/wp-content/uploads/2016/02/640.png" alt="" width="840" height="309" class="aligncenter size-full wp-image-3561" />
+
+这里看一下重点代码，`readOrdinaryObject`方法的代码片段： code 3
+
+    private Object readOrdinaryObject(boolean unshared)
+            throws IOException
+        {
+            //此处省略部分代码
+    
+            Object obj;
+            try {
+                obj = desc.isInstantiable() ? desc.newInstance() : null;
+            } catch (Exception ex) {
+                throw (IOException) new InvalidClassException(
+                    desc.forClass().getName(),
+                    "unable to create instance").initCause(ex);
+            }
+    
+            //此处省略部分代码
+    
+            if (obj != null &&
+                handles.lookupException(passHandle) == null &&
+                desc.hasReadResolveMethod())
+            {
+                Object rep = desc.invokeReadResolve(obj);
+                if (unshared && rep.getClass().isArray()) {
+                    rep = cloneArray(rep);
+                }
+                if (rep != obj) {
+                    handles.setObject(passHandle, obj = rep);
+                }
+            }
+    
+            return obj;
+        }
+    
+
+code 3 中主要贴出两部分代码。先分析第一部分：
+
+code 3.1
+
+    Object obj;
+    try {
+        obj = desc.isInstantiable() ? desc.newInstance() : null;
+    } catch (Exception ex) {
+        throw (IOException) new InvalidClassException(desc.forClass().getName(),"unable to create instance").initCause(ex);
+    }
+    
+
+这里创建的这个obj对象，就是本方法要返回的对象，也可以暂时理解为是ObjectInputStream的`readObject`返回的对象。
+
+<img src="https://www.hollischuang.com/wp-content/uploads/2016/02/641.jpeg" alt="" width="1080" height="336" class="aligncenter size-full wp-image-3563" />
+
+> `isInstantiable`：如果一个serializable/externalizable的类可以在运行时被实例化，那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。
+> 
+> `desc.newInstance`：该方法通过反射的方式调用无参构造方法新建一个对象。
+
+所以。到目前为止，也就可以解释，为什么序列化可以破坏单例了？
+
+> 答：序列化会通过反射调用无参数的构造方法创建一个新的对象。
+
+那么，接下来我们再看刚开始留下的问题，如何防止序列化/反序列化破坏单例模式。
+
+## 防止序列化破坏单例模式
+
+先给出解决方案，然后再具体分析原理：
+
+只要在Singleton类中定义`readResolve`就可以解决该问题：
+
+code 4
+
+    package com.hollis;
+    import java.io.Serializable;
+    /**
+     * Created by hollis on 16/2/5.
+     * 使用双重校验锁方式实现单例
+     */
+    public class Singleton implements Serializable{
+        private volatile static Singleton singleton;
+        private Singleton (){}
+        public static Singleton getSingleton() {
+            if (singleton == null) {
+                synchronized (Singleton.class) {
+                    if (singleton == null) {
+                        singleton = new Singleton();
+                    }
+                }
+            }
+            return singleton;
+        }
+    
+        private Object readResolve() {
+            return singleton;
+        }
+    }
+    
+
+还是运行以下测试类：
+
+    package com.hollis;
+    import java.io.*;
+    /**
+     * Created by hollis on 16/2/5.
+     */
+    public class SerializableDemo1 {
+        //为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
+        //Exception直接抛出
+        public static void main(String[] args) throws IOException, ClassNotFoundException {
+            //Write Obj to file
+            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
+            oos.writeObject(Singleton.getSingleton());
+            //Read Obj from file
+            File file = new File("tempFile");
+            ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
+            Singleton newInstance = (Singleton) ois.readObject();
+            //判断是否是同一个对象
+            System.out.println(newInstance == Singleton.getSingleton());
+        }
+    }
+    //true
+    
+
+本次输出结果为true。具体原理，我们回过头继续分析code 3中的第二段代码:
+
+code 3.2
+
+    if (obj != null &&
+                handles.lookupException(passHandle) == null &&
+                desc.hasReadResolveMethod())
+            {
+                Object rep = desc.invokeReadResolve(obj);
+                if (unshared && rep.getClass().isArray()) {
+                    rep = cloneArray(rep);
+                }
+                if (rep != obj) {
+                    handles.setObject(passHandle, obj = rep);
+                }
+            }
+    
+
+`hasReadResolveMethod`:如果实现了serializable 或者 externalizable接口的类中包含`readResolve`则返回true
+
+`invokeReadResolve`:通过反射的方式调用要被反序列化的类的readResolve方法。
+
+所以，原理也就清楚了，主要在Singleton中定义readResolve方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。
+
+## 总结
+
+在涉及到序列化的场景时，要格外注意他对单例的破坏。
+
+## 推荐阅读
+
+[深入分析Java的序列化与反序列化][2]
+
+ [1]: http://www.hollischuang.com/archives/205
+ [2]: http://www.hollischuang.com/archives/1140
\ No newline at end of file

basics/java-basic/serialize.md

+序列化是将对象转换为可传输格式的过程。 是一种数据的持久化手段。一般广泛应用于网络传输，RMI和RPC等场景中。
+
+反序列化是序列化的逆操作。
+
+序列化是将对象的状态信息转换为可存储或传输的形式的过程。一般是以字节码或XML格式传输。而字节码或XML编码格式可以还原为完全相等的对象。这个相反的过程称为反序列化。
\ No newline at end of file

basics/java-basic/spi-principle.md

+看ServiceLoader类的签名类的成员变量：
+
+    public final class ServiceLoader<S> implements Iterable<S>{
+    private static final String PREFIX = "META-INF/services/";
+    
+        // 代表被加载的类或者接口
+        private final Class<S> service;
+    
+        // 用于定位，加载和实例化providers的类加载器
+        private final ClassLoader loader;
+    
+        // 创建ServiceLoader时采用的访问控制上下文
+        private final AccessControlContext acc;
+    
+        // 缓存providers，按实例化的顺序排列
+        private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
+    
+        // 懒查找迭代器
+        private LazyIterator lookupIterator;
+    
+        ......
+    }
+    
+参考具体源码，梳理了一下，实现的流程如下：
+
+1 应用程序调用ServiceLoader.load方法
+
+ServiceLoader.load方法内先创建一个新的ServiceLoader，并实例化该类中的成员变量，包括：
+
+loader(ClassLoader类型，类加载器)
+
+acc(AccessControlContext类型，访问控制器)
+
+providers(LinkedHashMap类型，用于缓存加载成功的类)
+
+lookupIterator(实现迭代器功能)
+
+2 应用程序通过迭代器接口获取对象实例
+
+ServiceLoader先判断成员变量providers对象中(LinkedHashMap类型)是否有缓存实例对象，如果有缓存，直接返回。
+如果没有缓存，执行类的装载：
+
+读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称
+
+通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化
+
+把实例化后的类缓存到providers对象中(LinkedHashMap类型）
+
+然后返回实例对象。
\ No newline at end of file