//Observer是一个接口，观察者。当数据改变时就回调onChanged
public interface Observer<T> {
    void onChanged(@Nullable T t);
}

//LiveData类是个抽象类，这里先看看有什么暴露出去的方法
public abstract class LiveData<T> {
    //添加观察者观察, 传入LifecycleOwner，用于来绑定生命周期
    public void observe(LifecycleOwner owner, Observer<T> observer)
    //添加观察者观察, 但是是没有LifecycleOwner
    public void observeForever(Observer<T> observer) 
    //移除观察者   
    public void removeObserver(Observer<T> observer) 
    //移除某个LifecycleOwner里所有的观察者    
    public void removeObservers(final LifecycleOwner owner)
    //是否有观察者    
    public boolean hasObservers()    
    //是否有活的观察者    
    public boolean hasActiveObservers()
}    
//MutableLiveData继承LiveData, 多开放2个方法。
public class MutableLiveData<T> extends LiveData<T> {
    public void postValue(T value) //post一个数据 
    public void setValue(T value)  //设置一个数据
    //postValue和setValue的区别是：post可以在子线程用，而setValue只能在UI线程调用
}

// 这段代码通常在Activity或者Fragment中, 用liveData去添加一个观察者
// AppCompatActivity或者Fragment已经LifecycleOwner，通常传this即可
// 当User数据有变化时，onChanged方法会被调用, 用于更新UI
liveData.observe(this, new Observer<User>() {
    @Override
    public void onChanged(@Nullable User user) {
    //更新UI
    }
});

//下面这段代码通常在ViewModel中，这里liveData和上面代码的liveData是同一个
//可以通过postValue或者setValue去改成user数据, 有数据改变时, onChanged方法会被回调
//假如一个场景, 在ViewModel中，通过网络请求去拿user数据，然后postValue就会去通知UI层onChanged去更新UI
//liveData大概就是这个流程
liveData = new MutableLiveData<User>()
liveData.postValue(user)// 或者setValue(user)

@MainThread
   public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
       //判断当前生命周期是DESTROYED, 立马return, 都销毁了，添加观察者没意义
       if (owner.getLifecycle().getCurrentState() == DESTROYED) {
           // ignore
           return;
       }
       
       
       LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
       ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
       //LifecycleBoundObserver继承ObserverWrapper, LifecycleBoundObserver实现LifecycleOwner
       //mObservers这是一个Map, key是observer, value是ObserverWrapper
       if (existing != null && !existing.isAttachedTo(owner)) {
           throw new IllegalArgumentException("Cannot add the same observer"
                   + " with different lifecycles");
       }
       if (existing != null) {
           return;
       }
       //添加生命周期的观察者
       owner.getLifecycle().addObserver(wrapper);
   }

class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull final LifecycleOwner mOwner;
        
        @Override
        boolean shouldBeActive() {
            //至少是STARTED状态
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        //GenericLifecycleObserver继承自LifecycleObserver, 当生命周期改变时onStateChanged会被回调
        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            //生命周期处于DESTROYED时, 移除观察者，mObserver是livedata.observe时传进来
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            //shouldBeActive()方法实现在当前类， 调用isAtLeast(STARTED), 至少是STARTED状态才是true
            //就是生命周期在STARTED和RESUME状态时, 才是true
            //接着调用了父类的activeStateChanged
            activeStateChanged(shouldBeActive());
        }
    }

    private abstract class ObserverWrapper {
        
        void activeStateChanged(boolean newActive) {
            // mActive状态相同立即返回
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            //就是生命周期在STARTED和RESUME时, mActive为true, 其他为false
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            //当mActive=true时， mActiveCount会加1, 当mActive=false时， mActiveCount会减1。
            //这里为什么要加1和减1呢，结合Activity生命周期去考虑，当Activity.onCreate -> Activity.onStart -> Activity.onResume, State由CREATED->STARTED->RESUMED,这个过程当到STARTED时mActive为true,mActiveCount加1后为1, 接着RESUMED, mActive还是true, 这方法第一句（newActive == mActive）条件成立直接return, mActiveCount此时还是1。
            //当Activity.onResume->Activity.onPause->Activity.onStop，State由RESUMED->STARTED->CREATED, Activity.onStop后State为CREATED, isAtLeast(STARTED)就为false, 此时mActive=false, mActiveCount减1，mActiveCount为0啦。
            //当Activity.onStop->Activity.onStart->Activity.onResume, State由CREATED->STARTED->RESUMED, mActive为true,mActiveCount加1后为1, mActiveCount此时为1。
            if (wasInactive && mActive) {
                //根据上面一大段分析后，onActive会在Activity首次显示UI调用，从后台返回或者从另一个Activity回退后又调用一次。(打开透明Activity不走onStop,这种情况除外)
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                // Activity.onStop后调用
                onInactive();
            }
            if (mActive) {
                //分发数据, 跟踪dispatchingValue方法，会到LiveData.considerNotify方法
                dispatchingValue(this);
            }
        }
    }

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) { 
            //mActive可以知道是否处于onStop状态, 是Stop状态就不要分发数据
            return;
        }
        if (!observer.shouldBeActive()) {
            //shouldBeActive()再次检查是否observer活着
            //ObserverWrapper的实现类不止LifecycleBoundObserver, 这里暂时没看懂为什么再次检查
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            //mVersion会在调用postValue()或者setValue()处+1
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
        调用onChanged分发改变的数据
    }

 
protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) { 
        // 一开始看到这里有点疑问，1. 为什么加锁, 1. 为什么要一个NOT_SET变量(NOT_SET是一个Obj对象)
        // 先带着疑问往下看
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) { // 先往下看，和加锁问题一起解释
        return;
    }
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    // mPostValueRunnable运行在主线程
}

private final Runnable mPostValueRunnable = new Runnable() {
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {  //加锁, 和postValue里的锁是一样的
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        setValue((T) newValue);
    }
};  

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++; // 版本号加1，保证mVersion>mLastVersion
    mData = value; // 赋值给mData, 数据会分发到mObserver.onChanged
    dispatchingValue(null);
    
    //到这里很清晰啦，现在回头看看postValue和mPostValueRunnable里的锁，和NOT_SET的作用
    //1. postValue方法可能会被很多条线程调用
    //2. mPostValueRunnable异步运行在主线程, 主线程是串联执行的，一次执行一个runnable
    //3. 不加锁很明显不行, 多线程调用时, value从postValue方法赋值给mPendingData, 
    //在mPostValueRunnable主线程里把mPendingData赋值给mData, 
    //mPendingData和mData都是指向同一个对象, mData在主线程都是指向了最新的对象。
    //在主线程队列的里mPostValueRunnable每次运行都是拿了最新的数据，有点多余
    //4. 假如去掉NOT_SET, value从postValue方法赋值给mPendingData, 
    // 再到setValue的mData, mPendingData和mData都是指向同一个对象，
    // 虽然加了锁也没用。但有了NOT_SET就不同啦, mPendingData地址给mData，NOT_SET地址给mPendingData, 
    // 在postValue方法的子线程里新进来的value地址又赋值给mPendingData。
    //5.看回postValue方法里 if (!postTask) { return } 这个地方，
    // 假如A线程调用了postValue, 把value赋值给mPendingData并释放了锁, 
    // 把A.mPostValueRunnable放到主线程的Message中, 
    // 但这时之前的B.mPostValueRunnable还没运行完，运行到setValue方法，也没有持有锁。
    // 这时B线程也调用了postValue, 这时A.mPostValueRunnable还没运行，没有把mPendingData=NOT_SET，
    // B线程postTask就为false了, 接着又把value赋值给mPendingData, 接着就直接return。
    // 等A.mPostValueRunnable运行时, mPendingData又被B线程更新啦。
    // if (!postTask) { return } 这个判断能减少主线程没必要mPostValueRunnable运行, 
    // 而且能更新到最新的数据。
    
}

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // initiator是null , 下面是遍历mObservers存储ObserverWrapper通知所有观察者
    ...
    for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
         mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
        considerNotify(iterator.next().getValue()); 
        // considerNotify前面分析过了，看回LiveData.observe的过程, 最终分发数据Observer.onChanged
    }
}

public class MainActivity extends Activity {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         
         MyViewModel viewModel = ViewModelProviders.of(this).get(MyViewModel.class);
         
         viewModel.getUsers().observer(this, new Observer() {
            @Override
             public void onChanged(@Nullable User data) {
                 // update the ui.
             }
         });
        
     }
 }

public class MyViewModel extends ViewModel {
    
    private MutableLiveData<List<User>> users;
    
    public LiveData<List<User>> getUsers() {
        if (users == null) {
            users = new MutableLiveData<List<User>>();
            loadUsers();
        }
        return users;
    }

    private void loadUsers() {
        // perform an asynchronous operation to fetch users.
    }
}

/**
 * Utilities methods for {@link ViewModelStore} class.
 */
public class ViewModelProviders {
/**
     * Creates a {@link ViewModelProvider}, which retains ViewModels while a scope of given Activity
     * is alive. More detailed explanation is in {@link ViewModel}.
     * <p>
     * It uses {@link ViewModelProvider.AndroidViewModelFactory} to instantiate new ViewModels.
     *
     * @param activity an activity, in whose scope ViewModels should be retained
     * @return a ViewModelProvider instance
     */
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        ViewModelProvider.AndroidViewModelFactory factory =
                ViewModelProvider.AndroidViewModelFactory.getInstance(
                        checkApplication(activity));
        return new ViewModelProvider(ViewModelStores.of(activity), factory);
    }
  
 }

/**
     * Simple factory, which calls empty constructor on the give class.
     */
    public static class NewInstanceFactory implements Factory {

        @SuppressWarnings("ClassNewInstance")
        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            //noinspection TryWithIdenticalCatches
            try {
                return modelClass.newInstance();
            } catch (InstantiationException e) {
                throw new RuntimeException("Cannot create an instance of " + modelClass, e);
            } catch (IllegalAccessException e) {
                throw new RuntimeException("Cannot create an instance of " + modelClass, e);
            }
        }
    }

/**
     * {@link Factory} which may create {@link AndroidViewModel} and
     * {@link ViewModel}, which have an empty constructor.
     */
    public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {

        private static AndroidViewModelFactory sInstance;

        /**
         * Retrieve a singleton instance of AndroidViewModelFactory.
         *
         * @param application an application to pass in {@link AndroidViewModel}
         * @return A valid {@link AndroidViewModelFactory}
         */
        public static AndroidViewModelFactory getInstance(@NonNull Application application) {
            if (sInstance == null) {
                sInstance = new AndroidViewModelFactory(application);
            }
            return sInstance;
        }

        private Application mApplication;

        /**
         * Creates a {@code AndroidViewModelFactory}
         *
         * @param application an application to pass in {@link AndroidViewModel}
         */
        public AndroidViewModelFactory(@NonNull Application application) {
            mApplication = application;
        }

        @NonNull
        @Override
        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
            if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
                //noinspection TryWithIdenticalCatches
                try {
                    return modelClass.getConstructor(Application.class).newInstance(mApplication);
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (InstantiationException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                } catch (InvocationTargetException e) {
                    throw new RuntimeException("Cannot create an instance of " + modelClass, e);
                }
            }
            return super.create(modelClass);
        }
    }

public class MyViewModelFactory extends ViewModelProvider.NewInstanceFactory {
 
    private String data1;
    private String data2;

    public MyViewModelFactory(String data1, String data2) {
        this.data1 = data1;
        this.data2 = data2;
    }
 
    @NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
        if (MyViewModel.class.isAssignableFrom(modelClass)) {
            try {
                return modelClass.getConstructor(MyViewModel.class).newInstance(data1, data2);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
        return super.create(modelClass);
    }
    
}

//initializing the custom factory class 
MyViewModelFactory factory = new MyViewModelFactory(data1, data2);
ViewModelProviders.of(this, factory).get(MyViewModel.class);

/**
 * Factory methods for {@link ViewModelStore} class.
 */
@SuppressWarnings("WeakerAccess")
public class ViewModelStores {

    private ViewModelStores() {
    }

    /**
     * Returns the {@link ViewModelStore} of the given activity.
     *
     * @param activity an activity whose {@code ViewModelStore} is requested
     * @return a {@code ViewModelStore}
     */
    @NonNull
    @MainThread
    public static ViewModelStore of(@NonNull FragmentActivity activity) {
        if (activity instanceof ViewModelStoreOwner) {
            return ((ViewModelStoreOwner) activity).getViewModelStore();
        }
        return holderFragmentFor(activity).getViewModelStore();
    }

    /**
     * Returns the {@link ViewModelStore} of the given fragment.
     *
     * @param fragment a fragment whose {@code ViewModelStore} is requested
     * @return a {@code ViewModelStore}
     */
    @NonNull
    @MainThread
    public static ViewModelStore of(@NonNull Fragment fragment) {
        if (fragment instanceof ViewModelStoreOwner) {
            return ((ViewModelStoreOwner) fragment).getViewModelStore();
        }
        return holderFragmentFor(fragment).getViewModelStore();
    }
}

/**
 * Class to store {@code ViewModels}.
 * <p>
 * An instance of {@code ViewModelStore} must be retained through configuration changes:
 * if an owner of this {@code ViewModelStore} is destroyed and recreated due to configuration
 * changes, new instance of an owner should still have the same old instance of
 * {@code ViewModelStore}.
 * <p>
 * If an owner of this {@code ViewModelStore} is destroyed and is not going to be recreated,
 * then it should call {@link #clear()} on this {@code ViewModelStore}, so {@code ViewModels} would
 * be notified that they are no longer used.
 * <p>
 * {@link android.arch.lifecycle.ViewModelStores} provides a {@code ViewModelStore} for
 * activities and fragments.
 */
public class ViewModelStore {

    private final HashMap<String, ViewModel> mMap = new HashMap<>();

    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.get(key);
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
        mMap.put(key, viewModel);
    }

    final ViewModel get(String key) {
        return mMap.get(key);
    }

    /**
     *  Clears internal storage and notifies ViewModels that they are no longer used.
     */
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.onCleared();
        }
        mMap.clear();
    }
}

/**
 * A scope that owns {@link ViewModelStore}.
 * <p>
 * A responsibility of an implementation of this interface is to retain owned ViewModelStore
 * during the configuration changes and call {@link ViewModelStore#clear()}, when this scope is
 * going to be destroyed.
 */
@SuppressWarnings("WeakerAccess")
public interface ViewModelStoreOwner {
    /**
     * Returns owned {@link ViewModelStore}
     *
     * @return a {@code ViewModelStore}
     */
    @NonNull
    ViewModelStore getViewModelStore();
}

public class HolderFragment extends Fragment implements ViewModelStoreOwner {
    private static final String LOG_TAG = "ViewModelStores";

    private static final HolderFragmentManager sHolderFragmentManager = new HolderFragmentManager();

    /**
     * @hide
     */
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public static final String HOLDER_TAG =
            "android.arch.lifecycle.state.StateProviderHolderFragment";

    private ViewModelStore mViewModelStore = new ViewModelStore();

    public HolderFragment() {
        setRetainInstance(true);
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        sHolderFragmentManager.holderFragmentCreated(this);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mViewModelStore.clear();
    }

    @NonNull
    @Override
    public ViewModelStore getViewModelStore() {
        return mViewModelStore;
    }

    /**
     * @hide
     */
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public static HolderFragment holderFragmentFor(FragmentActivity activity) {
        return sHolderFragmentManager.holderFragmentFor(activity);
    }

    /**
     * @hide
     */
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    public static HolderFragment holderFragmentFor(Fragment fragment) {
        return sHolderFragmentManager.holderFragmentFor(fragment);
    }

    @SuppressWarnings("WeakerAccess")
    static class HolderFragmentManager {
        private Map<Activity, HolderFragment> mNotCommittedActivityHolders = new HashMap<>();
        private Map<Fragment, HolderFragment> mNotCommittedFragmentHolders = new HashMap<>();

        private ActivityLifecycleCallbacks mActivityCallbacks =
                new EmptyActivityLifecycleCallbacks() {
                    @Override
                    public void onActivityDestroyed(Activity activity) {
                        HolderFragment fragment = mNotCommittedActivityHolders.remove(activity);
                        if (fragment != null) {
                            Log.e(LOG_TAG, "Failed to save a ViewModel for " + activity);
                        }
                    }
                };

        private boolean mActivityCallbacksIsAdded = false;

        private FragmentLifecycleCallbacks mParentDestroyedCallback =
                new FragmentLifecycleCallbacks() {
                    @Override
                    public void onFragmentDestroyed(FragmentManager fm, Fragment parentFragment) {
                        super.onFragmentDestroyed(fm, parentFragment);
                        HolderFragment fragment = mNotCommittedFragmentHolders.remove(
                                parentFragment);
                        if (fragment != null) {
                            Log.e(LOG_TAG, "Failed to save a ViewModel for " + parentFragment);
                        }
                    }
                };

        void holderFragmentCreated(Fragment holderFragment) {
            Fragment parentFragment = holderFragment.getParentFragment();
            if (parentFragment != null) {
                mNotCommittedFragmentHolders.remove(parentFragment);
                parentFragment.getFragmentManager().unregisterFragmentLifecycleCallbacks(
                        mParentDestroyedCallback);
            } else {
                mNotCommittedActivityHolders.remove(holderFragment.getActivity());
            }
        }

        private static HolderFragment findHolderFragment(FragmentManager manager) {
            if (manager.isDestroyed()) {
                throw new IllegalStateException("Can't access ViewModels from onDestroy");
            }

            Fragment fragmentByTag = manager.findFragmentByTag(HOLDER_TAG);
            if (fragmentByTag != null && !(fragmentByTag instanceof HolderFragment)) {
                throw new IllegalStateException("Unexpected "
                        + "fragment instance was returned by HOLDER_TAG");
            }
            return (HolderFragment) fragmentByTag;
        }

        private static HolderFragment createHolderFragment(FragmentManager fragmentManager) {
            HolderFragment holder = new HolderFragment();
            fragmentManager.beginTransaction().add(holder, HOLDER_TAG).commitAllowingStateLoss();
            return holder;
        }

        HolderFragment holderFragmentFor(FragmentActivity activity) {
            FragmentManager fm = activity.getSupportFragmentManager();
            HolderFragment holder = findHolderFragment(fm);
            if (holder != null) {
                return holder;
            }
            holder = mNotCommittedActivityHolders.get(activity);
            if (holder != null) {
                return holder;
            }

            if (!mActivityCallbacksIsAdded) {
                mActivityCallbacksIsAdded = true;
                activity.getApplication().registerActivityLifecycleCallbacks(mActivityCallbacks);
            }
            holder = createHolderFragment(fm);
            mNotCommittedActivityHolders.put(activity, holder);
            return holder;
        }

        HolderFragment holderFragmentFor(Fragment parentFragment) {
            FragmentManager fm = parentFragment.getChildFragmentManager();
            HolderFragment holder = findHolderFragment(fm);
            if (holder != null) {
                return holder;
            }
            holder = mNotCommittedFragmentHolders.get(parentFragment);
            if (holder != null) {
                return holder;
            }

            parentFragment.getFragmentManager()
                    .registerFragmentLifecycleCallbacks(mParentDestroyedCallback, false);
            holder = createHolderFragment(fm);
            mNotCommittedFragmentHolders.put(parentFragment, holder);
            return holder;
        }
    }
}

public HolderFragment() {
   setRetainInstance(true);
}

get(MyViewModel.class)

public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ............
        {
    ............
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    ............       
 }

LifecycleRegistry类   

@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        //初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //通过ObserverWithState将观察者和状态进行包装
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //将包装类放到 FastSafeIterableMap<LifecycleObserver, ObserverWithState> 中 。
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        ............
        //将状态进行对齐  
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " +                statefulObserver.mState);
            }
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            popParentState();         
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            //同步状态 
            sync();
        }
        mAddingObserverCounter--;
    }

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ............
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

public static void injectIfNeededIn(Activity activity) {
    ........
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

public State getTargetState() {
    switch (this) {
        case ON_CREATE:
        case ON_STOP:
            return State.CREATED;
        case ON_START:
        case ON_PAUSE:
            return State.STARTED;
        case ON_RESUME:
            return State.RESUMED;
        case ON_DESTROY:
            return State.DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException(this + " has no target state");
}

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    ......
    //当 mObserverMap 中存储的最新的状态(刚插入的) 与 最老的状态(最先插入的) 一致，并且当前状态等于最新的状态，停止同步。 
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }
}

class Task {
    Date dateDue;
    String title;
    String description;

    // getters and setters here
}

class MyRecyclerView.Adapter extends RecyclerView.Adapter {

    static final TODAYS_DATE = new Date();
    static final DATE_FORMAT = new SimpleDateFormat("MM dd, yyyy");

    public onBindViewHolder(Task.ViewHolder tvh, int position) {
        Task task = getItem(position);

        if (TODAYS_DATE.compareTo(task.dateDue) > 0) {
            tvh.backgroundView.setColor(Color.GREEN);
        } else {
            tvh.backgroundView.setColor(Color.RED);
        }

        String dueDateFormatted = DATE_FORMAT.format(task.getDateDue());
        tvh.dateTextView.setDate(dueDateFormatted);
    }
}

public class TaskViewModel {
    int overdueColor;
    String dateDue;
}

public onBindViewHolder(Task.ViewHolder tvh, int position) {
    TaskViewModel taskViewModel = getItem(position);
    tvh.backgroundView.setColor(taskViewModel.getOverdueColor());
    tvh.dateTextView.setDate(taskViewModel.getDateDue());
}

// mAdapter.notifyDataSetChanged()
DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new DiffCallBack(oldDatas, newDatas), true);
diffResult.dispatchUpdatesTo(mAdapter);

mAdapter.notifyItemRangeInserted(position, count);
mAdapter.notifyItemRangeRemoved(position, count);
mAdapter.notifyItemMoved(fromPosition, toPosition);
mAdapter.notifyItemRangeChanged(position, count, payload);

class OuterAdapter extends RecyclerView.Adapter<OuterAdapter.ViewHolder> {
    RecyclerView.RecycledViewPool mSharedPool = new RecyclerView.RecycledViewPool();

...

    @Override
    public OuterAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

        RecyclerView innerLLM = new RecyclerView(inflater.getContext());

        LinearLayoutManager innerLLM = new LinearLayoutManager(parent.getContext(), LinearLayoutManager.HORIZONTAL);
        innerLLM.setRecycleChildrenOnDetach(true);
        innerRv.setLayoutManager(innerLLM);
        innerRv.setRecycledViewPool(mSharedPool);
        return new OuterAdapter.ViewHolder(innerRv);
    }

// 在嵌套内部的LayoutManager中调用LinearLayoutManger的设置方法
// num的取值：如果列表刚刚展示4个半item，则设置为5
innerLLM.setInitialItemsPrefetchCount(num);

recyclerView.setItemViewCacheSize(20);
recyclerView.setDrawingCacheEnabled(true);
recyclerView.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);

new LinearLayoutManager(this) {
    @Override
    protected int getExtraLayoutSpace(RecyclerView.State state) {
        return size;
    }
};

@Aspect
public class MethodAspect {
    private static final String TAG = "MethodAspect5";

    //切面表达式，声明需要过滤的类和方法 
    @Pointcut("execution(* android.view.View.OnClickListener+.onClick(..))")
    public void callMethod() {
    }

    //before表示在方法调用前织入
    @before("callMethod()")
    public void beforeMethodCall(ProceedingJoinPoint joinPoint) {
    //编写业务代码
    }
}

import javassist.*;

public class JavassistExample {
    public static void main(String[] args) throws Exception {
        // 创建类池
        ClassPool classPool = ClassPool.getDefault();

        // 创建一个新的类
        CtClass newClass = classPool.makeClass("ExampleClass");

        // 添加一个新的方法
        CtMethod newMethod = CtNewMethod.make("public void hello() { System.out.println(\"Hello, Javassist!\"); }", newClass);
        newClass.addMethod(newMethod);

        // 将新类加载到内存中
        Class<?> clazz = newClass.toClass();

        // 实例化新类并调用方法
        Object obj = clazz.newInstance();
        clazz.getMethod("hello").invoke(obj);
    }
}

Log.d("tag", " onCreate");

mv.visitLdcInsn("tag");
mv.visitLdcInsn("onCreate");
mv.visitMethodInsn(INVOKESTATIC, "android/util/Log", "d", "(Ljava/lang/String;Ljava/lang/String;)I", false);
mv.visitInsn(POP);

//java.lang.reflect.Proxy
public static Object newProxyInstance(ClassLoader loader,
    Class<?>[] interfaces, 
    InvocationHandler h)

public class InvocationHandlerImpl implements InvocationHandler {

    /** 被代理的实例 */
    private Object mObj = null;

    public InvocationHandlerImpl(Object obj){
        this.mObj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //前切入点
        Object result = method.invoke(this.mObj, args);
        //后切入点
        return result;
    }
}

public class MyView extends View {
    public MyView(Context context) {
        super(context, null);
        init(context);
    }

    public MyView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }
}

private void init(Context context, AttributeSet attrs, int defStyleAttr) {
    TypedArray typedArray = context.obtainStyledAttributes(attrs,
            R.styleable.MyView, defStyleAttr, 0);

    text = typedArray.getString(R.styleable.MyView_customText);
    dimension = typedArray.getDimension(R.styleable.MyView_customSize, 30);

    typedArray.recycle();
  
 //执行初始化逻辑
}

// 获取测量模式（Mode）
int specMode = MeasureSpec.getMode(measureSpec)
// 获取测量大小（Size）
int specSize = MeasureSpec.getSize(measureSpec)
// 通过Mode 和 Size 生成新的SpecMode
int measureSpec=MeasureSpec.makeMeasureSpec(size, mode);

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
        int specMode = MeasureSpec.getMode(spec);
        int specSize = MeasureSpec.getSize(spec);
        int size = Math.max(0, specSize - padding);
        int resultSize = 0;
        int resultMode = 0;
        switch (specMode) {
        //当父View要求一个精确值时，为子View赋值
        case MeasureSpec.EXACTLY:
            //如果子view有自己的尺寸，则使用自己的尺寸
            if (childDimension >= 0) {
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
                //当子View是match_parent,将父View的大小赋值给子View
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                resultSize = size;
                resultMode = MeasureSpec.EXACTLY;
                //如果子View是wrap_content，设置子View的最大尺寸为父View
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;
        // 父布局给子View了一个最大界限
        case MeasureSpec.AT_MOST:
            if (childDimension >= 0) {
                //如果子view有自己的尺寸，则使用自己的尺寸
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                // 父View的尺寸为子View的最大尺寸
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                //父View的尺寸为子View的最大尺寸
                resultSize = size;
                resultMode = MeasureSpec.AT_MOST;
            }
            break;
        // 父布局对子View没有做任何限制
        case MeasureSpec.UNSPECIFIED:
            if (childDimension >= 0) {
            //如果子view有自己的尺寸，则使用自己的尺寸
                resultSize = childDimension;
                resultMode = MeasureSpec.EXACTLY;
            } else if (childDimension == LayoutParams.MATCH_PARENT) {
                //因父布局没有对子View做出限制，当子View为MATCH_PARENT时则大小为0
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            } else if (childDimension == LayoutParams.WRAP_CONTENT) {
                //因父布局没有对子View做出限制，当子View为WRAP_CONTENT时则大小为0
                resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
                resultMode = MeasureSpec.UNSPECIFIED;
            }
            break;
        }
        return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
    }

@Override
  protected void onDraw(Canvas canvas) {
      //调用父类的onDraw函数，因为View这个类实现了一些基本的绘制功能，比如绘制背景颜色和背景图片
      super.onDraw(canvas);
      //半径
      int r = getMeasuredWidth()/2;
      int centerX = getLeft() + r;
      int centerY = getTop() + r;
      canvas.drawCircle(centerX,centerY,r,mPaint);

mWebView.setWebViewClient(new WebViewClient() {
    @Override
    public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
        // 根据url得到文件名
        String fileName = getFileNameByUrl(request.getUrl().toString());
        if (!fileInCache(fileName)) {
            // 如果当前文件不在缓存列表中, 不使用缓存
            return super.shouldInterceptRequest(view, request);
        } else {
            // 当前文件可以使用缓存, 根据后缀判断 mimetype
            InputStream inputStream = null;
            String mimeType = null;
            if (fileName.endsWith("css")) {
                mimeType = "text/css";
            } else if (fileName.endsWith("js")) {
                mimeType = "text/javascript";
            } else if (fileName.endsWith("png")) {
                mimeType = "image/png";
            }
            if (mimeType == null) {
                return null;
            }
            try {
                inputStream = App.getContext().getAssets().open(fileName);
            } catch (IOException e) {
                Log.e(LOG_TAG, "read file IOException: " + e.getMessage());
            }
            if (inputStream != null) {
                WebResourceResponse response = new WebResourceResponse(
                            mimeType, "utf-8", inputStream);
                // 解决css、js的跨域问题
                Map<String, String> headers = new HashMap<>();
                headers.put("Access-Control-Allow-Origin", "*");
                headers.put("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE, PUT");
                headers.put("Access-Control-Max-Age", "3600");
                headers.put("Access-Control-Allow-Headers", "Content-Type,Access-Token,Authorization");
                response.setResponseHeaders(headers);
                return response;
            }
            return null;
        }
    }
});