Java动态代理浅析

定义：

在学习Spring AOP的时候都知道，它的实现机制是由动态代理和字节码生成技术实现的，动态代理和字节码生成技术是在运行期间为目标对象生成一个代理对象而将横切逻辑织入到这个代理对象中。
动态代理： Java动态代理是写一个类实现InvocationHandler接口，重写invoke方法，在invoke方法中可以进行增强处理的逻辑编写，这个公共代理类在运行的时候才能明白自己要代理的对象，同时可以实现该被代理类的方法的实现，然后在实现类方法的时候可以进行增强处理
实际上： 代理对象的方法 = 被代理对象的方法 + 增强处理

代理入口：

在JDK的Java.lang.reflect包下有个Proxy类，它正是构造代理类的入口，JDK代理都是通过该类来创造代理对象的。
该类方法如下

第一个方法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);
        }
    }

这个方法需要三个参数：

• ClassLoader，用于加载被代理类的Load类，通常这个Loader类和被代理的类是同一个Loader类
• Interfaces，是要被代理的接口
• InvocationHandler，用于执行除了被代理接口方法之外的用户自定义的操作，它也是用户需要代理的最终目的

用户调用目标方法都被代理在InvocationHandler类中唯一定义的方法invoke()中。

代码实现：

先创建一个接口，随便定义一个方法

public interface ProInteferce {
      
	public void biubiu();
}

实现了接口的类：

public class ProImpl implements ProInteferce{

	@Override
	public void biubiu() {
		System.out.println("我是被代理的方法，biubiubiu");
	}

}

一个执行代理接口中方法之外的自定义方法的类：

//必须通过继承InvocationHandler接口来实现
public class ProHandler implements InvocationHandler {
     
	Object obj;
	
	public ProHandler(Object obj) {
		this.obj = obj;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("代理方法执行前执行的操作");
		Object result = method.invoke(obj, args);
		System.out.println("代理方法执行后执行的操作");
		return result;
	}

}

测试类：

public class ProxyTest {
     
	public static void main(String[] args) {
		ProInteferce pt = new ProImpl();
		ProHandler proxy = new ProHandler(pt);  //把目标对象传入执行类中
		//创建代理对象
		ProInteferce pif = (ProInteferce) Proxy.newProxyInstance(pt.getClass().getClassLoader(), pt.getClass().getInterfaces(),proxy);
		pif.biubiu();
	}
	
}

实现结果：

代理方法执行前执行的操作
我是被代理的方法，biubiubiu
代理方法执行后执行的操作

所以我们可以看到目标方法的实现是放到InvocationHandler类中的invoke方法中实现的

JDK和CGLIB生成动态代理的区别：

• JDK动态代理只能针对实现了接口的代理类（实例化一个类）。此时代理对象和目标对象实现了相同的对象，目标对象作为代理对象中的一个属性，具体接口实现中，可以在调节目标对象相应方法前后加上其他业务处理逻辑。
• CGLIB时针对类实现代理，主要是针对指定的类生成一个子类（没有实例化一个类），覆盖其中的方法。