Spring开发AOP

在软件业务中，AOP（Aspect Oriented Programming 的缩写）,意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续。是软件开发中的一个热点。也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型，利用AOP也可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。

不适用动态代理：

使用了动态代理：

耦合度大大降低，而且代理类还是spring帮我们创建好，动态产生的，不用自己去创建。动态代理就是编译器跑起来的时候才帮你去创建对象。

AOP需要导入的jar包：

bean context core expression基本的

aop 和aspect特有的

下面是依赖包：

E:\spring-framework_5.2.0-release\3.0.2\org.aopalliance\com.springsource.org.aopalliance\1.0.0\com.springsource.org.aopalliance-1.0.0.jar

E:\spring-framework_5.2.0-release\3.0.2\org.aspectj\com.springsource.org.aspectj.weaver\1.6.8.RELEASE\com.springsource.org.aspectj.weaver-1.6.8.RELEASE

E:\spring-framework_5.2.0-release\3.0.2\org.apache.commons\com.springsource.org.apache.commons.logging\1.1.1\com.springsource.org.apache.commons.logging-1.1.1

编写配置文件：E:\spring-framework_5.2.0-release\4.2.4\spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->


    <bean name="UserService" class="com.shop.target.UserService"/>
    <bean name="MyAdvice" class="com.shop.advice.MyAdvice"/>
    <aop:config>
        <aop:pointcut id="pc" expression="execution(public void com.shop.target.UserService.addUser())"/>
        <aop:aspect ref="MyAdvice">
            <aop:before method="before" pointcut-ref="pc"></aop:before>
            <aop:after method="after" pointcut-ref="pc"></aop:after>
        </aop:aspect>
    </aop:config>

</beans>

package com.shop.advice;

public class MyAdvice {
    public void before(){
        System.out.println("开启事务---before()...");
    }
    public void after(){
        System.out.println("提交事务---after()...");
    }
}


package com.shop.target;

public class UserService {
    public void addUser(){
        System.out.println("addUser()...");
    }
    public void updateUser(){
        System.out.println("updateUser()....");
    }
    public void deleteUser(){
        System.out.println("deleteUser()...");
    }
}

<!--
        切入点表达式其它写法
        void com.shop.target.UserService.addUser()//无修饰符特定返回值
        * com.shop.target.UserService.addUser()//无修饰符任意返回值
        void com.shop.target.UserService.*User()//User前面可以用任意的表示
        * com.shop.target.UserService.*User(..))//参数个数
         * com.shop.target.UserService.add*(..)
         com.shop.target..add*(..))//当前父包下的子包全部扫描到

        -->

通知的物种写法：

特别注意环绕通知的写法：

import com.shop.target.UserService;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {
    public void before(){
        System.out.println("开启事务---before()...");
    }
    public void after(){
        System.out.println("提交事务---after()...");
    }

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

    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知在之前执行了");
        Object object= (UserService) proceedingJoinPoint.proceed();
        System.out.println("环绕通知在之后执行了");
        return object;
    }
}

        <aop:pointcut id="pc" expression="execution(* com.shop.target..add*(..))"/>
        <aop:aspect ref="MyAdvice">
            <aop:before method="before" pointcut-ref="pc"></aop:before>
            <aop:after method="after" pointcut-ref="pc"></aop:after>
            <aop:after-returning method="after_returning" pointcut-ref="pc"/>
            <aop:after-throwing method="after_throwing" pointcut-ref="pc"/>
            <aop:around method="around" pointcut-ref="pc"/>
        </aop:aspect>