Android AOP三剑客之APT

作者: Code猎人 | 来源:发表于2018-09-20 15:45 被阅读23次

    AOP概念

    AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    Android AOP三剑客: APT, AspectJ, Javassist
    这是一张用烂了的图.jpg

    项目地址:android-aop-samples

    工程目录结构

    .

    • annotation 定义注解
    • apt-library apt辅助工具类
    • apt-processor 自定义注解解析器,生成辅助代码
    • apt-plugin 自定义Gradle插件,实现切面和操作字节码的插件
    • app 主目录

    Android APT

    APT(Annotation Processing Tool 的简称),可以在代码编译期解析注解,并且生成新的 Java 文件,减少手动的代码输入。现在有很多主流库都用上了 APT,比如 Dagger2, ButterKnife, EventBus3 等

    定义注解
    @Retention(RetentionPolicy.CLASS)
    @Target(ElementType.FIELD)
    public @interface BindView {
    int value();
    }
    
    创建一个Module,自定义AbstractProcessor,并且用@AutoService标记
    • AutoService会自动在META-INF文件夹下生成Processor配置信息文件,该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候,
      就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名,并装载实例化,完成模块的注入
    @AutoService(Processor.class)
    public class BindViewProcessor extends AbstractProcessor {
    
    private Messager mMessager;
    private Elements mElementUtils;
    private Map<String, ClassFactory> mProxyMap = new HashMap<>();
    
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        mMessager = processingEnv.getMessager();
        mElementUtils = processingEnv.getElementUtils();
    }
    
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        HashSet<String> supportTypes = new LinkedHashSet<>();
        supportTypes.add(BindView.class.getCanonicalName());
        return supportTypes;
    }
    
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }
    
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
        mProxyMap.clear();
        //得到所有的注解
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
        for (Element element : elements) {
            VariableElement variableElement = (VariableElement) element;
            TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
            String fullClassName = classElement.getQualifiedName().toString();
            //elements的信息保存到mProxyMap中
            ClassFactory proxy = mProxyMap.get(fullClassName);
            if (proxy == null) {
                proxy = new ClassFactory(mElementUtils, classElement);
                mProxyMap.put(fullClassName, proxy);
            }
            BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
            int id = bindAnnotation.value();
            proxy.putElement(id, variableElement);
        }
    
        //通过javapoet生成
        for (String key : mProxyMap.keySet()) {
            ClassFactory proxyInfo = mProxyMap.get(key);
            JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(), proxyInfo.generateJavaCode()).build();
            try {
                // 生成文件
                javaFile.writeTo(processingEnv.getFiler());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
        return true;
    }
    

    }

    process方法,处理我们自定义的注解,生成代码,这里使用的squareup公司的javapoet库辅助生成代码

    public class ClassFactory {
    private String mBindingClassName;
    private String mPackageName;
    private TypeElement mTypeElement;
    private Map<Integer, VariableElement> mVariableElementMap = new HashMap<>();
    
    public ClassFactory(Elements elementUtils, TypeElement classElement) {
        this.mTypeElement = classElement;
        PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
        String packageName = packageElement.getQualifiedName().toString();
        String className = mTypeElement.getSimpleName().toString();
        this.mPackageName = packageName;
        this.mBindingClassName = className + "_ViewBinding";
    }
    
    public void putElement(int id, VariableElement element) {
        mVariableElementMap.put(id, element);
    }
    
    public TypeSpec generateJavaCode() {
        TypeSpec bindingClass = TypeSpec.classBuilder(mBindingClassName)
                .addModifiers(Modifier.PUBLIC)
                .addMethod(generateMethods())
                .build();
        return bindingClass;
    
    }
    
        private MethodSpec generateMethods() {
        ClassName activity = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("bind")
                .addModifiers(Modifier.PUBLIC)
                .returns(void.class)
                .addParameter(activity, "activity");
    
        for (int id : mVariableElementMap.keySet()) {
            VariableElement element = mVariableElementMap.get(id);
            String name = element.getSimpleName().toString();
            String type = element.asType().toString();
    
            methodBuilder.addCode("activity." + name + " = " + "(" + type + ")(((android.app.Activity)activity).findViewById( " + id + "));\n\n");
        }
    
        return methodBuilder.build();
    }
    
    
    public String getPackageName() {
        return mPackageName;
    }
    }
    

    generateMethods方法通过for循环构建代码,findViewById绑定view

    我们先看下原本的MainActivity有什么东东

    public class MainActivity extends AppCompatActivity {
    
    @BindView(R.id.button)
    Button button;
    
    @BindView(R.id.tv)
    TextView textView;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    
        BindViewTools.bind(this);
        textView.setText("bind Button success");
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                doMarkDown();
            }
        });
    }
    }
    

    这个BindViewTools.bind(this)传送门进去看看

    public class BindViewTools {
    public static void bind(Activity activity) {
        Class clazz = activity.getClass();
        try {
            Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
            Method method = bindViewClass.getMethod("bind", activity.getClass());
            method.invoke(bindViewClass.newInstance(), activity);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    

    }
    我们可以看到他是通过反射寻找的是MainActivity_ViewBinding的类,并进行Id绑定的

    可以在build/intermediates/classes/debug/包名/MainActivity_ViewBinding.class看到生成的代码

    这下就很清晰了

    1.首先定义注解
    2.BindViewProcessor里的process 解析注解,生成辅助类MainActivity_ViewBinding
    3.在入口BindViewTools.bind(this),反射找到生成的MainActivity_ViewBinding类并进行findViewById。

    总结

    本章节主要说了APT的简单使用,从使用角度来说,APT技术并没有难度,重点是怎么设计,在实际项目中可以把很多繁琐重复性的工作,通过APT来生成各种代码,作为老司机,这是弯道超车的必备秘籍,天下武功、唯快不破!

    相关文章

      网友评论

      • sollian:使用起来很方便,但是阅读难度比较大,也不利于找问题。不知道说的对不对
        Code猎人:@sollian so还是那句话在于你怎么设计?apt应用在知名框架里太多了 DataBinding、Dagger2、ButterKnife、EventBus3、DBFlow、AndroidAnnotation
        sollian:@Code猎人 自己理解透彻肯定是没有问题,问题在于团队协作,包括新入职的伙伴等,感觉成本不低。而且注解这东西并不减少实际的代码量,反而可能增加包的大小以及排查问题的难度。所以我一直感觉使用注解有些得不偿失。
        Code猎人:我的理解是这样的,APT的技术使用起来是没有难度的,难的地方是怎么去设计,其实无论是注解、解析器、或者gradle plugin只要写好了基本上不会在变了,理解透彻了就没有啥阅读难度,都是死的东西

      本文标题:Android AOP三剑客之APT

      本文链接:https://www.haomeiwen.com/subject/vxminftx.html