之前学习很多的框架，我个人觉得学习框架的目的主要两点：

1. 理解框架的原理，在实际开发中，才会得心应手，游刃有余。
2. 学习框架的设计思想和技术亮点。我觉得这才是学习框架的最终目的，只有学到了东西，才算是对自己有提升。

  今天，我写这篇文章主要是为了介绍我的第一个框架--Blade。Blade其实不是非常厉害的框架，就是基于APT技术开发的依赖注入框架，简称DI框架。

1. 概述

  其实，熟悉Java开发的同学应该都知道，Google有一个非常著名的依赖注入框架--Dagger，那我为什么还要自己开发一个依赖注入的框架呢？俗话说，重复造轮子是对轮子最大的不尊重。
  当然我也不是吃饱了撑的没事干(其实仔细想一想，还是有那么一点)，这里面是有一定的原因。最近，楼主做自己的毕业设计，想在自己的毕业设计中加上依赖注入的框架，使得写的代码更加简洁。介于这个原因，我去学习了Google爸爸的Dagger框架。在学习过程中，我发现Dagger的一个设计，就是它提供对象都是通过方法来实现的，这个与我的想法有点相悖(有可能还有其他方式可以实现，但是我不知道)。由于这个原因，我就狠下心，打算自己来写一个，自己想要什么都可以自己来实现，然后入坑了。。。
  在这框架开发过程中，我借鉴了Dagger的部分思想。其实，我们可以从框架命名可以看出来，Dagger的中文意思是匕首，而Blade是剑的意思，看上去也是非常相似，以表示我对Dagger的尊重。
  接下来，我将简单介绍一下Blade（其实就是将github的ReadMe拷贝过来）。

2. gradle 导入方式

(1). 项目的build.gradle

allprojects {
    repositories {
        // ······
        maven { url 'https://jitpack.io' }
    }
}

(2). app的build.gradle

dependencies {
    // ······
    implementation 'com.github.BeauteousJade.blade:inject:latest version'
    annotationProcessor 'com.github.BeauteousJade.blade:processor:latest version'
}

3. 基本结构

  在整个DI框架，有两个注解，分别是Inject, Provides，先来解释这三个注解所表示的意思。

  如果使用注解成功的标记我们想要被注入和注入的变量，我们可以在通过调用Blade的inject(Object target, Object source)方法进行注入操作的最后一步，也只有经过这一步，想要注入的变量才会成功赋值。如下是Blade的代码：

public class Blade {

    public static void inject(Object target, Object source) {
        inject(target, source, null);
    }

    private static void inject(Object target, Map<String, ?> extraMap) {
        inject(target, new EmptyProviderImpl(), extraMap);
    }

    public static void inject(Object target, Object source, Map<String, ?> extraMap) {
        try {
            Object targetObject = Class.forName(target.getClass().getName() + "_Inject").newInstance();
            Provider sourceObject = (Provider) Class.forName(source.getClass().getName() + "ProviderImpl")
                    .getConstructor(source.getClass(), Map.class)
                    .newInstance(source, extraMap);
            targetObject.getClass()
                    .getMethod("inject", target.getClass(), Provider.class)
                    .invoke(targetObject, target, sourceObject);
        } 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();
        }
    }
}

  这也是本框架唯一通过反射方式来实现的地方。

  在编译器时期，APT会扫面每个被Module标记的类，然后对应着会生成一个Java类，上面代码的作用就是调用生成的Java类的inject方法进行赋值。下面是一个Demo代码：

public class MainActivity_Inject {
  public void inject(MainActivity target, Provider source) {
    target.strings = (java.lang.String[])(source.find("strings"));
    target.demoDemoString = (java.lang.String)(source.find("demoDemoString"));
    target.pby = (java.lang.String)(source.find("pby"));
    target.string1 = (java.lang.String)(source.find("demo3String"));
    target.strings1 = (java.lang.String[])(source.find("java.lang.String[]"));
    target.code = (int)(source.find("int"));
  }
}

4. 基本使用

  首先我们有一个类的有一些变量注入，比如MainActivity

public class MainActivity extends AppCompatActivity {

    @Inject
    String string;
    @Inject
    int a;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Blade.inject(this, new Context());
    }
    // ······
}

  这里需要注意的是：

1. 注入的变量需要标记Inject

  然后我们定义一个Context对象：

public class MainActivity extends AppCompatActivity {

    // ······
    public static class Context {
        @Provides
        String string = "string";
        @Provides
        int a = 1;
    }
}

  这里需要注意的是：

1. 作为数据源的变量需要标记Provides

  最后在调用Blade的inject方法。

        Blade.inject(this, new Context());

  整个注入过程就完成了。

5. github地址

   github:blade

6. 参考框架

1. dagger
2. butterKnife
3. AptPreferences