Dhroid框架六大组件之Ioc容器【上】

本文，是假设你有使用或了解过dhroid框架的基础上进行讲解的，如果对该框架并不了解，但想学习的，可以先到这里去学习一下：http://www.oschina.net/p/dhroid。 这里有提供下载地址和简单教程。努力深入学习别人的框架，看看别人是如何从0到1做出一个框架的，当你有能力优化，乃至创建一个新的、更优的框架的时候，你就是下一个大神了，距离升职加薪，迎取白富美，又跨进了一大步！就算迎取不到白富美，至少加薪应该不成问题，有了钱，大宝健杠杠的，大宝健上，要啥白富美没有，是吧！！！好了，不扯蛋了。让我们开始进入主题，走向通往大神之路吧。
dhroid框架的六大组件之一的Ioc容器，他的功能，官方描述起来，很抽象：“视图注入,对象注入,接口注入,解决类依赖关系”。现在，我开始一步一步的解剖Ioc，尽量更简单化的将其描述出来。
dhroid框架，在使用之前，必须在app的启动类里进行初始化，这个类必须是application的子类。

Dhroid.init(this); //Dhroid初始化

通过，查看源代码，可以知道init的实现，如下(此处只讲Ioc，图片和DB等无关的，不列出代码)：

Ioc.initApplication(app);
Ioc.bind(SimpleValueFix.class)
.to(ValueFix.class).scope(InstanceScope.SCOPE_SINGLETON);

咱们，先继续纵深，了解initApplication(app)这个方法：

public static void initApplication(Application application) {
    IocContainer.getShare().initApplication(application);
}

咱们，再继续纵深。。。这里是多包了一层了：

public void initApplication(Application application) {
    this.application = application;
}

这个方法是在一个叫做IocContainer的类里面的，用于全局存放这个application的子类对象。毕竟，这个类有大用处。后面再慢慢说。到此为止，就已经了解了框架的第一步初始化代码，竟然仅仅只是保存一个application子类的对象而已。然后，我们再继续讨论，init方法的第二行代码，因为这行代码有多个方法，咱们一个一个来解剖，先看bind。

Ioc.bind(SimpleValueFix.class);

这行代码，从bind这个单词就可以见名知义，即是将这个类捆绑起来。捆绑起来做啥？就是用来做单例。。。这样以后，你再想引用这个单例类（哪怕这个类本身并无单例模式的实现方式）。知道作用后，咱们再，继续解剖bind的源码：

public static Instance bind(Class<?> clazz) {
    return IocContainer.getShare().bind(clazz);
}

下一层bind类的具体实现。

/**
* 对象配置
* @param clazz 类名.class
*/
public Instance bind(Class clazz) {
        Instance instance = new Instance(clazz);
        instance.setAsAlians(new AsAlians() {
            public void as(Instance ins, String name, Class toClazz) {
                if (name != null) {
                    if (instanceByName.containsKey(name)) {
                        instanceByName.remove(name);
                    }
                    instanceByName.put(name, ins);
                }
                if (toClazz != null) {
                    if (instanceByClazz.containsKey(toClazz)) {
                        instanceByClazz.remove(toClazz);
                    }
                    instanceByClazz.put(toClazz, ins);
                }
            }
        });
    return instance;
}

这里通过给Instance构造函数传一个Class对象，来构造一个Instance实例。说到这里，又得再先深入Instance类的实现，不知道看客你的递归思维如何，这一层套一层的，或许可以先讲功能，再解剖这个类，但我还是比较喜欢一层一层纵深解剖，这样才不会出现有些代码看后出现，一知半解的情况。但是Instance类过于庞大，咱们这里先讲用到的，看到的，那就先从Instance的构造函数来说。

//对应的类
public Class clazz;
//绑定到对象(这是官方注释，但我觉得应该说成，用对象来绑定，更好理解...因为这里的toClaszz是作为key出现的，下面的name字段同理，因为name也是作为key出现，我读的还不够深，或许可能还有别的意思，后面边看边优化)
public Class toClazz;
//名
public String name;

//初始化一个Instance实例
public Instance(Class clazz) {
    this.clazz = clazz;
}
//AsAlians类是一个接口
public interface AsAlians {
    public void as(Instance me, String name, Class toClazz);
}

没错…就是这么简单。来，咱们继续看下一行代码，这行代码，简化着来看就是 instance.setAsAlians(new AsAlians());但这里的AsAlians类是一个接口，这里采用匿名类的写法，并通过重写AsAlians类里的方法，来实例化一个AsAlians对象。上面看到的匿名AsAlians的实现代码的触发，是在另一个地方，这里看不看都无所谓，只要知道Instance类里有一个Aslians变量，而且这个变量的as(Instance ins, String name, Class toClazz)方法的具体实现，是在这里就行。
那么，即然这个Bind方法的最复杂的部分，在这里不需要看，那我们就“先”continue，看下一行代码：return instance，噢，没了。。。这个bind方法到此就没了。
Ioc.bind(SimpleValueFix.class)
那我们来总结一下，这行代码做了啥事：
1、将SimpleValueFix类，传给Instance类的构造方法，来实例化一个带有SimpleValueFix类变量(这个变量是Class类，所以，可以赋值所有xxx.class类)的Instance类。
2、给Instance类的实例，赋值一个有具体实现的AsAlians接口类对象。
3、返回一个初始化过的Instance类对象。
4、总结，其实，就是绑定了一个具体的类。
好了，到此，我们就已经知道了bind方法做了什么事。接下来，继续看下一行代码，to方法的实现：

Ioc.initApplication(app);
Ioc.bind(SimpleValueFix.class)
.to(ValueFix.class)

/**
* to方法的具体实现
* 需要注入的类型
* @param clazz xxx.class
* @return 返回一个Instance对象
*/
    public Instance to(Class clazz) {
        this.toClazz = clazz;
        if (this.asAlians != null) {
            this.asAlians.as(this, null, clazz);
        }
        return this;
    }
//这里我把name方法也放出来，因为as的具体实现里，有一个判断涉及到这个方法。
    public Instance name(String name) {
        this.name = name;
        if (this.asAlians != null) {
            this.asAlians.as(this, name, null);
        }
        return this;
    }

这个to方法，是用来将一个类，注入到bind方法中已绑定的类里面。现在，就得review一下前面as方法的具体实现代码了！

instance.setAsAlians(new AsAlians() {
            public void as(Instance ins, String name, Class toClazz) {
                if (name != null) {
                    if (instanceByName.containsKey(name)) {
                        instanceByName.remove(name);
                    }
                    instanceByName.put(name, ins);
                }
                if (toClazz != null) {
                    if (instanceByClazz.containsKey(toClazz)) {
                        instanceByClazz.remove(toClazz);
                    }
                    instanceByClazz.put(toClazz, ins);
                }
            }
        });

如果name不为空。因为从name方法里面，可以看到as方法，只传name，是因为这里是通过以name为key，来绑定对应的instance对象。而to方法里面，可以看到as方法，只传Class，是因为这里通过以Class为key，来绑定对应的instance对象。到此，对于bind和to方法，我们已经够明白了。
最后，我们来讨论一下最后一个方法，scope方法的实现：

Ioc.initApplication(app);
Ioc.bind(SimpleValueFix.class)
.to(ValueFix.class).scope(InstanceScope.SCOPE_SINGLETON);

下面是scope方法的具体实现：

    /**
     * 作用域
     * @param scope
     * @return
     */
    public Instance scope(InstanceScope scope) {
        this.scope = scope;
        return this;
    }

从注释可以看出来，这个方法是用来设置作用域的。那么，问题就来了：
1、是谁的作用域？
2、一共有哪些作用域？
为了解答这两个问题，我们有必要继续看一下Instance类的其它代码段：

//保存的对象
public Object obj;
//对象的作用域
public InstanceScope scope;
//
对象作用域的类别
public enum InstanceScope {

        // 应用中单例
        SCOPE_SINGLETON,
        // 每次创建一个
        SCOPE_PROTOTYPE;
    }

//获取某个对象
public Object get(Context context) {
        //获取单例
        if (scope == InstanceScope.SCOPE_SINGLETON) {
            if (obj == null) {
                obj=bulidObj(context);
                injectChild(obj);
            }
            //这里需要先保证自己可以在容器中拿到然后才能注入

            return obj;
        //获取context类型的对象
        }else if (scope == InstanceScope.SCOPE_PROTOTYPE) {
            Object obj=bulidObj(context);
            //这里需要先保证自己可以在容器中拿到然后才能注入
            injectChild(obj);
            return obj;
        }
        return null;
    }

看完上面的代码后，答案恐怕大家都知道了：
一、 成员变量obj的作用域。
二、作用域有两种：
1、单例，即整个应用只保存一个对象，只要对象存在，就不再创建。（具体可以参考，设计模式之单例模式，但这里，是通过对某一个类的对象的保存来实现单例。即先判断类，如果该类有已存在的对象，就返回该对象。否则，才创建新的）
2、每次都创建。。这个不需要解释了，与new没啥区别了。
这里，我们就只讲解单例模式，即scope == InstanceScope.SCOPE_SINGLETON的情况。由代码，可知，框架首先会先判断当前的obj对象是为空，如果为空就执行一个叫做bulidObj的方法来创建一个obj对象。如果已存在，就直接返回这个obj对象来实现单例效果。那么，问题来了，这个buildObj究竟是创建哪个类的对象呢？为了答案，我们就得继续来解剖一下bulidObj(context)方法，看他是如何创建一个对象的。

    /**
     * 构建对象<br/>
     * 如果传入的context 不为空会尝试用context构建对象 否者会调用默认构造函数
     * @param context
     * @return 返回一个clazz类对象
     */
    public Object bulidObj(Context context) {
        Object obj = null;
        Constructor construstor = null;
        if(context!=null){
            Constructor[] constructors = clazz.getDeclaredConstructors();
            for (int i = 0; i < constructors.length; i++) {
                Constructor ctr = constructors[i];
                Type[] types = ctr.getParameterTypes();
                if (types != null && types.length == 1
                        && types[0].equals(Context.class)) {
                    construstor = ctr;
                }
            }
        }
        try {
            if (construstor != null) {
                obj= construstor.newInstance(context);
            } else {
                obj= clazz.newInstance();
            }
        } catch (IllegalArgumentException e) {
        } catch (InstantiationException e) {
        } catch (IllegalAccessException e) {
        } catch (InvocationTargetException e) {
        }
        if(obj!=null&&perpare!=null){
            perpare.perpare(obj);
        }
        return obj;

    }

这段代码，如果你是大牛，那可以一口气看完，如果跟我一样是小渣渣的话，咱们不妨把这个方法，拆分成两部分，化繁为简，由易入难。先看第一部分：

//context是上面完整代码里，方法的参数。
    Object obj = null;
        Constructor construstor = null;
        if(context!=null){
            /**
             * getDeclaredConstructors会返回类的多个构造函数
             * 并且，他们是无序的存在于这个返回的数组中。
             * 如果没有自定义的构造函数，则返回默认构造函数。
             * 如果该类是一个接口、数组、void、基本数据类型，则数组的长度为0
             */
            Constructor[] constructors = clazz.getDeclaredConstructors();
            for (int i = 0; i < constructors.length; i++) {
                Constructor ctr = constructors[i];
                Type[] types = ctr.getParameterTypes();
                if (types != null && types.length == 1
                        && types[0].equals(Context.class)) {
                    construstor = ctr;
                }
            }
        }

首先，是定义两个临时变量，一个Object ，一个Constructor。然后，再判断这个context是否为空，如果不非为空，就通过claszz类的getDeclaredConstructors()方法，来获取claszz类的所有构造方法。然后，再判断某个类里面的所有构造方法里面有没有一个构造方法，只需要传一个context传数，就能创建实例的，如果有，就将这个构造方法赋值给Constructor类的对象。如果没有，那么Contructor类的对象则为null。好了，上部分代码就是这么简单，下面我们继续看第二部分。

        try {
            if (construstor != null) {
                obj= construstor.newInstance(context);
            } else {
                obj= clazz.newInstance();
            }
        } catch (IllegalArgumentException e) {
        } catch (InstantiationException e) {
        } catch (IllegalAccessException e) {
        } catch (InvocationTargetException e) {
        }
        //下面这个判断永远不成立，可以删除，对项目并不影响，此处不做分析。
        if(obj!=null&&perpare!=null){
            perpare.perpare(obj);
        }
        return obj;

如果construstor不为空，即存在一个只需一个context参数就能创建实例的构造方法时，就用这个构造方法来创建实例。如果没有，就通过调用Class的newInstance();来创建实例。有人就想问了，那创建的是哪个类的实例呢？为了回答这个问题，我们就得看看这个claszz对象是由谁给赋的值了。细心和记忆力好的朋友，可能就已经发现了，在本文的前段，有这样的代码，这里再贴出来，免得大家还得往上拉去看看。

/**
* 对象配置
* @param clazz 类名.class
*/
public Instance bind(Class clazz) {
        Instance instance = new Instance(clazz);
        ....//此处省略该方法的其它代码，具体可以往上拉去看或查看框架源码
}

这里的Instance的clazz参数是的bind方法的clazz参数，直接传递赋值的。所以，你bind传了一个什么类，那么这里clazz.newInstance()就会创建出一个什么类对象来。

到此为止，我们就已经完整的分析了Ioc容器的初始化代码

Ioc.bind(SimpleValueFix.class).to(ValueFix.class).scope(InstanceScope.SCOPE_SINGLETON);

但是，我们平时使用Ioc的时候，都不是Ioc.bind.to.scope这样使用，而是直接通过下面的代码，来创建一个类对象的。

类名 变量名 = Ioc.get(类名.class);

那么，我们就有必要，继续来解剖Ioc的get方法，来看看这个get方法是做啥的，又与前面的Ioc初始化有毛关系。但限于篇幅，剩下的我们就在“Dhroid框架六大组件之Ioc容器【下】”来详细解剖和分析，坚持下去，Ioc容器剩下的内容并不多了。