SpringMVC干货系列：从零搭建SpringMVC+mybatis（四）：Spring两大核心之AOP学习

springMVC干货系列

前言

上一篇我们介绍了Spring的核心概念DI,DI有助与应用对象之间的解耦。今天我们就来介绍下另一个非常核心的概念，面向切面编程AOP。

正文

在软件开发中，散布于应用中多处的功能被称为横切关注点（cross-cutting concern）。通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的。比如：日志、声明式事物、安全和缓存。这些东西都不是我们平时写代码的核心功能，但许多地方都要用到。
把这些横切关注点与业务相分离正是面向切面编程（AOP）索要解决的问题。
简单的说就是把这些许多地方都要用到，但又不是核心业务的功能，单独剥离出来封装，通过配置指定要切入到指定的方法中去。

什么是面向切面编程

如上图所示，这就是横切关注点的概念，水平的是核心业务，这些切入的箭头就是我们的横切关注点。

横切关注点可以被模块化为特殊的类，这些类被称为切面（aspect）。这样做有两个好处：

  • 首先，现在每个关注点都集中于一个地方，而不是分割到多处代码中
  • 其次，服务模块更简洁，因为它们只包含主要关注点（或核心功能）的代码，而次要关注点的代码被转移到切面中了。

定义AOP术语

为了理解AOP，我们必须先了解AOP的相关术语，很简单不难:

通知（Advice）：
在AOP中，切面的工作被称为通知。通知定义了切面“是什么”以及“何时”使用。除了描述切面要完成的工作，通知还解决了何时执行这个工作的问题。
Spring切面可以应用5种类型的通知：

  • 前置通知（Before）：在目标方法被调用之前调用通知功能
  • 后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么
  • 返回通知（After-returning）：在目标方法成功执行之后调用通知
  • 异常通知（After-throwing）：在目标方法抛出异常后调用通知
  • 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为

连接点（Join point）：
连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加行为。

切点（Pointcut）:
如果说通知定义了切面“是什么”和“何时”的话，那么切点就定义了“何处”。比如我想把日志引入到某个具体的方法中，这个方法就是所谓的切点。

切面（Aspect）：
切面是通知和切点的结合。通知和切点共同定义了切面的全部内容———他是什么，在何时和何处完成其功能。

引入（Introduction）：
引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）。

织入(Weaving)：
把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:

  • 编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例如AspectJ的织入编译器
  • 类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码
  • 运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原理应该是使用了JDK的动态代理技术

Spring对AOP的支持

创建切入点来定义切面所织入的连接点是AOP框架的基本功能。
Spring提供了4种类型的AOP支持：

  • 基于代理的经典Spring AOP
  • 纯POJO切面
  • @AspectJ注解驱动的切面
  • 注入式AspectJ切面（使用与Spring各版本）

前三种都是Spring AOP实现的变体，Spring AOP构建在动态代理基础之上，因此，Spring对AOP的支持局限于方法拦截。
这里我不准备介绍经典Spring AOP，因为引入了简单的声明式AOP和基于直接的AOP后，Spring经典的AOP看起来就显得非常笨重和过于复杂。
对于新手入门来说，我们不需要知道这么多，在这里我也只介绍2,3两种方式，简单的说就是一个基于xml配置，一个基于注解。
下面就直接开始举两个例子分别来介绍下这两种AOP方式，我们就拿简单的日志来说明。

基于注解的方式

首先基于注解的方式需要引入这些包，对用的pom.xml如下： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.1.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.8</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.8</version>
</dependency>

我们还是举前面用到的UserController来说明，下面方法很简单，执行进入这个方法的时候会打印“进来了”信息，现在我打算给这个方法加日志，在执行该方法前打印“进来前”，在执行完方法后执行“进来后”。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.tengj.demo.controller;

@Controller
@RequestMapping(value="/test")
public class UserController {
    @Autowired
    UserService userService;
    
    @RequestMapping(value="/view",method = RequestMethod.GET)
    public String index(){
        userService.sayHello("tengj");
        return "index";
    }
}

servie层代码： 

1
2
3
4
package com.tengj.demo.service
public interface UserService {
    public void sayHello(String name);
}

servie实现类代码： 

1
2
3
4
5
6
7
8
package com.tengj.demo.service.impl;
@Service("userService")
public class UserServiceImpl implements UserService{
    @Override
    public void sayHello(String name) {
        System.out.println("hello，"+name);
    }
}

上面方法index()其实就是我们之前定义的切点，表示在哪里切入AOP。

如图所示，我们使用execution()指示器选择UserServiceImpl的sayHello方法。方法表达式以“*”号开始，表明了我们不关心方法返回值的类型。然后，我们指定了全限定类名和方法名。对于方法参数列表，我们使用两个点号（..）表明切点要选择任意的sayHello()方法，无论该方法的入参是什么。

接下来我们要定义个切面，也就是所谓的日志功能的类。 

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
package com.tengj.demo.aspect;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //注入依赖
@Aspect //该注解标示该类为切面类
public class LogAspect {
    @Pointcut("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
    public void logAop(){}

    @Before("logAop() && args(name)")
    public void logBefore(String name){
        System.out.println(name+"前置通知Before");
    }

    @AfterReturning("logAop()")
    public void logAfterReturning(){
        System.out.println("返回通知AfterReturning");
    }

    @After("logAop() && args(name)")
    public void logAfter(String name){
        System.out.println(name+"后置通知After");
    }

    @AfterThrowing("logAop()")
    public void logAfterThrow(){
        System.out.println("异常通知AfterThrowing");
    }
}

上面就是切面类的代码，很简单，这里用到了前面提的通知的几种类型。
这样就能实现切入功能了

1
2
@Pointcut("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
public void logAop(){}

这里的@Pointcut注解是为了定义切面内重用的切点，也就是说把公共的东西抽出来，定义了任意的方法名称logAop，这样下面用到的各种类型通知就只要写成

1
2
3
@Before("logAop() && args(name)")
@AfterReturning("logAop()")
@AfterThrowing("logAop()")

这样既可，否则就要写成

1
2
3
@Before("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
@AfterReturning("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
@AfterThrowing("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")

大家是否注意到了@Before("logAop() && args(name)")这里多出来个&& args(name),这个是用来传递参数的，定义只要跟sayHello参数名称一样就可以。

如果就此止步的话，LogAspect只会是Spring容器中的一个Bean,即便使用了AspectJ注解，但它并不会被视为切面，这些注解不会解析，也不会创建将其转换为切面的代理。

所以需要在XML里面配置一下，需要使用Spring aop命名空间中的<aop:aspectj-autoproxy/>元素，简单如下：

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
<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-4.1.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd"
       default-lazy-init="true">
    <context:component-scan base-package="com.tengj.demo"/>
    <mvc:resources location="/WEB-INF/pages/" mapping="/pages/**"/>
    <!-- 默认的注解映射的支持 -->
    <mvc:annotation-driven/>
    <!--启用AspectJ自动代理-->
    <aop:aspectj-autoproxy/>
    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

接着就可以启动工程，访问index这个方法，http://localhost:8080/SpringMVCMybatis/test/view
执行结果：

1
2
3
4
tengj前置通知Before
hello，tengj
tengj后置通知After
返回通知AfterReturning

根据前面学的我们知道，除了上面提到的通知外，还有一个更强大通知类型，就是环绕通知。可以自定义我们需要切入的位置，可以替代上面提到的所有通知。看例子：

1
2
3
4
5
6
7
8
9
10
11
@Around("logAop()")
public void logAround(ProceedingJoinPoint jp){
    try {
        System.out.println("自定义前置通知Before");
        jp.proceed();//将控制权交给被通知的方法，也就是执行sayHello方法
        System.out.println("自定义后置通知After");
    } catch (Throwable throwable) {
        System.out.println("异常处理~");
        throwable.printStackTrace();
    }
}

执行结果：

1
2
3
自定义前置通知Before
hello，tengj
自定义后置通知After

这里主要是通过ProceedingJoinPoint这个参数。其中里面的proceed()方法就是将控制权交给被通知的方法。如果你忘记调用这个方法，那么你的通知实际上会阻塞对被通知方法的调用。

有意思的是，你可以不调用proceed()方法，从而阻塞堆被通知方法的访问，与之类似，你也可以在通知中对它进行多次调用。要这样做的一个场景就是实现重试逻辑，也就是在被通知方法失败后，进行重复尝试。

基于XML配置的方式

这里介绍使用XML配置的方式来实现，在Spring的aop命名空间中，提供了多个元素用来在XML中声明切面。

AOP配置元素 用 途
<aop:advisor> 定义AOP通知器
<aop:after> 定义AOP后置通知（不管被通知的方法是否执行成功）
<aop:after-returning> 定义AOP返回通知
<aop:after-throwing> 定义AOP异常通知
<aop:around> 定义AOP环绕通知
<aop:aspect> 定义一个切面
<aop:aspectj-autoproxy> 启用@AspectJ注解驱动的切面
<aop:before> 定义一个AOP前置通知
<aop:config> 顶层的AOP配置元素，大多数的<aop:*>元素必须包含在<aop:config>元素内
<aop:declare-parents> 以透明的方式为被通知的对象引入额外的接口
<aop:pointcut> 定义一个切点

我们已经看过了<aop:aspectj-autoproxy/>元素，它能够自动代理AspectJ注解的通知类。aop命名空间的其他元素能够让我们直接在Spring配置中声明切面，而不需要使用注解。
所以，我们重新来看看一下这个LogAspect类，这次我们将它所有的AspectJ注解全部移除掉：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tengj.demo.aspect;

public class LogAspect {
    public void logBefore(String name){
        System.out.println(name+"前置通知Before");
    }

    public void logAfterReturning(String name){
        System.out.println("返回通知AfterReturning");
    }

    public void logAfter(String name){
        System.out.println(name+"后置通知After");
    }

    public void logAfterThrow(String name){
        System.out.println("异常通知AfterThrowing");
    }
}

然后在xml配置文件中使用Spring aop命名空间中的一些元素，详细基本配置参考上面注解方式中的xml配置，这里是贴出来关键的代码：

1
2
3
4
5
6
7
8
9
10
11
<bean id="logAspect" class="com.tengj.demo.aspect.LogAspect" />
<aop:config>
        <aop:aspect id="log"  ref="logAspect">
            <aop:pointcut id="logAop" expression="execution(* com.tengj.demo.service.impl.UserServiceImpl.sayHello(..)) and args(name)"/>
            <aop:before method="logBefore" pointcut-ref="logAop"/>
            <aop:after method="logAfter"  pointcut-ref="logAop"/>
            <aop:after-returning method="logAfterReturning"  pointcut-ref="logAop"/>
            <aop:after-throwing method="logAfterThrow" pointcut-ref="logAop"/>
            <!--<aop:around method="logAfterThrow"  pointcut-ref="logAop"/>-->
        </aop:aspect>
</aop:config>

配置也 很好理解

  • xml里面配置aop，都是放在<aop:config>里面
  • 然后使用<aop:aspect>一个切面，指向具体的bean类。
  • 使用<aop:pointcut>定义切点，基本跟注解的很像，其中要注意的是xml配置里面如果要带参数的，用的不再是&&，要使用and关键字才行（因为在XML中，“&”符号会被解析为实体的开始）
  • 然后就是使用各种通知标签了，简单。

执行效果如下：

1
tengj前置通知Before
hello，tengj
tengj后置通知After
返回通知AfterReturning

环绕通知也很简单，直接贴代码：
xml配置：

1
<aop:around method="logAround"  pointcut-ref="logAop"/>

切面方法：

1
2
3
4
5
6
7
8
9
10
public void logAround(ProceedingJoinPoint jp,String name){
    try {
        System.out.println(name+"自定义前置通知Before");
        jp.proceed();
        System.out.println(name+"自定义后置通知After");
    } catch (Throwable throwable) {
        System.out.println("异常处理~");
        throwable.printStackTrace();
    }
}

执行结果：

1
2
3
tengj自定义前置通知Before
hello，tengj
tengj自定义后置通知After

总结

Spring AOP是Spring学习中最关键的，我总结的这2种写法也是开发中最常用的。也不知道大家能不能理解~看得时候如果有不懂的地方可以提出来，我好修改一下，让更多的人理解并掌握AOP，希望对你有所帮助。

一直觉得自己写的不是技术，而是情怀，一篇篇文章是自己这一路走来的痕迹。靠专业技能的成功是最具可复制性的，希望我的这条路能让你少走弯路，希望我能帮你抹去知识的蒙尘，希望我能帮你理清知识的脉络，希望未来技术之巅上有你也有我。

博主弄了个java学习资源的公众号，学习资源超级多，视频，电子书，最新开发工具一个都不能少，已全部分享到百度云盘，求资源共享，打造一个学习方便，工作方便的java公众号，开源开源，有需求的可以关注~撒花

本文标题:SpringMVC干货系列：从零搭建SpringMVC+mybatis（四）：Spring两大核心之AOP学习

文章作者:Teng Jun

发布时间:2016-05-12, 10:01:56

最后更新:2017-03-18, 08:10:54

原始链接:http://tengj.top/2016/05/12/springmvc4aop/

许可协议: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 前言
  2. 2. 正文
    1. 2.1. 什么是面向切面编程
    2. 2.2. 定义AOP术语
    3. 2.3. Spring对AOP的支持
      1. 2.3.1. 基于注解的方式
      2. 2.3.2. 基于XML配置的方式
  3. 3. 总结
|