内卷程序员
内卷程序员

Jetpack-Lifecycle

Lifecycle概述

Lifecycle是生命周期感知型组件，可感知组件（如 Activity、 Fragment、service）的生命周期状态的变化。并将生命周期变化的事件通知分发到已注册的观察者。它也是Jetpack组件库的核心基础。Lifecycle整个就是一个观察者模式，来监听activity或者fragment的生命周期。

引入依赖

  • kotlin
dependencies {
        val lifecycle_version = "2.3.1"
        val arch_version = "2.1.0"
 
        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
        // 仅Lifecycles (没有 ViewModel 或 LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
 
        // 为 ViewModel 保存状态模块
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")
 
        // Annotation processor（注释处理器）
        kapt("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // 或者 - 如果使用 Java8，请使用以下代码代替生命周期编译器
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")
 
        // 可选 - 在服务中实现 LifecycleOwner 的助手
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")
 
        // 可选 - ProcessLifecycleOwner 为整个应用程序进程提供生命周期
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")
        // 可选 - 对 LiveData 的 ReactiveStreams 支持
        implementation("androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version")
 
        // 可选 - LiveData 的测试助手
        testImplementation("androidx.arch.core:core-testing:$arch_version")
    }
  • java
dependencies {
        val lifecycle_version = "2.3.1"
        val arch_version = "2.1.0"
 
        // ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version")
        // LiveData
        implementation("androidx.lifecycle:lifecycle-livedata:$lifecycle_version")
        // Lifecycles only (without ViewModel or LiveData)
        implementation("androidx.lifecycle:lifecycle-runtime:$lifecycle_version")
 
        // Saved state module for ViewModel
        implementation("androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version")
 
        // Annotation processor
        annotationProcessor("androidx.lifecycle:lifecycle-compiler:$lifecycle_version")
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation("androidx.lifecycle:lifecycle-common-java8:$lifecycle_version")
 
        // optional - helpers for implementing LifecycleOwner in a Service
        implementation("androidx.lifecycle:lifecycle-service:$lifecycle_version")
 
        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation("androidx.lifecycle:lifecycle-process:$lifecycle_version")
 
        // optional - ReactiveStreams support for LiveData
        implementation("androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version")
 
        // optional - Test helpers for LiveData
        testImplementation("androidx.arch.core:core-testing:$arch_version")
    }
————————————————
版权声明：本文为CSDN博主「盛开的伤」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010217055/article/details/118315013

Lifecycle使用分两步

第一步构建观察者
//第一种实现 LifecycleObserver 接口，在对应的方法上面用配合注解声明，当感知到生命周期变化会通知相应事件对应的注解方法，OnLifecycle.Event 注解来接收生命周期回调。
public class MyLifecycle implements LifecycleObserver {
   
   @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
   void onCreate(LifecycleOwner owner) {
     //初始化业务
   }

   @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
   void onStop(LifecycleOwner owner) {
    //结束业务
   }
   ...
}

//第二中实现 LifecycleEventObserver 的onStateChanged 声明周期改变会回调onStateChanged，然后进行判断
public class TestLifecycle implements LifecycleEventObserver {

   @Override
   public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
       switch (event) {
           case ON_CREATE: { }
           break;
           case ON_START: {  }
           break;
           case ON_STOP: 
           break;
       }
   }
}
第二步注册观察者
//得到Lifecycle并注册观察者
public class MyActivity extends AppCompatActivity {

    MyLifecycle myLifecycle;
    TestLifecycle testLifecycle;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myLifecycle =new MyLifecycle();
        testLifecycle=new TestLifecycle();
 
        //getLifecycle 返回的是LifecycleRegistry实例
        getLifecycle().addObserver(myLifecycle);   
        getLifecycle().addObserver(testLifecycle);
    }
}

原理分析

Lifecycle是用观察者模式实现，个人理解可以从四个方面（观察者、被观察者、注册、事件分发）来分析。

观察者：

LifecycleObserver、FullLifecycleObserver、FullLifecycleObserver 他们之间的关系，我们通常需要实现LifecycleObserver或者LifecycleEventObserver就可以作为观察者

public interface LifecycleObserver {
     
}


public interface LifecycleEventObserver extends LifecycleObserver {

    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}


interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}
被观察者：

实现了LifecycleOwner接口的Activity、service和Fragment等组件，getLifecycle返回Lifecycle实现对象实例，

// Activity
public class ComponentActivity extends ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {
    
       private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
 
       ...

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

//Fragment
public class Fragment implements ComponentCallbacks, 
         OnCreateContextMenuListener, 
         LifecycleOwner,
         ViewModelStoreOwner,
         SavedStateRegistryOwner {

        LifecycleRegistry mLifecycleRegistry;
       ...
        
       public Fragment() {
           initLifecycle();
        }
 
      private void initLifecycle() {
         mLifecycleRegistry = new LifecycleRegistry(this);
         ...
      }

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

}
//Service
public class LifecycleService extends Service implements LifecycleOwner {
    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);
       ...

    @Override
    public Lifecycle getLifecycle() {
        return mDispatcher.getLifecycle();
    }

}
注册：

注册需要获得Lifecycle 对象实例（activity、fragment、service默认实现Lifecycle接口类是LifecycleRegistry），Lifecycle 类中定义了添加观察者和移除观察者的方法，并定义了两个枚举类， Event - 对应了组件（Activity和Fragment）的生命周期事件，State - 组件生命周期的状态

 
public abstract class Lifecycle {
 
    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    AtomicReference mInternalScopeRef = new AtomicReference<>();
 
   //添加观察者LifecycleObserver，组件的状态变化可以通知LifecycleObserver
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
   //从观察者列表中移除观察者
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    //返回当前的声明周期状态
    @MainThread
    @NonNull
    public abstract State getCurrentState();

  //Event：生命周期事件，只要通过注解进行声明，就能够使LifecycleObserver观察到对应的生命周期事件
    @SuppressWarnings("WeakerAccess")
    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;
        }
    }
}

 
 
当Lifecycle注册观察者（调用addObserver方法）,就是调用Lifecycle接口 实现类LifecycleRegistry相关方法，这里注册调用的是addObserver，下面是LifecycleRegistry的主要方法
 
 
public class LifecycleRegistry extends Lifecycle {

   //保存 LifecycleObserver 及其对应的 State
   private FastSafeIterableMap mObserverMap =
           new FastSafeIterableMap<>();

   // 当前生命周期状态
   private State mState;
   private final WeakReference mLifecycleOwner;

   private ArrayList mParentStates = new ArrayList<>();

   public LifecycleRegistry(@NonNull LifecycleOwner provider) {
       mLifecycleOwner = new WeakReference<>(provider);
       mState = INITIALIZED;
   }

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


   @MainThread
   public void setCurrentState(@NonNull State state) {
       moveToState(state);
   }

  ...

    // ObserverWithState
   @Override
   public void addObserver(@NonNull LifecycleObserver observer) {
        //假如当前状态为DESTROYED则设置为DESTROYED, 否则设置为INITIALIZED,在onResume()中调用 addObserver()，那么，观察者依然可以接收到 onCreate 和 onStart 事件。 
       State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
       ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
       // 将包装的observer添加到mObserverMap，以observer自身作为Key值
       ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
      //observer已添加，不进行后续操作
       if (previous != null) {
           return;
       }
       LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
       // 假如lifecycleOwner已销毁，不进行后续操作
       if (lifecycleOwner == null) {
           // it is null we should be destroyed. Fallback quickly
           return;
       }
    //mAddingObserverCounter： 记录正在初始化同步的新添加Observer的数量，大于0时，表示正在对新添加的Observer进行初始化同步。 防止addObserver()重入时，多次调用sync()。使sync()仅仅在最外层的addObserver()同步逻辑完成后执行一次。

    //mHandlingEvent：标记正在进行状态事件同步。 防止moveToState()重入时,多次调用sync()。
      // 判断是否重入
   // mHandlingEvent表示正在执行生命周期迁移导致的sync()同步
   // mAddingObserverCounter>0 表示addObserver()导致的单个Observer同步
       boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
       State targetState = calculateTargetState(observer);
       mAddingObserverCounter++;
       // 如果观察者的初始状态小于 targetState ，则同步到 targetState
     // 通过calculateTargetState获取当前目标需要迁移的目标状态
   State targetState = calculateTargetState(observer);

   // 正在添加Observer的记录自增
   mAddingObserverCounter++;

   // 使Observer迁移到目标状态
   //
   // 当Observer的状态小于目标状态时，升级到目标状态
   // Observer的初始状态时DESTROYED或INITIALIZED，且当初始状态为DESTROYED时，目标状态
   // 也应为DESTROYED，所以新添加的Observer在初始化同步的时候只需要考虑升级同步。
   // 
   // 这里同时做了mObserverMap.contains(observer)的判断，之所以要这么处理，是因为有时候
   // 用户会在observer的生命周期回调中removeObserver移除自身，当发生这种情况时，立即结束
   // 迁移操作
   while ((statefulObserver.mState.compareTo(targetState) < 0 && 
           mObserverMap.contains(observer))) {
       // 缓存observer的状态，用于remove+add问题
       pushParentState(statefulObserver.mState);
       // 派分事件
       statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
       // 移除状态缓存
       popParentState();
       // 由于可能存在的变更，重新调用calculateTargetState获取当前目标需要迁移的目标状态
       targetState = calculateTargetState(observer);
   }

   // 非重入状态执行sync同步
   if (!isReentrance) {
       sync();
   }

   // 正在添加Observer的记录自减
       mAddingObserverCounter--;
   }

   @Override
   public void removeObserver(@NonNull LifecycleObserver observer) {
       mObserverMap.remove(observer);
   }

   @Override
   public State getCurrentState() {
       return mState;
   }

  //对传入的Observer封装成LifecycleEventObserver对象，并同时保存对应的mState状态。
   static class ObserverWithState {
       State mState;
      //LifecycleEventObserver 是继承自LifecycleObserver的接口 声明了onStateChanged()函数
       LifecycleEventObserver mLifecycleObserver;

       ObserverWithState(LifecycleObserver observer, State initialState) {
          //将传入的observer封装成LifecycleEventObserver 对象
           mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
         //保存对应的mState状态
           mState = initialState;
       }
    ...
   }
}

 
 
observer转换LifecycleEventObserver源码分析
 
 
public class Lifecycling {

      ...

    @NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        //类型判断
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
       //类型判断
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;

       //如果Observer 实现的是LifecycleEventObserver或者FullLifecycleObserver 则不会处理注解信息，转换成LifecycleEventObserver对象然后返回

        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
      
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }
        //到这里是生成LifecycleObserver实现类对象，获取observer类的类型，然后判断是需要解析注解信息，还是用反射的方式构建LifecycleEventObserver对象并返回
        final Class klass = object.getClass();
        int type = getObserverConstructorType(klass);
     // 获取 type
    // GENERATED_CALLBACK 表示注解生成的代码
    // REFLECTIVE_CALLBACK 表示使用反射
        if (type == GENERATED_CALLBACK) {
            List> 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);
    }
 
    ...
}


 
 
事件分发：
 
 
Activity 注入了一个没有页面的 Fragment（ReportFragment） 。通过注入 Fragment 来代理权限请求。，ReportFragment 才是真正分发生命周期的地方。
 
 
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

     ...

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

     ...
}

 
 
ReportFragment 的各个生命周期函数中通过 dispatch() 方法来分发生命周期事件， 然后调用 LifecycleRegistry 的 handleLifecycleEvent() 方法来处理
 
 
public class ReportFragment extends Fragment {

     ...

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @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);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
         ...
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        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);
            }
        }
    }

   ...
 
}


 
 
public class LifecycleRegistry extends Lifecycle {

    ...

     // 设置当前状态并通知观察者
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
       // 通知观察者同步到此生命周期状态
        moveToState(next);
    }

    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
    // 检查moveToState是否重入
    // 检查addObserver是否重入
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }

        mHandlingEvent = true;
        sync();
        mHandlingEvent = false;
    }

  // 根据 Event 获取事件之后处于的状态 
    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);
    }

  // 同步所有观察者的状态，比较 mState 和  mObserverMap 中观察者的 State 值，判断是需要向前还是向后同步状态
    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;
             // mState 是当前状态，如果 mState 小于 mObserverMap 中的状态值，调用 backwardPass()
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry newest = mObserverMap.newest();
            // 如果 mState 大于 mObserverMap 中的状态值，调用 forwardPass()
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        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;
}

  //分发 mObserverMap 中的所有观察者到指定生命周期状态，如果跨度比较大，会依次分发中间状态。分发生命周期事件最终依赖 ObserverWithState 的 dispatchEvent() 方法 
    private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            // 向上传递事件，直到 observer 的状态值等于当前状态值
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                 //分发生命周期事件
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

    private void backwardPass(LifecycleOwner lifecycleOwner) {
        Iterator> descendingIterator =
                mObserverMap.descendingIterator();
        // 向下传递事件，直到 observer 的状态值等于当前状态值
        while (descendingIterator.hasNext() && !mNewEventOccurred) {
            Entry entry = descendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                Event event = downEvent(observer.mState);
                pushParentState(getStateAfter(event));
                //分发生命周期事件
                observer.dispatchEvent(lifecycleOwner, event);
                popParentState();
            }
        }
    }

//获取 state 降级所需要经历的事件。
    private static Event downEvent(State state) {
        switch (state) {
            case INITIALIZED:
                throw new IllegalArgumentException();
            case CREATED:
                return ON_DESTROY;
            case STARTED:
                return ON_STOP;
            case RESUMED:
                return ON_PAUSE;
            case DESTROYED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

   //获取 state 升级所需要经历的事件 
    private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }


 
 
State 和 Event 对应关系
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
同步 Observer 生命周期的 sync() 方法最终会调用 ObserverWithState 的 dispatchEvent() 方法。
 
 
    static class ObserverWithState {
       ...
        //在调用dispatchEvent的时候间接调用了LifecycleEventObserver的onStateChanged函数
        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }


 
 
参考链接
 
 
https://www.jianshu.com/p/7087f1dae359
https://www.jianshu.com/p/375c7913ffb0
https://www.jianshu.com/p/4973c4b10f37
https://www.jianshu.com/p/dbc7a2350acc

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Jetpack-Lifecycle)

        

            

                
    
                    
  • Android学习记录之jetpack-lifecycle
                        撸码的NE

                        
    使用起来相当简单，Activity是我们的被观察者publicclassMainActivity1extendsAppCompatActivity{@OverrideprotectedvoidonCreate(BundlesavedInstanceState){super.onCreate(savedInstanceState);setContentView(R.layout.activity_m
    
                    
    • 
                    
  • Jetpack-Lifecycle
                        薛之涛

                        
    lifecycle是jetpack的架构组件成员,其主要作用是对Activity/Fragment的生命周期进行监听。比如:监听activity的onStart()状态来进行耗时操作，onDestory()进行资源的回收销毁等。lifecycle的主要几个类lifecycle核心抽象类，继承该类的子类具有Andorid生命周期特性的对象。lifecycleRegisterlifecycle的唯一子
    
                    
    • 
                    
  • Jetpack-Lifecycle 原理解析
                        明朗__

                        
    介绍Lifecycle它是Jetpack组件库的的核心基础，具备宿主生命周期感知能力的组件。它能持有组件（如Activity或Fragment）生命周期状态的信息，并且允许其他观察者监听宿主的状态，大大减少了业务代码发生内存泄漏和NPE的风险，LiveData、ViewModel组件等也都是基于它来实现的（观察者模式）Googledeveloper介绍工程引入implementation'andr
    
                    
    • 
                    
  • JetPack-Lifecycle
                        niknowzcd

                        
    概述Lifecycle是生命周期感知型组件,用于存储有关组件（如Activity或Fragment）的生命周期状态的信息，并允许其他对象观察此状态使用导入依赖//如果已经集成了AndroidX的不需要额外操作，没有集成的话需要导入对应的依赖implementation"androidx.lifecycle:lifecycle-extensions:2.2.0"annotationProcessor
    
                    
    • 
                    
  • Jetpack-ViewModel源码解析
                        张荣旗

                        
    ViewModel源码解析源码版本：ViewModel：2.4.0Android：31androidx.activity:activity：1.4.0androidx.fragment:fragment：1.4.0需会使用：Lifecycle导航：Jetpack-Lifecycle源码解析Jetpack-LiveData源码解析Jetpack-ViewModel源码详解更多的文章看这里：主页使用声
    
                    
    • 
                    
  • Jetpack-Lifecycle
                        Showdy

                        
    【AAC系列二】深入理解架构组件的基石：LifecycleAndroid官方架构组件Lifecycle:生命周期组件详解&原理分析AndroidJetpack架构组件（三）带你了解Lifecycle（原理篇
    
                    
    • 
                    
  • Jetpack-Startup源码解析
                        张荣旗

                        
    Startup源码解析源码版本：Startup：1.1.0导航：Jetpack-Lifecycle源码解析Jetpack-LiveData源码解析Jetpack-ViewModel源码详解Jetpack-Startup源码详解更多的文章看这里：主页使用实现InitializerclassWorkManagerInitializer:Initializer{overridefuncreate(con
    
                    
    • 
                    
  • jetpack-lifecycle原理解析
                        付小影子

                        
    定义lifecycle就是对activity和fragment生命周期进行监控。一般不会独立使用，都是配合livedata和viewmodel使用。避免内存泄漏jetpack-lifecycle定义.PNGjetpack-lifecycle结构图.PNG总结原理流程1.在Androidx之后，componentActivity默认实现LifeCycleOwner接口，实现getLifecycle(
    
                    
    • 
                    
  • Jetpack-LifeCycle记录
                        東方月初

                        
    初次见到这个心仪的男人，她就假装扭脚碰洒了一杯水，男人衬衫湿了大半，然后一眼看到始作俑者的明眸皓齿和俏皮笑容，呆在当场。感知生命周期。1.LifeCycle创建新建一个类实现LifecycleObserver接口，接下来就可以定义方法为所欲为了。packagecom.litton.myjetpack.lifecycleimportandroidx.lifecycle.Lifecycleimport
    
                    
    • 
                    
  • Jetpack-Lifecycle源码解析
                        张荣旗

                        
    Lifecycle源码解析源码版本：Lifecycle：2.4.0androidx.activity:activity：1.4.0androidx.fragment:fragment：1.4.0导航：Jetpack-Lifecycle源码解析Jetpack-LiveData源码解析Jetpack-ViewModel源码详解更多的文章看这里：主页使用声明LifecycleObserver1.Defa
    
                    
    • 
                    
  • Jetpack-Lifecycle
                        内卷程序员

                        
    Lifecycle概述Lifecycle是生命周期感知型组件，可感知组件（如Activity、Fragment、service）的生命周期状态的变化。并将生命周期变化的事件通知分发到已注册的观察者。它也是Jetpack组件库的核心基础。Lifecycle整个就是一个观察者模式，来监听activity或者fragment的生命周期。引入依赖kotlindependencies{vallifecycl
    
                    
    • 
                    
  • Jetpack-Lifecycle源码分析
                        积木小玩家

                        
    Lifecycle简介Lifecycle类持有相关组件（Activity或者Fragment）生命周期状态的信息，通过Event和State来体现关联的生命周期的状态，允许业务组件观察此生命周期状态，从而达到业务组件分别处理生命周期相关的业务。Lifecyle是LiveData的基石，充分理解Lifecycle实现机制对于后续研究Jetpack其他组件很有必要。特点感知Activity或者Frag
    
                    
    • 
                    
  • Jetpack-Lifecycle
                        慕涵盛华

                        
    Lifecycle介绍相关类和接口使用实现原理Lifecycle-生命周期感知组件Lifecycle是Jetpack中提供的一个用于感知生命周期的组件，在应用中主要用于监听Activity和Fragment的生命周期变化，在合适的时候释放资源，防止内存泄露。使用Lifecycle可以将依赖组件的代码从生命周期方法移入组件本身中。避免了直接在Activity或Fragment的生命周期方法中操作组件
    
                    
    • 
                    
  • Jetpack-Lifecycle
                        有腹肌的豌豆Z

                        
    使用生命周期感知型组件处理生命周期生命周期感知型组件可执行操作来响应另一个组件（如Activity和Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。一种常见的模式是在Activity和Fragment的生命周期方法中实现依赖组件的操作。但是，这种模式会导致代码条理性很差而且会扩散错误。通过使用生命周期感知型组件，您可以将依赖组件的代码从
    
                    
    • 
                    
  • Android Jetpack-Lifecycle
                        大狼狗skr~
Android
                        
    AndroidJetpack-Lifecycle为什么要使用Lifecycle？Activity和Fragment是有生命周期的，有时候，我们的很多操作需要写在生命周期的方法中，比如，下载，文件操作等，这样很多情况下会导致，我们在Activity的生命周期方法中写越来越多的代码，Activity或者Fragment越来越臃肿，代码维护越来越困难。使用Lifecycle就可以很好的解决这类问题。Li
    
                    
    • 
                                
  • 关于旗正规则引擎规则中的上传和下载问题
                                    何必如此
文件下载压缩jsp文件上传
                                    
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 
一、文件打包下载 
1.文件写入压缩包 
string mainPath="D:\upload\";     下载路径 
 
string tmpfileName=jar.zip;        &n
    
                                
    • 
                                
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析
                                    bit1129
Stream
                                    
      
以如下代码为例（SocketInputDStream）： 
Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
    
                                
    • 
                                
  • spark master web ui 端口8080被占用解决方法
                                    daizj
8080端口占用sparkmaster web ui
                                    
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法： 
  
1、cd SPARK_HOME/sbin 
  
2、vi start-master.sh 
  
  
3、定位到下面部分
    
                                
    • 
                                
  • oracle_执行计划_谓词信息和数据获取
                                    周凡杨
oracle执行计划
                                    
      
oracle_执行计划_谓词信息和数据获取(上) 
一：简要说明  
在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 
简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
    
                                
    • 
                                
  • spring中datasource配置
                                    g21121
dataSource
                                    
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： 
http://baike.baidu.com/view/920062.htm 
  
	<!-- spring加载资源文件 -->
	<bean name="propertiesConfig"
		class="org.springframework.b
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三）
                                    老A不折腾
finereportFAQ报表软件
                                    
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
1、repeated column width is largerthan paper width： 
这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
    
                                
    • 
                                
  • mysql 用户管理
                                    墙头上一根草
linuxmysqluser
                                    
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
    
                                
    • 
                                
  • 关于使用Spring导致c3p0数据库死锁问题
                                    aijuans
springSpring 入门Spring 实例Spring3Spring 教程
                                    
    这个问题我实在是为整个 springsource 的员工蒙羞  
如果大家使用 spring 控制事务，使用 Open Session In View 模式，  
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
    
                                
    • 
                                
  • 百度词库联想
                                    annan211
百度
                                    
    

<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>RunJS</title&g
    
                                
    • 
                                
  • int数据与byte之间的相互转换实现代码
                                    百合不是茶
位移int转bytebyte转int基本数据类型的实现
                                    
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来; 
  
主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029 
  
int转byte; 
  
byte转int; 
  
/**
 * 字节转成int,int转成字节
 * @author Administrator
 *

    
                                
    • 
                                
  • 简单模拟实现数据库连接池
                                    bijian1013
javathreadjava多线程简单模拟实现数据库连接池
                                    
    简单模拟实现数据库连接池 
实例1： 
package com.bijian.thread;

public class DB {

	//private static final int MAX_COUNT = 10;
	private static final DB instance = new DB();

	private int count = 0;
	private i
    
                                
    • 
                                
  • 一种基于Weblogic容器的鉴权设计
                                    bijian1013
javaweblogic
                                    
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： 
String  vuser_id = "weblogic";
String  vuse
    
                                
    • 
                                
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化
                                    bit1129
hessian
                                    
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。 
  1. 定义三个POJO 
   Person类 
package com.tom.hes
    
                                
    • 
                                
  • 【Hadoop十四】Hadoop提供的脚本的功能
                                    bit1129
hadoop
                                    
    1. hadoop-daemon.sh 
1.1 启动HDFS 
./hadoop-daemon.sh start namenode
./hadoop-daemon.sh start datanode 
 通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
    
                                
    • 
                                
  • 中国互联网走在“灰度”上
                                    ronin47
管理 灰度
                                    
    中国互联网走在“灰度”上（转） 
文/孕峰 
  
第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。 
  
灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
    
                                
    • 
                                
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
                                    bylijinnan
java
                                    
    

public class PrintMatrixClockwisely {

	/**
	 * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2             3            4
5              6             7            8
9 
    
                                
    • 
                                
  • mongoDB 用户管理
                                    开窍的石头
mongoDB用户管理
                                    
      1:添加用户 
   第一次设置用户需要进入admin数据库下设置超级用户（use admin） 
  
   db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]}); 
   第一个参数用户的名字 
   第二个参数
    
                                
    • 
                                
  • [游戏与生活]玩暗黑破坏神3的一些问题
                                    comsci
生活
                                    
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意 
 
 
     玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天 
 
     结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气 
 
  &nb
    
                                
    • 
                                
  • java 二维数组如何存入数据库
                                    cuiyadll
java
                                    
    using System;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
 
namespace WindowsFormsApplication1
{
    
    
                                
    • 
                                
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA)
                                    darrenzhu
javaspringlocalglobaltransaction
                                    
    Configuring Spring and JTA without full Java EE 
 
http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ 
 
Spring doc -Transaction Management 
 
http://docs.spring.io/spri
    
                                
    • 
                                
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练
                                    dcj3sjt126com
linuxalias
                                    
    用途说明 
设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。 
  常用参数 
格式：alias 
格式：ali
    
                                
    • 
                                
  • yii2 restful web服务[格式响应]
                                    dcj3sjt126com
PHPyii2
                                    
    响应格式 
当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 
 
 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 
 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
    
                                
    • 
                                
  • MongoDB索引调优（2）——[十]
                                    eksliang
mongodbMongoDB索引优化
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述 
      上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档 
    可以在嵌套文档的键上建立索引，方式与正常
    
                                
    • 
                                
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView
                                    gundumw100
android
                                    
    拉动ListView，Item之间的间距会变大，释放后恢复原样； 
 

package cn.tangdada.tangbang.widget;

import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.TypedArray;
import andr
    
                                
    • 
                                
  • 程序员用HTML5制作的爱心树表白动画
                                    ini
JavaScriptjqueryWebhtml5css
                                    
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" >
<ti
    
                                
    • 
                                
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版
                                    kakajw
ThinkPad预装改装windows 7windows 8
                                    
      
该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 
该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！ 
  
缘由 
小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
    
                                
    • 
                                
  • Nginx学习笔记
                                    mcj8089
nginx
                                    
    一、安装nginx                      1、在nginx官方网站下载一个包，下载地址是：  
http://nginx.org/download/nginx-1.4.2.tar.gz  
     2、WinSCP(ftp上传工
    
                                
    • 
                                
  • mongodb 聚合查询每天论坛链接点击次数
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 18 */
{
    "_id" : ObjectId("5596414cbe4d73a327e50274"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
    
                                
    • 
                                
  • java术语（PO/POJO/VO/BO/DAO/DTO）
                                    Luob.
DAOPOJODTOpoVO BO
                                    
    
PO(persistant object) 持久对象
在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作.

VO(value object) 值对象
通
    
                                
    • 
                                
  • 算法复杂度
                                    Wuaner
Algorithm
                                    
    Time Complexity & Big-O： 
 
http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o 
 
http://bigocheatsheet.com/ 
 
http://www.sitepoint.com/time-complexity-algorithms/ 
 
 

    
                                
    •