Java动态代理详解-优快云博客

本文链接：https://blog.youkuaiyun.com/iteye_254/article/details/81959548

Proxy 提供用于创建动态代理类和实例的静态方法。简洁方法：
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class[] { Foo.class },
handler);

InvocationHandler 是代理实例的调用处理程序实现的接口。
每个代码实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

对java的动态代理机制有点陌生了，整理一下以前的代码。

package invocation;

/** *//**
* 定义一个接口,两个方法
* @author Jessica
*
*/
public interface Subject ...{
    public void print(String str);

    public void print2();

}package invocation;
/** *//**
* 定义一个类,实现Subject接口
* @author Jessica
*
*/
public class RealObject implements Subject...{

    public RealObject() ...{
        super();
    }
    public void print(String str)...{
        System.out.println("run into print");
    }

    public void print2()...{
        System.out.println("run into print2");
    }

}package invocation;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/** *//**
* 实现InvocationHandler接口，为RealObject对象提供代理（代理类）
* @author Jessica
*
*/
public class CallBack implements InvocationHandler...{

private Object obj;

    public CallBack(Object obj) ...{
        this.obj = obj;
    }
    /** *//**
     * 给对象创建动态代理
     * @param obj 需要创建代理的对象
     * @return 返回动态代理对象
     */
    public static Object factory(Object obj) ...{
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(),
                cls.getInterfaces(), new CallBack(obj));
    }
    /** *//**
     * 在代理实例上处理方法调用并返回结果。
     * 在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
     * @proxy - 在其上调用方法的代理实例
     * @method - 对应于在代理实例上调用的接口方法的 Method 实例
     * @args - 包含传入代理实例上方法调用的参数值的对象数组
     * @Throwable - 从代理实例上的方法调用抛出的异常
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable ...{
        Object obj1 = null;
        System.out.println("##########before calling##########");
        if(method.getName().equals("print"))...{
            System.out.println("args:"+args[0]);
            System.out.println("the invoke method is print()");
        }
        //在代理实例上处理方法调用
        obj1 = method.invoke(obj, args);
        //返回结果
        return obj1;
    }
}
写完了，测试一下：

package invocation;

/** *//**
* 触发类-测试
* @author Jessica
*/
public class Inspiration ...{

    public Inspiration() ...{
        super();
    }

    public static void main(String args[])...{
        RealObject realObj = new RealObject();
        //创建代理对象
        Subject subject = (Subject)CallBack.factory(realObj);
        //方法调用
        subject.print("JESSICA");
        subject.print2();
    }
}

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/anerou/archive/2007/06/20/1659107.aspx

分析：

1. Proxy即动态代理类；

2. Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用；

它有三个参数：

ClassLoader loader ----指定被代理对象的类加载器

Class[] Interfaces ----指定被代理对象所以事项的接口

InvocationHandler h ----指定需要调用的InvocationHandler对象

3. 实现InVocationHandler接口的LogHandler_old对象

这个对象的invoke()方法就是Proxy这个动态代理类所代理的接口类的抽象方法的真实实现；

它有三个参数：

Object proxy -----代理类对象