深入理解java：1.1.1.反射机制

标签：lsp   article   oid   range   dos   sys   hello   mod   idt   

反射

到底什么是反射（Reflection）呢？

反射有时候也被称为内省（Introspection），事实上，反射，就是一种内省的方式，

Java不允许在运行时改变程序结构或类型变量的结构，但它允许在运行时去探知、加载、调用在编译期完全未知的class，可以在运行时加载该class，生成实例对象（instance object），调用method，或对field赋值。

这种类似于“看透”了class的特性被称为反射（Reflection），我们可以将反射直接理解为：可以看到自己在水中的倒影，这种操作与直接操作源代码效果相同，但灵活性高得多。

反射概念，反射的应用场景

反射的应用场景：如果我们在程序运行时，一个对象想要检视自己所拥有的成员属性，该如何操作？

如果我们想要在运行期获得某个类Class的信息如它的属性、构造方法、一般方法 后再考虑是否创建它的对象，这种情况该怎么办呢？

这就需要用到反射！

.Java文件在编译后会变成.class文件，

这就像是个镜面，本身是.java，在镜中是.class，他们其实是一样的；

那么同理，我们看到镜子的反射是.class，就能通过反编译，了解到.java文件的本来面目。即为反射。

官方给出的概念：反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。

例如它允许一个java的类获取它所有的成员变量和方法并且显示出来。

反射机制的作用：

              1，反编译：.class-->.java

              2,通过反射机制访问java对象的属性，方法，构造方法，甚至其父类，接口等。

获取类的三种方式

1. //第一种方式：    
2. Class c1 = Class.forName(User);    
3. //第二种方式：    
4. //java中每个类型都有class 属性.    
5. Class c2 = User.class 
6. //第三种方式：    
7. //java语言中任何一个java对象都有getClass 方法    
8. User u = new User();    
9. Class c3 = u.getClass(); //c3是运行时类 (e的运行时类是User)

创建对象方法

[java] 

 

 

1. Class c =Class.forName("User");    
2.     
3. //创建此Class 对象所表示的类的一个新实例    
4. Object o = c.newInstance(); //调用了User的无参数构造方法. 

获取类属性

1.             //获取整个类    
2.             Class c = Class.forName("java.lang.Integer");    
3.             //获取所有的属性  
4.             Field[] fs = c.getDeclaredFields(); 

获取方法

 getDeclaredMethods()

...

反射的缺点：

反射机制给予Java开发很大的灵活性，但反射机制本身也有缺点，代表性的缺陷就是反射的性能，

一般来说，通过反射调用方法的效率比直接调用的效率要至少慢一倍以上。

关于性能的问题，可以参考这篇博客http://blog.csdn.net/l_serein/article/details/6219897

优点：

a、Java的反射机制就是增加程序的灵活性，避免将程序写死到代码里。
例如： 实例化一个 person()对象， 不使用反射，需要new person(); 如果想变成实例化其他类，那么必须修改源代码，并重新编译。
使用反射： class.forName("person").newInstance()；

而且这个类描述可以写到配置文件中，如 **.xml, 这样如果想实例化其他类，只要修改配置文件的"类描述"就可以了，不需要重新修改代码并编译。

在JavaWeb中加载数据库驱动时会用到。
b、增加程序的灵活性。
例如：struts中。请求的派发控制。
当请求来到时。struts通过查询配置文件。找到该请求对应的action方法。然后通过反射实例化action。并调用响应method。

如果不适用反射，那么你就只能写死到代码里了。

反射一般在框架中使用较多。

因为框架要适用更多的情况。对灵活性要求较高。

反射与设计模式

反射的一个很重要的作用，就是在设计模式中的应用，包括在工厂模式和代理模式中的应用。

工厂模式和代理模式又在各种框架（如Strust2，Spring）中广泛应用。

先来看看，如果不用反射的时候，的工厂模式吧：

这样，当我们在添加一个子类的时候，就需要修改工厂类了。如加一个梨的子类时，需要修改工厂类。

如果我们添加太多的子类的时候，改的就会很多。

现在我们看看利用反射机制：

我们传给工厂类的参数是子类的全名，现在就算我们添加任意多个子类的时候，工厂类就不需要修改。

上面的代码虽然可以通过反射取得接口的实例，但是需要传入完整的包和类名。

而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类。

下面我们来看看： 结合属性文件的工厂模式，可以称之为  动态工厂模式。

首先创建一个fruit.properties的资源文件，

内容为：

　然后编写主类代码：

【运行结果】：Apple

动态代理模式

接下来我们来看一下代理。
代理可以帮助我们进行很好的封装，使底层的代码能够有效的隐藏起来。
我们先来看看静态代理吧。

public class Main2 {
    //这里传入的是接口类型的对象，方便向上转型，实现多态
    public static void consumer(ProxyInterface pi){
        pi.say();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        consumer(new ProxyObject());
    }
}

//代理接口
interface ProxyInterface{
    public void say();
}


//被代理者
class RealObject implements ProxyInterface{
    //实现接口方法
    @Override
    public void say() {
        // TODO Auto-generated method stub
        System.out.println("say");
    }
    
}


//代理者
class ProxyObject implements ProxyInterface{

    @Override
    public void say() {
        // TODO Auto-generated method stub
        //dosomething for example
        System.out.println("hello proxy");
        new RealObject().say();
        System.out.println("this is method end");
    }
    
}
output:
hello proxy
say
this is method end

这就是静态代理，理解这个应该不难。
下面我们再来看看动态代理

import java.lang.reflect.*;

public class Main {
    static void customer(ProxyInterface pi){
        pi.say();
    }
    public static void main(String[] args){
        RealObject real = new RealObject();
        //当运行时（动态）才创建代理类
        ProxyInterface proxy = (ProxyInterface)Proxy.newProxyInstance(real.getClass().getClassLoader(), real.getClass().getInterfaces(), new ProxyObject(real));

        customer(proxy);
    }
}


interface ProxyInterface{
    void say();
}

//被代理类
class RealObject implements ProxyInterface{
    public void say(){
        System.out.println("i‘m talking");
    }
}

//代理类，实现InvocationHandler 接口
class ProxyObject implements InvocationHandler{
    private Object proxied = null;
    public ProxyObject(){
        
    }
    public ProxyObject(Object proxied){
        this.proxied  = proxied;
    }
    public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
        System.out.println("hello");
        return arg1.invoke(proxied, arg2);
    };
}

可以看到动态代理的代理类是实现了一个InvocationHandler的接口，

我们通过reflect.Proxy的类的newProxyInstance方法就可以得到这个接口的实例，然后再来作为参数传递进去，

这里每一个在代理类上处理的东西也会被重定向到调用处理器上。

至于动态代理和静态代理的区别，

即动态代理是动态的创建代理和动态的处理方法的，这也是反射的一个重要体现之处。

深入理解java：1.1.1.反射机制

标签：lsp   article   oid   range   dos   sys   hello   mod   idt   

原文地址：http://www.cnblogs.com/my376908915/p/6752707.html