概念
代理,概念并不陌生,因为在日常生活中就有鲜明的例子。比如销售中间商,我们可能无法直接联系造产品的厂家,只能找到中间商,我们就一样可以拿到我们需要的产品,这个中间商本质上就是个代理。返回来,程序中的代理模式,其实就是现实中的写照。代理的定义,就是为一个对象提供一种代理以控制对这个对象的访问。
分类
- 静态代理
静态代理,就是编译之前就已经写好的代理类;- 动态代理
动态代理,就是运行时通过反射的机制动态的创建的代理类;
动态代理分类
动态代理分为两类,JDK动态代理和CGLIB动态代理,使用场景:
- JDK动态代理
被代理的目标类至少实现了一个接口;- CGLIB动态代理
被代理的类没有实现接口,当然实现了接口的场合也可以;
JDK动态代理
下面将以一个小的示例来说明JDK动态代理的整个过程,示例如下:
步骤一,创建目标接口,即被代理的接口
package com.silence.spring.proxy.jdk.bussiness;
public interface TargetInterface {
void methodA();
}
步骤二,创建目标类,即被代理的接口的实现类
package com.silence.spring.proxy.jdk.bussiness.impl;
import com.silence.spring.proxy.jdk.bussiness.TargetInterface;
public class TargetImpl implements TargetInterface {
public void methodA() {
System.out.println("invoke methodA");
}
}
步骤三,创建代理处理器类
package com.silence.spring.proxy.jdk.handler;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyInvokeHandler implements InvocationHandler {
private Object target;
public ProxyInvokeHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("start invoke");
Object obj = method.invoke(target, args);
System.out.println("finish invoke");
return obj;
}
}
步骤四,创建测试类
package com.silence.spring.proxy.jdk.test;
import com.silence.spring.proxy.jdk.bussiness.TargetInterface;
import com.silence.spring.proxy.jdk.bussiness.impl.TargetImpl;
import com.silence.spring.proxy.jdk.handler.ProxyInvokeHandler;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
//创建一个被代理对象的实例,作为代理类调用时的具体对象
TargetImpl target = new TargetImpl();
//创建代理处理器对象的实例
InvocationHandler invokeHandler = new ProxyInvokeHandler(target);
//动态生成了一个代理类,代理类也同样实现了被代理的接口
TargetInterface targetInterface = (TargetInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), invokeHandler);
//调用接口的方法,等同于调用代理类对应的方法
targetInterface.methodA();
}
}
步骤五,输出测试结果,证实代理成功
start invoke
invoke methodA
finish invoke
CGLIB动态代理
下面将以一个小的示例来说明CGLIB动态代理的整个过程,示例如下:
步骤一,创建目标类,即被代理的类
package com.silence.spring.proxy.cglib.bussiness;
public class CglibTargetImpl {
public void methodA() {
System.out.println("invoke method");
}
}
创建代理处理器类
package com.silence.spring.proxy.cglib.handler;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;
public class ProxyHandler implements MethodInterceptor {
private static ConcurrentHashMap<Class, Object> map = new ConcurrentHashMap<Class, Object>();
public static <T> T getProxy(Class<T> clazz) {
if (!map.containsKey(clazz)) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(new ProxyHandler());
map.putIfAbsent(clazz, enhancer.create());
}
return (T) map.get(clazz);
}
public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("start invoke");
//这里一定要调用invokeSuper,否则会出现死循环,死循环原因是处理器类回调了自己
Object result = methodProxy.invokeSuper(obj, objects);
System.out.println("finish invoke");
return result;
}
}
步骤三,创建测试类
package com.silence.spring.proxy.cglib.test;
import com.silence.spring.proxy.cglib.bussiness.CglibTargetImpl;
import com.silence.spring.proxy.cglib.handler.ProxyHandler;
public class Test {
public static void main(String[] args) {
CglibTargetImpl cglibTarget = ProxyHandler.getProxy(CglibTargetImpl.class);
cglibTarget.methodA();
}
}
步骤四,输出测试结果,证实代理成功
start invoke
invoke methodA
finish invoke
总结
JDK动态代理与CGLIB动态代理区别:
1.目标:JDK动态代理针对的目标是接口,而CGLIB动态代理针对的目标是实现类;
2.实现方式:JDK动态代理采用目标类与代理类实现相同接口的方式,而CGLIB动态代理采用目标类与代理类继承相同父类的方式;