Java代理模式
静态代理
代理类自己编写，在编译器已经确认了代理类。
实现步骤
1.定义接口及其实现类
public interface SayHelloService { void say(); } public class SayHelloServiceImpl implements SayHelloService { @Override public void say() { System.out.println("Hello Bitch"); } }
2.定义类代理对象
public class SayHelloServiceProxy implements SayHelloService { private SayHelloService target; public SayHelloServiceProxy(SayHelloService service) { this.target = service; } @Override public void say() { System.out.println("记录日志。。。。。。"); target.say(); System.out.println("清理数据。。。。。。"); } public static void main(String[] args) { SayHelloServiceProxy proxy = new SayHelloServiceProxy(new SayHelloServiceImpl()); proxy.say(); } }
代理类实现了目标对象的接口，对原有得接口做了扩展，其中所有的对象都是在编译期都确定好了。
缺点
需要代理对象实现目标对象的接口，假如目标对象方法很多或者需要代理多个对象，复杂度就会很高。
而动态代理不需要在编译期确定代理类，可以在运行时期动态生成，反射是动态代理的一种实现方式。
java中的动态代理
主要由以下两种方式实现：
JDK动态代理
JDK动态代理需要目标对象实现一个或多个接口，否则只能使用CGLIB实现动态代理。
实现步骤
1.定义目标类和公共接口
public interface UserService { void add(); } public class UserServiceImpl implements UserService { @Override public void add() { // TOD Auto-generated method stub System.out.println("-------add--------"); } }
2.定义调用处理器类，可以再运行时生成代理类，并带上一些增强的功能
java.lang.reflect.Proxy : 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即 DynamicProxyClas extends Proxy。
java.lang.reflect.InvocationHandler：调用处理类
public class MyInvocationHandler implements InvocationHandler { private Object target; public MyInvocationHandler(Object target) { super(); this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------begin " + method.getName() + "------"); Object result = method.invoke(target, args); System.out.println("------end " + method.getName() + "-------"); return result; } public Object getProxy() { return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this); } public static void main(String[] args) { UserService service = new UserServiceImpl(); MyInvocationHandler handler = new MyInvocationHandler(service); UserService proxy = (UserService) handler.getProxy(); proxy.add(); } }
原理解析
上面关键点在于Proxy.newProxyInstance() 方法创建了一个代理对象，查看他的源码，封装了创建代理类及对象的方法，如下：
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); } }
其中的getProxyClass0(loader, intfs)实际生成了代理类，这个代理类是动态代理的关键，因为是在运行时动态生成的，我们可以通过下面的方法将生成的文件显示出来，探探究竟
public static void main(String[] args) throws IOException { byte[] testProxies = ProxyGenerator.generateProxyClass("Proxy0", UserServiceImpl.class.getInterfaces()); String path = "E:/userProxies.class"; FileOutputStream fileOutputStream = new FileOutputStream(path); fileOutputStream.write(testProxies); fileOutputStream.flush(); fileOutputStream.close(); }
反编译生成的文件如下
public final class Proxy0 extends Proxy implements UserService { private static Method m1; private static Method m2; private static Method m3; private static Method m0; public Proxy0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void add() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m3 = Class.forName("org.example.proxy.inter.UserService").getMethod("add"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
分析：jdk动态生成了一个代理类，继承于Proxy,当我们调用add()方法时，将此方法当做参数传了进去，super.h.invoke(this, m3, (Object[])null)。 最终调用了InvocationHandler的invoke方法。
InvocationHandler的invoke：
public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { Class<?> caller = Reflection.getCallerClass(); checkAccess(caller, clazz, obj, modifiers); } } MethodAccessor ma = methodAccessor; // read volatile if (ma == null) { ma = acquireMethodAccessor(); } return ma.invoke(obj, args); }
通过反射，得到被代理对象的方法实现。
一整套下来，达到了代理的功能。
Cglib动态代理
Cglib 是一个强大的高性能的代码生成包，它可以在运行期扩展 Java 类与实现 Java接口。
public class CglibProxy implements MethodInterceptor { private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz) { //设置需要创建子类的类 enhancer.setSuperclass(clazz); enhancer.setCallback(this); //通过字节码技术动态创建子类实例 return enhancer.create(); } //实现 MethodInterceptor接口方法 @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("前置代理"); //通过代理类调用父类中的方法 Object result = methodProxy.invokeSuper(obj, args); System.out.println("后置代理"); return result; } public static void main(String[] args) { CglibProxy proxy = new CglibProxy(); //通过生成子类的方式创建代理类 UserServiceImpl proxyImp = (UserServiceImpl) proxy.getProxy(UserServiceImpl.class); proxyImp.add(); } }
二者区别
使用动态代理的对象必须实现一个或多个接口
使用 cglib 代理的对象则无需实现接口，达到代理类无侵入。
SpringAOP
主要由JDK动态代理和CGLIB动态代理实现
JDK 动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK 动态代理的核心是 InvocationHandler 接口和 Proxy 类。如果目标类没有实现接口，那么 Spring AOP 会选择使用 CGLIB 来动态代理目标类。
CGLIB（Code Genration Libray），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，CGLIB 是通过继承的方式做的动态代理，因此如果某个类被标记为 final，那么它是无法使用 CGLIB 做动态代理的。
