简单使用案例：
MainActivity：

viewModel.getMessageObserver().observe(this, new Observer<MessageBean>() {
    @Override
    public void onChanged(@Nullable MessageBean messageBean) {
        if (messageBean != null) {
            LogUtils.d(messageBean.toString());
        }
    }
});

MessageViewModel：

public class MessageViewModel extends ViewModel {

    private final MutableLiveData<MessageBean> mMessageObserver = new MutableLiveData<>();

    public LiveData<MessageBean> getMessageObserver() {
        return mMessageObserver ;
    }

    public void setHoroscopeId(int horoscopeId) {
        List<MessageBean> characters = new ArrayList<>();
        characters.add(new MessageBean("body1"));
        characters.add(new MessageBean("body2"));
        characters.add(new MessageBean("body3"));
        characters.add(new MessageBean("body4"));

        mMessageObserver.setValue(characters.get(horoscopeId));
    }

    public void getProjectList() {
        DataRepository.getInstance().getProjectList(mMessageObserver , "1", 294);
    }
}

其中viewModel.getMessageObserver().observe(this, new Observer() )
中的this即SupportActivity ：LifecycleOwner

SupportActivity implements LifecycleOwner

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}

SupportActivity

public class SupportActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }

    @CallSuper
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
        super.onSaveInstanceState(outState);
    }

  
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

SupportActivity就是通过getLifecycle()获取 mLifecycleRegistry来标记当前Activity或Fragment的各种状态，其中ReportFragment.injectIfNeededIn(this)内部源码也是与mLifecycleRegistry.markState(Lifecycle.State.CREATED) 类似，状态的信息记录在mLifecycleRegistry对象内部。Activity的其他类型的事件如onCreate,onPause等都是通过getLifecycle()获取 mLifecycleRegistry对象调用mLifecycleRegistry内部方法来改变其状态的。

Fragment的状态更加容易看到，FragmentActivity即在Activity的生命周期中获取

FragmentActivity部分源码：

    @Override
    protected void onStop() {
        super.onStop();

        mStopped = true;
        markState(getSupportFragmentManager(), Lifecycle.State.CREATED);
        mHandler.sendEmptyMessage(MSG_REALLY_STOPPED);

        mFragments.dispatchStop();
    }

    private static void markState(FragmentManager manager, Lifecycle.State state) {
        Collection<Fragment> fragments = manager.getFragments();
        for (Fragment fragment : fragments) {
            if (fragment == null) {
                continue;
            }
            fragment.mLifecycleRegistry.markState(state);
            markState(fragment.getChildFragmentManager(), state);
        }
    }

通过上面的简单分析，两个重要的类即 LifecycleRegistry extends Lifecycle：

下面是Lifecycle抽象类：

public abstract class Lifecycle {
  
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);

  
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    @MainThread
    public abstract State getCurrentState();

    public enum Event {
        
        ON_CREATE,
      
        ON_START,
      
        ON_RESUME,
      
        ON_PAUSE,
       
        ON_STOP,
       
        ON_DESTROY,
       
        ON_ANY
    }

    public enum State {
       
        DESTROYED,

        INITIALIZED,

        CREATED,

        STARTED,

        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}

回到开始的案例：
LiveData.observe(this, new Observer);

    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        // 经典的装饰器模式，这里的设计很精妙，可以看出我们传入的Observer和 owner.getLifecycle().addObserver()是不同的。
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 判断是否已经添加过防止重复添加
        LifecycleBoundObserver existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && existing.owner != wrapper.owner) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

这里我们传入的Observer和 owner.getLifecycle().addObserver()即 Activity中的Lifecycle 是不同的。
我们上面已经知道Activity中的Lifecycle是与生命周期相关的，通过Lifecycle.addObserver()可以监听到 Activity的生命周期 然后在LifecycleBoundObserver作出
相应的处理，具体的实现在LifecycleRegistry.addObserver中(Lifecycle实现类)，最终会根据事件变化调用 mLifecycleObserver.onStateChanged(owner, event)，

class LifecycleBoundObserver implements GenericLifecycleObserver {
    public final LifecycleOwner owner;
    public final Observer<T> observer;

    LifecycleBoundObserver(LifecycleOwner owner, Observer<T> observer) {
        this.owner = owner;
        this.observer = observer;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        // 此处在组件如Activity onDestroy的时候自动移除观察者。
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(observer);
            return;
        }
        // immediately set active state, so we'd never dispatch anything to inactive
        // owner
        activeStateChanged(isActiveState(owner.getLifecycle().getCurrentState()));
    }
}

LifecycleBoundObserver.onStateChanged -> activeStateChanged -> dispatchingValue -> considerNotify(initiator) -> observer.observer.onChanged((T) mData);

最终调用的是我们传入的observer。

这样看来 LiveData<T> 就没有什么特殊的了，把它看做一个普通的观察者模式的管理者即可，比如EventBus。

public abstract class LiveData<T> {
    
    private static final Object NOT_SET = new Object();
    
    // LiveData<T> 存取的值，即T， setValue，postValue 会强制转换为T。    
    private volatile Object mData = NOT_SET;
}

https://developer.android.com/reference/android/arch/lifecycle/Lifecycle