Android Jetpack-DataBinding

已于 2022-05-12 14:16:23 修改
阅读量716 收藏 1
点赞数 1
分类专栏： Android JectPack 文章标签： android android jetpack kotlin
于 2022-05-03 21:31:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014078003/article/details/124562092
版权

Android标准化项目架构：MVVM+Jectpack

助力研发，本篇将对Jectpack 中的DataBinding进行简要分析

1.什么是DataBinding？

DataBinding是Google在2015年推出的组件库。Databinding支持双向绑定，可以大大减少绑定App逻辑于Layout的胶水代码。双向绑定，指的是将Model数据与界面绑定起来，当数据发生变化会直接体现在界面上，反过来界面发生变化也会同步到数据结构，使用DataBinding可以轻松实现MVVM模式。

2.开启DataBinding

在build.gradle配置

dataBinding{
    enabled true
}

在Activity中加载

class DataBindingActivity : BaseActivity() {

    private val personInfo = PersonInfo()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding: ActivityDataBindingBinding? = DataBindingUtil.
            setContentView(this,R.layout.activity_data_binding)

        personInfo.name.set("Tom")
        personInfo.pwd.set("123456")

        binding?.personInfo=personInfo

    }
}

在xml中进行绑定

<?xml version="1.0" encoding="utf-8"?>
<!-- DataBinding的编译标准 -->
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- 定义该View（布局）需要绑定的数据来源 -->

    <data>
        <variable
            name="personInfo"
            type="com.meishe.jetpackcollection.databinding.PersonInfo" />
    </data>



    <!-- 安卓认识的 常规布局 -->
    <!-- 布局常规代码如下 -->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity"
        android:orientation="vertical">

        <EditText
            android:id="@+id/et_name1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{personInfo.name}"
            />

        <EditText
            android:id="@+id/et_pwd1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{personInfo.pwd}"
            android:layout_marginBottom="60dp"
            />
            
    </LinearLayout>
</layout>

这样就实现了DataBinding

在Kotlin中的数据Bean中，由于不需要设置get、set方法，所以ObservableField进行包裹才行

Kotlinclass PersonInfo {

 val name : ObservableField<String> by lazy { ObservableField<String>() }
 val pwd : ObservableField<String> by lazy { ObservableField<String>() }

}

3.实现双向绑定

上面实现了单向绑定，实现双向绑定也很简单，只需要在Xml布局文件进行调整就好

<EditText
    android:id="@+id/et_name3"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@={personInfo.name}"
    />

<EditText
    android:id="@+id/et_pwd3"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="@={personInfo.pwd}"
    android:layout_marginBottom="60dp"
    />

@{personInfo.pwd}更改为 @={personInfo.pwd}就可以实现另外另外一向的绑定操作。

4.DataBinding中实现图片更改文本颜色等

object CommonBindingAdapter {

    /**
     * 加载网络图片
     */
    @JvmStatic
    @BindingAdapter(value = ["imageUrl", "placeHolder"], requireAll = false)
    fun loadUrl(view: ImageView, url: String?, placeHolder: Drawable?) {
        Glide.with(view.context).load(url).placeholder(placeHolder).into(view)
    }

    /**
     * 控制显示隐藏
     */
    @BindingAdapter(value = ["visible"], requireAll = false)
    fun visible(view: View, visible: Boolean) {
        view.visibility = if (visible) View.VISIBLE else View.GONE
    }

    /**
     * 加载Drawable资源图片
     */
    @BindingAdapter(value = ["showDrawable", "drawableShowed"], requireAll = false)
    fun showDrawable(view: ImageView, showDrawable: Boolean, drawableShowed: Int) {
        view.setImageResource(if (showDrawable) drawableShowed else R.color.transparent)
    }

    /**
     * 动态设置文案颜色
     */
    @BindingAdapter(value = ["textColor"], requireAll = false)
    fun setTextColor(textView: TextView, textColorRes: Int) {
        textView.setTextColor(textView.resources.getColor(textColorRes))
    }

    /**
     * 通过Id加载图片资源
     */
    @BindingAdapter(value = ["imageRes"], requireAll = false)
    fun setImageRes(imageView: ImageView, imageRes: Int) {
        imageView.setImageResource(imageRes)
    }

    /**
     * 动态控制显示隐藏
     */
    @BindingAdapter(value = ["selected"], requireAll = false)
    fun selected(view: View, select: Boolean) {
        view.isSelected = select
    }
}

上面是DataBinding常用的动态加载资源的工具方法，收藏起来方便使用。

5.DataBainding的原理

构建之后，在这个路径下面会生成这个文件：

build/intermediates/data_binding_layout_info_type_merge/debug/out/activity_data_binding-layout.xml

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Layout directory="layout" filePath="app\src\main\res\layout\activity_data_binding.xml"
    isBindingData="true" isMerge="false" layout="activity_data_binding"
    modulePackage="com.meishe.jetpackcollection" rootNodeType="android.widget.LinearLayout">
    <Targets>
        <Target tag="layout/activity_data_binding_0" view="LinearLayout">
            <Expressions />
            <location endLine="69" endOffset="18" startLine="16" startOffset="4" />
        </Target>
        <Target id="@+id/et_name2" tag="binding_1" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.name">
                    <Location endLine="27" endOffset="44" startLine="27" startOffset="12" />
                    <TwoWay>false</TwoWay>
                    <ValueLocation endLine="27" endOffset="42" startLine="27" startOffset="28" />
                </Expression>
            </Expressions>
            <location endLine="28" endOffset="13" startLine="23" startOffset="8" />
        </Target>
        <Target id="@+id/et_pwd2" tag="binding_2" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.pwd">
                    <Location endLine="34" endOffset="43" startLine="34" startOffset="12" />
                    <TwoWay>false</TwoWay>
                    <ValueLocation endLine="34" endOffset="41" startLine="34" startOffset="28" />
                </Expression>
            </Expressions>
            <location endLine="36" endOffset="13" startLine="30" startOffset="8" />
        </Target>
        <Target id="@+id/et_name3" tag="binding_3" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.name">
                    <Location endLine="45" endOffset="45" startLine="45" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="45" endOffset="43" startLine="45" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="46" endOffset="13" startLine="41" startOffset="8" />
        </Target>
        <Target id="@+id/et_pwd3" tag="binding_4" view="EditText">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.pwd">
                    <Location endLine="52" endOffset="44" startLine="52" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="52" endOffset="42" startLine="52" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="54" endOffset="13" startLine="48" startOffset="8" />
        </Target>
        <Target tag="binding_5" view="TextView">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.name">
                    <Location endLine="60" endOffset="45" startLine="60" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="60" endOffset="43" startLine="60" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="61" endOffset="13" startLine="57" startOffset="8" />
        </Target>
        <Target tag="binding_6" view="TextView">
            <Expressions>
                <Expression attribute="android:text" text="personInfo.pwd">
                    <Location endLine="66" endOffset="44" startLine="66" startOffset="12" />
                    <TwoWay>true</TwoWay>
                    <ValueLocation endLine="66" endOffset="42" startLine="66" startOffset="29" />
                </Expression>
            </Expressions>
            <location endLine="67" endOffset="13" startLine="63" startOffset="8" />
        </Target>
    </Targets>
    <Variables name="personInfo" declared="true"
        type="com.meishe.jetpackcollection.databinding.PersonInfo">
        <location endLine="10" endOffset="72" startLine="8" startOffset="8" />
    </Variables>
</Layout>

可以看出定义了多个Target标记，这些Target跟tag对应，tag跟布局文件的id是对应。

同时会生成

build/intermediates/incremental/mergeDebugResources/stripped.dir/layout/activity_data_binding.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- DataBinding的编译标准 -->

                                                   

    <!-- 定义该View（布局）需要绑定的数据来源 -->

    
                 
                             
                                                                         
           



    <!-- 布局常规代码如下 -->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity"
        android:orientation="vertical" android:tag="layout/activity_data_binding_0" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">


        <EditText
            android:id="@+id/et_name2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_1"          
            />

        <EditText
            android:id="@+id/et_pwd2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_2"         
            android:layout_marginBottom="60dp"
            />



        <!-- 双向绑定   @= View  -->
        <EditText
            android:id="@+id/et_name3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_3"           
            />

        <EditText
            android:id="@+id/et_pwd3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_4"          
            android:layout_marginBottom="60dp"
            />


        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_5"           
            />

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:tag="binding_6"          
            />

    </LinearLayout>

所以项目中的布局文件构建后会生成两个xml文件

  • activity_data_binding-layout.xml
  • activity_data_binding.xml

sdk层通过变量上面两个布局文件来解析数据的实现动态绑定数据的，其中tag是关键。

DataBindingUtil.setContentView()

主要就是调用Activity的setContentView设置布局，并且绑定对应的View。

public static <T extends ViewDataBinding> T setContentView(@NonNull Activity activity,
        int layoutId, @Nullable DataBindingComponent bindingComponent) {
    activity.setContentView(layoutId);
    View decorView = activity.getWindow().getDecorView();
    ViewGroup contentView = (ViewGroup) decorView.findViewById(android.R.id.content);
    return bindToAddedViews(bindingComponent, contentView, 0, layoutId);
}

DataBindingUtil.bindToAddedViews()

private static <T extends ViewDataBinding> T bindToAddedViews(DataBindingComponent component,
        ViewGroup parent, int startChildren, int layoutId) {
    final int endChildren = parent.getChildCount();
    final int childrenAdded = endChildren - startChildren;
    
    if (childrenAdded == 1) { //只有一个View
        final View childView = parent.getChildAt(endChildren - 1);
        return bind(component, childView, layoutId);
    } else { //多个View
        final View[] children = new View[childrenAdded];
        for (int i = 0; i < childrenAdded; i++) {
            children[i] = parent.getChildAt(i + startChildren);
        }
        return bind(component, children, layoutId); //绑定多个View
    }
}

DataBindingUtil.bind()

static <T extends ViewDataBinding> T bind(DataBindingComponent bindingComponent, View[] roots,
        int layoutId) {
    return (T) sMapper.getDataBinder(bindingComponent, roots, layoutId);
}

sMapper是DataBindingMapper的一个对象，实现类是DataBinderMapperImpl，DataBinderMapperImpl这个类是通过调用APT注解处理器生成的。

sMapper.getDataBinder方法，其实调用了MergedDataBinderMapper的addMepper方法

MergedDataBinderMapper也是继承DataBindingMapper的

MergedDataBinderMapper.getDataBinder()

@Override
public ViewDataBinding getDataBinder(DataBindingComponent bindingComponent, View view,
        int layoutId) {
    for(DataBinderMapper mapper : mMappers) {
        ViewDataBinding result = mapper.getDataBinder(bindingComponent, view, layoutId);
        if (result != null) {
            return result;
        }
    }
    if (loadFeatures()) {
        return getDataBinder(bindingComponent, view, layoutId);
    }
    return null;
}

数据mMappers来源于DataBinderMapperImpl的构造器调用了addMapper方法得到的。

所以这里的数据就是com.meishe.jetpackcollection.DataBinderMapperImpl中的数据。

build/generated/ap_generated_sources/debug/out/com/meishe/jetpackcollection/DataBinderMapperImpl.java

DataBinderMapperImpl.getDataBinder()

  @Override
  public ViewDataBinding getDataBinder(DataBindingComponent component, View view, int layoutId) {
    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
    if(localizedLayoutId > 0) {
      final Object tag = view.getTag();
      if(tag == null) {
        throw new RuntimeException("view must have a tag");
      }
      switch(localizedLayoutId) {
        case  LAYOUT_ACTIVITYDATABINDING: {
          if ("layout/activity_data_binding_0".equals(tag)) {
            return new ActivityDataBindingBindingImpl(component, view);
          }
          throw new IllegalArgumentException("The tag for activity_data_binding is invalid. Received: " + tag);
        }
      }
    }
    return null;
  }

 @Override
  public ViewDataBinding getDataBinder(DataBindingComponent component, View[] views, int layoutId) {
    if(views == null || views.length == 0) {
      return null;
    }
    int localizedLayoutId = INTERNAL_LAYOUT_ID_LOOKUP.get(layoutId);
    if(localizedLayoutId > 0) {
      final Object tag = views[0].getTag();
      if(tag == null) {
        throw new RuntimeException("view must have a tag");
      }
      switch(localizedLayoutId) {
      }
    }
    return null;
  }

如果是底层的View，tag是layout/activity_data_binding_0，就会new ActivityDataBindingBindingImpl一个对象。

DataBinderMapperImpl的构造器在new处ActivityDataBindingBindingImpl之后会进行一些View的绑定操作。

通过tag取出来的view跟属性进行绑定操作。

public ActivityDataBindingBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
    this(bindingComponent, root, mapBindings(bindingComponent, root, 7, sIncludes, sViewsWithIds));
}

调用mapBindings方法，这里的参数7就是说明布局文件包含7个节点，这个方法会返回Object[]数组。

ViewDataBinding.mapBindings()

protected static Object[] mapBindings(DataBindingComponent bindingComponent, View root,
        int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
    Object[] bindings = new Object[numBindings];
    mapBindings(bindingComponent, root, bindings, includes, viewsWithIds, true);
    return bindings;
}

 private static void mapBindings(DataBindingComponent bindingComponent, View view,
            Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
            boolean isRoot) {
        final int indexInIncludes;
        final ViewDataBinding existingBinding = getBinding(view);
		//判断view是否已经存在，如果已经绑定了直接返回
        if (existingBinding != null) {
            return;
        }
        //获取view的tag标签
        Object objTag = view.getTag();
        final String tag = (objTag instanceof String) ? (String) objTag : null;
        boolean isBound = false;
     	 //如果是跟布局，并且以layout开头的tag
        if (isRoot && tag != null && tag.startsWith("layout")) {
            final int underscoreIndex = tag.lastIndexOf('_');
            if (underscoreIndex > 0 && isNumeric(tag, underscoreIndex + 1)) {
                final int index = parseTagInt(tag, underscoreIndex + 1);
                //将布局对应的view放置在bindings数组里边
                if (bindings[index] == null) {
                    bindings[index] = view;
                }
                indexInIncludes = includes == null ? -1 : index;
                isBound = true;
            } else {
                indexInIncludes = -1;
            }
        } else if (tag != null && tag.startsWith(BINDING_TAG_PREFIX)) {
            int tagIndex = parseTagInt(tag, BINDING_NUMBER_START);
            if (bindings[tagIndex] == null) {
                bindings[tagIndex] = view;
            }
            isBound = true;
            indexInIncludes = includes == null ? -1 : tagIndex;
        } else {
            // Not a bound view
            indexInIncludes = -1;
        }
        if (!isBound) {
            final int id = view.getId();
            if (id > 0) {
                int index;
                if (viewsWithIds != null && (index = viewsWithIds.get(id, -1)) >= 0 &&
                        bindings[index] == null) {
                    bindings[index] = view;
                }
            }
        }

        if (view instanceof  ViewGroup) {
            final ViewGroup viewGroup = (ViewGroup) view;
            final int count = viewGroup.getChildCount();
            int minInclude = 0;
            for (int i = 0; i < count; i++) {
                final View child = viewGroup.getChildAt(i);
                boolean isInclude = false;
                if (indexInIncludes >= 0 && child.getTag() instanceof String) {
                    String childTag = (String) child.getTag();
                    if (childTag.endsWith("_0") &&
                            childTag.startsWith("layout") && childTag.indexOf('/') > 0) {
                        // This *could* be an include. Test against the expected includes.
                        int includeIndex = findIncludeIndex(childTag, minInclude,
                                includes, indexInIncludes);
                        if (includeIndex >= 0) {
                            isInclude = true;
                            minInclude = includeIndex + 1;
                            final int index = includes.indexes[indexInIncludes][includeIndex];
                            final int layoutId = includes.layoutIds[indexInIncludes][includeIndex];
                            int lastMatchingIndex = findLastMatching(viewGroup, i);
                            if (lastMatchingIndex == i) {
                                bindings[index] = DataBindingUtil.bind(bindingComponent, child,
                                        layoutId);
                            } else {
                                final int includeCount =  lastMatchingIndex - i + 1;
                                final View[] included = new View[includeCount];
                                for (int j = 0; j < includeCount; j++) {
                                    included[j] = viewGroup.getChildAt(i + j);
                                }
                                bindings[index] = DataBindingUtil.bind(bindingComponent, included,
                                        layoutId);
                                i += includeCount - 1;
                            }
                        }
                    }
                }
                if (!isInclude) {
                    mapBindings(bindingComponent, child, bindings, includes, viewsWithIds, false);
                }
            }
        }
    }

ActivityDataBindingBindingImpl的父类在ActivityDataBindingBinding

build/generated/data_binding_base_class_source_out/debug/out/com/meishe/jetpackcollection/databinding/ActivityDataBindingBinding.java

public abstract class ActivityDataBindingBinding extends ViewDataBinding {
    //将xml布局文件的内容做了声明
  @NonNull
  public final EditText etName2;

  @NonNull
  public final EditText etName3;

  @NonNull
  public final EditText etPwd2;

  @NonNull
  public final EditText etPwd3;

   //将使用到的数据结构也做了声明
  @Bindable
  protected PersonInfo mPersonInfo;

  protected ActivityDataBindingBinding(Object _bindingComponent, View _root, int _localFieldCount,
      EditText etName2, EditText etName3, EditText etPwd2, EditText etPwd3) {
    super(_bindingComponent, _root, _localFieldCount);
    this.etName2 = etName2;
    this.etName3 = etName3;
    this.etPwd2 = etPwd2;
    this.etPwd3 = etPwd3;
  }

  public abstract void setPersonInfo(@Nullable PersonInfo personInfo);

  @Nullable
  public PersonInfo getPersonInfo() {
    return mPersonInfo;
  }

  @NonNull
  public static ActivityDataBindingBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable ViewGroup root, boolean attachToRoot) {
    return inflate(inflater, root, attachToRoot, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.inflate(inflater, R.layout.activity_data_binding, root, attachToRoot, component)
   */
  @NonNull
  @Deprecated
  public static ActivityDataBindingBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable ViewGroup root, boolean attachToRoot, @Nullable Object component) {
    return ViewDataBinding.<ActivityDataBindingBinding>inflateInternal(inflater, R.layout.activity_data_binding, root, attachToRoot, component);
  }

  @NonNull
  public static ActivityDataBindingBinding inflate(@NonNull LayoutInflater inflater) {
    return inflate(inflater, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.inflate(inflater, R.layout.activity_data_binding, null, false, component)
   */
  @NonNull
  @Deprecated
  public static ActivityDataBindingBinding inflate(@NonNull LayoutInflater inflater,
      @Nullable Object component) {
    return ViewDataBinding.<ActivityDataBindingBinding>inflateInternal(inflater, R.layout.activity_data_binding, null, false, component);
  }

  public static ActivityDataBindingBinding bind(@NonNull View view) {
    return bind(view, DataBindingUtil.getDefaultComponent());
  }

  /**
   * This method receives DataBindingComponent instance as type Object instead of
   * type DataBindingComponent to avoid causing too many compilation errors if
   * compilation fails for another reason.
   * https://issuetracker.google.com/issues/116541301
   * @Deprecated Use DataBindingUtil.bind(view, component)
   */
  @Deprecated
  public static ActivityDataBindingBinding bind(@NonNull View view, @Nullable Object component) {
    return (ActivityDataBindingBinding)bind(component, view, R.layout.activity_data_binding);
  }
}
若之灵动
关注
专栏目录
Android-Jetpack笔记-DataBinding
01-03
DataBinding即数据绑定，可以实现数据和UI的双向...Jetpack笔记代码 使用 在app/build.gradle中开启： android { dataBinding { enabled = true } } 在布局文件中，将光标定位在根布局，alt+enter，然后convert t
Android Jetpack 之 DataBinding
接受自己的普通，然后拼尽全力去与众不同
10-24 588
1.DataBinding 通过声明的方式，将 xml 布局中的组件与程序中的源数据进行绑定的框架库。当数据变化的同时组件能够及时同步并更新，减少Activity 中 View 的定义以及初始化，代码更加简洁。 2.DataBinding 的使用 2.1 在项目中对应 module 的 build.gradle 文件中添加 dataBinding 可用的配置： android { ...
Android Jetpack（2）：DataBinding的使用
qq_36699930的博客
11-13 2066
Android DataBinding 从入门到进阶 DataBinding 介绍 DataBinding 是谷歌官方发布的一个框架，顾名思义即为数据绑定，是 MVVM 模式在 Android 上的一种实现，用于降低布局和逻辑的耦合性，使代码逻辑更加清晰。MVVM 相对于 MVP，其实就是将 Presenter 层替换成了 ViewModel 层。DataBinding 能够省去我们一直以来的 findViewById() 步骤，大量减少 Activity 内的代码，数据能够单向或双向绑定到 layout
Android--Jetpack--Databinding详解
袁震的博客
12-06 1259
不经一番寒彻骨，怎得梅花扑鼻香
JetPack之DataBinding
似霰的博客
03-22 1297
JetPack之DataBinding基础使用
Android Jetpack 之ViewBinding和DataBinding
2401_84412895的博客
04-29 993
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
android-databinding-master.zip
08-30
jetpack中databinding的使用方式
android-mvvm-databinding-kotlin:一个简单的Android应用程序项目，使用MVVM +数据绑定+改造+ RxJava并用Kotlin编写
04-30
这个名为"android-mvvm-databinding-kotlin"的项目就是一个很好的实例，它展示了如何在Android应用中有效利用这些技术。 首先，MVVM模式是一种分离视图和业务逻辑的设计模式。在MVVM中，Model代表数据模型，负责...
android-jetpack-demo：:fire:快速入门Android Jetpack以及相关的Kotlin，RxJava，MVVM等主流技术，独立构架App的基础技能
02-03
:fire: Android-Jetpack-Demo 目录 一，项目简介 写在前面，首先感谢各位童鞋对本项目的关注和支持，项目新生之时，也是自己学习jetpack初期，转变这两年的企业项目实践，对于jetpack的认识也有深入的了解，后续将...
Android-JetPack+MVVM开发示例Demo
08-02
Demo采用Retrofit+RxJava+Okhttp网络请求，演示了JetPack中Navigation、LifeCycle+ViewModel+LiveData+Room+DataBinding+MVVM开发使用示例。
【Android Jetpack】DataBinding 从入门到精通
最新发布
2401_84408814的博客
05-07 664
例如，如果要在名为MyView的自定义视图中对"time"使用，对用来设置初始值并在值更改时进行更新的方法进行注释：使用对从视图中读取值的方法进行注释：更多内容请参考这里。今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套。
Android JetPack组件之DataBinding的使用详解
路宇的博客
11-12 2548
前言：DataBinding的介绍 数据绑定库是一种支持库，借助该库，您可以使用声明性格式（而非程序化地）将布局中的界面组件绑定到应用中的数据源。 要开始使用数据绑定，必须将应用配置为使用数据绑定，在应用模块的build.gradle 文件中添加 dataBinding 元素 android { ... dataBinding { enabled = true } } 接下来我们使用一个例子，来理解和使用DataBind
【Android Jetpack】DataBinding 从入门到精通，绝对干货分享
mm627mm的博客
03-20 725
自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**[外链图片转存中…(img-vn0StkKf-1710930330104)][外链图片转存中…(img-XxQqWZVH-1710930330104)][外链图片转存中…(img-OfbVZrx0-1710930330105)][外链图片转存中…(img-VngfXYMZ-1710930330105)]
Android---Jetpack之DataBinding
qq_44950283的博客
04-01 764
让布局文件承担了部分原本属于页面的工作，使页面与布局耦合度进一步降低。
Android Jetpack之DataBinding
chxip的博客
12-25 199
Jetpack学习-7-Databinding的基本使用及单向&双向绑定
行者Sun
05-14 1492
Databinding的基本使用
Jetpack学习之DataBinding(一)
这个杀手不太累的博客
11-13 1891
文章目录一、 JetPack是什么 一、 JetPack是什么 百度下都是差不多的说明，我这里结合自己的理解记录下，可能理解的也不是很全面正确。 JetPack是一套工具库，包含4类组件、分别是架构、界面、行为、基础。(这里不结合代码个人感觉也不太好理解)。因为是一套工具库，可以单独使用，也可以配合使用。每个组件都给用户提供了一个标准，能够帮助开发者遵循最佳做法。（意思就是好用呗）。 这里从copy了一张图，大体了解下: 从图片可以看出，4大类，每种分类下面好多工具，这里学到哪个，通过简单的例子记录下，方
Jetpack组件之数据绑定组件——DataBinding
aylr2015的博客
04-26 348
本文是Jetpack组件专题的第一篇，Jetpack是Google官方在2018年推出的一套组件库，用来帮助开发者更轻松地编写优质应用。包含四大模块：Architecture（ 架构组件）、Foundation(基础组件)、Behavior（行为组件）、UI(界面组件)。工欲善其事,必先利其器。一起来学习先进的组件知识。DataBinding就是一个绑定数据和UI的框架，简化代码，同步刷新。
DataBinding的基本使用
xuyin1204的博客
08-28 1147
特别注意：MVVM模式下的ViewModel（VM）和 Jetpack的ViewModel 不是同一东西，MVVM中的ViewModel是层次结构，而Jetpack的ViewModel是组件库。缺点：Activity不仅要做View的事情还要做控制和模型的处理，导致Activity太过臃肿，管理混乱，没有单一职责，耦合度、扩展性都不太好。MVVM: 适用于界面更新很频繁，比如网易云音乐。MVP：适用于大型项目、业务很重、项目很大。MVC： 适用于小型项目，够灵活，缺点：出现接口过多、接口地狱问题。
Android Jetpack架构组件：ViewModel+LiveData+DataBinding实战指南
在这个示例中，我们将探讨Android Jetpack组件ViewModel、LiveData和DataBinding的综合使用，包括各自的核心要点、如何将它们组合使用以及具体的代码示例。 一、ViewModel + LiveData + DataBinding 核心要点 1、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值