动态代理16/11/25

 

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

一、Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method,Object[] args）。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

二、Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h）：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader,Class[] interfaces）：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h）：返回代理类的一个实例，返回后的代理类可以当作被代理类使用（可使用被代理类的在Subject接口中声明过的方法）。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现InvocationHandler接口

代理机制及特点

通过实现 InvocationHandler 接口创建自己的调用处理器；

通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；

通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；

通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

↑ ↑ ↑ 以上来自百度百科↑ ↑ ↑ 

 

下面是实验代码

 

　　主要过程是创建一个Attack接口，中有一个攻击的方法，Gun类和Tank类实现Attack接口。在测试用例的我们不知道会具体使用哪种实现类进行调用，故需要

使用动态代理的方式生成一个Proxy对象，并在new Proxy对象是将目标被代理类对象注入到构造方法中，这样我们就可以通过使用代理对象赋给接口使用，当我们

调用目标方法（即调用invoke方法）时，就可以实现动态调用的目的。

 

一、创建接口及被代理类

1.创建接口

package proxy;

public interface Attack {
    
    void attack();

}

2.以下两个实现类为被代理类

package proxy;
/**
 * 被代理类，手枪类
 * @author Wzefeng
 *
 */
public class Gun implements Attack{

    @Override
    public void attack() {
        System.out.println("手枪的攻击力为100");
    }
}

package proxy;

/**
 * 被代理类，坦克类
 * @author Wzefeng
 *
 */
public class Tank implements Attack{

    @Override
    public void attack() {
        System.out.println("坦克的攻击力为800");
    }
}

二、创建代理类实现对被代理类对象的动态代理

package proxy;

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

public class AttackProxy {

    //要被代理的目标对象
    private Object target;
    
    //构造方法注入被代理的目标对象
    public AttackProxy(Attack target){
        this.target = target;
    }
    
    //获取动态代理对象
    public Object getAttackProxy(){
        //使用被代理类的类加载器
        ClassLoader loader = target.getClass().getClassLoader();
        //需要实现的接口
        Class[] interfaces = new Class[]{Attack.class};
        
        InvocationHandler h = new InvocationHandler() {
            /*
             * 当代理对象调用其方法时，即调用此invoke方法，实现动态代理
             * proxy:被代理的对象，一般不使用
             * method：被代理对象调用的方法
             * args：method中的形参
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                
                //可对目标方法进行增强
                
                //调用目标方法
                method.invoke(target, args);
                
                return null;
            }
        };
        
        //使用Proxy类创建一个新的代理对象
        //loader 被代理类使用的类加载器，interfaces被代理类需要实现的接口
        Object proxy = (Attack) Proxy.newProxyInstance(loader, interfaces, h);
        
        //返回代理对象
        return proxy;
    }
}

三、对代理类进行测试

package proxy;

public class Client {
    //测试
    public static void main(String[] args) {
        System.out.println("使用手枪攻击");
        Attack attack1 = (Attack) new AttackProxy(getGun()).getAttackProxy();
        attack1.attack();
        
        System.out.println("使用坦克攻击");
        Attack attack2 = (Attack) new AttackProxy(getTank()).getAttackProxy();
        attack2.attack();
    }
    
    //要被代理的对象
    public static Attack getGun(){
        return new Gun();
    }
    //要被代理的对象
    public static Attack getTank(){
        return new Tank();
    }
}

 结果截图

 

 

16:53:16笔记