Java动态代理与反射详解

柔情只为你懂 2022-06-01 13:38 259阅读 0赞

转载自 https://www.cnblogs.com/haodawang/p/5967185.html

首先我得先请大家不要误会，博客园说转载的文章放在文章分类里，原创的文章用随笔写，我开先还以为随笔是拿来写抒情文的（滑稽），后来才发现不是这样的，但是自己所有的文章都在文章分类里了，又懒得搬运，所以我就用js重定向了一下。所以现在标题栏里进来的都是文章分类哦，大部分都是自己原创的，转载会注明转载的url。

废话不多说，今天我想来聊一下java里的反射和动态代理的问题，因为这两个东西实在撩人，而且动态代理百度几乎都是千篇一律，今天我写这篇博文希望能帮助大家，顺便也是为了巩固自己，毕竟自己也折腾了好久。

先来看看反射。  
java里的class文件加载分为两种情况，一种就是类型是编译器已知的，这种文件的.class文件在编译的时候，编译器会把.class文件打开检查，但是注意不是加载哦，第二种就是我们可能是从别的地方获取到了一个引用，然后动态的把这个未知类型的引用的对象的.class文件加载进jvm虚拟机里。

那么我们称前者为RTTI,即Run- Time Type Identification 运行时类型识别，有的人把RTTI翻译成 Run - Time Type Information ，我个人认为是不对的，因为我觉得它概括的不够全面，所以我建议大家把I 翻译成Identification更容易理解。

我们称后者为“反射”，这对于正在学习JAVA的人来说可是一个新的名词，但反射也是作为一个java的核心技术的存在。下面就来看看反射究竟有多重要吧。

## 反射 ##

在java里提供了一个叫做reflect的库，这个库里封装了Method,Constructor,field,Proxy,InvocationHandler 等类，这些类的API在我们学习反射会很有帮助。

反射最大的作用就在于我们可以不在编译时知道某个对象的类型，而在运行时得到。同时我们只需要得到我们想得到的类的名字即可(如果不在一个包，必须写完整的名字包括包名)。

package com.bike;
    
    import java.lang.reflect.*;
    
    public class Main {
        public static void main(String[] args) throws Exception{
            //返回A的构造方法
            Constructor c = A.class.getConstructor();
            //返回A类的所有为public 声明的构造方法
            Constructor[] cons = A.class.getConstructors();
            //返回A类所有的构造方法，包括private
            Constructor[] cons2 = A.class.getDeclaredConstructors();
            //返回A类的第一个public 方法
            Method m = A.class.getMethod("say");
            //执行
            m.invoke(A.class.newInstance(), null);
            //返回A类所有的public 方法
            Method[] ms = A.class.getMethods();
            //返回A类所有的方法，包括private
            Method[] allMs = A.class.getDeclaredMethods();
            //返回A类的public字段
            Field field = A.class.getField("i");
            System.out.println(field.get(A.class.newInstance()));
            //返回A类的static 字段
            System.out.println(field.get(null));
        }
    }
    
    class A{
        public int i = 1;
        public static int b = 2;
        public A(){
            System.out.println("无参构造");
        }
        private A(String s){
            System.out.println("有参构造"+s);
        }
        
        public void say(){
            System.out.println("say");
        }
    }

这里我只是简单的把API罗列了一下，大家可以自己动手试试，我这里就不再去描述了。  
通过上面的例子我们可以看出我们只用知道一个类的名字便可以得知它内部方法和字段，那么这里已经强烈的体现到了反射的作用。只是我这里做例子的时候把A作为了自己内部包的一个类，而在实际开发中，你可能是跨包的，所以你必须要写上全名才行。

关于.class类字面常量的知识请参照我的上一篇博文:[http://www.cnblogs.com/haodawang/articles/5954368.html][http_www.cnblogs.com_haodawang_articles_5954368.html]

## 代理 ##

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

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(ProxyInterface.class.getClassLoader(),new Class[]{ProxyInterface.class}, 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方法就可以得到这个接口的实例，然后再来作为参数传递进去，这里每一个在代理类上处理的东西也会被重定向到调用处理器上。

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

[http_www.cnblogs.com_haodawang_articles_5954368.html]: http://www.cnblogs.com/haodawang/articles/5954368.html