天天看点

Spring系列:代理(jdk动态代理,cglib代理)

使用代理的目的:

1)为其他对象提供一种代理以控制对这个对象的访问.
2)方便系统的扩展和测试。
           

举例两个具体情况:

(1)如果那个对象是一个是很大的图片,需要花费很长时间才能显示出来,那么当这个图片包含在文档中时,使用编辑器或浏览器打开这个文档,打开文档必须很迅速,不能等待大图片处理完成,这时需要做个图片Proxy来代替真正的图片.

(2)如果那个对象在Internet的某个远端服务器上,直接操作这个对象因为网络速度原因可能比较慢,那我们可以先用Proxy来代替那个对象.

通用代理的2种实现:

1)jdk动态代理
2)cglib代理
           

1.jdk动态代理

jdk中为实现代理提供了支持,主要用到2个类:

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler
           
java.lang.reflect.Proxy:这是jdk动态代理中主要的一个类,主要用到里面有一些静态方法。

Proxy::getProxyClass方法:为指定的接口创建代理类,返回代理类的Class对象

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
参数说明:
loader:定义代理类的类加载器
interfaces:指定需要实现的接口列表,创建的代理默认会按顺序实现interfaces指定的接口
           

Proxy::newProxyInstance方法:创建代理类的实例对象

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
           

这个方法先为指定的接口创建代理类,然后会生成代理类的一个实例,最后一个参数比较特殊,是InvocationHandler类型的,这个是个借口如下:

public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
           

上面方法会返回一个代理对象,当调用代理对象的任何方法的时候,会就被InvocationHandler接口的invoke方法处理,所以主要代码需要卸载invoke方法中。

Proxy::isProxy方法:判断指定的类是否是一个代理类

Proxy::getInvocationHandler方法:获取代理对象的InvocationHandler对象

public static InvocationHandler getInvocationHandler(Object proxy)
        throws IllegalArgumentException
           

JDK动态代理不足之处:

1)调用主要是通过反射的方式,JVM中运行时的效率比较低,如果调用反射的频率比较高时,很容易成为系统中的性能瓶颈。不建议在循环中使用。

2)代理类只能是接口类型,不能是具体的实现类

JDK代理使用示例 : 方法功能扩展运行时间功能

public class UserService implements IUserService {
    @Override
    public void insert(String name) {
        System.out.println(String.format("用户[name:%s]插入成功!", name));
    }
}

	
           

使用Proxy::newProxyInstance 的方式实现JDK代理

/*
下面代码面主要是createProxy方法用来创建代理对象,2个参数:
target:目标对象,需要实现targetInterface接口
targetInterface:需要创建代理的接口
invoke方法中通过method.invoke(this.target, args)调用目标方法,然后统计方法的耗时。
使用的是Proxy.newProxyInstance方法
*/
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class CostTimeInvocationHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long starTime = System.nanoTime();
        Object result = method.invoke(this.target, args);//@1
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
        return result;
    }

    /**
     * 用来创建targetInterface接口的代理对象
     *
     * @param target          需要被代理的对象
     * @param targetInterface 被代理的接口
     * @param <T>
     * @return
     */
    public static <T> T createProxy(Object target, Class<T> targetInterface) {
        if (!targetInterface.isInterface()) {
            throw new IllegalStateException("targetInterface必须是接口类型!");
        } else if (!targetInterface.isAssignableFrom(target.getClass())) {
            throw new IllegalStateException("target必须是targetInterface接口的实现类!");
        }
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
    }
}
           
@Test
    public void costTimeProxy2() {
        IUserService serviceA = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);
        serviceA.insert("隔壁二牛");
    }
           

使用Proxy::getProxyClass 的方式实现JDK代理

@Test
    public void costTimeProxy3() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        UserService service = new UserService();
        Class<?> proxyClass = Proxy.getProxyClass(IUserService.class.getClassLoader(), IUserService.class);
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                long starTime = System.nanoTime();
                Object result = method.invoke(service, args);//@1
                long endTime = System.nanoTime();
                System.out.println(service.getClass() + "." + method.getName() + "方法耗时(纳秒):" + (endTime - starTime));
                return result;
            }
        };
        IUserService serviceA =(IUserService)proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
        serviceA.insert("隔壁二牛");
    }
           

Proxy使用注意

1.jdk中的Proxy只能为接口生成代理类,如果你想给某个类创建代理类,那么Proxy是无能
为力的,此时需要我们用到下面要说的cglib了。

2.Proxy类中提供的几个常用的静态方法大家需要掌握

3.通过Proxy创建代理对象,当调用代理对象任意方法时候,会被InvocationHandler接
口中的invoke方法进行处理,这个接口内容是关
           

2.cglib代理

cglib是一个强大、高性能的字节码生成库底层封装了ASM,它用于在运行时扩展Java类和实现接口;本质上它是通过动态的生成一个子类去覆盖所要代理的类(非final修饰的类和方法)。Enhancer可能是CGLIB中最常用的一个类,和jdk中的Proxy不同的是,Enhancer既能够代理普通的class,也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用(包括从Object中继承的toString和hashCode方法)。Enhancer不能够拦截final方法,例如Object.getClass()方法,这是由于Java final方法语义决定的。基于同样的道理,Enhancer也不能对final类进行代理操作。

ASM优势

ASM 能够通过改造既有类,直接生成需要的代码。增强的代码是硬编码在新生成的类文件内部的,没有反射带来性能上的付出。同时,ASM 与 Proxy 编程不同,不需要为增强代码而新定义一个接口,生成的代码可以覆盖原来的类,或者是原始类的子类。它是一个普通的 Java 类而不是 proxy 类,甚至可以在应用程序的类框架中拥有自己的位置,派生自己的子类。

相比于其他流行的 Java 字节码操纵工具,ASM 更小更快。ASM 具有类似于 BCEL 或者 SERP 的功能,而只有 33k 大小,而后者分别有 350k 和 150k。同时,同样类转换的负载,如果 ASM 是 60% 的话,BCEL 需要 700%,而 SERP 需要 1100% 或者更多。

cglib组成结构

Spring系列:代理(jdk动态代理,cglib代理)
cglib常见的用法
1.拦截所有方法(MethodInterceptor)
2.拦截所有方法并返回固定值(FixedValue)
3.直接放行,不做任何操作(NoOp.INSTANCE)
5.不同的方法使用不同的拦截器(CallbackFilter)
6.对第五条的优化(CallbackHelper)
           

1.拦截所有方法(MethodInterceptor)

public class Service1 {
    public void m1() {
        System.out.println("我是m1方法");
    }

    public void m2() {
        System.out.println("我是m2方法");
    }
}
           
import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibTest {

    @Test
    public void test1() {
        //使用Enhancer来给某个类创建代理类,步骤
        //1.创建Enhancer对象
        Enhancer enhancer = new Enhancer();
        //2.通过setSuperclass来设置父类型,即需要给哪个类创建代理类
        enhancer.setSuperclass(Service1.class);
        /*3.设置回调,需实现org.springframework.cglib.proxy.Callback接口,
        此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor,也是一个接口,实现了Callback接口,
        当调用代理对象的任何方法的时候,都会被MethodInterceptor接口的invoke方法处理*/
        enhancer.setCallback(new MethodInterceptor() {
            /**
             * 代理对象方法拦截器
             * @param o 代理对象
             * @param method 被代理的类的方法,即Service1中的方法
             * @param objects 调用方法传递的参数
             * @param methodProxy 方法代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("调用方法:" + method);
                //可以调用MethodProxy的invokeSuper调用被代理类的方法
                Object result = methodProxy.invokeSuper(o, objects);
                return result;
            }
        });
        //4.获取代理对象,调用enhancer.create方法获取代理对象,这个方法返回的是Object类型的,所以需要强转一下
        Service1 proxy = (Service1) enhancer.create();
        //5.调用代理对象的方法
        proxy.m1();
        proxy.m2();
    }
}
           

上面代码中的注释很详细,列出了给指定的类创建代理的具体步骤,整个过程中主要用到了Enhancer类和MethodInterceptor接口。enhancer.setSuperclass用来设置代理类的父类,

即需要给哪个类创建代理类,此处是Service1enhancer.setCallback传递的是MethodInterceptor接口类型的参数,MethodInterceptor接口有个intercept方法,这个方法会拦截代理对象所有的方法调用。还有一个重点是

Object result = methodProxy.invokeSuper(o, objects);可以调用被代理类,也就是Service1类中的具体的方法,从方法名称的意思可以看出是调用父类,实际对某个类创建代理,cglib底层通过修改字节码的方式为Service1类创建了一个子类。

2.拦截所有方法并返回固定值(FixedValue)

@Test
    public void test3() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service1.class);
        // 创建的代理对象,调用其任意方法返回的都是"路人甲"。
        enhancer.setCallback(new FixedValue() {
            @Override
            public Object loadObject() throws Exception {
                return "路人甲";
            }
        });
        Service1proxy = (Service1) enhancer.create();
        System.out.println(proxy.m1());//@1
        System.out.println(proxy.m2()); //@2
        System.out.println(proxy.toString());//@3
    }
           

3.直接放行,不做任何操作(NoOp.INSTANCE)

@Test
    public void test6() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service1.class);
        // 不做任何处理,直接放行
        enhancer.setCallback(NoOp.INSTANCE);
        Service1proxy = (Service1) enhancer.create();
        System.out.println(proxy.m1());
        System.out.println(proxy.m2());
    }
           

5.不同的方法使用不同的拦截器(CallbackFilter)

public class Service4 {

    public void insert1() {
        System.out.println("我是insert1");
    }

    public void insert2() {
        System.out.println("我是insert2");
    }

    public String get1() {
        System.out.println("我是get1");
        return "get1";
    }

    public String get2() {
        System.out.println("我是get2");
        return "get2";
    }
}
           
/**
     * 需求,给这个类创建一个代理需要实现下面的功能:
     * 以insert开头的方法需要统计方法耗时
     * 以get开头的的方法直接返回固定字符串
     */
    @Test
    public void test4() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service4.class);
        //创建2个Callback
        Callback[] callbacks = {
                //下面这个用来拦截所有get开头的方法,返回固定值的
                new FixedValue() {
                    @Override
                    public Object loadObject() throws Exception {
                        return "EXECUTE METHOD";
                    }
                },//这个用来拦截所有insert开头的方法
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        long starTime = System.nanoTime();
                        Object result = methodProxy.invokeSuper(o, objects);
                        long endTime = System.nanoTime();
                        System.out.println(method + ",耗时(纳秒):" + (endTime - starTime));
                        return result;
                    }
                }
        };
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                return 0;
            }
        });
        //调用enhancer的setCallbacks传递Callback数组
        enhancer.setCallbacks(callbacks);
        /**
         * 设置过滤器CallbackFilter
         * CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
         * 返回的是callbacks数组的下标
         */
        enhancer.setCallbackFilter(new CallbackFilter() {
            @Override
            public int accept(Method method) {
                //获取当前调用的方法的名称
                String methodName = method.getName();
                /**
                 * 方法名称以insert开头,
                 * 返回callbacks中的第1个Callback对象来处理当前方法,
                 * 否则使用第二个Callback处理被调用的方法
                 */
                return methodName.startsWith("insert") ? 1 : 0;
            }
        });
        Service4 proxy = (Service4) enhancer.create();
        System.out.println("---------------");
        proxy.insert1();
        System.out.println("---------------");
        proxy.insert2();
        System.out.println("---------------");
        // proxy.get1();
        System.out.println(proxy.get1());
        // proxy.get2();
        System.out.println("---------------");
        System.out.println(proxy.get2());
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
           

6.对第五条的优化(CallbackHelper)

/**
     * cglib中有个CallbackHelper类,可以对案例5的代码进行有环,CallbackHelper类相当于对一些代码进行了封装,
     * 方便实现案例5的需求,实现如下:
     */
    @Test
    public void test5() {
        Enhancer enhancer = new Enhancer();
        //创建2个Callback
        Callback costTimeCallback = (MethodInterceptor) (Object o, Method method, Object[] objects, MethodProxy methodProxy) -> {
            long starTime = System.nanoTime();
            Object result = methodProxy.invokeSuper(o, objects);
            long endTime = System.nanoTime();
            System.out.println(method + ",耗时(纳秒):" + (endTime - starTime));
            return result;
        };
        //下面这个用来拦截所有get开头的方法,返回固定值的
        Callback fixdValueCallback = (FixedValue) () -> "EXECUTE METHOD";
        CallbackHelper callbackHelper = new CallbackHelper(Service4.class, null) {
            @Override
            protected Object getCallback(Method method) {
                return method.getName().startsWith("insert") ? costTimeCallback : fixdValueCallback;
            }
        };
        enhancer.setSuperclass(Service4.class);
        //调用enhancer的setCallbacks传递Callback数组
        enhancer.setCallbacks(callbackHelper.getCallbacks());
        /**
         * 设置CallbackFilter,用来判断某个方法具体走哪个Callback
         */
        enhancer.setCallbackFilter(callbackHelper);
        Service4 proxy = (Service4) enhancer.create();
        System.out.println("---------------");
        proxy.insert1();
        System.out.println("---------------");
        proxy.insert2();
        System.out.println("---------------");
        System.out.println(proxy.get1());
        System.out.println("---------------");
        System.out.println(proxy.get2());

    }
           

cglib实现通用的统计任意类方法耗时代理类

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CostTimeProxy implements MethodInterceptor {
    //目标对象
    private Object target;

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

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        long starTime = System.nanoTime();
        //调用被代理对象(即target)的方法,获取结果
        Object result = method.invoke(target, objects); //@1
        long endTime = System.nanoTime();
        System.out.println(method + ",耗时(纳秒):" + (endTime - starTime));
        return result;
    }

    /**
     * 创建任意类的代理对象
     *
     * @param target
     * @param <T>
     * @return
     */
    public static <T> T createProxy(T target) {
        CostTimeProxy costTimeProxy = new CostTimeProxy(target);
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(costTimeProxy);
        enhancer.setSuperclass(target.getClass());
        return (T) enhancer.create();
    }
}
           

用例:

@Test
public void test7() {
    //创建Service1代理
    Service1 service1 = CostTimeProxy.createProxy(new Service1());
    service1.m1();
}
           

CGLIB和Java动态代理的区别

1.Java动态代理只能够对接口进行代理,不能对普通的类进行代理(因为所有生成的代理类
的父类为Proxy,Java类继承机制不允许多重继承);CGLIB能够代理普通类;

2.Java动态代理使用Java原生的反射API进行操作,在生成类上比较高效;CGLIB使用ASM
框架直接对字节码进行操作,在类的执行过程中比较高效