使用代理的目的:
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组成结构
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
框架直接对字节码进行操作,在类的执行过程中比较高效