学习AOP之认识一下Spring AOP

心碎之事

要说知道AOP这个词倒是很久很久以前了,但是直到今天我也不敢说非常的理解它,其中的各种概念即抽象又太拗口。 在几次面试中都被问及AOP,但是真的没有答上来,或者都在面上,这给面试官的感觉就是java基础不行。可见这还是挺重要的一个概念。

在看工作中也遇到了相关的问题,在RPC的一种实现机制里应用了AOP,结果各种类一直绕来绕去看着头都大了,这也就是没有对动态代理和aop有了解导致的。

所以要好好的去掌握它,否则吃亏的还是自己。

先从概念开始

面向侧面的程序设计(aspect-oriented programming,AOP,又译作面向方面的程序设计、观点导向编程、剖面导向程序设计)是计算机科学中的一个术语,指一种程序设计范型。该范型以一种称为侧面(aspect,又译作方面)的语言构造为基础,侧面是一种新的模块化机制,用来描述分散在对象、类或函数中的横切关注点(crosscutting concern)。——维基百科

不知道看完这段话你能理解AOP是个啥吗?并不能,最多知道AOP是一种规范。所以说要理解AOP最重要还是要从具体的实现入手,才能真正明白AOP到底是干啥子的。

那么AOP的核心是什么?

其实就是一种代码增强方式,可以实现动态的代理,在运行期完成;也有一些是静态的为对象增强,在编绎期间完成。说的白话一点就是在对象进行代码上的扩展增强,就是说原先可能只能跑10行代码,增强后就可以多跑些代码,而且这种增强是通过织入的方式完成,而不是直接修改目标对象的代码。

为此还是要先理解代理这个概念,可以更好的理解AOP,那么就从学习代理开始吧。

写个静态代理例子

//创建一个接口
public interface ISay {
    void say();
}

//接口的实现类(可以理解为业务类)
public class SayImpl implements ISay{

    @Override
    public void say() {
        System.out.print("我是5207.");
    }

}

//只说一个名字太单调了,需要多多拉票,创建一个代理类来增强一下

class StaticSayImplProxy implements ISay {
    private ISay target;
    
    public StaticSayImplProxy(ISay target) {
        this.target = target;
    }

    @Override
    public void say() {
        SayHello();
        this.target.say();
        ThumbUp();
    }
    
    void SayHello() {
        System.out.print("大家好:");
    }
    
    void ThumbUp() {
        System.out.print("希望大家多多点赞.");
    }
}


//调用代码
public class StaticProxy {
    public static void main(String[] args) {
        ISay aop = new SayImpl();
        ISay aopProxy = new StaticSayImplProxy(aop);
        aopProxy.say();
    }
}

代码很简单,静态代理代码中通过增加一个StaticSayImplProxy类来对原先的实现类进行增强。注意这里的增强很重要。也就是原本只会说一句“我是5207.”,通过代理的类后就完整了许多。

但是静态代理的缺点是,代理时必须知道其类型是,比如上面代码中就必须知道ISay这个接口,最终才能在代理类里才能调用:this.target.say()这样的代码。那么也就是说如果还有另外的IOtherSay接口也需要用这个代理类就没法使用了。

所以如果能把代理集中一个类中,只要将要代理的对象给这个类就能代理是不是比较方便,代码少写好多。

整成动态代理

办法当然是有的,JDK提供了一种动态代理的技术,可以动态的为接口创建代理对象,从而实现代理模式。那么接着上面的例子我们需要做成动态代理代码如下:

class DynamicProxyImpl implements InvocationHandler {
    private Object target;
    
    public DynamicProxyImpl(Object target) {
        this.target = target;
    }
    
    @SuppressWarnings("unchecked")
    public <T> T getObject() {
        return (T) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this
            );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        SayHello();
        Object result = method.invoke(target, args);
        ThumbUp();
        return result;
    }
    
    void SayHello() {
        System.out.print("大家好:");
    }
    
    void ThumbUp() {
        System.out.println("希望大家多多点赞.");
    }
}

这里可以发现DynamicProxyImpl类并没有指定具体代理的接口类型,而使用Object类型。这样就不用关心传入给这个代理类的具体对象了。所以说这个代理类的范围一下子就大了许多,只要是类似的增强功能都可以用这个代理类来完成。举个例子:

public interface IOtherSay {
    void applause();
}

public class OtherSayImpl implements IOtherSay {

    @Override
    public void applause() {
        System.out.print("大家鼓掌.");
    }

}

public static void main(String[] args) {
    IOtherSay oSay = new OtherSayImpl();
    DynamicProxyImpl oSayProxy = new DynamicProxyImpl(oSay);
    IOtherSay oSay2 = oSayProxy.getObject();
    oSay2.applause();
}

可以看到使用同一个代理类也可以代理IOtherSay接口派生的对象啦。

InvocationHandler接口 另外一点就是DynamicProxyImpl实现了InvocationHandler接口,这个接口是关键,其实应当是JDK代理对象时的一个调用处理程序,这应当是暴露给开发者的代码增强接口啦。InvocationHandler接口只有一个invoke方法,我们需要做的就是在这个方法中增加需要的增强代码。

Proxy工具类 对于getObject方法才是真正的代理对象生成的过程,可以看到最终是Proxy.newProxyInstance这个方法来完成代理对象生成并返回的。那么这里可以看看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);
    }
}

方法的三个参数中要注意interfaces和h

  • interfaces 是指的传入需要代理的接口列表,==这里有一点比较重要JDK的动态代理只能代理接口哦==。
  • h 另外一个h则是指调用处理程序,发现在上面的DynamicProxyImpl类就是一个调用处理程序的实现,这里的关键就是InvocationHandler。

接着看方法体中的代码主要是几个过程:

  1. 获取/创建代理类Class:Class<?> cl = getProxyClass0(loader, intfs);
  2. 获得代理Class的构造函数:final Constructor<?> cons = cl.getConstructor(constructorParams);
  3. 创建代理类的对象实例并返回:return cons.newInstance(new Object[]{h});

这里还有些反射相关的知识就不再说明了,但是有一个点比较好奇,就是最终代理对象是如何通过invoke把目标对象的方法代理的呢?

篇幅有点多就引用一篇吧JDK动态代理实现原理

其实大体意思是最终JDK会自动的为指定的接口生成代理对象,而这个生成的代理对象就和前面手写的动态代理方法类似,只不过生成的代理类调用的是InvocationHandler的invoke。jdk帮我们做了自动生成的过程,这样就可以在运行期生成代理类。

到此,最为重要的代理差不多说完了,这也就是AOP的奥秘所在。

Spring中的AOP

了解了代理后再来看AOP的相关概念还是理解不了,什么切面、连接点、通知、切入点之类的,所以说还是抛开吧,这样要轻松许多。相信大家看aop的时候肯定是看到了Advice这个东东吧?嗯,就从它入手吧。

在Spring中Advice下面这些类型:

  • Before Advice:在目标方法被调用前调用,涉及接口org.springframework.aop.MethodBeforeAdvice
  • After Advice:在目标方法被调用后调用,涉及接口为org.springframework.aop.AfterReturningAdvice
  • Throws Advice:目标方法抛出异常时调用,涉及接口org.springframework.aop.ThrowsAdvice
  • Around Advice:拦截对目标对象方法调用,涉及接口为org.aopalliance.intercept.MethodInterceptor
  • Introduction Advice:为拦截的目标增加方法,涉及的接口为org.springframework.aop.support.DelegatingIntroductionInterceptor

嗯,都是些啥意思?Berfore Advice可以理解为SayHello方法,那么ThumbUp就是After Advice,两个加一起就是Around Advice。对于Throws Advice是针对异常抛出时的增强。最后还有一个比较牛的就是Introduction Advice则是可以对即有的对象进行增加方法,这个貌似更强大点。

从这些描述可以总结出来和前面动态代理时有异曲同工之处,在Spring中其实就是利用了动态代理的技术,结合AOP的概念对代码提供了一种更友好的扩展方式。当然也可以说换了一个角度来理解代码。举个例子说,希望在现有系统中监控所有action的执行时间,就可以拦截所有的action,加一个Before Advice记录一下进入的时间,再加一个After Advice计算一下完成的时间。这样就不会对现有action代码做什么修改,非常优雅啊,这对于系统设计时会有非常有用。

进一步理解Spring AOP

为了能够更深入的理解Spring AOP,还是需要更深入的去阅读源代码。这里再以DynamicProxyImpl为例子,如果使用Spring如何实现它的功能呢?以Spring xml配置方式试一下吧。

  • 首先实现用于增强SayImpl的代码,这里使用环绕增强,和前面DynamicProxyImpl的效果一致。
package aop.demo;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class SayImplAroundAdvice implements MethodInterceptor{

    public Object invoke(MethodInvocation invocation) throws Throwable {
        SayHello();
        Object result = invocation.proceed();
        ThumbUp();
        return result;
    }
    
    void SayHello() {
        System.out.print("大家好:");
    }
    
    void ThumbUp() {
        System.out.println("希望大家多多点赞.");
    }
}
  • 使用Spring的配置文件声明对象和AOP代理,spring.xml如下:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 声明被代理的目标对象 -->
    <bean id="sayImpl" class="aop.demo.SayImpl"></bean>
    <!-- 声明用于增强的拦截器对象 -->
    <bean id="sayImplAroundAdvice" class="aop.demo.SayImplAroundAdvice"></bean>
    <!-- 声明代理对象 -->
    <bean id="sayProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="aop.demo.ISay"/>            <!-- 这个就是被代理的接口 -->
        <property name="target" ref="sayImpl"/>                        <!-- 这个就是被代理的对象 -->
        <property name="interceptorNames" value="sayImplAroundAdvice"/><!-- 这个就是代理的增强器 --> 
    </bean>
</beans>
  • 实现代理的访问
package aop.demo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {

    @SuppressWarnings("resource")
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("aop/demo/spring.xml");
        ISay say = (ISay)context.getBean("sayProxy");
        
        say.say();
    }

}

最后执行一下程序输出的结果是:

大家好:我是5207.希望大家多多点赞.

哎呀呀和前面的动态代理一致,效果达成。^_^

当然也可以通过代码方式完成上面的功能

package aop.demo;

import org.springframework.aop.framework.ProxyFactory;

public class ClientCode {

    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();     // 创建代理工厂
        proxyFactory.setTarget(new SayImpl());         // 射入目标类对象
        proxyFactory.addAdvice(new SayImplAroundAdvice());
        ISay say = (ISay) proxyFactory.getProxy();
        say.say();
    }

}

总结

写了一天才写到这里,只不过还是值得的。原来一直以为AOP就是动态代理,没想到自己错了,AOP是一种规范,而动态代理只是实现AOP的一种方式而已。

接下来继续研究spring aop,进一步学习ProxyFactoryBean和ProxyFactory。

引用与参考

AOP 那点事儿 Java之美[从菜鸟到高手演练]之JDK动态代理的实现及原理 JDK动态代理实现原理 Spring AOP代理详解

注:此文章为原创,欢迎转载,请在文章页面明显位置给出此文链接! http://www.cnblogs.com/5207

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏余林丰

Effective Java通俗理解(下)

第31条:用实例域代替序数   枚举类型有一个ordinal方法,它范围该常量的序数从0开始,不建议使用这个方法,因为这不能很好地对枚举进行维护,正确应该是利用...

2559
来自专栏函数式编程语言及工具

FunDA(12)- 示范:强类型数据源 - strong typed data sources

    FunDA设计的主要目的是解决FRM(Functional Relation Mapping)如Slick这样的批次型操作工具库数据源行间游动操作的缺失...

19810
来自专栏mini188

学习AOP之认识一下Spring AOP

心碎之事 要说知道AOP这个词倒是很久很久以前了,但是直到今天我也不敢说非常的理解它,其中的各种概念即抽象又太拗口。 在几次面试中都被问及AOP,但是真的没有...

20110
来自专栏逍遥剑客的游戏开发

C++的反射和序列化

1472
来自专栏JMCui

Swagger文档转Word 文档

GitHub 地址:https://github.com/JMCuixy/SwaggerToWord/tree/developer 一、前言     为什么会产...

6488
来自专栏Java技术栈

Java 面试题经典 77 问(含答案)!

1763
来自专栏C语言及其他语言

[每日一题]C语言程序设计教程(第三版)课后习题4.9

题目描述 输入一个华氏温度,要求输出摄氏温度。公式为 c=5(F-32)/9 输出要求有文字说明,取位2小数。 输入 一个华氏温度,浮点数 输出 摄氏温度,浮点...

2976
来自专栏大闲人柴毛毛

跟着柴毛毛学Spring(4)——面向切面编程![这里写图片描述](http://img.blog.csdn.net/20171031111402095)

面向切面编程简介 1. 什么是面向切面编程?   面向切面编程是Spring的第二大特性,它能将一个函数中非主体但有很必要的代码封装到一个单独的类中,在程序运行...

3236
来自专栏Crossin的编程教室

【编程课堂】有序字典 OrderedDict

编程课堂将和每周一坑一样,成为本教室公众号的一个长期固定栏目。每期讲解一个编程知识点,包括但不限于 Python 语法、模块介绍、编程小技巧等。用简短的篇幅,让...

3678
来自专栏项勇

笔记45 | 代码性能优化建议[转]

1346

扫码关注云+社区

领取腾讯云代金券