1、AOP concepts（AOP術語）

• Aspect/Advisors（切面）
  一個關注點的模塊化，這個關注點可能會橫切多個對象。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式來實現。

• Join point（連接點）
  在程序執行期間的一點。在Spring AOP中，連接點總是表示方法執行。

• Advice（通知）
  在切面的某個特定的連接點上執行的動作。許多AOP框架（包括Spring）都是以攔截器做通知模型，并維護一個以連接點為中心的攔截器鏈。

• Pointcut（切入點）
  查找連接點的條件。通知和一個切入點表達式關聯，并在滿足這個切入點的連接點上運行。

• Introduction（引入）
  給一個類型聲明額外的方法或屬性。Spring允許引入新的接口（以及一個對應的實現）到任何被代理的對象。

• Target object（目標對象）
  被一個或者多個切面所通知的對象。也被稱做被通知（advised）對象。 既然Spring AOP是通過運行時代理實現的，這個對象永遠是一個被代理（proxied）對象。

• AOP proxy
  AOP框架創建的對象，用來實現切面契約（例如通知方法執行等等）。在Spring中，AOP代理可以是JDK動態代理或者CGLIB代理。

• Weaving（織入）
  織入是一個過程，是將切面應用到目標對象從而創建出AOP代理對象的過程，織入可以在編譯期、類裝載期、運行期進行。

1.1 通知類型

• Before advice（前置通知）：在某連接點之前執行的通知，但這個通知不能阻止連接點之前的執行流程（除非它拋出一個異常）。

• After returning advice（后置通知）：在某連接點正常完成后執行的通知：例如，一個方法沒有拋出任何異常，正常返回。

• After throwing advice（異常通知）：在方法拋出異常退出時執行的通知。

• After (finally) advice（最終通知）：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。

• Around Advice（環繞通知）：包圍一個連接點的通知，如方法調用。這是最強大的一種通知類型。環繞通知可以在方法調用前后完成自定義的行為。它也會選擇是否繼續執行連接點或直接返回它自己的返回值或拋出異常來結束執行。

2、Spring AOP

1、Spring AOP使用純Java實現，它不需要專門的編譯過程。Spring AOP不需要控制類加載器層次結構，因此適用于Servlet容器或應用程序服務器。

2、Spring AOP目前僅支持方法執行連接點。

3、Spring實現AOP的方法跟其他的框架不同。Spring并不是要提供最完整的AOP實現（盡管Spring AOP有這個能力），相反的，它其實側重于提供一種AOP實現和Spring IoC容器之間的整合，用于幫助解決在企業級開發中的常見問題。

4、Spring AOP從來沒有打算通過提供一種全面的AOP解決方案來與AspectJ競爭。我們相信無論是基于代理（proxy-based）的框架如Spring AOP或者是成熟的框架如AspectJ都是很有價值的，他們之間應該是互補而不是競爭的關系。

2.1、Spring AOP基于XML的應用程序

1、Jar包依賴

<dependencies>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
    </dependency>
    </dependencies> 

2、定義切面和需要被攔截的對象

public class Student {

    private Integer age;
    private String name;

    public void setAge(Integer age) {
        this.age = age;
    }
    public Integer getAge() {
        System.out.println("Age : " + age );
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        System.out.println("Name : " + name );
        return name;
    }

    public void printThrowException(){
        System.out.println("Exception raised");
        throw new IllegalArgumentException();
    }
}

public class Logging {

    public void beforeAdvice(){
        System.out.println("beforeAdvice.");
    }

    public void afterAdvice(){
        System.out.println("afterAdvice");
    }

    public void afterReturningAdvice(Object retVal){
        System.out.println("afterReturningAdvice:" + retVal.toString() );
    }

    public void afterThrowingAdvice(IllegalArgumentException ex){
        System.out.println("afterThrowingAdvice: " + ex.toString());
    }

}

3、配置XML

    <aop:config>
        <aop:aspect id="log" ref="logging">
            <aop:pointcut id="all" expression="execution(* com.codersm.study.spring.aop.*.*(..))"/>
            <aop:before method="beforeAdvice" pointcut-ref="all"/>
            <aop:after method="afterAdvice" pointcut-ref="all"/>
            <aop:after-returning method="afterReturningAdvice" pointcut-ref="all" returning="retVal"/>
            <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="all" throwing="ex"/>
        </aop:aspect>
    </aop:config>

    <bean id="student" class="com.codersm.study.spring.aop.Student">
        <property name="name" value="zhangsan"/>
        <property name="age" value="21"/>
    </bean>

    <bean id="logging" class="com.codersm.study.spring.aop.Logging"/>

4、測試

ApplicationContext context = 
    new ClassPathXmlApplicationContext("classpath:spring-aop.xml");
    Student student = (Student) context.getBean("student");
    student.getAge();

2.3、Spring AOP基于@Aspect的應用程序

1、定義切面

@Aspect
@Component
public class LoggingAspect {

    /**
     * 單獨定義切入點，可復用
     */
    @Pointcut("execution(* com.codersm.study.spring.aop.*.*(..))")
    public void pointcut() {
    }

    @Before(value = "pointcut()")
    public void before() {
        System.out.println("Before advice");
    }


    @Around(value = "pointcut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around advice begin");
        Object ret = proceedingJoinPoint.proceed();
        System.out.println("Around advice end,execute method result is " + ret);
    }

    @After(value = "pointcut()")
    public void after() {
        System.out.println("After advice");
    }

    @AfterThrowing(value = "pointcut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        System.out.println("afterThrowing advice exception is " + ex);
    }

    @AfterReturning(value = "pointcut()", returning = "ret")
    public void AfterReturning(Object ret) {
        System.out.println("AfterReturning advice result is :" + ret);
    }
}

2、配置xml文件開啟@Aspect

 <context:component-scan base-package="com.codersm.study.spring.*"/>
 <aop:aspectj-autoproxy/>

3、測試

 ApplicationContext applicationContext = null;

    @Before
    public void before() {
        applicationContext = 
            new ClassPathXmlApplicationContext("classpath:spring-aop-annotation.xml");
    }

    @Test
    public void testAop() {
        Student student = (Student) applicationContext.getBean("student");
        student.setName("hello world");
        System.out.println("---------------------------------");
        student.printThrowException();
    }

2.4、 通知類型小結

3、獲取通知參數

• 任何通知聲明JoinPoint作為通知方法第一個參數，JoinPoint提供一些有用的方法。
  around advice is required to declare a first parameter of type ProceedingJoinPoint, which is a subclass of JoinPoint.

** ProceedingJoinPoint is only supported for around advice.**

• 傳遞參數給通知
  To make argument values available to the advice body, you can use the binding form of args.

@Before("execution(* com.codersm.study.spring.aop.*.*(..)) && args(name,..)")
public void before(String name) {
        System.out.println("Before advice,name = " + name);
}

另外一種定義方式：

@Pointcut("execution(* com.codersm.study.spring.aop.*.*(..))  && args(name,..)")
public void pointcut(String name) {
}
@Before(value = "pointcut(name)")
public void before(String name) {
       System.out.println("Before advice,name = " + name);
}

4、AOP proxies

4.1、 AOP介紹

Spring AOP使用JDK動態代理或CGLIB創建目標類的代理對象，如果目標類實現了至少一個接口，則使用JDK動態代理；否則，使用CGLIB代理。如果強制使用CGLIB代理，需要考慮這些問題：

• final methods cannot be advised, as they cannot be overridden.
• As of Spring 3.2, it is no longer necessary to add CGLIB to your project classpath, as CGLIB classes are repackaged under org.springframework and included directly in the spring-core JAR. This means that CGLIB-based proxy support 'just works' in the same way that JDK dynamic proxies always have.
• As of Spring 4.0, the constructor of your proxied object will NOT be called twice anymore since the CGLIB proxy instance will be created via Objenesis. Only if your JVM does not allow for constructor bypassing, you might see double invocations and corresponding debug log entries from Spring’s AOP support.

4.2、理解AOP代理

any method calls that it may make on itself, such as this.bar() or this.foo(), are going to be invoked against the this reference, and not the proxy. This has important implications. It means that self-invocation is not going to result in the advice associated with a method invocation getting a chance to execute.

solution

• refactor your code such that the self-invocation does not happen.
• You can (choke!) totally tie the logic within your class to Spring AOP by doing this

public class SimplePojo implements Pojo {

    public void foo() {
        // this works, but... gah!
        ((Pojo) AopContext.currentProxy()).bar();
    }

    public void bar() {
        // some logic...
    }
}

 public static void main(String[] args) {

        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.adddInterface(Pojo.class);
        factory.addAdvice(new RetryAdvice());
        factory.setExposeProxy(true);

        Pojo pojo = (Pojo) factory.getProxy();

        // this is a method call on the proxy!
        pojo.foo();
    }

5、AOP源碼分析

spring.handlers

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

public class AopNamespaceHandler extends NamespaceHandlerSupport {

    /**
     * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
     * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
     * and '{@code scoped-proxy}' tags.
     */
    @Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

}

ConfigBeanDefinitionParser.parse( )方法：

public BeanDefinition parse(Element element, ParserContext parserContext) {
        CompositeComponentDefinition compositeDef =
                new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
        parserContext.pushContainingComponent(compositeDef);

        configureAutoProxyCreator(parserContext, element);

        List<Element> childElts = DomUtils.getChildElements(element);
        for (Element elt: childElts) {
            String localName = parserContext.getDelegate().getLocalName(elt);
            if (POINTCUT.equals(localName)) {
                parsePointcut(elt, parserContext);
            }
            else if (ADVISOR.equals(localName)) {
                parseAdvisor(elt, parserContext);
            }
            else if (ASPECT.equals(localName)) {
                parseAspect(elt, parserContext);
            }
        }

        parserContext.popAndRegisterContainingComponent();
        return null;
    }

configureAutoProxyCreator(parserContext, element)

private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
        AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
    }

    public static void registerAspectJAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {

        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

Spring對XML文件解析

/**
     * Parse the elements at the root level in the document:
     * "import", "alias", "bean".
     * @param root the DOM root element of the document
     */
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root)) {
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
    }

AspectJAwareAdvisorAutoProxyCreator

AspectJAwareAdvisorAutoProxyCreator層次結構.png

public interface BeanPostProcessor {

    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

BeanPostProcessor接口定義回調方法，允許修改新的實例化Bean，例如檢查標記接口或用代理進行包裝。

• postProcessBeforeInitialization
  在任何bean初始化回調（如InitializingBean的afterPropertiesSet或自定義init方法）之前，將此BeanPostProcessor應用于給定的新bean實例。
• postProcessAfterInitialization
  在任何bean初始化回調之后，將此BeanPostProcessor應用于給定的新Bean實例（如InitializingBean的afterPropertiesSet或自定義init方法）。

ApplicationContext 會自動檢測由 BeanPostProcessor 接口的實現定義的 bean，注冊這些 bean 為后置處理器，然后通過在容器中創建 bean，在適當的時候調用它。

AspectJAwareAdvisorAutoProxyCreator這兩個方法的實現：

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

繼續跟蹤源碼，發現了createProxy方法：

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

createProxy方法

protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }

        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }

創建AopProxy代理對象，具體流程：

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

ObjenesisCglibAopProxy繼承CglibAopProxy。方法調用原理可以查看CglibAopProxy和JdkDynamicAopProxy。