Jetpack之Lifecycle源码分析

Lifecycle是Jetpack的核心组件，他可以无侵入的观测到Activity/Fragment的生命周期变化，解耦代码。对于ViewModel，LifeData，以及一些需要感知生命周期的方法或组件可以提供帮助。官网使用介绍地址是lifecycle。

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 推荐引入提供DefaultLifecycleObserver，只要继承该类，按需要重写对应生命周期回调，然后注册，即可收到回调
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
// 不推荐，这是通过注解生成对应的文件然后得到回调的方式，使用lifecycle-common-java8更合适，具体后续再说
kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
//viewmodel集合了lifecycle的ktx依赖，可以通过viewModelScope方法获取带有生命周期的协程对象
//引入了-ktx那么他们原本的依赖也会引入，不用重复，比如下面的androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version就不必额外引入，他提供了ViewModel需要相关类
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
//livedata相关的依赖
implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
//Saved组件的依赖，可以用来替换onSaveInstance相关，用于自动保存被系统回收的数据
implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
//提供了ProcessLifecycleOwner用于监测应用的生命周期，比如是出于前台还是后台等，详细后续再说
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
//提供了LifecycleService用于检测Service的生命周期变化
implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
//其他...

使用

我们使用它的最基础的功能，然后再分析它的具体的几个类和分别在Activity的调用情况。我们的版本是2.2.0，androidx版本是1.3.2。
假如我们有一个组件需要监测生命周期的变化，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class TestLife : DefaultLifecycleObserver {
    private fun startPlay() {
        Log.i("TestLife", "startPlay")
    }
    private fun stopPlay() {
        Log.i("TestLife", "stopPlay")
    }
    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        startPlay()
    }
    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        stopPlay()
    }
    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        owner.lifecycle.removeObserver(this)
    }
}

//然后在Activity中
override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(TestLife())
    }

我们只需要在Activity中通过lifecycle.addObserver(TestLife())把他作为一个组件添加到lifecycle中即可，TestLife就可以收到Activity的生命周期回调。

源码分析

他的类图结构大概是这样的：

主要的逻辑集中在LifecycleRegistry，我们先列举出几个关键的类和他的作用。

1.Lifecycle，是一个抽象类，可以添加或者删除需要观测Activity生命周期的组件

1
2
3
4
5
6
//增加
addObserver(LifecycleObserver observer)
//删除
removeObserver(LifecycleObserver observer);
// 获取当前Activity的状态
State getCurrentState()

2.State，是Lifecycle的内部枚举类，他提供了一些值用于判断当前Activity的状态

1
2
3
4
5
6
DESTROYED, //在调用了onDestory之后getCurrentState()变为它，他是最小的
INITIALIZED,// 在没有调用onCreate之前是这个
CREATED, //在调用了onCreate之后，onStop之前
STARTED, //在调用了onStart之后，onPause之前
RESUMED; //在调用了onResume之后
isAtLeast(State) // 还提供了另外一个方法判断是否大于某个状态，上面的是从小打到排序

3.Event类，也是Lifecycle的内部枚举类，他一一对应了Activity的所有生命周期，可以作为OnLifecycleEvent注解的值，被OnLifecycleEvent注解的方法可以收到对应的生命周期回调(后续再说)

1
2
3
4
5
6
7
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY //表示任何状态都可以

4.LifecycleRegistry，是Lifecycle的具体实现类，提供了所有的关键实现
5.LifecycleOwner，是一个接口，提供了一个获取Lifecycle的方法Lifecycle getLifecycle()，实际用是用来获取LifecycleRegistry。
6.ComponentActivity，是位于androidx.activity包下的Activity，FragmentActivity继承自他，AppCompatActivity继承自ComponentActivity。
7.LifecycleObserver，他是一个空接口，他主要有两种实现，第一类是LifecycleEventObserver，第二类是FullLifecycleObserver，他们二者的区别如下

1
2
3
4
5
6
7
8
9
10
//LifecycleEventObserver接口的方法
//他是每一个Activity生命周期发生变化都可以通过onStateChanged方法得知，实现类实现该接口，然后通过LifecycleRegistry添加进入生命周期观测接口
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
//FullLifecycleObserver，他是回调了每一个具体的生命周期
  void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);

8.Lifecycling，处理各种不同的生命周期监听方式，是一个工具类的定位。

LifecycleRegistry的源码实现

基本构成

他是继承自Lifecycle的，他是每一个Act都拥有一个实例。我们先看他的成员变量

  1. mObserverMap，是FastSafeIterableMap<LifecycleObserver, ObserverWithState> 类型，用于存储包装LifecycleObserver作为key，把拥有的组件状态包装为value，FastSafeIterableMap的相关介绍文章Jetpack之FastSafeIterableMap源码
  2. WeakReference<LifecycleOwner> mLifecycleOwner，他是生命周期组件的引用持有者，使用弱引用避免内存泄漏
  3. int mAddingObserverCounter，用于维护事件嵌套发生时LifecycleRegistry的状态维护。下面三个属性也是
  4. boolean mHandlingEvent ，用于维护事件嵌套发生时LifecycleRegistry的状态维护
  5. boolean mNewEventOccurred，用于维护事件嵌套发生时LifecycleRegistry的状态维护
  6. ArrayList<State> mParentStates，用于维护事件嵌套发生时LifecycleRegistry的状态维护

首先我们先明确一下LifecycleRegistry维护的状态他是有大小的，即State枚举类，从小打到是

1
DESTROYED<INITIALIZED<CREATED<STARTED<RESUMED

LifecycleRegistry维护的LifecycleObserver有一个规则，在任意时候，新的订阅者的状态小于等于之前的订阅者的状态，即状态的有序性。

订阅者之前的状态为何不一致？因为LifecycleRegistry通知所有的LifecycleObserver是一个同步的过程，前面的订阅者先同步到了后面的订阅者还没有，所以会存在订阅者状态不一致的情况。
LifecycleRegistry中最重要的一个方法是addObserver，他的实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //获取初始状态，假如不是DESTROYED则是INITIALIZED
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //把observer和initialState包裹成ObserverWithState，关于ObserverWithState后续再说
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //假如之前存在就不存入mObserverMap，之前不存在则存入mObserverMap，key是observer
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        if (previous != null) {
            //之前已经添加过一次了
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // 生命组件不存在引用则返回
            return;
        }
        //是否是再次进入
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        //计算observer的状态，他一定是<=之前的observer的
        State targetState = calculateTargetState(observer);
        //标识为处理中
        mAddingObserverCounter++;
        //假如初始状态小于需要设置到observer目标状态则进行循环并且进行事件通知
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }
        //假如不是再次添加
        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        //计算完成
        mAddingObserverCounter--;
    }

上面已经解析了他的大概流程，我们就分析mObserverMap如何维护状态，为何需要ObserverWithState，如何通知以及同步状态给各个观察者。

ObserverWithState

首先是ObserverWithState，我们先看它的源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            //把传入的observer转为LifecycleEventObserver，如何转下面说
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            //设置初始状态
            mState = initialState;
        }
        //外部状态改变，调用该方法
        void dispatchEvent(LifecycleOwner owner, Event event) {
            //获取新的state，getStateAfter后面再说
            State newState = getStateAfter(event);
            //找到最小的
            mState = min(mState, newState);
            //然后mLifecycleObserver更新状态
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

我们先看如何把LifecycleObserver转为LifecycleEventObserver以及他的作用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@NonNull
   static LifecycleEventObserver lifecycleEventObserver(Object object) {
       //是否是LifecycleEventObserver的子类
       boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
       //是否是FullLifecycleObserver的子类
       boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
       //假如二者都是，那么就构建二者都有的FullLifecycleObserverAdapter
       if (isLifecycleEventObserver && isFullLifecycleObserver) {
           return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                   (LifecycleEventObserver) object);
       }
       //假如只是FullLifecycleObserver则只构建他自己的
       if (isFullLifecycleObserver) {
           return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
       }
       //假如是LifecycleEventObserver则直接返回
       if (isLifecycleEventObserver) {
           return (LifecycleEventObserver) object;
       }
       //以上都不是，那么他应该是直接继承了LifecycleObserver
       final Class<?> klass = object.getClass();
       int type = getObserverConstructorType(klass);
       if (type == GENERATED_CALLBACK) {
           //假如是通过编译生成的
           List<Constructor<? extends GeneratedAdapter>> constructors =
                   sClassToAdapters.get(klass);
           if (constructors.size() == 1) {
               GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                       constructors.get(0), object);
               return new SingleGeneratedAdapterObserver(generatedAdapter);
           }
           GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
           for (int i = 0; i < constructors.size(); i++) {
               adapters[i] = createGeneratedAdapter(constructors.get(i), object);
           }
           //多个构造函数的
           return new CompositeGeneratedAdaptersObserver(adapters);
       }
          //否则使用反射处理
       return new ReflectiveGenericLifecycleObserver(object);
   }

其中FullLifecycleObserverAdapter，SingleGeneratedAdapterObserver，CompositeGeneratedAdaptersObserver，ReflectiveGenericLifecycleObserver是实现了LifecycleEventObserver的类，在onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event)中调用各个观察者的方法。他的作用是统一观测者的接口，方便不同方式的观测者接受到事件更新。

从上面返回LifecycleEventObserver的方式我们就知道我们观察者需要观察生命周期的方式一般是由四种方式

  1. 直接继承FullLifecycleObserver，也可以同时继承LifecycleEventObserver(一般不用)
  2. 直接继承LifecycleEventObserver，选择性继承FullLifecycleObserver(一般不用)
  3. 直接继承自LifecycleObserver，然后需要观察的生命周期添加OnLifecycleEvent注解
  4. 直接继承自LifecycleObserver，然后需要观察的生命周期添加OnLifecycleEvent注解，并且添加 kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"依赖，通过注解生成文件。
    以上四种方式，其中第一种是最简单的值得推荐的，所以我们一开始就不推荐引入lifecycle-compiler而是直接使用lifecycle-common-java8。

然后我们再次把眼光回到ObserverWithState的dispatchEvent(LifecycleOwner owner, Event event)中，他通过调用转化得来的mLifecycleObserver，通过它去调用观测者的对应方法。

状态更新和同步

我们先看上面提到的getStateAfter(event)方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   //他是把Act的生命周期转换成State的方法
static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

downEvent则是把State转为Event，方向是向下的，即ON_STOP，ON_DESTROY，ON_PAUSE，upEvent则是向上的，把State转为Event，对应的是ON_CREATE，ON_START，ON_RESUME。

外部更新LifecycleRegistry的状态，一般是通过setCurrentState(@NonNull State state)或者是handleLifecycleEvent(@NonNull Lifecycle.Event event)，他们都最终调用到了moveToState(State next)中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void moveToState(State next) {
       if (mState == next) {
           //如果当前状态是一致的则不处理
           return;
       }
       mState = next;
       if (mHandlingEvent || mAddingObserverCounter != 0) {
           //正在处理别的时间中，暂不处理，并标记具有新事件发生
           mNewEventOccurred = true;
           // we will figure out what to do on upper level.
           return;
       }
       //正在处理事件
       mHandlingEvent = true;
       sync();
       //完成
       mHandlingEvent = false;
   }

可以看到最终是来到我们的核心方法sync()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
      //判断是否同步过
private boolean isSynced() {
        if (mObserverMap.size() == 0) {
            return true;
        }
        State eldestObserverState = mObserverMap.eldest().getValue().mState;
        State newestObserverState = mObserverMap.newest().getValue().mState;
        //假如mObserverMap头跟尾部都一致而且也与当前的mState一直，那么这个组件就不用更新了
        return eldestObserverState == newestObserverState && mState == newestObserverState;
    }

private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            //生命组件不存在了
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) {
            //没有同步过开始同步
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                //假如观测者中的首次存入的状态比当前状态大的state，比如mState是CREATED，但是，观测者的是STARTED，则需要把观测者的mState往后移动，后面细说
                backwardPass(lifecycleOwner);
            }
            //假如观测者中最后存入的state比mState小
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                //比如newest是出于CREATED，但是mState是STARTED，则需要把它的state往前移动，后面细说
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }

其实一般而言，newest是等于eldest的，一个LifecycleObserver只会被存入mObserverMap一次。
然后我们再看最后的两个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private void backwardPass(LifecycleOwner lifecycleOwner) {
           //获取倒叙的Iterator，从后往前
        Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
                mObserverMap.descendingIterator();
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
          //只有observer的state比mState大继续用继续分发
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                //把state转为ON_STOP，ON_PAUSE，ON_DESTROY
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                //通知观测者，同时observer的mState会被改变
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
               //只有observer的state比mState小继续用继续分发
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                   //把mState转为`ON_CREATE，ON_START，ON_RESUME`，同时observer的mState会被改变
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

可以看到观测者接受的生命周期的顺序不是断开的而是联系的

以上基本就是LifecycleRegistry的源码解析了

LifecycleRegistry源码总结

  1. 需要观测声明周期的组件一般是继承DefaultLifecycleObserver，重写需要的方法，然后在Activity中调用（也可以是其他三种方式）lifecycle.addObserver(life)，然后就可以收到生命周期回调
  2. 在addObserver(@NonNull LifecycleObserver observer)过程中，把observer存入到mObserverMap中，后续生命周期发生变化进行通知。如果observer的初始状态比当前Act的小则进行同步，比如我们可以在onResume中才去addObserver，但是life又有onCreate，这是Act执行了onResume会通知到life的onCreate和onResume
  3. 外部通过调用LifecycleRegistry的markState(@NonNull State state)或者是handleLifecycleEvent(@NonNull Lifecycle.Event event)去更新State，然后通知所有的observer

触发LifecycleRegistry

具有生命周期的组件只有在对应的生命周期调用LifecycleRegistry的方法更新即可，常见的有下面两种种方式

  1. 对于Activity而言，使用ReportFragment，它内部封装了对LifecycleRegistry的调用，我们的ComponentActivity就是使用这种方式，我们的lifecycle-process依赖也是，关于lifecycle-process后续再说
  2. 自己直接拥有LifecycleRegistry对象，然后调用它，比如Fragment中，比如自己直接继承Activity然后需要管理生命周期，就可以声明一个LifecycleRegistry对象然后在声明周期调用他
    我们主要是讲解第一种，我们平常假如没有引入lifecycle-process，既可以直接继承ComponentActivity或者他的子类AppCompatActivity或者是通过ProcessLifecycleOwner.get().lifecycle来得到LifecycleOwner，但是这种方式是有缺陷的，他是用来监听应用程序的生命周期的，后续再说他的用法。

ReportFragment

他的源码也比较的简单，他有一个注入Act的方法，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // api29以上的增加LifecycleCallbacks，2.2.0的才有这个，2.1.0的lifecycle是没有的
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }
        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.
             //把一个无内容的Fragment附着到Activity中
            manager.executePendingTransactions();
        }
    }

他的主要思路就是利用一个无内容的，ReportFragment在他的生命周期当中可以回调到LifecycleOwner中(比如AppCompatActivity)，假如他的宿主是实现了LifecycleOwner就可以调动Lifecycle组件的方法更新观测者了。
他的代码并不复杂，主要是重写Activity对应的生命周期方法，然后最终都调用到dispatch方法中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private void dispatch(Lifecycle.Event event) {
       Activity activity = getActivity();
       if (activity instanceof LifecycleRegistryOwner) {
           //该方式一般是直接继承Activity然后实现LifecycleRegistryOwner类，他与LifecycleOwner差不多
           //适用于老代码，一般是不建议自己去实现LifecycleRegistryOwner的，他已经废弃了
           ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
           return;
       }

       if (activity instanceof LifecycleOwner) {
           Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
           if (lifecycle instanceof LifecycleRegistry) {
               //调用这个去更新观测者的生命周期变化
               ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
           }
       }
   }

为什么不直接在ComponentActivity里面去调用呢？这是因为要解耦，有的Activity不一定是要间接或者是直接继承ComponentActivity的，但是假如他们也需要使用Lifecycle组件的话，就可以直接使用ReportFragment了。

总结

LifeCycle的几个类的职责我们再说下

  1. LifeCycleOwner是定义获取Lifecycle的接口
  2. Lifecycle，他是一个接口，定义了一些方法，是用来管理需要观测生命周期的组件的。他有一个实现类LifecycleRegistry，都是使用这个类去实现Lifecycle的逻辑
  3. LifecycleObserver，他是用于生命周期的具体感知回调接口，观测者需要间接或者直接的实现它。然后要么是通过注解(apt可以选择性添加)，要么是继承FullLifecycleObserver，要么是继承LifecycleEventObserver。
  4. ReportFragment，是用它来触发LifecycleRegistry的方法。他是一个无内容的Fragment，绑定了Activity的生命周期。

参考文章

  1. Android架构组件（2）LifecycleRegistry 源码分析
  2. 官方文档

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

职业：移动开发者<br><br>Skill：Java,Kotlin,RN,Flutter<br>