模式的秘密-代理模式（2）-JDK动态代理

代理模式-动态代理

（1）

（2）

代码实践动态代理：

第一步：被代理类的接口：

package com.JdkProxy;

public interface Moveable {

    void move();

}

第二步：被代理类：

package com.JdkProxy;

import java.util.Random;

public class Car implements Moveable {

    @Override
    public void move()
    {

        //实现开车
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

第三步：代理类：实现接口：InvocationHandler，同时把被代理类对象接口传入构造方法，

重写的接口的invoke方法。

package com.JdkProxy;

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

public class TimeHandler implements InvocationHandler {

    private Object target;

    public TimeHandler(Object target)
    {
        this.target=target;
    }

    /*
     * 参数：
     * proxy：被代理对象
     * method：被代理对象方法
     * arg：方法的参数
     * 返回值：
     * Object 方法的返回值
     * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] arg) throws Throwable {

        long starttime=System.currentTimeMillis();
        System.out.println("汽车开始形式....");

        method.invoke(target);

        long endtime=System.currentTimeMillis();
        System.out.println("汽车结束行驶...汽车形式时间："+(endtime-starttime)+"毫秒");

        return null;
    }

}

测试类中实现代理：

使用Proxy类的newProxyInstance方法产生一个被代理类的实例，该实例可以当作被代理类使用接口（对应cls.getInterfaces()）中声明过的方法。

package com.JdkProxy;

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

public class Test {

    /*JDK动态代理测试类
     * */
    public static void main(String[] args) {

        Car car=new Car();

        //InvocationHandler是一个接口，接口中定义了一个方法invoke。要想实现JDK动态代理，
        //代理类必须继承这个接口
        InvocationHandler h=new TimeHandler(car);//
        Class cls=car.getClass();//获取类对象，以便获取类加载器，以及获取类的接口

        /*
         * newProxyInstance返回代理类的实例，返回后的代理类可以当作被代理类使用
         * （可使用被代理类的接口中声明过的方法）
         * loader:类加载器
         * interfaces:实现接口
         * h：InvocationHandler
         * */
        Moveable m=(Moveable) Proxy.newProxyInstance(cls.getClassLoader(),
                cls.getInterfaces(), h);
        m.move();

    }

}

测试结果：

汽车开始形式....
汽车行驶中....
汽车结束行驶...汽车形式时间：863毫秒

代理模式-动态代理

所以动态代理是这样一种Class：

• 他在运行时候产生了的Class
• 该class需要实现一组interface
• 使用动态代理类时，必须实现InvocationHandler接口

动态代理实现步骤

1，创建一个实现InvocationHandler的类，他必须实现Invoke方法

2，创建被代理的类以及接口

3，调用Proxy的静态方法，创建一个代理类：

newProxyInstance(ClassLoader，class[] interfaces，InvocationHandler  h)。

4，通过代理调用方法。

jdk动态代理只能实现了接口的类。

原文地址：https://www.cnblogs.com/alsf/p/8508425.html