Android 状态管理之Lifecycle浅析

作者:??rEd_???? 时间:2023-06-27 21:34:05 

原理概述

Lifecycle主要用于Activity、Fragment这一类具有状态的组件的状态监听,最主要的一个作用就是将原先Activity、Fragment中的大量的生命周期相关的回调函数移出View层文件,从设计角度上来说,使得MVVM中的View层文件的结构更加清晰、简单,简化了View层的任务,使得代码更清晰、易于维护。

Lifecycle实现监听的原理主要有两种方式,在API29以下的版本主要采用的是方法一,而在API29+的版本采用的是方法二。

  • 和Glide插件一样的,采用一个专门用于报告状态的Fragment,当这个特殊的空白Fragment * 入到宿主Activity时,就可以获取到宿主的生命周期状态改变。

  • 实现Application.ActivityLifecycleCallbacks,监听相关的生命周期的改变。

大概的使用步骤如下:

  • 声明自己的监听组件:MyUtil实现LifecycleObserver接口

  • 采用注解声明生命周期回调函数:

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
   private void fun1(){
       //on_create时需要做的事情
   }

在MainActivity.java中调用:

getLifecycle().addObserver(new MyUtil());

显然,在这个模型中,lifecycle本身只是一个事件的源头,而我们自己实现的监听者MyUtil则是观察者,我们像lifecycle注册我们的工具,一旦lifecycle收到了生命周期的变化通知,那么就通知一系列的观察者进行更新:

Android 状态管理之Lifecycle浅析

Lifecycle本身更像是一个代理,我们的工具类不需要自己去做监听这一件事情了,所以这实际上可以看做是两个观察者模式的合成,而中间的lifecycle是一个系统为我们提供的接口,用于获得回调。我们只需要注册我们的Observer即可。这样一来,分析lifecycle的过程明显被拆成了两个子问题:

问题1. MyUtil(LifecycleObserver)是如何监听lifecycle的?

问题2. lifecycle是如何监听宿主(LifecycleOwner)生命周期变化的?

构成

Lifecycle的构成对象:

  • Lifecycle:即生命周期,某个组件(Activity、Fragment)可能会具有自己的Lifecycle。

  • LifecycleOwner:Lifecycle的持有者,某个组件(Activity、Fragment)。

  • LifecycleObserver:即观察者,我们需要对某个组件的生命周期进行观察,那么就必须实现LifecycleObserver,通过lifecycle的addObserver方法对LifecycleObserver进行注册监听,这样一来对应的LifecycleObserver的类就能够得到生命周期的相关回调了。

  • Event:即生命周期回调的方法,例如ON_CREATE、ON_START等等。

  • State:当某个Event发生后,会导致State的转变,例如ON_CREATE事件发生时,State将会从INITIALIZED走向CREATED,如下【模型】中的状态转移关系图。

    • INITIALIZED:刚刚被初始化。

    • CREATED:ON_CREATE之后、ON_STOP之后。

    • STARTED:ON_START之后、ON_PAUSE之后。

    • RESUMED:ON_RESUME之后、ON_PAUSE之前

    • ON_DESTORYED:ON_DESTROY之后,还未被创建或者已经销毁。

模型

Android 状态管理之Lifecycle浅析

//对应的状态转移函数
@NonNull
public State getTargetState() {
 //枚举类,this标识的是某种事件,例如ON_CREATE、ON_STOP等等。
   switch (this) {
       //对于ON_CREATE和ON_STOP事件,都对应CREATED状态。(图上二者都指向CREATED)
       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");
}

源码

1. addObserver(observer)

LifecycleOwner作为事件的源头,Fragment、Activity都是LifecycleOwner。换句话说就是这两者会产生一些列生命周期相关的事件。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
       LifecycleOwner

LifecycleOwner提供了唯一一个方法,并且,在ComponentActivity类中,使用的是Lifecycle的一个实现类:mLifecycleRegistry

public interface LifecycleOwner {
   @NonNull
   Lifecycle getLifecycle();
}
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
//LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
   enforceMainThreadIfNeeded("addObserver");//主线程断言
   State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;//如果mState是已经销毁的则就标记为已经销毁;如果是其他的(所有有效的),就标记为已初始化过的。
   ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//传入自定义的观察者(非被观察者)和状态。
   ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//尝试放入被观察者维护的观察者对象集合中(如果不存在的话,防止多次注册)。如果存在,返回既有值的value;如果不存在put,并返回null。
 //如果之前存在一个相同的observer,那么直接return;
   if (previous != null) {
       return;
   }
 //取得lifecycleOwner对象,通常是Activity或者是Fragment,注意,此处的LifecycleOwner是被WeakReference<LivecycleOwner>引用住的。是在LifecycleRegistry的构造函数中,被注入了值。
  //private final WeakReference<LifecycleOwner> mLifecycleOwner;

LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

//如果为空,说明对象已经被回收了,return掉。
   if (lifecycleOwner == null) {
       // it is null we should be destroyed. Fallback quickly
       return;
   }

boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
   State targetState = calculateTargetState(observer);
   mAddingObserverCounter++;
//正在注册的观察者数量+1

//ENUM Class之间的比较,二者相等会返回0。这个循环作用就是追加之前的生命周期事件派发(粘性)
   while ((statefulObserver.mState.compareTo(targetState) < 0
           && mObserverMap.contains(observer))) {
     //该行代码的内部实现是:mParentStates.add(state);其中的mParentStates是一个ArrayList,用于存储一些“旧”的消息。例如我们在running(create、start、resume都走完了)状态通过点击按钮注册一个监听,此时的pushParentState中的参数:statefulObserver.mState就是“INITIALIZED”。
       pushParentState(statefulObserver.mState);
     //接着上面的情况,传入的参数是:INITIALIZED,从upFrom中取出的Event是“ON_CREATE”,但是此时onCreate状态实际上早已走完了。
       final Event event = Event.upFrom(statefulObserver.mState);
       if (event == null) {
           throw new IllegalStateException("no event up from " + statefulObserver.mState);
       }
     //注意,我们在实例中的ON_CREATE等等回调都是在这步里面执行的【图1】,主要是更新状态,和派发事件,走完这代码,statefulObserver.mState就变成了CREATED
       statefulObserver.dispatchEvent(lifecycleOwner, event);

//和pushParentState对应,此时删除后parentState长度为0。
       popParentState();

targetState = calculateTargetState(observer);
     //此时statefulObserver.mState为CREATED,而targetState的值被更新为:RESUME。
   }

if (!isReentrance) {
       // we do sync only on the top level.
       sync();
   }
   mAddingObserverCounter--;
}

接下来的第二轮代码的,其实和第一轮类似,就是从Event从ON_CREATE变成了ON_START,然后派发了ON_START事件。ON_RESUME同理。大概的流程是,添加Observer的时候。以statefulObserver为主,不论Activity是什么状态,进入时initialState都是INITIALIZED状态,然后利用Event.upFrom函数,根据状态(State,例如CREATED),取出事件(Event,例如ON_CREATE),然后, statefulObserver.dispatchEvent(lifecycleOwner, event);更新了statefulObserver的状态,依次类推。

Android 状态管理之Lifecycle浅析

以上代码的几个比较关键的展开:

private State calculateTargetState(LifecycleObserver observer) {

//mObserverMap即上面addObserver主干代码中的第七行:
 //ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
 //此处是对该Map唯一的加入调用。

//取出临近的ObserverWithState,FastSafeIterableMap,注释中说是:Poor's man LinkedHashMap
 //LifecycleObserver在androidx.core.app.ComponentActivity中可以看到,ComponentActivity实现了该接口。
 //所以,该Map是一个Activity对应ObserverWithState(一个State、一个LifecycleEventObserver)的结构:

Map.Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

//如果不为空,那么就设置siblingState为previous中存储对象的mState else null
   State siblingState = previous != null ? previous.getValue().mState : null;
 //如果有parentState,那么获取其中的最后一个的State else null
   State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
           : null;
 //取mState、siblingState和parentState中最小值。
   return min(min(mState, siblingState), parentState);
}

//statefulObserver.dispatchEvent(lifecycleOwner, event);
void dispatchEvent(LifecycleOwner owner, Event event)
  //根据event(ENUM)获取其状态,这个和上面的状态图是一样的。
  State newState = event.getTargetState();
//取最小状态
  mState = min(mState, newState);
  //更新状态,响应回调
  mLifecycleObserver.onStateChanged(owner, event);
//设置新状态
  mState = newState;
}

Android 状态管理之Lifecycle浅析

2. sync()

private void sync() {
 //即Activity、Fragment这类生命周期持有者。
   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.");
   }
 //如果mObserverMap中的元素还没有完全同步就进行循环,进行所有保存着的观察者的状态同步。
   while (!isSynced()) {
     //标记是否有新的事件出现,当moveToState被调用时,满足条件(mHandlingEvent || mAddingObserverCounter != 0)时,该属性会被置为true。
     //这两个条件是:1是否正在处理事件,2是是否正在处理新加入的观察者。
       mNewEventOccurred = false;
       //利用mState和mObserverMap中最老的元素状态相比较,如果更小(最小的是DESTROY,INITIALIZED,一直到RESUMED),那么久从最早被加入的元素,顺着这个LinkedHashMap进行后向的更新。例如CREATED < RESUMED
       if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
         //后向传播
           backwardPass(lifecycleOwner);
       }
       Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
     //如果没有新的事件出现(期间没有moveToState被触发),最新的观察者不为空,并且有当前组件的状态更先于最新组件的状态。
     //例如mState = RESUMED和newest.mState = CREATED,那么就触发前向传播。
       if (!mNewEventOccurred && newest != null
               && mState.compareTo(newest.getValue().mState) > 0) {
         //前向传播
           forwardPass(lifecycleOwner);
       }
     //在这个循环中,直到所有Observer状态全部同步为止。
   }
   mNewEventOccurred = false;
}

private boolean isSynced() {
 if (mObserverMap.size() == 0) {
   return true;
 }
 State eldestObserverState = mObserverMap.eldest().getValue().mState;
 State newestObserverState = mObserverMap.newest().getValue().mState;
 //判断最晚加入的 是否等于 最早加入的 是否等于 当前的状态。
 return eldestObserverState == newestObserverState && mState == newestObserverState;
}
//forwardPass同理;
private void backwardPass(LifecycleOwner lifecycleOwner) {
 //迭代器
   Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
           mObserverMap.descendingIterator();
 //在forwardPass中:
   //Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
   //mObserverMap.iteratorWithAdditions();
 //在没有新的事件(moveToState触发)的情况下进行迭代。
   while (descendingIterator.hasNext() && !mNewEventOccurred) {
       Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
       ObserverWithState observer = entry.getValue();
       while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
               && mObserverMap.contains(entry.getKey()))) {
         //和addObserver中相似的逻辑,同步时主动去回调其他滞后的监听者的状态。
           Event event = Event.downFrom(observer.mState);
           if (event == null) {
               throw new IllegalStateException("no event down from " + observer.mState);
           }
           pushParentState(event.getTargetState());
           observer.dispatchEvent(lifecycleOwner, event);
           popParentState();
       }
   }
}

3. setCurrentState、moveToState

这一类的方法用于外部调用,用于lifecycle的状态转移。例如我们可以显式地在一个Activity的所有生命周期中,调用setCurrentState方法来标记(通知)lifecycle状态。标记完成后,将触发sync进行所有观察者状态的同步。

@MainThread
   public void setCurrentState(@NonNull State state) {
       enforceMainThreadIfNeeded("setCurrentState");//断言主线程
       moveToState(state);
   }

/**
    * Sets the current state and notifies the observers.
    * <p>
    * Note that if the {@code currentState} is the same state as the last call to this method,
    * calling this method has no effect.(如果在相同的State下调用此方法无效。)
    *
    * @param event The event that was received
    */
   public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
       enforceMainThreadIfNeeded("handleLifecycleEvent");//断言主线程
       moveToState(event.getTargetState());
   }

private void moveToState(State next) {
     //相同状态下调用无效。
       if (mState == next) {
           return;
       }
       mState = next;
     //如果正在处理事件,或者含有某个刚刚加入的Observer(数量不为0),那么久标记当前有新的事件出现了。
       if (mHandlingEvent || mAddingObserverCounter != 0) {
           mNewEventOccurred = true;
           // we will figure out what to do on upper level.
           return;
       }
       mHandlingEvent = true;//标记正在处理事件,有点像锁
       sync();//同步(前后向传播)
       mHandlingEvent = false;//结束
   }

监听

从moveToState说起,它有三个调用。

@Deprecated
@MainThread
public void markState(@NonNull State state) {
   enforceMainThreadIfNeeded("markState");
   setCurrentState(state);
}

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

markState已经被标记为@Deprecated,但是我们可以找到它的一个调用:package androidx.core.app下的ComponentActivity中的onSaveInstanceState仍然保持着这个方法的调用。

package androidx.core.app;

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

setCurrentState则在package androidx.activity;中的ComponentActivity被引用:

package androidx.activity;

@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
   Lifecycle lifecycle = getLifecycle();
   if (lifecycle instanceof LifecycleRegistry) {
       ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);//
   }
   super.onSaveInstanceState(outState);
   mSavedStateRegistryController.performSave(outState);
}

至于handleLifecycleEvent:

Android 状态管理之Lifecycle浅析

很明显在AppcompatActivity中,handleLifecycleEventlifecyle的关系比较密切。

例如,在onCreate方法中,有:

protected void onCreate(@Nullable Bundle savedInstanceState) {
       mFragments.attachHost(null /*parent*/);

if (savedInstanceState != null) {
          //如果是重建的Activity进行的操作,以下省略
          ......
       }

if (mPendingFragmentActivityResults == null) {
           mPendingFragmentActivityResults = new SparseArrayCompat<>();
           mNextCandidateRequestIndex = 0;
       }

super.onCreate(savedInstanceState);

mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);//派发事件
       mFragments.dispatchCreate();
   }

每当我们的Activity父类的FragmentActivity的方法:onCreate被回调时,必然会触发handleLifecycleEvent()的执行,这样一来非常简单地就实现了监听。

但是,在androidx.activity.ComponentActivity;中,有一段非常特殊的代码:

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   mSavedStateRegistryController.performRestore(savedInstanceState);
   ReportFragment.injectIfNeededIn(this);//
   if (mContentLayoutId != 0) {
       setContentView(mContentLayoutId);
   }
}
public static void injectIfNeededIn(Activity activity) {
   if (Build.VERSION.SDK_INT >= 29) {
       // On API 29+(Android 10.0 +), 我们可以直接注册正确的lifecycle监听,内部将会直接实现监听:在Activity类中的mActivityLifecycleCallbacks中,加入一个Callback:mActivityLifecycleCallbacks.add(callback);
       activity.registerActivityLifecycleCallbacks(
               new LifecycleCallbacks());
   }

android.app.FragmentManager manager = activity.getFragmentManager();
   if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
     //注意这里,我们向当前的Activity中新加入了一个new ReportFragment()。
       manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
       manager.executePendingTransactions();
   }
}

任取一个Fragment的生命周期函数作为观察,进入dispatch()方法。

@Override
public void onStart() {
   super.onStart();
   dispatchStart(mProcessListener);
   dispatch(Lifecycle.Event.ON_START);
}

@Override
public void onResume() {
   super.onResume();
   dispatchResume(mProcessListener);
   dispatch(Lifecycle.Event.ON_RESUME);
}

@Override
public void onPause() {
   super.onPause();
   dispatch(Lifecycle.Event.ON_PAUSE);
}

在dispatch方法中,发现将activity当做LifecycleOwner获取了其Lifecycle进行事件的处理。

@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
   if (activity instanceof LifecycleRegistryOwner) {
       ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);//
       return;
   }

if (activity instanceof LifecycleOwner) {
       Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
       if (lifecycle instanceof LifecycleRegistry) {
           ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);//
       }
   }
}

其中,LifecycleRegistryOwner是LifecycleOwner接口的子类,可以看到返回值不同。显然,当Activity生命周期发生变动时,Fragment的生命周期也会相应地发生变动,由ReportFragment的生命周期函数中进行handleLifecycleEvent就非常巧妙地实现了监听这一功能。这一点和Glide的实现(采用一个空白的RequestManagerFragment)非常相似。

Android 状态管理之Lifecycle浅析

但是,在API29+,程序会走这样一段代码:

public static void injectIfNeededIn(Activity activity) {
   if (Build.VERSION.SDK_INT >= 29) {
       // On API 29+, we can register for the correct Lifecycle callbacks directly
       LifecycleCallbacks.registerIn(activity);
   }
   //……
}

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

//有做省略
   static void registerIn(Activity activity) {
       activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
   }
   @Override
   public void onActivityPostCreated(@NonNull Activity activity,
           @Nullable Bundle savedInstanceState) {
       dispatch(activity, Lifecycle.Event.ON_CREATE);
   }
   @Override
   public void onActivityPostStarted(@NonNull Activity activity) {
       dispatch(activity, Lifecycle.Event.ON_START);
   }
   @Override
   public void onActivityPostResumed(@NonNull Activity activity) {
       dispatch(activity, Lifecycle.Event.ON_RESUME);
   }
   @Override
   public void onActivityPrePaused(@NonNull Activity activity) {
       dispatch(activity, Lifecycle.Event.ON_PAUSE);
   }
   @Override
   public void onActivityPreStopped(@NonNull Activity activity) {
       dispatch(activity, Lifecycle.Event.ON_STOP);
   }
   @Override
   public void onActivityPreDestroyed(@NonNull Activity activity) {
       dispatch(activity, Lifecycle.Event.ON_DESTROY);
   }
}

同时,Api29+的机型,也会走到:插入一个ReportFragment。理论上,通过Application.ActivityLifecycleCallbacks 回调就已经能够注册到监听了,至于为什么这么设计并不清楚。但是到派发事件时的dispatch方法:

private void dispatch(@NonNull Lifecycle.Event event) {
   if (Build.VERSION.SDK_INT < 29) {
       dispatch(getActivity(), event);//TAG
   }
}

它限制了通过Fragment生命周期回调产生的监听只在Api<29才会进行派发,所以不会产生两次派发。而标记的TAG处的dispatch是一个静态方法,注意,API29+的dispatch直接就是调用的这个静态方法。

static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
   if (activity instanceof LifecycleRegistryOwner) {
       ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
       return;
   }

if (activity instanceof LifecycleOwner) {
       Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
       if (lifecycle instanceof LifecycleRegistry) {
           ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
       }
   }
}

//API29中的调用,走的是上面的静态方法。
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
 dispatch(activity, Lifecycle.Event.ON_START);
}

不论是API29以下通过Fragment监听,还是API29以上,通过Application.ActivityLifecycleCallbacks进行监听,走的都是lifecycle.handleLifecycleEvent()方法。这也是为什么在上文中提handleLifecycleEvent有大量调用的调用:

Android 状态管理之Lifecycle浅析

其他

1. Application.ActivityLifecycleCallbacks

该接口含有大量的回调函数,和日常开发中的那三对回调函数不同,这里的划分更加细致,有三组,并且每组又区分pre和post,外加一个onActivitySaveInstanceState,每当Activity发生生命周期转变时,该回调函数都会被回调到,并且参数是发生变化的Activity。我们可以自定义一个类实现该接口,然后this.registerActivityLifecycleCallbacks(callbacks);注册一下即可。该类还可以实现更灵活的Activity 实例数量管控。大部分的事件都是在POST部分中处理的,而不是Pre。

@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
   dispatch(activity, Lifecycle.Event.ON_RESUME);//向监听者(MyUtils类等等)派发事件
}

来源:https://juejin.cn/post/6968395080721760292

标签:Android,状态,管理,Lifecycle
0
投稿

猜你喜欢

  • Unity的OnOpenAsset实用案例深入解析

    2021-05-30 01:37:16
  • java中常见的死锁以及解决方法代码

    2023-04-07 19:47:30
  • Jexcel实现按一定规则分割excel文件的方法

    2023-06-29 07:52:01
  • SpringBoot 配置文件加密的步骤

    2023-10-23 02:55:55
  • java微信公众号支付示例详解

    2023-11-15 05:52:01
  • C#加密解密文件小工具实现代码

    2021-09-21 07:31:41
  • SpringBoot整合Mybatis-plus案例及用法实例

    2022-03-31 12:02:44
  • Android倒计时的开始与停止 剩余时分秒的展示

    2023-07-20 03:11:31
  • Android多媒体应用使用SoundPool播放音频

    2022-07-16 22:21:04
  • C#使用foreach语句遍历二维数组的方法

    2023-01-19 22:06:05
  • Java统计字符串中字符出现次数的方法示例

    2023-11-25 08:23:02
  • java枚举类型-Enum

    2021-07-11 00:56:47
  • Android 双击返回键退出程序的方法总结

    2023-12-05 16:41:18
  • 详解Spring Security中的HttpBasic登录验证模式

    2023-12-03 03:58:14
  • Java中避免过多if-else的几种方法

    2023-11-28 13:07:09
  • c# 关闭窗体时提示的小例子

    2021-11-10 19:08:18
  • Java应用EasyExcel工具类

    2023-07-07 18:45:32
  • Android自定义顶部导航栏控件实例代码

    2022-02-11 13:43:16
  • android自定义滚动上下回弹scollView

    2023-05-19 13:10:40
  • MyBatis源码浅析(一)开篇

    2022-09-28 03:28:24
  • asp之家 软件编程 m.aspxhome.com