转载来源(路人甲Java)

https://mp.weixin.qq.com/s/xvidIGCL4mIYfGni4pq9wQ

JDK动态代理

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

java.lang.reflect.Proxy
java.lang.reflect.InvocationHandler
jdk自带的代理使用上面有个限制,只能为接口创建代理类

java.lang.reflect.Proxy

这是jdk代理最主要的一个类,里面的一些静态方法会经常用到
1. getProxyClass方法
为指定的接口创建代理类,返回代理类的Class对象
public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
参数说明:
  • loader: 定义代理类的类加载器
  • interfaces:指定需要实现的接口列表,创建的代理默认会按顺序实现interfaces指定的接口
2. 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方法中;
3. isProxy方法
判断指定的类是否是一个代理类
public static boolean isProxyClass(Class<?> cl)
4. getInvocationHandler方法
获取代理对象的InvocationHandler对象

public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException

创建代理

1. 编写接口
public interface IService {
    void m1();
    void m2();
    void m3();
}
2. 编写实现类
public class ServiceA implements IService{
    @Override
    public void m1() {
        System.out.println("调用了ServiceA类的m1方法");
    }

    @Override
    public void m2() {
        System.out.println("调用了ServiceA类的m2方法");
    }

    @Override
    public void m3() {
        System.out.println("调用了ServiceA类的m3方法");
    }
}

public class ServiceB implements IService{
    @Override
    public void m1() {
        System.out.println("调用了ServiceB类的m1方法");
    }

    @Override
    public void m2() {
        System.out.println("调用了ServiceB类的m2方法");
    }

    @Override
    public void m3() {
        System.out.println("调用了ServiceB类的m3方法");
    }
}
3. 创建代理
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

@SuppressWarnings("all")
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);
        long endTime = System.nanoTime();
        System.out.println(this.target.getClass() + "."+ 
         method.getName() +"()方法耗时(纳秒):" + (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(targetInterface)){
            throw new IllegalStateException("target必须是targetInterface接口的实现类!");
        }
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), 
               target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
    }
}
上面主要是createProxy方法用来创建代理对象,2个参数:
  • target:目标对象,需要实现targetInterface接口
  • targetInterface:需要创建代理的接口
invoke方法中通过method.invoke(this.target, args)调用目标方法,然后统计方法的耗时
4. 测试用例
@Test
public void costTimeProxy() {
    IService serviceA = CostTimeInvocationHandler.
      createProxy(new ServiceA(), IService.class);
    IService serviceB = CostTimeInvocationHandler.
      createProxy(new ServiceB(), IService.class);
    serviceA.m1();
    serviceA.m2();
    serviceA.m3();

    serviceB.m1();
    serviceB.m2();
    serviceB.m3();
}
5. 运行输出
调用了ServiceA类的m1方法
class com.example.demo.proxy.impl.ServiceA.m1()方法耗时(纳秒):104700
调用了ServiceA类的m2方法
class com.example.demo.proxy.impl.ServiceA.m2()方法耗时(纳秒):91100
调用了ServiceA类的m3方法
class com.example.demo.proxy.impl.ServiceA.m3()方法耗时(纳秒):39900
调用了ServiceB类的m1方法
class com.example.demo.proxy.impl.ServiceB.m1()方法耗时(纳秒):97200
调用了ServiceB类的m2方法
class com.example.demo.proxy.impl.ServiceB.m2()方法耗时(纳秒):29900
调用了ServiceB类的m3方法
class com.example.demo.proxy.impl.ServiceB.m3()方法耗时(纳秒):21000

CGLIB动态代理

什么是cglib

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

案例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();
    }
}

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

当调用某个类的任何方法的时候,都希望返回一个固定的值,此时可以使用FixedValue接口
public class Service3 {
    public String m1() {
        System.out.println("我是m1方法");
        return "hello:m1";
    }

    public String m2() {
        System.out.println("我是m2方法");
        return "hello:m2";
    }
}
对应的测试用例
@Test
public void test3() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service3.class);
    enhancer.setCallback(new FixedValue() {
        @Override
        public Object loadObject() throws Exception {
            return "路人甲";
        }
    });
    Service3 proxy = (Service3) enhancer.create();
    System.out.println(proxy.m1());//@1
    System.out.println(proxy.m2()); //@2
    System.out.println(proxy.toString());//@3
}
@1、@2、@3调用了代理对象的3个方法,运行输出:
路人甲
路人甲
路人甲

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

Callback接口下面有个子接口org.springframework.cglib.proxy.NoOp,
将这个作为Callback的时候,被调用的方法会直接放行,像没有任何代理一样
@Test
public void test6() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Service3.class);
    enhancer.setCallback(NoOp.INSTANCE);
    Service3 proxy = (Service3) enhancer.create();
    System.out.println(proxy.m1());
    System.out.println(proxy.m2());
}

案例4:不同的方法使用不同的拦截器(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";
    }
}
1. 以insert开头的方法需要统计方法耗时
2. 以get开头的的方法直接返回固定字符串欢迎和【路人甲java】一起学spring!
@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) () -> "路人甲Java";
    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());

}
运行输出:
---------------
我是insert1
public void com.javacode2018.lesson001.demo17.Service4.insert1(),耗时(纳秒):9777500
---------------
我是insert2
public void com.javacode2018.lesson001.demo17.Service4.insert2(),耗时(纳秒):50600
---------------
路人甲Java
---------------
路人甲Java

案例5:实现通用的统计任意类方法耗时代理类

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();
    }
}
我们可以直接使用上面的静态方法createProxy来为目标对象target创建一个代理对象,被代理的对象自动实现方法调用耗时统计。
@1:调用被代理对象的方法获取真正的结果。
@Test
public void test7() {
    //创建Service1代理
    Service1 service1 = CostTimeProxy.createProxy(new Service1());
    service1.m1();

    //创建Service3代理
    Service3 service3 = CostTimeProxy.createProxy(new Service3());
    System.out.println(service3.m1());
}

CGLIB和Java动态代理的区别

1. Java动态代理只能够对接口进行代理,不能对普通的类进行代理(因为所有生成的代理类的父类为Proxy,Java类继承机制不允许多重继承);CGLIB能够代理普通类;
2. Java动态代理使用Java原生的反射API进行操作,在生成类上比较高效;CGLIB使用ASM框架直接对字节码进行操作,在类的执行过程中比较高效

Q.E.D.

知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议

那一年,我也变成了光!!