Spring-06 Xml和注解方式配置Aop

基本环境准备

导入依赖

<dependency>
  <groupId>org.aspectjgroupId>
  <artifactId>aspectjrtartifactId>
  <version>1.9.1version>
dependency>

<dependency>
  <groupId>org.aspectjgroupId>
  <artifactId>aspectjweaverartifactId>
  <version>1.9.6version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12

添加xml 新约束

在 spring 核心配置文件中添加 aop 约束

<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:context="http://www.springframework.org/schema/context"
	   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/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd">
	
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Spring的 五种通知类型

XML 方式配置AOP

根据五种通知类型 配置增强类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class SelectAdvice {

    public void before(JoinPoint joinPoint){
        System.out.println("前置");
        System.out.println("目标类是: "+ joinPoint.getTarget());
        System.out.println("被织入的目标类方法为: "+ joinPoint.getSignature().getName());
    }

    public void afterReturning(){
        System.out.println("后置(方法不出现异常时调用! )");
    }

    public void around(ProceedingJoinPoint pjp) {
        System.out.println("环绕前置");
        try {
            // ProceedingJoinPoint 是joinpoint 的子接口, 用于执行目标方法, 确定在环绕通知中的位置
            pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕后置");
    }

    public void exception(){
        System.out.println("异常通知");
    }

    public void after(){
        System.out.println("最终通知(类似于异常处理机制中的 finally)");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

xml配置

<bean id="select" class="cn.Select"/>

<bean id="selectAdvice" class="cn.SelectAdvice"/>


<aop:config>

    <aop:pointcut id="abc" expression="execution(* cn..*.*(..))"/>
    <aop:pointcut id="def" expression="execution(* cn..*.update*(..))"/>

    <aop:aspect ref="selectAdvice">
        <aop:before method="before" pointcut-ref="abc"/>
        <aop:after-returning method="afterReturning" pointcut-ref="abc"/>
        <aop:around method="around" pointcut-ref="abc"/>
        <aop:after-throwing method="exception" pointcut-ref="abc"/>
        <aop:after method="after" pointcut-ref="abc"/>
    aop:aspect>
aop:config>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

测试

public static void main(String[] args) {
    ClassPathXmlApplicationContext app =
            new ClassPathXmlApplicationContext("classpath:application_context.xml");
    Select select =
            (Select)app.getBean("select");
    select.select();

}
1
2
3
4
5
6
7
8

基于注解方式配置 AOP

核心配置文件扫描目标类和增强类所在包

<context:component-scan base-package="cn.aop"/>

<aop:aspectj-autoproxy/>
1
2
3
4

目标类添加注解

@Component
1

增强类配置(切面)

切入点表达式

// 声明增强类
@Aspect
@Component

@Pointcut("execution(* cn..*.select(..))")
    private void abc(){
    }

    @Pointcut("execution(* cn..*.update(..))")
    private void def(){
    }
1
2
3
4
5
6
7
8
9
10
11

其他注解

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class SelectAdvice {
    @Pointcut("execution(* cn..*.select(..))")
    private void abc(){
    }

    @Pointcut("execution(* cn..*.update(..))")
    private void def(){
    }

    @Before("abc()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置");
        System.out.println("目标类是: "+ joinPoint.getTarget());
        System.out.println("被织入的目标类方法为: "+ joinPoint.getSignature().getName());
    }

    @AfterReturning("abc()")
    public void afterReturning(){
        System.out.println("后置(方法不出现异常时调用! )");
    }

    @Around("abc()")
    public void around(ProceedingJoinPoint pjp) {
        System.out.println("环绕前置");
        try {
            // ProceedingJoinPoint 是joinpoint 的子接口, 用于执行目标方法, 确定在环绕通知中的位置
            pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕后置");
    }

    @AfterThrowing("abc()")
    public void exception(){
        System.out.println("异常通知");
    }
    @After("abc()")
    public void after(){
        System.out.println("最终通知(类似于异常处理机制中的 finally)");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations ={"classpath:application_context.xml"})
public class Test1 {

    @Autowired
    Select select;

    @Test
    public void aopTest(){
        select.add();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13