在1.4版本之前，Blade有一个很大的弊端，就是注入源和注入目标有耦合。其中注入目标必须有一个@Module的注解，这个导致同一个注入目标不能被复用。我举一个简单的例子：

1. Provider接口

  从1.4版本开始新增了一个接口--Provider接口，在编译时，每个Context都会对应生成一个叫Context类名ProviderImpl名字的类，这个类实现了Provider接口。然后在这个生成类里面，进行了数据的存储，主要是将对应的Context数据放在这个生成类的一个HashMap成员中。例如，如下的Context：

public class Context {
    @Provides(deepProvides = true, value = "contextString1")
    public Demo string1 = new Demo();
    @Provides(value = "contextString2")
    public String string2;
    @Provides(value = "int")
    public int code = 2;
}

  对应生成的ProviderImpl类是：

public class ContextProviderImpl implements Provider {
  private Map<String, Object> pathMap;

  public ContextProviderImpl() {
    pathMap = new HashMap<>();
  }

  @Override
  public Object find(String id) {
    return pathMap.get(id);
  }

  @Override
  public void put(Map<String, Object> map) {
    pathMap.putAll(map);
  }

  public void init(Context source) {
    pathMap.put("contextString1", source.string1);;
    pathMap.put("contextString2", source.string2);;
    pathMap.put("strings", source.string1.string3.strings);;
    pathMap.put("demoDemoString", source.string1.string3.demo.demoDemoString);;
    pathMap.put("demoString", source.string1.string3);;
    pathMap.put("com.example.pby.injectdemo.demo.Demo", source.string1.string3.demo);;
    pathMap.put("demo3String", source.string1.string3.string);;
    pathMap.put("java.lang.String[]", source.string1.string3.string1);;
    pathMap.put("int", source.code);;
  }
}

  在生成的ProviderImpl类中，主要实现了Provider的两个方法--put方法和find方法。
  其中put方法表示可以将我们自定义的某些数据存在一个Map里面，然后在注入的时候可以从这个数据源来寻找数据。这样做的好处就是，一个注入目标没必要再次定义一个Context类，只需要在基类里面定义一个Context类就行了，然后子类只需要维护一个Map数组就OK了。
  find方法在这里就没必要解释了，很明显就是从存储数据的Map去寻找数据，这个方法在生成的Inject类里面会被调用。
  在生成的ProviderImpl类中，还有一个方法比较重要，那就是init方法。这个方法主要将Context里面的数据放在Map数组里面去，需要注意的是，这里进行了递归，也就是说将子节点的数据也放在了Map数组里面的。

2. Inject类

  在整个框架当中，每个注入目标都会生成一个Inject类，而对注入目标的数据初始化就是这个Inject类里面完成的。我们来看看一个例子：

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"));
  }
}

  在1.4版本中，彻底的重构了Inject类的结构。在上面的例子当中，我们会发现数据源参数直接是一个Provider接口，初始化代码调用的是Provider接口的find方法。所以从这里，我们可以看出来，在1.4版本中，Context不再持有数据，进而让Provider接口的实现类来持有数据。

3. Blade类

  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").newInstance();
            if (extraMap != null && !extraMap.isEmpty()) {
                sourceObject.getClass().getMethod("put", Map.class).invoke(sourceObject, extraMap);
            }
            sourceObject.getClass().getMethod("init", source.getClass()).invoke(sourceObject, source);
            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();
        }
    }
}

  在Blade类里面主要做了如下几件事：

1. 根据传递进来的注入源找到对应的ProviderImpl类， 然后创建它的对象，初始化数据。
2. 根据传递进来的注入目标找到对应的Inject类，然后调用它的inject方法,同时将ProviderImpl对象传递进去。

  经过如上两步就完成了整个注入过程。