第一次感受DI & java.lang.reflect.* 学习

原创 2005年05月13日 21:53:00

                                      

           第一次感受DI(Dependency Injection) & java.lang.reflect.* 学习
                          糊涂鬼 2005-05-12

  说是说感受一下这个东西DI(也可以说是IoC-(Inversion of Control)吧),其实我对它的认识只有一点点,甚至说我今天写的这个程序有没有用到它我都不敢肯定,只是我感觉我是用到了的。好了,废话我不多说了,先把两个程序贴出来,浏览一下,别细读。

Program 1(without DI):Program 2(with DI):
package cn.liltos.reflect;
import java.lang.reflect.*;
public class GetClassInfo_1 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "cn.liltos.reflect.Beans";
        getClassName(s);
        getFields(s);
        getConstructor(s);
        getMethods(s);
        System.out.println("}");
        long end = System.currentTimeMillis();
        long cost = end - start;
        System.out.println("this program last : " + cost);
    }   
    public static void getConstructor(String s) {
        System.out.println("/n    //构造方法");
        Class c = getClass(s);
        Constructor[] constructor = c.getConstructors();
        printObjectArray(constructor);
    }
    public static void getMethods(String s) {
        System.out.println("/n    //成员方法/n");
        Class c = getClass(s);
        Method[] method = c.getDeclaredMethods();
        printObjectArray(method);
    }
    public static void getFields(String s) {
        System.out.println("{/n    //成员变量");
        Class c = getClass(s);
        Field[] field = c.getFields();
        printObjectArray(field);
    }
    public static void getClassName(String s) {
        System.out.print("class ");
        String className = getClass(s).getName();
        System.out.println(className);
    }
    public static Class getClass(String s) {
        Class c;
        try {
            c = Class.forName(s);
        } catch(ClassNotFoundException ex) {
            return null;
        }
        return c;
    }
    public static void printObjectArray(Object[] obj) {
        for(int i = 0; i < obj.length; ++i) {
            System.out.println("    " + obj[i]);
        }
    }
}
package cn.liltos.reflect;
import java.lang.reflect.*;
public class GetClassInfo_2 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "cn.liltos.reflect.Beans";
        Class c = getClass(s);
        getClassName(c);
        getFields(c);
        getConstructor(c);
        getMethods(c);
        System.out.println("}");
        long end = System.currentTimeMillis();
        long cost = end - start;
        System.out.println("this program last : " + cost);
    }
    public static void getMethods(Class c) {
        System.out.println("/n    //成员方法");
        Method[] method = c.getDeclaredMethods();
        printObjectArray(method);
    }
    public static void getFields(Class c) {
        System.out.println("{/n    //成员变量");
        Field[] field = c.getFields();
        printObjectArray(field);
    }   
    public static void getConstructor(Class c) {
        System.out.println("/n    //构造方法");
        Constructor[] constructor = c.getConstructors();
        printObjectArray(constructor);
    }
    public static void getClassName(Class c) {
        System.out.print("class ");
        System.out.println(c.getName());
    }
    public static Class getClass(String s) {
        Class c;
        try {
            c = Class.forName(s);
        } catch(ClassNotFoundException ex) {
            return null;
        }
        return c;
    }
    public static void printObjectArray(Object[] obj) {
        for(int i = 0; i < obj.length; ++i) {
            System.out.println("    " + obj[i]);
        }
    }
}

  这两个程序我把注释全部删除了,对于一个如此简单的程序,实在没有必要把注释都写出来,我想我的命名应该还是可以的,看方法名就可以知道方法是做什么的吧(:-),有点臭美,容忍一下)。
  另外程序还涉及到一个叫‘cn.liltos.reflect.Beans’的类,看名字就知道啦,这个类里面无非也就是一些 field 和一些 method,再没有其它什么值得注意的东东了。

  现在说一下这两个程序是用途,运用JAVA的反射机制,读取想查看的类(这里是cn.liltos.reflect.Beans)的一些细节,并将得到的结果打印在屏幕上。为了打印出来的东西具有一定的可读性,我在程序里便有了那些不美观的、一大堆的换行控制。同时,为了检查程序的执行时间,在 main() 的开始和结束都调用了 System.currentTimeMillis() 来确定时间。最后输出程序的执行时间。在程序里运用的反射的几个方法也比较简单。我晕,又说了一堆废话 :-(

  两个程序的方法(均为 static),相同的有 void printObjectArray(Object[] obj)、Class getClass(String s)、void main(String[] args)。而其它的方法,只有名字是相同的,参数则不一样。第一个程序里其它的方法的参数都是 String s, 而后者则是以 Class c 为参数,这也是我认为后者采用的是 DI 的原因,方法体都是根据传入的参数所代表的类去寻找类的细节。

  看一个JAVA程序的运行效率有多高,一般是看第一次运行的,这个观点不知道是否正确,因为如果JVM一次次地运行同一个程序的话,它会一次次的优化字节码,相信有很多朋友有这样的经验,编译同一个程序,第二次编译的时间会很明显地比第一次编译花的时间少。对于运行,同理可证。呵呵~~~~
  那这上面的两个程序的效率到底差了多少呢?在第一次运行的时候,Program 1 花了 7000 多 Milliseconds ,而 Program 2 只花了 170 个单位。这个数字有点吓人会吗?反正我执行完第二个程序后看到的这个数字差时是被吓了一跳。不过在运行了将近十次以后,两个程序的时间差少了非常非常之多,只有 40 个单位的时间了。
  40 Milliseconds,这个数字太不大了,呵呵,才40,只要我的机器配置再高一些,这点时间,压根就感觉不到,确实,一点都没错。但是——最讨厌看到一堆美好之词后面加这个词了——但是,这只是一个非常小的程序,非常非常小。如果现在运行的不是一个程序,而是一组、或是几个 package 的程序,那么这个时间就非常之可观了,不是么?

  看到这里了,先打住,有一件事情我不敢确定,上面的程序有用到 DI 的思想吗?恳请高手指点一下,我实在是没什么自信。


  相信有很多朋友对于那些高手们左口一个 IoC 右口一个 DI 一定感到很羡慕,羡慕人家知道那么多东西。如果到这里我上面的程序确实有用到 DI 的思想的话,那么,请允许我班门弄斧似滴说一下上面在什么地方用到了 DI 吧。

    public static void getMethods(String s) {
        System.out.println("/n    //成员方法/n");
        Class c = getClass(s);
        Method[] method = c.getDeclaredMethods();
        printObjectArray(method);
    }
  这一段程序,为了得到 s 代表的类的自己声明的方法,参数 String s 是类在 classpath 上的位置。进入方法体后,再用 Class c = getClass(s); 得到 Class 类的实例,然后调用 c.getDeclaredMethods() 得到这个实例自己声明的方法。
  与之对应的另一个方法如下:
    public static void getMethods(Class c) {
        System.out.println("/n    //成员方法");
        Method[] method = c.getDeclaredMethods();
        printObjectArray(method);
    }
  参数直接变成了 Class c,也就是说,直接把 Class 的实例注入方法,而不是在方法中再去寻找/创建。在这个小程序中,外在的好处只是处理时间减少了一点点,但是,将控制权从方法内部转移到外部,减少方法需要做的工作,便意味着一个提高。有一点是必须注意的尽量简化方法,让一个方法只做好自己本职的那份工作,是面向对象的一个很基本的原则,可以提高代码的复用率。虽然只是一个方法的重用,但养成一个好习惯会比较好一点。

内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:第一次感受DI & java.lang.reflect.* 学习
举报原因:
原因补充:

(最多只允许输入30个字)