Spring AOP

最新推荐文章于 2024-10-19 14:41:34 发布

右耳兔

最新推荐文章于 2024-10-19 14:41:34 发布

阅读量1.6k

点赞数 9

分类专栏： spring framework 文章标签： spring aop

本文链接：https://blog.csdn.net/fasbit/article/details/83823051

版权

spring framework 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring AOP

主要内容：

AOP是什么？
为什么需要AOP？
什么场景适用AOP？
AOP的几个核心概念
Spring AOP源码使如何实现的？
如何使用 Spring AOP？

1. AOP是什么？

AOP （Aspect-oriented Programming）面向切面编程。是OOP（Object-Oriented Programming）的一种补充。

OOP允许开发者定义纵向的关系，而不适用定义横向的关系。AOP很好地支持定义横向关系。

（图片来源：百度）

2. 为什么需要AOP？

在开发中，难免有一些特殊的需求：

我们定义了一个方法，并希望方法 1、方法 2、方法 3中都不显示调用该方法，且三个方法执行时，系统会自动执行方法4。

（图片来源：IBM developerWorks）

AOP很好地满足了上述需求。

3. 什么场景适用AOP？

AOP通常用来处理一些具有横切性质的系统级服务，比如事务管理、安全检查、缓存、对象池管理等。

Spring的事务管理就是基于AOP实现的。

4. AOP的几个核心概念

AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理。根据AOP代理类型分类如下：

静态代理（编译时增强——AspectJ）
动态代理（运行时增强——Spring AOP）

几个核心概念：

切面（Aspect）：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。
连接点（Joinpoint）：程序执行过程中的某一行为。
通知（Advice）：“切面”对于某个“连接点”所产生的动作。
切入点（Pointcut）：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。
目标对象（Target Object）：被一个或者多个切面所通知的对象。
AOP代理（AOP Proxy）在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。

通知（Advice）类型：

前置通知（Before advice）：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext中在<aop:aspect>里面使用<aop:before>元素进行声明。
后通知（After advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext中在<aop:aspect>里面使用<aop:after>元素进行声明。
返回后通知（After return advice）：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext中在<aop:aspect>里面使用<after-returning>元素进行声明。
环绕通知（Around advice）：包围一个连接点的通知，类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext中在<aop:aspect>里面使用<aop:around>元素进行声明。
抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。 ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素进行声明。

5. Spring AOP源码使如何实现的？

Spring AOP实现主要在bean加载和bean实例化过程做了一些操作：

加载Bean流程

加载过程中读取配置，根据配置选择AopNamespacehanler处理，解析类并生成Bean注册信息。注册到DefaultListableBeanFactory。

参阅文档

Bean实例化

实例化过程，判断是否有advice，如果有就创建代理。

创建代理过程，如果bean是接口或者类，使用JDK原生的Proxy创建；也可以通过配置使用CGLIB创建代理。

参阅文档

6. 如何使用 Spring AOP？

如何定义切面：

package com.andrewzhj.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * @author andrewzhj
 * @create 2018/11/2 16:18
 **/
@Aspect
@Component
public class LogAop {

    private static final Logger logger = LoggerFactory.getLogger(LogAop.class);

    /**
     * 定义切面
     */
    @Pointcut("execution(* com.andrewzhj.controller.Example.home())")
    public void log () {
        logger.info("Never print this, why??? ");
    }

    /**
     * 方法执行前执行
     * @param joinPoint
     */
    @Before("log()")
    public void doBefore(JoinPoint joinPoint) {
        logger.info("doBefore ... ");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        //URL
        logger.info("url={}", request.getRequestURI());
        //method
        logger.info("method={}", request.getMethod());
        //ip
        logger.info("ip={}",request.getRemoteAddr());
        //类方法
        logger.info("class={} and method name = {}", joinPoint.getSignature().getDeclaringTypeName(),joinPoint.getSignature().getName());
        //参数
        logger.info("参数={}", joinPoint.getArgs());
    }

    /*@Around("log()")
    public void doAround() {
        logger.info("do around ... ");
    }*/

    /**
     * 方法体完成前执行。先于抛异常和正常返回
     */
    @After("log()")
    public void doAfter() {
        logger.info("doAfter ... ");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        logger.info("url = {} end of execution", request.getRequestURL());
    }

    /**
     * 正常返回前执行
     * @param object
     */
    @AfterReturning(returning = "object", pointcut = "log()")
    public void doAfterReturn(Object object) {
        logger.info("do after returning ... ");
        logger.info("response={}",object.toString());
    }

    /**
     * 抛出异常后执行
     */
    @AfterThrowing(pointcut = "log()")
    public void doAfterThrowing() {
        logger.info("Throw Exception... ");
    }
}

上面定义了一个切面，

完整代码：https://github.com/Andrewzhj/spring-tutorial.git