ViewMode+LiveData總結

Activity/Fragment只應關注UI，而不應關系操作邏輯，因此操作邏輯應放到Viewmodel中去
下面是我手畫的資料流圖：
在這里插入圖片描述
首先有Fragment、ViewModel、Livedata這三個物件，

Fragment觀察Viewmodel的Livedata資料，如果livedata的值改變會通知Frament，
ViewModel獲取資料（網路、資料庫），然后設定Livedata的值
Livedata的值改變就通知Fragment
Fragment重繪界面

代碼如下：
Fragment


import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.widget.TextView;

import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;

/**
*
* @author hys huyunsong@58.com
* @date 2020/9/19
*/
public class MyActivity extends AppCompatActivity {
   Handler messageHandler;
   MyViewModel myViewModel;
   Handler mainHandler;

   @Override
   protected void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       final TextView textView = findViewById(R.id.textView);
       // 新建ViewModel
       myViewModel = new MyViewModel();

       // 子執行緒
       HandlerThread handlerThread = new HandlerThread("");
       handlerThread.start();
       // 子執行緒Handler
       messageHandler = new Handler(handlerThread.getLooper());
       // 主執行緒handler
       mainHandler = new Handler(getMainLooper());
       // 開啟自自執行緒改變資料
       messageHandler.post(new Runnable() {
           @Override
           public void run() {
               int i = 0;
               while (i < 100) {
                   mainHandler.post(new Runnable() {
                       @Override
                       public void run() {
                           myViewModel.requestChangeText();
                       }
                   });
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   i++;
               }
           }
       });

       myViewModel.getmText().observe(this, new Observer<String>() {
           @Override
           public void onChanged(final String s) {
               runOnUiThread(new Runnable() {
                   @Override
                   public void run() {
                       textView.setText(s);
                   }
               });

           }
       });
   }
}

viewmodel


import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

import java.util.Observable;
import java.util.Random;

/**
 * Describe:<p></p>
 * 描述：<p></p>
 *
 * @author hys huyunsong@58.com
 * @date 2020/9/19
 */
public class MyViewModel extends ViewModel implements IMyModelHelper {


    private MutableLiveData<String> mText = new MutableLiveData<String>();

    public MyViewModel() {
    }

    public MutableLiveData<String> getmText() {
        return mText;
    }

    @Override
    public void requestChangeText() {
        changeText();
    }

    private void changeText(){
        getmText().setValue(new Random(10).toString());
    }
}

package com.loyal888.tets;

/**
 * Describe:<p></p>
 * 描述：<p></p>
 *
 * @author hys huyunsong@58.com
 * @date 2020/9/19
 */
public interface IMyModelHelper  {
    void requestChangeText();
}

總結：資料通知可以使用Observer，實作進一步解耦合

MVP 和MVVM的區別

在這里插入圖片描述

獲取VidewModel實體

// 新建ViewModel
myViewModel = ViewModelProviders.of(this).get(MyViewModel.class);

VideoModel的生命周期

系統首次呼叫 Activity 物件的 onCreate() 方法時請求 ViewModel，系統可能會在 Activity 的整個生命周期內多次呼叫 onCreate()，如在旋轉設備螢屏時，ViewModel 存在的時間范圍是從您首次請求 ViewModel 直到 Activity 完成并銷毀，

在當前生命周期為Destrory的時候，清除了mViewModelStore

ViewModel中使用Context

擴展AndroidViewModel

ViewModel 物件可以包含 LifecycleObservers，如 LiveData 物件，但是，ViewModel 物件絕不能觀察對生命周期感知型可觀察物件（如 LiveData 物件）的更改，如果 ViewModel 需要 Application 背景關系（例如，為了查找系統服務），它可以擴展 AndroidViewModel 類并設定用于接收 Application 的建構式，因為 Application 類會擴展 Context，

ViewModel原始碼分析

1. ViewModelProvider.of(this)

檢查應用的背景關系
構造了AndroidViewModelFactory
回傳provider

   public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        return of(activity, null);
    }
    
    @NonNull
    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity,
            @Nullable Factory factory) {
        // 1. 檢查應用的背景關系且必須是application
        Application application = checkApplication(activity);
        if (factory == null) {
        // 2.構造了AndroidViewModelFactory
            factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
        }
        // 3.回傳provider
        // 3.1 注意這里的activity.getViewModelStore()
        return new ViewModelProvider(activity.getViewModelStore(), factory);
    }

2. activity.getViewModelStore()

public ViewModelStore getViewModelStore() {
        if (getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the "
                    + "Application instance. You can't request ViewModel before onCreate call.");
        }
        if (mViewModelStore == null) {
           	// 獲取上一次配置改變保存的NonConfigurationInstances，比如螢屏旋轉
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                // 配置改變，viewModelStore不空，直接使用
                // 這個viewModelStore是在哪里保存的？見下文
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                // 第一次來就新建一個ViewModelStore,保存的上一次的狀態
                // 新建來之后保存到哪里？見下文
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }

3.保存ViewModelStore

getLastNonConfigurationInstance();
保存呢？呼叫的是ConponentActivity中的onRetainNonConfigurationInstance,呼叫時機介于onStop和onDestroy中間，onSaveInstance之后，

public final Object onRetainNonConfigurationInstance() {
       Object custom = onRetainCustomNonConfigurationInstance();
   	// 這里就是上文的new出來的mViewModelStore
       ViewModelStore viewModelStore = mViewModelStore;
       if (viewModelStore == null) {
           // No one called getViewModelStore(), so see if there was an existing
           // ViewModelStore from our last NonConfigurationInstance
           NonConfigurationInstances nc =
                   (NonConfigurationInstances) getLastNonConfigurationInstance();
           if (nc != null) {
               viewModelStore = nc.viewModelStore;
           }
       }

       if (viewModelStore == null && custom == null) {
           return null;
       }

       NonConfigurationInstances nci = new NonConfigurationInstances();
       nci.custom = custom;
       // 把mViewModelStore保存到NonConfigurationInstances中去
       nci.viewModelStore = viewModelStore;
       return nci;
   }

4. 獲取上一次保存的viewmodel

public ViewModelStore getViewModelStore() {
       if (getApplication() == null) {
           throw new IllegalStateException("Your activity is not yet attached to the "
                   + "Application instance. You can't request ViewModel before onCreate call.");
       }
       if (mViewModelStore == null) {
           NonConfigurationInstances nc =
                   (NonConfigurationInstances) getLastNonConfigurationInstance();
           if (nc != null) {
           
               // Restore the ViewModelStore from NonConfigurationInstances
               //  注意上面這句英文
               mViewModelStore = nc.viewModelStore;
           }
           if (mViewModelStore == null) {
               mViewModelStore = new ViewModelStore();
           }
       }
       return mViewModelStore;
   }

5. 獲取ViewModel
ViewModelProviders.of(this).get(MyViewModel.class);

public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
      String canonicalName = modelClass.getCanonicalName();
      if (canonicalName == null) {
          throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
      }
      return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
  }
  
  public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
  // 上文提到構建出來的mViewModelStore,從HashMap取出實體
      ViewModel viewModel = mViewModelStore.get(key);

      if (modelClass.isInstance(viewModel)) {
          //noinspection unchecked
          // 	有就回傳
          return (T) viewModel;
      } else {
          //noinspection StatementWithEmptyBody
          if (viewModel != null) {
              // TODO: log a warning.
          }
      }
      if (mFactory instanceof KeyedFactory) {
          viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
      } else {
      	// 沒有反射創建出來
          viewModel = (mFactory).create(modelClass);
      }
      // 將mViewModelStore保存到HashMap，保存的時候會銷毀舊物件
      mViewModelStore.put(key, viewModel);
      //noinspection unchecked
      return (T) viewModel;
  }

public class ViewModelStore {

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

   final void put(String key, ViewModel viewModel) {
       ViewModel oldViewModel = mMap.put(key, viewModel);
       if (oldViewModel != null) {
       	// 舊viewmodel會被清除！！！
           oldViewModel.onCleared();
       }
   }

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

   Set<String> keys() {
       return new HashSet<>(mMap.keySet());
   }

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

總結： `VieModelStore`存在于`FragmentActivity`中，在配置更改導致Activity銷毀前通過`onRetainNonConfiguraionInstance`將資料物件保存，并在重建時通過`getLastNonConfigurationInstance`將資料還原回來，從而保證了Activity內ViewModelStore 的`唯一性`和`一致性`，

LiveData

LiveData 是一種可觀察的資料存盤器類，與常規的可觀察類不同，LiveData 具有生命周期感知能力，意指它遵循其他應用組件（如 Activity、Fragment 或 Service）的生命周期，這種感知能力可確保 LiveData 僅更新處于活躍生命周期狀態的應用組件觀察者，

原始碼分析

構造方法

 public LiveData(T value) {
 		// 保存具體的值
        mData = value;
        // 當前版本
        mVersion = START_VERSION + 1;
    }
}

觀察Livedata

 myViewModel.getmText().observe(this, new Observer<String>() {
            @Override
            public void onChanged(final String s) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText(s);
                    }
                });

            }
        });

observe了什么

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
       // mObservers 添加了當前觀察者
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        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);
    }

資料改變setValue之后

 protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

   void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                        // 通知并回呼每一個觀察者的回呼方法
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

Transformations#map()

eg：

public static <X, Y> LiveData<Y> map(
            @NonNull LiveData<X> source,
            @NonNull final Function<X, Y> mapFunction) {
        final MediatorLiveData<Y> result = new MediatorLiveData<>();
        // X改變了，Y繼續
        result.addSource(source, new Observer<X>() {
            @Override
            public void onChanged(@Nullable X x) {
                result.setValue(mapFunction.apply(x));
            }
        });
        return result;
    }

Transtormations#switchMap

 MutableLiveData userIdLiveData = ...;
 LiveData userLiveData = Transformations.switchMap(userIdLiveData, id ->
     repository.getUserById(id));

 void setUserId(String userId) {
      this.userIdLiveData.setValue(userId);
 }

總結，使用ViewModel和LiveData的優勢

1 不需要手動處理生命周期
ViewModel和LiveData本身是生命周期可感知的

2 確保View可以及時拿到資料狀態

LiveData遵循觀察者模式，資料更改時，LiveData會通知物件，這也是它的優勢，如果UI改變很多，MVP就需要寫很多的介面，View被動的接受Presenter的指令，

3 減少記憶體泄漏

LiveData系結了Lifecycle物件，ViewModel 在生命周期方法中自行清理回收

4 共享資源
單例使用ViewModel和LiveData，可以在程式中共享他們，例兩個fragment共享一個ViewModel

1、建議添加LiveData和ViewModel的詳細使用介紹，方便大家知道一些高級使用方式，比如LiveData對資料的拼裝等，

2、檔案不太能體現出和MVP的對比及優勢，比如ViewModel和View解耦之類的，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/94062.html

標籤：python

上一篇：01-為什么要學爬蟲-python小白爬蟲入門教程

下一篇：vue 實作平滑滾動及導航欄固定偏移問題

ViewModel+LiveData總結