Spring中AspectJ的实现AOP（配置文件+注解）

AOP相关术语如下：

    1. Joinpoint(连接点)       -- 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点
    2. Pointcut(切入点)        -- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
    3. Advice(通知/增强)        -- 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
    4. Introduction(引介)      -- 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field
    5. Target(目标对象)         -- 代理的目标对象
    6. Weaving(织入)           -- 是指把增强应用到目标对象来创建新的代理对象的过程
    7. Proxy（代理）            -- 一个类被AOP织入增强后，就产生一个结果代理类
    8. Aspect(切面)            -- 是切入点和通知的结合，以后咱们自己来编写和配置的

切入点的表达式

原：<aop:before method="log" pointcut="execution(public void com.spring.demo08.UserDaoImpl.save())"/> 
简：<aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>
 //切入点表达式
1.execution()     固定的，必须写
2.public          可以忽略
3.void            返回值可以出现* 表示任意返回类型，但不能不写
4.可以使用*代替每层包名，不能不写，简写方式*..*方法，任意位置
5.*DaoImpl
6.方法save*()
7.方法参数：save*(..)任意参数

AOP的通知类型

1. 前置通知
        * 在目标类的方法执行之前执行。
        * 配置文件信息：<aop:after method="before" pointcut-ref="myPointcut3"/>
        * 应用：可以对方法的参数来做校验
    
    2. 最终通知
        * 在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行。
        * 在配置文件中编写具体的配置：<aop:after method="after" pointcut-ref="myPointcut3"/>
        * 应用：例如像释放资源
    
    3. 后置通知
        * 方法正常执行后的通知。        
        * 在配置文件中编写具体的配置：<aop:after-returning method="afterReturning" pointcut-ref="myPointcut2"/>
        * 应用：可以修改方法的返回值
    
    4. 异常抛出通知
        * 在抛出异常后通知
        * 在配置文件中编写具体的配置：<aop:after-throwing method="afterThorwing" pointcut-ref="myPointcut3"/>    
        * 应用：包装异常的信息
    
    5. 环绕通知
        * 方法的执行前后执行。
        * 在配置文件中编写具体的配置：<aop:around method="around" pointcut-ref="myPointcut2"/>
        * 要注意：目标的方法默认不执行，需要使用ProceedingJoinPoint对来让目标对象的方法执行。

XML方式实现

UserDao,UserDaoImol:

package com.spring.demo08;

public interface UserDao {
    public void save();
    public void update();
}

package com.spring.demo08;

public class UserDaoImpl implements UserDao{

    public void save() {
        System.out.println("保存数据库。。。");
    }
    public void update() {
        System.out.println("更新数据库。。。");
    }

}

切面类：

package com.spring.demo08;

/*
 * 切面类
 */
public class MyAspectXml {
    //通知（具体的增强）
    public void log() {
        System.err.println("日志记录。。。");
    }
}

配置文件配置AOP:

<?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 id="userDao" class="com.spring.demo08.UserDaoImpl"/>
    <!-- 配置切面类 -->
    <bean id="myAspectXml" class="com.spring.demo08.MyAspectXml"/>
    <!-- 配置AOP -->
    <aop:config>
        <!-- 配置切面类：切入点+通知 -->
        <aop:aspect ref="myAspectXml">
            <!-- 配置的前置通知，save方法执行前，增强方法会执行 -->
            <!-- 切入点的表达式 ：execution(public void com.spring.demo08.UserDaoImpl.save())-->
            <!-- 
                1.execution()     固定的，必须写
                2.public          可以忽略
                3.void            返回值可以出现* 表示任意返回类型，但不能不写
                4.可以使用*代替每层包名，不能不写，简写方式*..*方法，任意位置
                5.*DaoImpl
                6.方法save*()
                7.方法参数：save*(..)任意参数    
             -->
            <!-- <aop:before method="log" pointcut="execution(public void com.spring.demo08.UserDaoImpl.save())"/> -->
            <aop:before method="log" pointcut="execution(* *..*.*DaoImpl.save*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

测试：

package com.spring.demo08;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/*
 * 测试AOP功能
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAOP {
    
    @Resource(name="userDao")
    private UserDao userDao;
    
    @Test
    public void run() {
        userDao.save();
        userDao.update();
    }
}

运行结果：

 

AOP实现注解方式

UserDao,UserDaoImpl:

package com.spring.demo09;

public interface UserDao {
    public void save();
    public void update();
}

package com.spring.demo09;

public class UserDaoImpl implements UserDao{

    public void save() {
        System.out.println("保存数据库。。。");
    }
    public void update() {
        System.out.println("更新数据库。。。");
    }

}

切面类：

package com.spring.demo09;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/*
 * 注解的方式切面类
 */
@Aspect
public class MyAspectAnno {
    /**
     * 切入点：@Before前置通知
     */
    @Before(value="execution(* *..*.*DaoImpl.save*(..))")
    public void log() {
        System.err.println("日志记录。。。");
    }
}

配置：

<?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">
    
        <!-- 开启自动代理 -->
        <aop:aspectj-autoproxy />
        <!-- 配置目标对象 -->
        <bean id="userDao" class="com.spring.demo09.UserDaoImpl"/>
        <!-- 配置切面类 -->
        <bean id="myAspectAnno" class="com.spring.demo09.MyAspectAnno"/>

</beans>

测试：

package com.spring.demo09;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/*
 * 测试AOP功能
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAOP {
    
    @Resource(name="userDao")
    private UserDao userDao;
    
    @Test
    public void run() {
        userDao.save();
        userDao.update();
    }
}

运行结果：

通知类型+自定义切入点：

通知类型：

* @Before            -- 前置通知
* @AfterReturing     -- 后置通知
* @Around            -- 环绕通知
* @After             -- 最终通知
* @AfterThrowing     -- 异常抛出通知

package com.spring.demo09;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/*
 * 注解的方式切面类
 */
@Aspect
public class MyAspectAnno {
    /**
     * 切入点：@Before前置通知
     */
    @Before(value="MyAspectAnno.fn()")
    public void log() {
        System.err.println("日志记录。。。");
    }
    @After(value="MyAspectAnno.fn()")
    public void after() {
        System.err.println("最终通知。。。");
    }
    @Around(value="MyAspectAnno.fn()")
    public void around(ProceedingJoinPoint joinPoint) {
        System.out.println("环绕通知1。。。。");
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("环绕通知2。。。。");
    }
    
    //自定义切入点
    @Pointcut(value="execution(* *..*.*DaoImpl.save*(..))")
    public void fn() {}
}

运行结果：