概述
上篇文章《Java反射——Class和ClassLoader 》，我们简单介绍了反射的基本概念及相关类。这里介绍下，反射的一个主要应用——动态代理。
动态代理
动态代理的实现，两种方式：JDK动态代理和CGLIB动态代理。
步骤都基本相同，获得代理类，执行调用方法进行方法增强。
代理模式类图如下：
此处Proxy代理了具体的对象（RealSubject），如果我们想让这种代理关系更普适，就引出了动态代理，即Proxy可以代理很多的对象，具体代理哪个对象在运行时才能确定。
Java中实现了这种方式，即JDK动态代理。
JDK
只能代理接口。
Proxy：通用的生成代理对象类，创建参数为InvocationHandler。
public class JDKProxy implements InvocationHandler{
//需要代理的目标对象
private Object target;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("动态代理开始");
Object invoke = method.invoke(target, args);
System.out.println("动态代理结束");
return invoke;
}
/**
* 获取代理对象
* @param targetObject 目标对象
* @return
*/
private Object getJDKProxy(Object targetObject){
this.target=targetObject;
//JDK动态代理，只能针对实现了接口的类进行代理。
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this);
}
public static void main(String[] args) {
JDKProxy jdkProxy=new JDKProxy();
//获取代理对象
AgencyService agencyService=(AgencyService)jdkProxy.getJDKProxy(new AgencyServiceImpl());
//执行代理对象的方法
agencyService.queryAgency(new AgencyInfo());
}
}
CGLIB
可以代理类。
import com.family.model.AgencyInfo;
import com.family.service.AgencyService;
import com.family.service.impl.AgencyServiceImpl;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @author
* @description
* @date Created in 下午6:42 2019/7/25
*/
public class CGLIBProxy implements MethodInterceptor {
private Object target;
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("CGLIB动态代理，开始");
Object invoke=method.invoke(target,objects);
System.out.println("CGLIB动态代理，结束");
return invoke;
}
/**
* 定义获取代理对象的方法
* @param targetObject
* @return
*/
public Object getCglibProxy(Object targetObject){
this.target=targetObject;
//设置父类
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(targetObject.getClass());
//设置回调
enhancer.setCallback(this);
//创建并返回代理对象
Object result=enhancer.create();
return result;
}
public static void main(String[] args) {
CGLIBProxy cglibProxy=new CGLIBProxy();
//获取代理对象
AgencyService agencyService=(AgencyService)cglibProxy.getCglibProxy(new AgencyServiceImpl());
agencyService.queryAgency(new AgencyInfo());
}
}
API
1.Proxy
提供了创建动态代理类和示例的静态方法，也是所有动态代理类的超类。
针对接口创建代理类
动态代理类：（动态代理）类在被创建时，实现了一系列在运行时指定的接口。
代理接口：被代理类实现的接口。
代理实例：代理类的一个实例。
//根据传入的类加载器、代理的接口、invocationHandler返回动态代理类实例。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//克隆代理接口
final Class<?>[] intfs = interfaces.clone();
//校验代理类的访问权限
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//获得代理类
Class<?> cl = getProxyClass0(loader, intfs);
/*
* 调用指定invocation handler的构造器
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//获取代理类的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//调用构造方法，创建实例
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
2.InvocationHandler
作用：完成方法的拦截与代理。
当调用代理实例的方法时，下面的invoke()会被执行。
invoke()的参数说明：
proxy:代理实例
method：对应的接口方法
args：（在代理实例的方法调用中）传递的参数值的对象数组
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
3.MethodInterceptor
通用的回调，做拦截。
public interface MethodInterceptor
extends Callback
{
public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
MethodProxy proxy) throws Throwable;
}
4.Enhancer
生成代理子类。动态生成的子类，会重写超类的非final方法，并且会有回调的钩子来实现用户自定义的拦截。
public class Enhancer extends AbstractClassGenerator
{
//设置超类（生成类需要继承的类）
public void setSuperclass(Class superclass) {
if (superclass != null && superclass.isInterface()) {
setInterfaces(new Class[]{ superclass });
} else if (superclass != null && superclass.equals(Object.class)) {
// affects choice of ClassLoader
this.superclass = null;
} else {
this.superclass = superclass;
}
}
//设置回调
public void setCallback(final Callback callback) {
setCallbacks(new Callback[]{ callback });
}
public void setCallbacks(Callback[] callbacks) {
if (callbacks != null && callbacks.length == 0) {
throw new IllegalArgumentException("Array cannot be empty");
}
this.callbacks = callbacks;
}
//获取/生成一个类
public Object create() {
classOnly = false;
argumentTypes = null;
return createHelper();
}
private Object createHelper() {
preValidate();
Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
ReflectUtils.getNames(interfaces),
filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
callbackTypes,
useFactory,
interceptDuringConstruction,
serialVersionUID);
this.currentKey = key;
Object result = super.create(key);
return result;
}
}
super.create(key)即AbstractClassGenerator中的create()
protected Object create(Object key) {
try {
ClassLoader loader = getClassLoader();
Map<ClassLoader, ClassLoaderData> cache = CACHE;
ClassLoaderData data = cache.get(loader);
if (data == null) {
synchronized (AbstractClassGenerator.class) {
cache = CACHE;
data = cache.get(loader);
if (data == null) {
Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
data = new ClassLoaderData(loader);
newCache.put(loader, data);
CACHE = newCache;
}
}
}
this.key = key;
Object obj = data.get(this, getUseCache());
if (obj instanceof Class) {
return firstInstance((Class) obj);
}
return nextInstance(obj);
} catch (RuntimeException e) {
throw e;
} catch (Error e) {
throw e;
} catch (Exception e) {
throw new CodeGenerationException(e);
}
}
小结
动态代理，可以动态的对指定方法进行增强。动态代理的两种实现方式：JDK动态代理和CGLIB动态代理。
JDK动态代理只可以为接口去完成操作，采用的是反射机制，无需引入其他jar包。
CGLIB对指定的目标生成一个子类，并覆盖其中方法实现增强，采用的是继承。
扫一扫
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
