MVVM的大名相信做手机开发的肯定不会陌生，我第一次听到它是从做IOS开发的同学那里听到的，我们的项目之前应用了MVP，要说服大家从MVP到MVVM，肯定得说说为啥，他优秀在那里？
首先我们看看正常MVP的依赖关系图：
这是个经典的MVP依赖关系，View 层和Presenter，Presenter和Model层彼此依赖，但是不会出现MVC那种跨层依赖，例如如果你写出来的View和Model层有依赖的话，那么就不是正常的MVP结构咯~这个结构好处很明显，Model和View层脱藕。因此修改Model层代码View层代码不用动~
好了说了那么多MVP的，MVP是个很优秀的脱藕的架构。那么MVVM比MVP优秀在那里，还是那句，看图：
我们看到，VM没了对View层的依赖~依赖的代码不由我们写是由框架代码生成~因此我们的进一步看到升级版的MVP~当然我知道最优秀当然是Spring~这里不离题了。MVVM为我们带来的就是这个，那么MVVM运用困难吗？我先跟你说：
1.用了MVVM后，只要写一次后以后不用再写Adapter!
2.用了MVVM后，只要写一次后以后不用再写Dialog!
最重要是，Android官方提供了官方的针对MVVM开发的dataBinding . 所以主角出场，DataBinding!
基本：
然后我们说说配置，很简单一句话，在BuildGradle增加:
android {
....
dataBinding {
enabled = true
}
}没有其他了，除了你的Android Studio 要超过1.3版本。
DataBinding XML和我们平时有点不一样他，他的顶层必须是layout:
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
<data>
<variable
name="vm"
type="com.silver.testdatabinding.AMainPresenterVM" />
<variable
name="user"
type="com.silver.model.BindingUser" />
</data>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@android:color/white"
android:orientation="vertical"
>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"/>
<Button
android:layout_width="100dp"
android:layout_height="wrap_content"
android:background="@android:color/holo_orange_light"
android:gravity="center"
android:layout_marginTop="20dp"
android:onClick="@{()->vm.onClickInit()}"
android:text="initList" />
<Button
android:layout_width="100dp"
android:layout_height="wrap_content"
android:background="@android:color/holo_orange_light"
android:gravity="center"
android:layout_marginTop="20dp"
android:onClick="@{()->vm.onClickTestUpdate()}"
android:text="initList" />
<ImageView
android:id="@+id/image"
android:layout_width="150dp"
android:layout_height="150dp"
bind:imageUrl="@{user.url}"/>
</LinearLayout>
</layout>
其中data标题表示数据，要绑定的数据，variable表示绑定变量，那么怎么绑定到某些Text或者什么的，上面代码也看到”@{}“加这个标志，譬如上面的Text我要显示User的Name的话，就直接user.name，当然这个name 是public ,那么马上有人问，我不喜欢这样，我是经过特殊处理的方法出来的字段，是否能显示，答案是可以的。例如user有过处理过Name的方法，叫getFirstName(),那么 TextView哪里要引用的话变成 以下:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.getFirstName()}"/>
除了字段显示字段这些我们还有很多的才能做到VM层不再依赖V层的，所以我们再看，点击事件回调，包括最普通的Onclick
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"
android:onClick="@{()->vm.onClickUser(view)}"/>
就如上面，是直接调用Lambda表达式，默认是省略了View 如果你要引用呢？
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"
android:onClick="@{(view)->vm.onClickUser(view)}"/>
当然其他View中有的点击事件也是类似炮制例如（onTextChange），这里不再多说~那如果木有定义过的事件呢？例如上面的 我要为ImageView设置 图片的URL？这里先留个悬念，下面说。因为那个是个人认为DataBinding非常牛逼有用的地方。
接下来先说说在Activity怎么绑定这些~先看代码：
ActivityMainDataBinding binding;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = DataBindingUtil.setContentView(this ,R.layout.activity_main);
AMainVM vm = new AMainVM();
binding.setVm(vm);
binding.setUser(vm.user);
}
@Override
protected void onDestroy() {
// 这里不写也可以，写了加快回收~
binding.unbind();
super.onDestroy();
}
其中 ActivityMainDataBinding，是自动生成的，生成规则是layout的名字去掉下划线并首字母大写加上DataBinding，不用clean ,rebuiding,写完XML就有~爽吧~然后开始绑定View，调用DataBindingUtil 的静态方法自动setContentView就自动绑定了View，然后调用进行进一步数据绑定，包括VM和其他数据。这里有人发现其实这样写不是累赘了吗？其实我们大可以不绑定User，而直接调用vm里的User。优化如下：
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{vm.user.name}"/>then，我们的Activity只要绑定vm就可以咯~是不是觉得突然Activity什么都没了？我的项目也差不多这样的~
再看看我们的User结构跟vm里面是啥：
public class BindingUser{
public String name;
public Int clickCount;
public String url;
}
public class BindingUser{
public ObservableField<String> name = new ObservableField<>();
public final ObservableInt clickCount = new ObservableInt();
public final ObservableField<String> url = new ObservableField<>();
}这个是User类，其中上面的是我们这里用的，不需要动态更新的可以这样，但是实际上我们需要动态更新因此引入Observable观察者类，这样可以动态刷新，当我们改变其中的值得时候，View会得到及时的通知刷新界面。这里可能有同学又要问，我们平时都是用Gson啥的序列化进去，你这样写，我们就不能反序列化进去了，其实上面的BindingUser可以写到如下面的效果，看代码：
public class BindingUser extends BaseObservable{
@Bindable
public String name;
@Bindable
public Int clickCount;
@Bindable
public String url;
public void setName(String name) {
this.name= name;
notifyPropertyChanged(BR.name);
}
public void setClickCount(String clickCount) {
this.clickCount= clickCount;
notifyPropertyChanged(BR.clickCount);
}
public void setUrl(String url) {
this.url= url;
notifyPropertyChanged(BR.url);
}
}
其中BaseObservable是基础观察者，我们首先需要继承他，否则之后的无效~然后在你需要动态刷新的字段上加上@Bindable 和写他们的set方法进行刷新，其中BR是DataBinding类动态生成的，对应每一个绑定变量variabl的ID值。
再来看看VM里的代码：
public class AMainVM{
private ObservableField<BindingUser> bindingUser;
public AMainVM(){
bindingUser = new ObservableField<>();
}
@Override
public void onClickUser() {
// 每点一此加1
bindingUser.clickCount.set(bindingUser.clickCount.get() + 1);
}
@Override
public void onClickInit() {
BindingUser bindingUserModel = new BindingUser();
bindingUser.name.set("just test");
bindingUser.clickCount.set(0);
bindingUser.url.set("http://img0.imgtn.bdimg.com/it/u=2770060730,47109478&fm=21&gp=0.jpg");
bindingUser.set(bindingUserModel);
}
@Override
public void onClickTestUpdate() {
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
bindingUser.name.set("update in thread");
return null;
}
}.execute();
}
}这里强烈推荐Observable这个类，超级方便，但是要注意的是，我为什么要再初始化VM的时候去初始化我们的User类的ObservableField，而不是点击的时候在方法onClickInit()中才懒加载？ 那是因为如果那时我才初始化，会发现View界面木有任何变化。为啥？因为在Activity里绑定VM的时候，dataBinding会帮我们绑定了VM以及VM里面其他绑定在其他View的变量，所以那时如果你木有初始化VM内的变量需要绑定的变量，那么DataBinding会注销哪个对应BR ID的变量。因此，当你在下面再重新新建一个Observable的时候压根是没做过任何View的绑定注册，因此就算你怎么更新数据，View也不会更新，除非这时你持有View，然后强制重新绑定，但是这样就违背我们VM不能依赖View的原则，因此这里要注意初始化。
大家都看到我还在下面做了个很邪恶的实验，在非UI线程更新BindingUser的name，验证下当我在非UI线程时候更新UI是否会出现问题，答案是不会。所以放心更新地操作数据，这里不多说里面实现了，无非就一个Handler嘛。
这样像上面的就是一个最简单的MVVM的结构，what 's more?除了这些我们还想有其他控制，例如我想决定某个View是否显示，看如下代码：
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"
android:visibility="@{user.name == null ? View.GONE : View.VISIBLE}" />当然我们在引用View.Gone这个静态常量时候要在上面data里声明，应用import字段：
<data>
...
<import type="android.view.View" />
</data>
如果需要增加某个@String字段拼接我们的变量，或者我们自己随便写的一个String组拼那么怎样?
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
bind:message='@{"名字：" + user.name}'/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
bind:message="@{@string/name + user.name}"/>
新增的特殊符号：
我们平时遇到的，我们两个字段，谁不空显示谁，那么按我们平时写的如下：
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
bind:message="@{user.name == null? user.count:user.name}"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
bind:message="@{user.name ?? user.count}"/>下面就是DataBinding提供的简化写法~用操作符？？，上下意思两种表达意思一样。
DataBinding的大概使用就是这样，当然还有很多我们探索的包括ObservableMap ,ObservableList这里使用也很方便，喜欢的同学自行查询~都很简单，以下介绍DataBinding最强大功能。
自定义设置器（Custom setter）：
注释 @BindingAdapter ,为什么我不说BindMethod，因为我觉得作用不是太大，没使用，如果有同学觉得有大用，请一定告诉我~好继续，大家看到我开始的XML中有个很奇怪的字段，“bind：imageURL”这个是哪里来的？首先这个就是自定义设置器，首先我们要使用的话必须在定义如下：
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
......
<ImageView
android:id="@+id/image"
android:layout_width="150dp"
android:layout_height="150dp"
bind:imageUrl="@{user.url}"/>
</layout>加上“xmlns:bind="http://schemas.android.com/apk/res-auto"” 有些同学会在之前的自定义View里用到“xmlns:app="http://schemas.android.com/apk/res-auto"”,这个没关系，将"bind:imageURL"改为"app:imageURL"就可以。那么我们定义了这个后还要写一个摆放这个imageUrl的处理方法，我自己起了一个类专门处理的，BindingUtil下面我们看看里面怎样的~
public class BindingUtil {
@BindingAdapter({"imageUrl"})
public static void loadImage(ImageView imageView, String imageUrl) {
if (imageUrl != null) {
Picasso.with(imageView.getContext()).load(imageUrl).into(imageView);
}
}
@BindingAdapter({"showLoading", "message"})
public static void showLoading(View view, boolean showLoading, String message) {
if (showLoading) {
// showLoading
} else {
// cancelLoading
}
}
@BindingAdapter("showLoading")
public static void showLoading(View view, boolean showLoading) {
if (showLoading) {
// showLoading
} else {
// cancelLoading
}
}
} 做的不多方法头加上注解@BindingAdapter ，方法必须是静态方法哦，其中函数第一个参数是你绑定的View，这个函数调用的前提是ImageView里有个参数bind:imageUrl，当绑定的user.url初始化或者改变了值的时候会调用这个loadImage方法。因此我们VM里做数据转换变化，View马上就有响应去加载图片。VM不用管View更新问题~这个给了我启发，我们的ShowLoading，ShowToast是不是也可以这样，因此有了下面方法。注意：当方法中有多个参数的时候，例如上面的ShowLoading 有一个布尔的showLoading参数和message参数，随便一个更改参数都会调用我们设定的方法，因此我们写这里方法时需要特别注意参数处理哦~
BaseRecycleAdapter:
接下来我会说说我写的一个BaseRecycleAdapter主要针对RecycleView的，大家觉得好的可以直接拿去用，以后就不用再写关于RecycleView的Adapter了，当然对于ListView和Dialog？也是类似的思想~先说说思路：
我们用DataBinding写一个Adapter会怎样？
public class MainAdapter extends BaseAdapter {
private LayoutInflater layoutInflater;
private List<String> listData;
public MainAdapter(Activity activity,List<String> listData) {
this.listData = listData;
layoutInflater = LayoutInflater.from(activity);
}
@Override
public int getCount() {
if (getData() != null) {
return getData().size();
} else {
return 0;
}
}
@Override
public Object getItem(int position) {
if (getData() != null) {
return getData().get(position);
} else {
return null;
}
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
BindingHolder bindingHolder;
if (convertView == null) {
AdapterMainBinding binding = DataBindingUtil.inflate(layoutInflater, R.layout.adapter_main, null, false);
bindingHolder = new BindingHolder();
bindingHolder.setBinding(binding);
convertView = binding.getRoot();
convertView.setTag(bindingHolder);
} else {
bindingHolder = (BindingHolder) convertView.getTag();
}
bindingHolder.getBinding().setVariable(com.silver.testdatabinding.BR.testString, listData .get(position));
bindingHolder.getBinding().executePendingBindings();
return convertView;
}
public static class BindingHolder {
private AdapterMainBinding binding;
public AdapterMainBinding getBinding() {
return binding;
}
public void setBinding(AdapterMainBinding binding) {
this.binding = binding;
}
}
}
首先我们写一个Holder，其中我们的Holder中其实只有一个binding，而binding在DataBindingUtil.inflate()时已经对ContentView进行了绑定，因此我们重新数据来刷新界面就可以，如上面setVariable然后再executePendingBindings()进行数据刷新操作。
那么我们得思考一下，我们其实很多DataBinding的Adapter会非常类似，因此很有必要写一个通用，以后省去我们很多写Adapter的时间了~我们来考虑下一个Adapter会需要些什么。
1.我们需要告诉Adapter我们contentView的LayoutId是啥。
2.首先我们需要一个List ，滚动的时候动态绑定里面的每个Model进行数据刷新。
3.我们需要告诉getView方法里我们需要绑定的Model 变量名 （BR的ID值）。
4.我们要有个onItemClickListener作为事件点击。
5.其他item里的onClick事件。
6.当List变化的时候通知Adapter进行notify。
这些基本构成了我们Adapter的要求了~如果还有还可以自行添加~
首先看看初始化方法
public class BaseRecycleViewAdapter<T> extends RecyclerView.Adapter<BaseRecycleViewAdapter.BindingHolder> {
private static final Object DATA_INVALIDATION = new Object();
public @LayoutRes ObservableInt layoutId;
private AdapterModule adapterModule;
private final WeakReferenceOnListChangedCallback<T> callback = new WeakReferenceOnListChangedCallback<>(this);
private LayoutInflater inflater;
// Currently attached recyclerview, we don't have to listen to notifications if null.
@Nullable
private RecyclerView recyclerView;
public BaseRecycleViewAdapter(int layoutId) {
this.layoutId = new ObservableInt(layoutId);
}
public void setAdapterModule(AdapterModule<T> adapterModule) {
if (this.adapterModule == adapterModule || adapterModule == null) {
return;
}
// If a recyclerview is listening, set up listeners. Otherwise wait until one is attached.
// No need to make a sound if nobody is listening right?
if (recyclerView != null) {
if (this.adapterModule != null && this.adapterModule.list != null && this.adapterModule.list instanceof ObservableArrayList) {
this.adapterModule.list.removeOnListChangedCallback(callback);
}
if (adapterModule != null && adapterModule.list != null && adapterModule.list instanceof ObservableList) {
adapterModule.list.addOnListChangedCallback(callback);
}
}
this.adapterModule = adapterModule;
notifyDataSetChanged();
}
......
}这是构造整个函数的基本参数，构造函数需要我们ContentView的LayoutId，而AdapterModule是针对Adapter的数据变量，其中对AdapterModule中list 进行addOnListChangedCallback 监听更新从而对Adapter进行刷新。Adapter是我们的数据变量组成类，我们来看看他内部：
public class AdapterModule<T> {
public ObservableArrayList<T> list = new ObservableArrayList<>();
// bindingVaiable id
public ObservableInt bindingVaiable;
// bind PositionId
public ObservableInt bindPositionVaiableId;
// the key is the resourceId!
public WeakReference<SparseArray<OnClickListener>> listeners;
public AdapterModule(ArrayList<T> list, int bindingVaiable,int bindPositionVaiableId) {
if (list != null && !list.isEmpty()) {
this.list.addAll(list);
}
this.bindingVaiable = new ObservableInt(bindingVaiable);
this.bindPositionVaiableId = new ObservableInt(bindPositionVaiableId);
}
public AdapterModule(ArrayList<T> list, int bindingVaiable, SparseArray<OnClickListener> listeners) {
if (list != null && !list.isEmpty()) {
this.list.addAll(list);
}
this.bindingVaiable = new ObservableInt(bindingVaiable);
this.listeners = new WeakReference<>(listeners);
}
public void setListeners(SparseArray<OnClickListener> listeners) {
this.listeners = new WeakReference<>(listeners);
}
}
list就是我们显示数据，bindingVaiable是我们每个getView 里contentView要绑定的Module变量 ，第三个参数是个很有意思的参数，绑定当前getView的点position,只有BR指定的ID值，实际值是在Adapter中进行绑定。这里下面看代码~最后一个是我们的onClickListener。这个 onClickListener是我自己写的，其中也很简单只有一个带position参数的onClick方法。至于onClickListener绑定变量的BR值巧用了下SparserArray的Key就是我们绑定的变量BR值。
我们继续看看Adapter的OnCreateViewHolder和OnBindHolder：
@Override
public BindingHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if (inflater == null) {
inflater = LayoutInflater.from(parent.getContext());
}
ViewDataBinding binding = DataBindingUtil.inflate(inflater, layoutId.get(), null, false);
final BindingHolder holder = new BindingHolder(binding, (SparseArray<OnClickListener>) adapterModule.listeners.get());
binding.addOnRebindCallback(new OnRebindCallback() {
@Override
public boolean onPreBind(ViewDataBinding binding) {
return recyclerView != null && recyclerView.isComputingLayout();
}
@Override
public void onCanceled(ViewDataBinding binding) {
if (recyclerView == null || recyclerView.isComputingLayout()) {
return;
}
int position = holder.getAdapterPosition();
if (position != RecyclerView.NO_POSITION) {
notifyItemChanged(position, DATA_INVALIDATION);
}
}
});
return holder;
}
@Override
public void onBindViewHolder(BindingHolder holder, int position) {
// bindPosition
onBindBinding(holder.binding, adapterModule.bindPositionVaiableId.get(), position, false);
onBindBinding(holder.binding, adapterModule.bindingVaiable.get(), adapterModule.list.get(position), true);
}
private void onBindBinding(ViewDataBinding binding, int bindingVariable, Object item, boolean executePendingBindings) {
if (bindingVariable != 0) {
boolean result = binding.setVariable(bindingVariable, item);
if (!result) {
throw new IllegalArgumentException("can't bind variable adapterModule because can't find the id,is it correct?");
}
// refresh
if (executePendingBindings) {
binding.executePendingBindings();
}
}
}
onCreateViewHolder 里不多说了,主要增加了在binging进行时绑定检测是否recycleView已经在onAttach，在onBindView进行数据绑定第一个绑定的是position，setVariable(bindPosiionVaiableId,position);其中bindpositionVaiableId就是显示ContentView的position变量值，然后绑定当前position。同时重新绑定我们list中对应position的module变量进行绑定数据刷新，最后执行 binding.executePendingBindings();进行数据刷新。这就是一个recycleView绑定的数据过程。
那么在哪里进行绑定OnClickListener？为甚么这里进行数据绑定还有要对position进行绑定？其实我们每个点击回调只需要一个回调变量函数，因此不用每次都进行绑定只要在ViewHolder里进行绑定，我们变化的只有Position。
下面我们再看看ViewHolder代码：
public static class BindingHolder<T> extends RecyclerView.ViewHolder {
ViewDataBinding binding;
private SparseArray<OnClickListener> listeners;
public BindingHolder(ViewDataBinding binding, SparseArray<OnClickListener> listeners) {
super(binding.getRoot());
this.binding = binding;
this.listeners = listeners;
onBindListeners();
}
public void onBindListeners() {
if (listeners != null && listeners.size() > 0) {
for (int i = 0; i < listeners.size(); i++) {
binding.setVariable(listeners.keyAt(i), listeners.get(listeners.keyAt(i)));
}
}
}
} 最后当我们List进行刷新的时候需要对我们的Adapter进行刷新，因此看看OnListChangeListener代码：
private static class WeakReferenceOnListChangedCallback<T> extends ObservableArrayList.OnListChangedCallback<ObservableArrayList<T>> {
final WeakReference<BaseRecycleViewAdapter<T>> adapterRef;
WeakReferenceOnListChangedCallback(BaseRecycleViewAdapter<T> adapter) {
this.adapterRef = new WeakReference<>(adapter);
}
@Override
public void onChanged(ObservableArrayList<T> ts) {
BaseRecycleViewAdapter<T> adapter = adapterRef.get();
if (adapter == null) {
return;
}
Utils.ensureChangeOnMainThread();
adapter.notifyDataSetChanged();
}
...
}主要是数据更改是对Adapter进行notify。
这样看还是有点抽象，我们再看看怎么用，就一目了然。
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
<variable
name="position"
type="Integer" />
<variable
name="user"
type="com.silver.model.BindingUser" />
<variable
name="onItemClick"
type="com.ykse.mvvm.adapter.listener" />
<variable
name="onClick"
type="com.ykse.mvvm.adapter.listener" />
</data>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@android:color/white"
android:orientation="vertical"
android:onClick="@{()->onItemClick.onClick(position)}"
>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@{user.name}"/>
<Button
android:layout_width="100dp"
android:layout_height="wrap_content"
android:background="@android:color/holo_orange_light"
android:gravity="center"
android:layout_marginTop="20dp"
android:onClick="@{()->onClick.onClick(position)}"
android:text="initList" />
<ImageView
android:id="@+id/image"
android:layout_width="150dp"
android:layout_height="150dp"
bind:imageUrl="@{user.url}"/>
</LinearLayout>
</layout>
这个就是我们写的Adapter的ContentView。我们的点击事件，还有变量还有OnItemClick都解决了。
还有那么我们的Activity的ContentView是怎么将AdapterModule和layoutId跟recycleView绑定的？看看XML：
<layout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:bind="http://schemas.android.com/apk/res-auto">
<variable
name="layoutId"
type="Integer" />
<variable
name="vm"
type="com.silver.model.AMainVM" />
</data>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@android:color/white"
android:orientation="vertical"
>
<android.support.v7.widget.RecyclerView
android:id="@+id/id_recyclerview"
android:layout_width="match_parent"
android:layout_height="match_parent"
bind:layoutId="@{layoutId}"
bind:listData="@{vm.adapterModule}"/>
</LinearLayout>
</layout> 这次@BindingAdapter又发挥作用~
public class BindingAdapterUtil {
@BindingAdapter({"layoutId"})
public static void bindRecycleViewLayoutId(RecyclerView recyclerView, int layoutId) {
BaseRecycleViewAdapter baseRecycleViewAdapter = new BaseRecycleViewAdapter(layoutId);
recyclerView.setAdapter(baseRecycleViewAdapter);
}
@BindingAdapter({"listData"})
public static <T> void bindRecycleViewAdapterModule(RecyclerView recyclerView, AdapterModule<T> adapterModule) {
BaseRecycleViewAdapter<T> adapter;
if (recyclerView.getAdapter() != null) {
adapter = (BaseRecycleViewAdapter<T>) recyclerView.getAdapter();
adapter.setAdapterModule(adapterModule);
} else {
return;
}
}
}
还有更多的双向绑定~大家可以参考下资料，原本DataBinding也有一些原生的~
到这里我们DataBinding的使用篇算是完了，更多的功能需要大家更多发现~谢谢能看到这里的人，你们都是热爱技术的人！