aop 获取方法入参_AOP编程思想与动态代理

    开讲前大家需要清晰一点： AOP像OOP一样，只是一种编程范式，AOP并没有规定说，实现AOP协议的代码，要用什么方式去实现。只是希望借此文章让大家理解AOP编程思想，大家要在自己工作中学会融汇贯通，切记生搬硬套。

点击上方蓝字  数据0101  关注我们，更多技术干货!

下面直接上干货：

                        概念理解                           

面向切面编程(AOP是Aspect Oriented Program的首字母缩写) ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。但是人们也发现，在分散代码的同时，也增加了代码的重复性。什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。按面向对象的设计方法，我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的，但就是因为面向对象的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。也许有人会说，那好办啊，我们可以将这段代码写在一个独立的类独立的方法里，然后再在这两个类中调用。但是，这样一来，这两个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。那么，有没有什么办法，能让我们在需要的时候，随意地加入代码呢？这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。这样看来，AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了。从技术上来说，AOP基本上是通过代理机制实现的。

下面利用一点图解来理解上面这段话：

OOP思想：按步骤来进行编程与实现业务逻辑。

OOP + AOP 编程：按功能来实现各个子任务，通过任务从切面注入的方式完成自己想要的业务功能。

    图上可以直观明了的感觉到AOP切面的模式 在功能的实现上更专注，核心业务逻辑完全是与鉴权、日志等相关的任务独立分开。耦合性更低，代码更简洁，使用也是更加灵活。

                        AOP经典实现                        

下面给小伙伴们带来一个经典的AOP实现：

定义一个接口public interface HelloInterface {      void sayHello();}

##被代理类：(实现自己的主要业务逻辑就好)public class Hello implements HelloInterface{    @Override    public void sayHello() {        System.out.println("Hello zhanghao!");  }}

动态代理的实现：public class ProxyHandler implements InvocationHandler{    private Object object;    public ProxyHandler(Object object){        this.object = object;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("Before invoke "  + method.getName());        //此处就可以统一实现日志，鉴权等功能。        method.invoke(object, args);        System.out.println("After invoke " + method.getName());        return null;    }}

动态代理的执行public static void main(String[] args) {//保存打印的动态代理class文件，配置参数 System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");HelloInterface hello = new Hello();        InvocationHandler handler = new ProxyHandler(hello);        HelloInterface proxyHello =         (HelloInterface) Proxy.newProxyInstance(              hello.getClass().getClassLoader(),               hello.getClass().getInterfaces(),                handler);                       proxyHello.sayHello();    }    输出：    Before invoke sayHello    Hello zhanghao!    After invoke sayHello

                动态代理的实现方式总结              

1、实现 InvocationHandler 接口创建自己的调用处理器；

2、通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；

3、通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；

4、通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

5、通过设置系统参数sun.misc.ProxyGenerator.saveGeneratedFiles为tue，可以在项目中查看生成的字节码文件。

扫码关注我们，后续更多精彩

                        相关源码解析                      

首先是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);        }         //生成代理类对象   **关键方法。        Class> cl = getProxyClass0(loader, intfs);        //使用指定的调用处理程序获取代理类的构造函数对象        try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }            final Constructor> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            //如果Class作用域为私有，通过 setAccessible 支持访问            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction() {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            //获取Proxy Class构造函数，创建Proxy代理实例。            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);        }    }

然后是动态代理字节码实现工厂类：

 private static final class ProxyClassFactory        implements BiFunction[], Class>>{        // 代理类的名字的前缀统一为“$Proxy”        private static final String proxyClassNamePrefix = "$Proxy";        // 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2        private static final AtomicLong nextUniqueNumber = new AtomicLong();        @Override        public Class> apply(ClassLoader loader, Class>[] interfaces) {            Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);            for (Class> intf : interfaces) {                //验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同                Class> interfaceClass = null;                try {                    interfaceClass = Class.forName(intf.getName(), false, loader);                } catch (ClassNotFoundException e) {                }                if (interfaceClass != intf) {                    throw new IllegalArgumentException(                        intf + " is not visible from class loader");                }                //验证这个Class对象是不是接口                if (!interfaceClass.isInterface()) {                    throw new IllegalArgumentException(                        interfaceClass.getName() + " is not an interface");                }                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {                    throw new IllegalArgumentException(                        "repeated interface: " + interfaceClass.getName());                }            }            String proxyPkg = null;     // package to define proxy class in            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;            /*             * Record the package of a non-public proxy interface so that the             * proxy class will be defined in the same package.  Verify that             * all non-public proxy interfaces are in the same package.             */            for (Class> intf : interfaces) {                int flags = intf.getModifiers();                if (!Modifier.isPublic(flags)) {                    accessFlags = Modifier.FINAL;                    String name = intf.getName();                    int n = name.lastIndexOf('.');                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));                    if (proxyPkg == null) {                        proxyPkg = pkg;                    } else if (!pkg.equals(proxyPkg)) {                        throw new IllegalArgumentException(                            "non-public interfaces from different packages");                    }                }            }            if (proxyPkg == null) {                // if no non-public proxy interfaces, use com.sun.proxy package                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }            /*             * Choose a name for the proxy class to generate.             */            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;            /*             *              * 生成指定代理类的字节码文件               * 关键，此方法中根据系统参数进行保存字节码文件             */            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);            try {                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                /*                 * A ClassFormatError here means that (barring bugs in the                 * proxy class generation code) there was some other                 * invalid aspect of the arguments supplied to the proxy                 * class creation (such as virtual machine limitations                 * exceeded).                 */                throw new IllegalArgumentException(e.toString());            }        }    }

扫码关注我们，后续更多精彩