上一篇介绍了Lifecycle使用以及原理：Jetpack全家桶之Lifecycle ，在原理解读中也提到了几个知识点，在这里进行一个补充。（各知识点中没有什么相互关联的地方，选择性阅读）

一、单例模式

单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。即：

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

为什么要有单例？

我们最为常用的网络请求实例对象（例如Retrofit对象），在整个应用程序中，我们要经常的使用，如果每次发起网络请求都去重新创建一个Retrofit对象实例，不仅仅浪费了每次创建对象的时间，还浪费了系统创建和销毁对象所需要的资源。所以：为什么要使用单例？一个全局类要频繁的使用，控制全局实例对象数量，防止频繁的创建和销毁节省系统资源，所以需要单例，如果对象存在则直接返回使用，如果不存在则创建返回使用。

单例的几种实现

• 懒汉式
  这种实现最大的问题就是不支持多线程。在使用时才创建对象，能够达到延迟初始化的目的，在不要求线程安全的情况下使用，在多线程不能正常工作。

//Java实现
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}
-------------------------------------------------------------------------
//Kotlin实现
class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
            get() {
                if (field == null) {
                    field = Singleton()
                }
                return field
            }
        fun get(): Singleton{
            //这里不用getInstance作为为方法名，是因为在伴生对象声明时，内部已有getInstance方法，所以只能取其他名字
            return instance!!
        }
    }
}

• 加锁懒汉式
  这种方式具备很好的延迟初始化，线程安全，能够在多线程中正常工作。但是，效率很低，一般不推荐使用。

//Java实现
public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}
------------------------------------------------------------------
//Kotlin实现
class Singleton private constructor() {
    companion object {
        private var instance: SingletonDemo? = null
            get() {
                if (field == null) {
                    field = Singleton()
                }
                return field
            }
        @Synchronized
        fun get(): Singleton{
            return instance!!
        }
    }

}

• 双重校验锁
  这种方式采用加锁双重校验的方式，能够延迟初始化且在多线程情况下能正常工作且保持较高性能。

//Java实现
public class Singleton {  
    private volatile static Singleton instance;  
    private Singleton (){}  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}
-------------------------------------------------------
//Kotlin实现
class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            Singleton()
        }
    }
}

这里需要讲一下Kotlin的实现：运用到了Kotlin的 延迟属性 Lazy。
Lazy是接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的 委托： 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

• 饿汉式
  这种方式比较常用，但容易产生垃圾对象。它基于 classloader 机制避免了多线程的同步问题，不过，instance对象在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 Singleton.getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance对象显然没有达到延迟加载的效果。
  还有这里，在Java实现中，使用了 volatile 关键字，关于volatile关键字解析可以看另外一篇文章： Java多线程编程之volatile关键字

//Java实现
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}
----------------------------------------------------------------
//Kotlin实现
object Singleton

• 静态内部类
  这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，这种方式是Singleton类被装载了，instance 不一定被初始化。因为静态内部类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载静态内部类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。

//Java实现
public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton instance = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.instance;  
    }  
}
---------------------------------------------------------------
//Kotlin实现
class Singleton private constructor() {
    companion object {
        val instance = SingletonHolder.holder
    }

    private object SingletonHolder {
        val holder= Singleton()
    }
}

• 枚举类
  这种方式不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。

//Java实现
public enum Singleton {
    INSTANCE;
    public void doSomething() {
    }
}
------------------------------------------------------
//Kotlin实现
enum class Singleton {
    INSTANCE;
    fun doSomething(){
    }
}

总结一下几种单例模式的实现方式：

二、Java对象引用

Java中有四种引用类型，分别是 强引用、弱引用、软引用、虚引用

• 强引用（StrongReference）：强引用是最为普遍和使用最多的一种引用方式，如果一个对象具有强引用，当内存不足时，虚拟机宁愿抛出OOM异常结束应用，也不会去回收这个对象。例如：A a = new A() 即a对象具有强引用。
• 弱引用（WeakReference）：只具有弱引用的对象在垃圾回收线程扫描其所管辖的内存区域时，不管当前内存是否不足都会直接回收它的内存。弱引用可以和引用队列（ReferenceQueue）结合使用，弱引用对象内存回收前，会将当前引用加入到引用队列中
  软引用（SoftReference）：只具有软引用的对象在垃圾回收线程扫描其所管些的内存区域时，会判断当前内存是否不足，如果当前内存不足则回收软引用对象的内存，如果当前内存足够，则不回收。软引用可以和引用队列（ReferenceQueue）结合使用，软引用对象内存回收前，会将当前引用加入到引用队列中
• 虚引用（PhantomReference）：如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动，必须配合引用队列（ReferenceQueue）联合使用，虚引用对象内存回收前，会将当前引用加入到引用队列中。

这里面试的时候经常会问到关于内存泄漏的一个点：在Handler（或者生命周期比Activity长的其他东西）中需要引用当前Activity的对象实例时，为什么说用弱引用可以防止Activity的内存泄漏，能不能用虚引用？ 这里就是考察对象的引用，因为Handler持有了activity的引用，Handler生命周期如果比Activity生命周期长，就会造成Activity无法被回收，造成Activity的所占用内存的泄漏，使用弱引用，能在垃圾回收线程扫描时被回收。不能使用虚引用，弱引用和虚引用的最大区别就是回收时机，弱引用是不管内存够不够都会回收，虚引用是内存不足时才回收。

三、注解

Java注解（Anotation）或者说是标注，在Java 语言中的类、方法、变量、参数和包等都可以被标注。和注释不同的是注解可以通过反射获取其内容。在编译器生成类文件时，注解可以被嵌入到字节码中。Java 虚拟机可以保留注解内容，在运行时可以获取到注解内容，Java中含有一系列内置注解，也可以自定义注解。
要了解注解（Anotation），就必须了解三个类：

• Anotation

package java.lang.annotation;
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

• ElementType

package java.lang.annotation;

public enum ElementType {
    TYPE,                                //类、接口（包括注释类型）或枚举声明
    FIELD,                               //字段声明（包括枚举）
    METHOD,                              //方法声明
    PARAMETER,                           //参数声明
    CONSTRUCTOR,                         //构造方法声明
    LOCAL_VARIABLE,                      //局部变量声明
    ANNOTATION_TYPE,                     //注解类型声明
    PACKAGE,                             //包声明
    TYPE_PARAMETER,                      //参数类型声明
    TYPE_USE;                            //用法声明

    private ElementType() {
    }
}

• RetentionPolicy

package java.lang.annotation;

public enum RetentionPolicy {
    SOURCE,          //注解信息仅存在于编译器处理期间，编译器处理完之后无注解信息
    CLASS,           //编译器将注解存储于类对应的.class文件中。默认行为
    RUNTIME;         //编译器将注解信息存储于class文件中，在运行时可由JVM读入

    private RetentionPolicy() {
    }
}

以上三个类对应关系分别是：Anotation与ElementType是一对多的关系，即一个注解可声明为多种类型，如一个注解声明为FIELD、METHOD，则这个注解可用来修饰字段、方法。Anotation与RetentionPolicy一对一的关系，即一个注解只能作用于某个期间，如声明为SOURCE（@Override），只在编译期间起作用。
回顾上一篇文章 Jetpack全家桶之Lifecycle中的，实现生命周期拥有者（LifecycleOwner）之后使用注解 @OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE) 来修饰方法，使得被观察者生命周期变化时，相应修饰的方法能够自动感知生命周期的变化。

@OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
fun onCreate(){
    Log.e("AAAABB", "Observer onCreate")
}

-----------------------------------------

package androidx.lifecycle;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@SuppressWarnings("unused")
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

其中 @Target 用来指示ElementType，用来标注该注解可用于修饰什么类型，METHOD即标注这个@OnLifecycleEvent注解只能用于修饰方法。@Retention 用来指示RetentionPolicy，用来标注该注解生效时期在RUNTIME运行时。同时需要一个Lifecycle.Event类型的参数。

• 如何使用呢？
  上一篇文章中指出：在事件分发的最后ClassesInfoCache中有一个方法叫createInfo，该方法中通过反射（反射稍后说）获取观察者的所有方法，再通过OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);方法获取注解为OnLifecycleEvent的注解信息，如果该方法注解不是OnLifecycleEvent则退出，如果为OnLifecycleEvent，则可以通过annotation.value()获取注解的值。如下：

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
        //通过反射获取观察者中的所有方法
        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
        boolean hasLifecycleMethods = false;
        for (Method method : methods) {
            //获取方法注解，如果没有注解的就不处理了
            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
            if (annotation == null) {
                continue;
            }
            hasLifecycleMethods = true;
            //获取方法参数
            Class<?>[] params = method.getParameterTypes();
            int callType = CALL_TYPE_NO_ARG;
            if (params.length > 0) {
                //如果参数个数 > 0，第一个参数必须是LifecycleOwner
                callType = CALL_TYPE_PROVIDER;
                if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. Must be one and instanceof LifecycleOwner");
                }
            }
            Lifecycle.Event event = annotation.value();

            if (params.length > 1) {
                //如果有两个参数的，第二个参数必须是Event，且注解值只能是ON_ANY
                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
                if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                    throw new IllegalArgumentException(
                            "invalid parameter type. second arg must be an event");
                }
                if (event != Lifecycle.Event.ON_ANY) {
                    throw new IllegalArgumentException(
                            "Second arg is supported only for ON_ANY value");
                }
            }
            if (params.length > 2) {
                //参数不能超过两个
                throw new IllegalArgumentException("cannot have more than 2 params");
            }
            MethodReference methodReference = new MethodReference(callType, method);
            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
        }
        //存储观察者类信息
        CallbackInfo info = new CallbackInfo(handlerToEvent);
        mCallbackMap.put(klass, info);
        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
        return info;
    }

到这里，注解其实只是简单的概括了一些东西及使用，现实开发中使用到很多的注解，如Retrofit的@GET、@POST、@Query()、@Url等等，有兴趣的可以去看看其实现。当然，注解还有编译器注解（APT）实现，例如Databinding、Viewbinding等，这个将来再说。

四、反射

要了解反射，首先得了解Class类

• Class是一个描述类信息的类，封装了当前对象所对应的类的信息
• 对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象
• 一个类在 JVM 中只会有一个Class实例

一、常用的Class类的方法

二、如何获取Class对象
Java中提供了三种获取Class对象的方法

//1、通过类名.class  如：
  Class clazz = Person.class

//2、通过对象名.getClass() 这种方式是用在传进来一个对象，却不知道对象类型的时候使用如：
  Person person = new Person();
  Class clazz = person.getClass();
  //实际上上面的方式没有必要，都已经知道Person对象了...
  //但是：如果传进来是一个Object类，这种做法就是应该的
  Object obj = new Person();
  Class clazz = obj.getClass();

//3.通过全类名(可能会抛出ClassNotFoundException异常)
  Class clazz = Class.forName("com.itdev.Person");

实际上，在分析Lifecycle源码过程中，我们会发现在使用反射时获取Class对象的方式就是用的第二种方式。
三、获取了Class对象有什么用呢？
通过获取Class对象之后，通过Class对象能够获取到Class对象所描述类的所有信息如：些属性，方法，构造器等，之后可以通过方法method获取到方法的注解信息，参数等等。具体使用可以参考上篇文章中的反射使用，或者搜索一下：Retrofit多baseUrl反射解决方案。

本篇文章就到这里结束了，只是对一些知识做了一些简单的补充。
有更多见解欢迎探讨，公众号招募好文，私信联系～

2021年是我开始写博客记录学习成长过程的一年，2022年希望能够更进一步，输出更多好的文章。这也是2022年的第一篇文章，拖了好长时间了...
同时，自己也做了一个自律计划，希望2022年是自律的一年！