上一篇介绍了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 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类的方法
| 方法名 | 功能说明 |
|---|---|
| static Class forName(String name) | 返回指定全类名的Class对象 |
| newInstance() | 调用缺省构造函数，返回该Class对象的一个实例 |
| newInstance(Object []args) | 调用当前格式构造函数，返回该Class对象的一个实例 |
| getName() | 返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称 |
| getSuperClass() | 返回当前Class对象的父类的Class对象 |
| getInterfaces() | 获取当前Class对象的接口 |
| getClassLoader() | 返回该类的类加载器 |
| getSuperclass() | 返回表示此Class所表示的实体的超类的Class |
| getInterfaces() | 获取当前Class对象的接口 |
| getMethods() | 获取当前Class对象所表示实体的所有方法，但是不能获取private方法,且获取从父类继承来的所有方法 |
| getDeclaredMethods() | 获取当前Class对象所表示实体的所有方法，且只获取当前类的方法 |
| getDeclaredMethod(String name, Class... parameterTypes) | 获取Class对象所表示实体的指定方法名 |
| getMethod(String name, Class... parameterTypes) | 获取Class对象所表示实体的指定方法名 |
| getDeclaredFields() | 获取所有变量字段 |
| getDeclaredField(String name) | 获取指定变量字段 |
二、如何获取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年是自律的一年！