fragmentargs 源码解析

发表于   |  

简介

fragmentargs可以用来处理Fragment属性的保存（Fragment.setArguments(Bundle bundle)）和自动赋值(Fragment.getArguments())逻辑，以在编译时自动生成源代码的方式来减少一些重复代码的编写，可以查看这篇博文了解一下

流程图

简单的流程图

流程图

编译时注解

由于运行时注解用到了反射技术，在性能方面会有影响，而编译时注解是在编译期生成源代码的方式，性能会好一些

如何Debug

在Android Studio中想在工程编译时进行Debug会比较麻烦一些，要做一些配置，具体的可以查看这篇博文，下面简要介绍下（小坑还挺多）
1、配置~/.gradle/gradle.properties

1
2
org.gradle.daemon=true
org.gradle.jvmargs=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

然后启动gradle daemon（mac平台）

1
./gradlew --daemon

2、在AS中配置remote debugger，其实是新建一个Run/Debug Configuration（remote类型）。我们每次创建一个Android Project的时候AS都会默认创建一个Run/Debug Configuration（Android Application类型），名字叫做app，这个大家都挺眼熟的:)
Run/Debug Configuration信息基本上不用做任何更改，只要确保端口号跟上一个步骤的一致就行

configration

3、在自定义的annotation processor设置断点，启动remote debugger，在命令行中运行./gradlew clean assembleDebug

debug

fragmentargs annotation processor分析

fragmentargs库中的annotation processor主要生成两种类型的java源代码，首先会生成被注解过的Frament的FragmentBuilder.java文件（会有多个），然后会生成FragmentArgsInjector.java文件（仅一个）

MyFragmentBuilder.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.tubb.argknife;

import android.os.Bundle;
public final class MyFragmentBuilder {
  private final Bundle mArguments = new Bundle();

  public MyFragmentBuilder(int dis) {
    mArguments.putInt("dis", dis);
  }
  public static MainActivity.MyFragment newMyFragment(int dis) {
    return new MyFragmentBuilder(dis).build();
  }
  public static final void injectArguments(MainActivity.MyFragment fragment) {
    Bundle args = fragment.getArguments();
    if (args == null) {
      throw new IllegalStateException("No arguments set");
    }
    if (!args.containsKey("dis")) {
      throw new IllegalStateException("required argument dis is not set");
    }
    fragment.dis = args.getInt("dis");
  }
  public MainActivity.MyFragment build() {
    com.tubb.argknife.MainActivity.MyFragment fragment = new com.tubb.argknife.MainActivity.MyFragment();
    fragment.setArguments(mArguments);
    return fragment;
  }
  public <F extends MainActivity.MyFragment> F build(F fragment) {
    fragment.setArguments(mArguments);
    return fragment;
  }
}

AutoFragmentArgInjector.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.hannesdorfmann.fragmentargs;

import android.os.Bundle;
public final class AutoFragmentArgInjector
    implements com.tubb.argknife.annotation.FragmentArgsInjector {

  public void inject(Object target) {

    Class<?> targetClass = target.getClass();
    String targetName = targetClass.getSimpleName();

    if ( com.tubb.argknife.OuterFragment.class.getSimpleName().equals(targetName) ) {
      com.tubb.argknife.OuterFragmentBuilder.injectArguments( ( com.tubb.argknife.OuterFragment ) target);
      return;
    }

    if ( com.tubb.argknife.MainActivity.MyFragment.class.getSimpleName().equals(targetName) ) {
      com.tubb.argknife.MyFragmentBuilder.injectArguments( ( com.tubb.argknife.MainActivity.MyFragment ) target);
      return;
    }
  }
}

fragmentargs使用squareup的javawriter来生成java源文件的，只需要配置下就行

1
compile 'com.squareup:javawriter:2.2.1'

但我自己在实践的过程中遇到一个很奇怪的问题，明明javawriter代码已经导入了，但就是引用不了，后来参考作者的做法把JavaWriter类拷贝到本地repackage了一下，问题解决

具体代码的生成过程挺繁琐和抽象的，首先会去得到注解的类（Fragment）和注解的属性（Fragment中的属性）的Element信息，然后根据这些Elements来动态生成类和类中的方法和属性，具体的源码大家可以看下我剥离出来的代码

fragmentargs的调用过程

fragmentargs通过annotation processor在工程编译完成后生成很多的FragmentBuilder.java源文件和一个AutoFragmentArgInjector。java源文件，当然最终也会编译成相应的class文件
fragmentargs的使用非常简单README，那它内部是如何工作的呢
通过FragmentArgs.inject(this)的调用，会进入到FragmentArgs类中的injectFromBundle(Object target)方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.hannesdorfmann.fragmentargs;

/**
 * The root class to inject arguments to a fragment
 *
 * @author Hannes Dorfmann
 */
public class FragmentArgs {

  public static final String AUTO_MAPPING_CLASS_NAME = "AutoFragmentArgInjector";
  public static final String AUTO_MAPPING_PACKAGE = "com.hannesdorfmann.fragmentargs";
  public static final String AUTO_MAPPING_QUALIFIED_CLASS =
      AUTO_MAPPING_PACKAGE + "." + AUTO_MAPPING_CLASS_NAME;

  private static FragmentArgsInjector autoMappingInjector;

  public static void inject(Object fragment) {
    injectFromBundle(fragment);
  }

  static void injectFromBundle(Object target) {

    if (autoMappingInjector == null) {
      // Load the automapping class
      try {
        Class<?> c = Class.forName(AUTO_MAPPING_QUALIFIED_CLASS);
        autoMappingInjector = (FragmentArgsInjector) c.newInstance();
      } catch (Exception e) {
        // Since 2.0.0 we don't throw an exception because of android library support.
        // Instead we print this exception as warning message

        /*
        Exception wrapped = new Exception("Could not load the generated automapping class. "
            + "However, that may be ok, if you use FragmentArgs in library projects", e);
        wrapped.printStackTrace();
        */
      }
    }

    if (autoMappingInjector != null) {
      autoMappingInjector.inject(target);
    }
  }
}

通过源码我们可以发现，会去反射（注意是static，性能上基本上不会有影响）实例化一个实现了FragmentArgsInjector接口的类的实例，其实就是我们之前介绍的AutoFragmentArgInjector，然后调用AutoFragmentArgInjector的AutoFragmentArgInjector.inject(target)方法，我们可以来看看这个方法中具体做了些啥

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void inject(Object target) {

  Class<?> targetClass = target.getClass();
  String targetName = targetClass.getSimpleName();

  if ( com.tubb.argknife.OuterFragment.class.getSimpleName().equals(targetName) ) {
    com.tubb.argknife.OuterFragmentBuilder.injectArguments( ( com.tubb.argknife.OuterFragment ) target);
    return;
  }

  if ( com.tubb.argknife.MainActivity.MyFragment.class.getSimpleName().equals(targetName) ) {
    com.tubb.argknife.MyFragmentBuilder.injectArguments( ( com.tubb.argknife.MainActivity.MyFragment ) target);
    return;
  }
}

看到这些代码是不是突然明悟了:) 在这个方法中把FragmentBuilder和我们自己的Fragment联系起来了，其实就是通过Fragment.getArguments()来为我们的属性赋值，也就是Auto Inject

1
2
3
4
5
6
7
8
9
10
public static final void injectArguments(MyFragment fragment) {
    Bundle args = fragment.getArguments();
    if(args == null) {
        throw new IllegalStateException("No arguments set");
    } else if(!args.containsKey("dis")) {
        throw new IllegalStateException("required argument dis is not set");
    } else {
        fragment.dis = args.getInt("dis");
    }
}

Note

在自己使用fragmentargs的过程中遇到一个比较坑的东西，发现当Fragment为内部类时不能正常工作，自己测试用的代码尝试修复了这个问题，也给作者提了一个issuse，估计作者下个版本会进行修复的

还有一点，ArgKnife并不能用在工作项目中，只是测试代码😄