代理的实质就是代理类保存着实际目标类的引用对象。代理分为静态代理和动态代理
静态代理
定义一个目标类接口，并定义两个方法：
public interface ITarget {
void fun1();
String fun2(String s);
}
定义一个真实目标类并且实现ITarget接口
public class TargetObject implements ITarget{
@Override
public void fun1() {
System.out.println("执行方法fun1...");
}
@Override
public String fun2(String s) {
System.out.println("执行方法fun2..." + s);
return s;
}
}
定义一个代理类保存着ITarget的引用
public class TargetObjectProxy {
private ITarget target;
public TargetObjectProxy(ITarget target){
this.target = target;
}
//目标方法执行前
public void before(){
System.out.println("静态代理方法执行前...");
}
//目标方法执行后
public void after(){
System.out.println("静态代理方法执行后...");
}
public void fun1() {
before();
target.fun1();
after();
}
public String fun2(String s) {
before();
String result = target.fun2();
after();
return result;
}
}
上面直接调用TargetObjectProxy的方法即可完成静态代理，传统的三层架构就是使用静态代理实现的，Controller代理Service，Service代理Dao
但是当目标类新增方法，也要在代理类中添加相应的方法，不符合开闭原则
动态代理
动态代理实现有两种，分别是JDK动态代理和CGlib动态代理
JDK动态代理
JDK动态代理要求代理类实现InvocationHandler接口，并且重写invoke方法，使用反射生成代理类
使用
创建一个ObjectProxy类
public class ObjectProxy implements InvocationHandler {
//目标类
private Object target;
public ObjectProxy(Object target){
this.target = target;
}
//反射获取目标类的代理实例
public <T> T getInstance(){
Class<?> clazz = target.getClass();
return (T) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public void before(){
System.out.println("动态代理执行前...");
}
public void after(){
System.out.println("动态代理执行后...");
}
/**
* @param proxy 代理对象 $Proxy0
* @param method 当前执行方法
* @param args 方法参数
* @return 方法的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object o = method.invoke(target, args);
after();
return o;
}
}
测试
public class JDKProxyDemo {
public static void main(String[] args) throws IOException {
TargetObjectProxy proxy = new TargetObjectProxy(new TargetObject());
ITarget target = proxy.getInstance();
target.fun1();
System.out.println(target.fun2("hello"));
}
}
原理
JDK动态代理实际上是在代码运行期间动态生成代理类，编译加载到JVM中，这里主要关注Proxy.newProxyInstance方法
@CallerSensitive
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);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated 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);
}
}
上述代码：
Class<?> cl = getProxyClass0(loader, intfs);
生成了代理类的字节码对象，跟踪发现在Proxy.ProxyClassFactory中有个apply方法，该方法中
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
生成代理类的字节数组然后通过defineClass加载到JVM中
看一下generateProxyClass方法
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
//定义代理代码生成器
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
最后使用反射生成代理类的对象
CGlib动态代理
使用
定义代理类实现MethodIntercept接口实现intercept方法
public class CGlibProxy implements MethodInterceptor {
private Object target;
public <T> T getInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
target = clazz.newInstance();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return (T) enhancer.create();
}
public void before(){
System.out.println("CGlib动态代理方法执行前...");
}
public void after(){
System.out.println("CGlib动态代理方法执行后...");
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object o1 = methodProxy.invokeSuper(o, objects);
after();
return o1;
}
}
原理
CGlib动态代理实际上通过继承目标类实现的，是通过ASM生成class字节码
代理类调用方法时会被拦截器拦截，最终执行methodProxy.invokeSuper方法
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
init();
FastClassInfo fci = fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
}
catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
JDK动态代理和CGlib动态代理对比
1.JDK 动态代理是实现了被代理对象的接口，CGLib 是继承了被代理对象。
2.JDK 和 CGLib 都是在运行期生成字节码，JDK 是直接写 Class 字节码，CGLib 使用 ASM
框架写 Class 字节码，Cglib 代理实现更复杂，生成代理类比 JDK 效率低。
3.JDK 调用代理方法，是通过反射机制调用，CGLib 是通过 FastClass 机制直接调用方法，
CGLib 执行效率更高。
CGlib生成代理类效率低，执行效率高
