Le code Android (Java) implémente manuellement une explication technique détaillée par injection de dépendances

Injection de dépendances dans la technologie de génération de code Android (Java). Je pense que tout le monde a entendu parler de ce terme dans le développement quotidien. Par exemple, ceux qui développent Android utilisent des bibliothèques tierces telles que Butterknife et Greendao. 🎜>génération instantanée de code lors de la compilation, et nous pouvons ensuite utiliser les classes compilées pour aider notre développement et réduire notre charge de travail. Cette technologie semble assez avancée. Lors de la génération de code, comment faire cela ? Je n'ai jamais entendu dire que la compilation pouvait aussi générer du code. Jetons un coup d'œil à cette technologie magique !

Principe de génération de code au moment de la compilation

Tout d'abord, nous connaissons peut-être plus ou moins une technologie appelée

JavaPoet Commençons par celle-ci. dans son code source, vous constaterez qu'il ne semble rien faire d'avancé. Il n'y a qu'une douzaine de classes au total, et la plupart d'entre elles encapsulent simplement certaines classes, fournissent des interfaces pour une utilisation facile et fournissent également une classe d'outils pour. Nous utilisons, comme le montre l'image, son code source ne contient que les classes suivantes

Pour le moment, nous sommes confus. Le code généré lors de la compilation n'est-il pas effectué par cette bibliothèque. nous? Pour être précis, ce n’est pas le cas. Alors quelle est sa fonction ? Il ne remplit en fait que la moitié des fonctions que nous avons mentionnées, à savoir la
génération de code, et il s'agit d'une génération de code simple et facile à comprendre, car elle est encapsulée et fournit essentiellement des réponses à certaines exigences courantes de génération de code. méthode, réduisant considérablement la complexité du code. Par rapport à ce que nous souhaitons, il y a un de moins généré lors de la compilation. Comment faire ? En fait, nous devons faire certaines choses lors de la compilation. Java l'a déjà fait pour nous. Regardons d'abord une classe

. Cette classe n'est peut-être pas utilisée normalement, mais cela n'a pas d'importance. . Disons simplement Pour le comprendre, vous pouvez d'abord le comprendre comme un

processeur d'annotations AbstractProcessor abstrait, qui se trouve en dessous et est une classe utilisée pour analyser et traiter les annotations au javax.annotation.processing.AbstractProcessor; moment de la compilation. . Si nous voulons implémenter des fonctions comme ButterKnife, nous devons d'abord définir notre propre processeur d'annotation, puis en hériter. Comme indiqué ci-dessous

, nous pouvons voir que nous devons implémenter une méthode abstraite appelée process. cette méthode Le contenu sera exécuté lors de la compilation.

public class MyProcessor extends AbstractProcessor{
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {        return false;
    }
}

Alors, comment faire en sorte que le jvm appelle le processeur d'annotation que nous avons écrit lors de la compilation ? Un moyen rapide consiste à utiliser la bibliothèque open source de Google auto, puis à utiliser l'annotation AutoService qu'elle fournit pour l'implémenter. Créez manuellement le dossier spécifié, puis configurez le chemin de notre processeur d'annotations.

Après avoir terminé le travail ci-dessus, lors de la compilation, jvm analysera toutes les

classes d'implémentation, voici

, puis appellera la méthode de processus de la classe d'implémentation pour effectuer les opérations correspondantes, puis notre travail de génération de code peut être écrite au cours du processus, puis la méthode spécifique de génération de code peut être simplifiée à l'aide de l'outil JavaPoet. AbstractProcessorÉtant donné que notre outil de génération de code est MyProcessorexécuté lors de la compilation
, le code Java final généré sera compilé avec le code Java ordinaire et utilisé comme une classe ordinaire, cela n'affectera donc pas le programme final. En termes de performances d'exécution, la vitesse de compilation est tout au plus un peu plus lente en raison des classes et du code supplémentaires qui doivent être générés. Jusqu'à présent, nous savons comment générer du code lors de la compilation, et nous avons l'idée de base de l'implémentation, mais il y a toujours un problème.

Comment utiliser un processeur d'annotation pour traiter une annotation afin d'obtenir un effet similaire à @BindView ? Tout d'abord, bien sûr, nous devons personnaliser une annotation. Si vous ne connaissez pas l'annotation personnalisée spécifique, vous pouvez l'apprendre. C'est assez simple et n'a pas beaucoup de contenu. Comme ce n'est pas le sujet de ce chapitre, je le fais. ne l'expliquera pas trop. Bien sûr, vous pouvez aussi simplement le mettre dans le lien de démonstration à la fin de l'article. Téléchargez le code source pour apprendre. Après avoir défini une annotation, nous voyons d'abord le paramètre

du <.> méthode de notre

processeur d'annotations. Ce paramètre est utilisé pour stocker toutes les données numérisées lors de la compilation (les annotations non méta sont également des annotations personnalisées. Il y a quatre méta annotations au total. À l'exception des méta annotations, le reste sont des annotations personnalisées). Ensuite, nous parcourons cette collection et lorsque nous obtenons nos annotations personnalisées, nous exécutons la logique correspondante. Le code spécifique est le suivant, où XXXAnnotation est le nom de votre annotation personnalisée MyProcessorprocess()annotations Ensuite, nous devons également réécrire la méthode

et la méthode

for (TypeElement element : annotations) {    if (element.getQualifiedName().toString().equals(XXXAnnotation.class.getCanonicalName())) {        //执行你的逻辑
    }
}

de la classe

, et le Utilisations de la méthode AbstractProcessor Pour spécifier quelle annotation le processeur d'annotation est utilisé pour traiter, la méthode getSupportedAnnotationTypes() est utilisée pour spécifier la version Java, et la valeur est généralement getSupportedSourceVersion(). getSupportedAnnotationTypes()

完成以上工作后，对于自定义注解作用的对象，编译期间就会自动执行相应process() 里的逻辑，比如生成辅助类，这个辅助类其实就可以理解为依赖类，这个编译期间通过注解生成辅助类的过程，就相当于实现了注入。
到这里，一整个依赖注入的思路和实现方法已经全部打通。
下面我们来动手实现一个小例子吧！

动手实现

首先我们新建一个Android工程，按照默认的配置就好，新建完毕后，会有个默认的app的module，我们暂且不管它，然后直接新建一个java module，新建方式为file -> New -> New Module
然后选择Java Libary，这里给libary取名为javapoet
然后在module对应的build.gradle下，加入下面两个依赖

implementation 'com.squareup:javapoet:1.11.1'implementation 'com.google.auto.service:auto-service:1.0-rc4'

第一个依赖是javaPoet的依赖，第二个是Google开源库auto的依赖
 上面提到让jvm加载我们自己的注解处理器有两种方式，这里我们先试一下用谷歌的这个开源库

这个module用来编写我们的注解处理器的实现类，先放着，待会再写。
继续新建一个java module，我这里取名为libannotation，然后在里面新建一个自定义注解，内容如下

@Retention(RetentionPolicy.CLASS)@Target(ElementType.TYPE)public @interface HelloAnnotation {}

@Retention(RetentionPolicy.CLASS)表示我们定义的这个注解会留存在class字节码文件中 ，但是在运行时是没有的，@Target(ElementType.TYPE) 表示我们的这个注解作用对象是类，然后我们看下整个目录的样子，

TestGenerator是一个我写的测试JavaPoet的测试类，可以忽略

现在我们开始写代码，首先在javapoet的build.gradle中加入libannotation  module的依赖，如下

implementation project(path: ':libannotation')

然后在javapoet module中新建HelloProcessor类，用AutoService标注它，然后继承AbstractProcessor方法，重写相应的方法，具体怎么写，原理里解释的比较详细，然后注释里我作了详细说明，如下

import com.aiiage.libannotation.HelloAnnotation;import com.google.auto.service.AutoService;import com.squareup.javapoet.JavaFile;import com.squareup.javapoet.MethodSpec;import com.squareup.javapoet.TypeSpec;import java.io.IOException;import java.util.Collections;import java.util.Set;import javax.annotation.processing.AbstractProcessor;import javax.annotation.processing.Filer;import javax.annotation.processing.ProcessingEnvironment;import javax.annotation.processing.Processor;import javax.annotation.processing.RoundEnvironment;import javax.lang.model.SourceVersion;import javax.lang.model.element.Modifier;import javax.lang.model.element.TypeElement;/**
 * Created By HuangQing on 2018/7/20 15:38
 **/@AutoService(Processor.class)public class HelloProcessor extends AbstractProcessor {
    private Filer filer;    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {        super.init(processingEnv);
        filer = processingEnv.getFiler(); // 获得filer对象，用来创建文件
    }    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {        for (TypeElement element : annotations) {//遍历扫描到的注解集合
            if (element.getQualifiedName().toString().equals(HelloAnnotation.class.getCanonicalName())) {                // 当前注解是我们自定义的注解，也就是HelloAnnotation时，执行下列代码
                TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")//声明类名为HelloWorld
                        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)//声明类的修饰符为 public final
                        .addMethod(getMethodSpec("hello1", "Hello"))//为HelloWorld类添加名为hello1的方法，返回值为Hello
                        .addMethod(getMethodSpec("hello2", "Java"))//同上
                        .addMethod(getMethodSpec("hello3", "Poet!"))//同上
                        .build();                try {                    // 建立 com.aiiage.testjavapoet.HelloWorld.java 对象
                    JavaFile javaFile = JavaFile.builder("com.aiiage.testjavapoet", helloWorld)
                            .addFileComment(" This codes are generated automatically. Do not modify!")
                            .build();                    // 写入文件
                    javaFile.writeTo(filer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }        return true;
    }    /**
     * @param methodStr  方法名
     * @param returnStr  返回值
     * @return
     */
    private static MethodSpec getMethodSpec(String methodStr, String returnStr) {        return MethodSpec.methodBuilder(methodStr)
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)//指定方法修饰符为 public static
                .returns(String.class) //指定返回值为String类型
                .addStatement("return $S", returnStr) //拼接返回值语句
                .build();
    }    @Override
    public Set<String> getSupportedAnnotationTypes() {        return Collections.singleton(HelloAnnotation.class.getCanonicalName());
    }    @Override
    public SourceVersion getSupportedSourceVersion() {        return SourceVersion.latestSupported();
    }
}

上述代码中，一定不要忘了加AutoService的注解，通过这个注解，我们的HelloProcessor注解处理器相当于执行了一个注册的过程，这样才会被jvm在编译时加载，代码生成部分最终生成的文件代码长下面这个样子，可以结合注释对着体会下，还是很方便的，有了javapoet之后

import java.lang.String;public final class HelloWorld {
  public static String hello1() {    return "Hello";
  }  public static String hello2() {    return "Java";
  }  public static String hello3() {    return "Poet!";
  }
}

ok，代码方面准备完毕。
接下来我们为app module添加依赖，如下

//必须使用annotationProcessor，而不是implementation//annotationProcessor修饰的，最终不会打包到apk中，可理解为在编译时执行的annotationProcessor project(':javapoet')implementation project(':libannotation')

然后我们手动编译一下项目，build -> make project，然后我们来到熟悉的MainActivity，首先使用我们的自定义注解标注MainActivity，要标在class上面，因为我们自定义的注解作用范围是Type，然后用一个TextView简单显示一下注入的HelloWorld类的几个静态方法，如下

@HelloAnnotationpublic class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView tv=findViewById(R.id.tv);
        String str1="";
        str1+=HelloWorld.hello1()+" ";
        str1+=HelloWorld.hello2()+" ";
        str1+=HelloWorld.hello3();
        tv.setText(str1);
    }
}

编译运行，看到Hello Java Poet字样即表示成功！

然后我们上面提到，除了使用Google开源库auto实现注册注解处理器外，还可以使用手动配置的方式，手动配置的方式如下

在自定义注解处理器的module中，这里也就是javapoet的module中，在main目录下创建出resources目录，然后在resources目录下创建出META-INF目录，然后在META-INF目录下创建出services目录，然后在services目录下创建一个名为javax.annotation.processing.Processor 的文件，在该文件中声明我们的注解处理器：

com.aiiage.javapoet.HelloProcessor;

结语

这样我们就完成了一个最简单的依赖注入的实现，掌握其原理后，我们就不难明白类似ButterKnife、GreenDao是怎么实现的了，不过我们这个只是一个简单的功能，不得不感叹要生成那么多的代码，这得是一个多么心细和考验耐心的活啊！

相关推荐：

php生成Android客户端扫描可登录的二维码，android客户端

视频：Java视频教程_免费Java教程在线学习

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!