spring——（7）Spring中的AOP

最新推荐文章于 2024-11-10 21:05:45 发布
最新推荐文章于 2024-11-10 21:05:45 发布
阅读量205 收藏 1
点赞数
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shanshui911587154/article/details/79123177
版权

在java中oop是面向对象编程，这个从我们刚接触java的时候就知道了，今天我们要说的是aop面向切面的编程，其实关于aop的具体思想我也不能完整的表达出来，对于初学者来说只需要知道他是代理模式的一种实现。

AOP核心概念

1、横切关注点

对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

2、切面（aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象

3、连接点（joinpoint）

被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（pointcut）

对连接点进行拦截的定义

5、通知（advice）

所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象

代理的目标对象

7、织入（weave）

将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）

在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

对于程序员来说使用Spring AOP只需要关注下面几个点就可以了。

  1. 配置切面aspect
  2. 配置切入点pointcut
  3. 配置Advice

配置切面aspect

aspect就是定义在代理模式中添加到方法前或方法后的代码。
Spring中所有关于aop的配置都必须放在< aop:config>标签内

    <bean id="aBean" class=""></bean>
    <aop:config>
        <aop:aspect id="myAspect" ref="aBean">

        </aop:aspect>
    </aop:config>

上面的代码首先声明一个bean，然后在< aop:config>标签下声明< aop:aspect>标签，Id代表切面的名称，ref是这个切面引用的资源，也就是一个类（我们在上面声明过的bean），这个类里有需要在代理中添加的方法，现在说有一点抽象，看了后面的例子之后就能理解。

首先创建两个类：

public class AspectBiz {

}

public class MoocAspect {

}

然后在配置文件中添加：

<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">
        </aop:aspect>
    </aop:config>

</beans>

配置切入点Pointcut

切入点Pointcut其实就是一个过滤器，过滤需要代理的方法。具体的过滤规则有很多中，这里就不详细讲了，大家可以查看官方文档或者直接百度。
接着上面的例子，我们接着写：

<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">
            <aop:pointcut expression="execution( *com.mss.aop.AspectBiz.*(..))"
                id="moocPiontcut" />
        </aop:aspect>
    </aop:config>

</beans>

这里我们只是修改了一下配置文件添加了一个切入点，这个切入点代表（过滤）所有com.mss.aop.AspectBiz包下的方法。

配置Advice

当一个方法执行，Spring AOP 可以劫持一个执行的方法，在方法执行之前或之后添加额外的功能，Advice就是配置添加的功能的位置。
在Spring AOP中，有 5 种类型通知(advices)的支持：

  1. 通知(Advice)之前 - 方法执行前运行< aop:before />
  2. 通知(Advice)返回之后 – 方法执行后返回一个结果后运行< aop:after-returning />
  3. 通知(Advice)之后 – 该方法执行后运行< aop:after />（在aop:after-returning之后运行）
  4. 通知(Advice)抛出之后 – 运行方法抛出异常后< aop:after-throwing />
  5. 环绕通知 – 环绕方法执行运行，结合以上这三个通知< aop:around />
<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">
            <aop:pointcut expression="execution(* com.mss.aop.AspectBiz.*(..))"
                id="moocPiontcut" />
            //引用pointcut-ref
            <aop:before method="before" pointcut-ref="moocPiontcut" />
            //直接定义pointcut
            <aop:before method="before"
                pointcut="execution(* com.mss.aop.AspectBiz.*(..))" />
        </aop:aspect>
    </aop:config>

</beans>

配置Advice需要指定pointcut，我们可以引用上面声明的pointcut，或者直接在标签内定义一个pointcut。method是指定一个方法名，这个方法必须是在aspect中配置的类中的方法。由于我们使用的是

public class MoocAspect {
    //切面，也就是插入的代码
    public void before() {
        System.out.println("MoocAspect before.");
    }

}
public class AspectBiz {

    public void biz() {
        System.out.println("AspectBiz biz.");
    }

}

写个测试类测试一下：

@RunWith(BlockJUnit4ClassRunner.class)
public class TestOneInterface extends UnitTestBase{

    public TestOneInterface() {
        super("classpath*:spring-ioc.xml");
    }

    @Test
    public void test() {
        AspectBiz aspectBiz=super.getBean("aspectBiz");
        aspectBiz.biz();
    }
}

运行结果：

MoocAspect before.
AspectBiz biz.

可以看到，我们成功把before() 中的代码插入到 biz() 之中，并且在biz()之前运行。
上面我们使用了< aop:before />，其他通知的使用方法是一样的，大家可以自己去测试一下，但是环绕通知有点特殊，下面我们讲一讲环绕通知：
环绕通知就是其他四种通知的结合，环绕通知需要在切面方法中添加一个ProceedingJoinPoint类型的参数，并且在切面方法中添加一行代码，看下面的方法：

    public Object around(ProceedingJoinPoint pjp) {
        Object obj = null;
        try {
            System.out.println("MoocAspect around 1.");
            obj = pjp.proceed();
            System.out.println("MoocAspect around 2.");
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return obj;
    }

可以看到方法中有一个ProceedingJoinPoint 类型的参数，并且多了一行obj = pjp.proceed();这行代码就是调用业务方法，这下就清晰了，我们可以在调用业务方法之前、之后、抛出异常中添加代码。这个方法有一个返回值，这个返回值就是业务方法的返回值，最后我们需要把这个返回值返回，如果你愿意甚至可以返回一个与业务方法完全无关的返回值。下面我们直接上例子：
首先在配置文件中添加环绕通知：

<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">
            <aop:pointcut expression="execution(* com.mss.aop.AspectBiz.*(..))"
                id="moocPiontcut" />
            <aop:around method="around" pointcut-ref="moocPiontcut"/>
        </aop:aspect>
    </aop:config>

</beans>

修改MoocAspect中的代码：

public class MoocAspect {

    public Object around(ProceedingJoinPoint pjp) {
        Object obj = null;
        try {
            //方法运行前
            System.out.println("MoocAspect around 1.");
            obj = pjp.proceed();
            //方法运行后
            System.out.println("MoocAspect around 2.");
        } catch (Throwable e) {
            //方法抛出异常后
            System.out.println("MoocAspect afterThrowing.");
        }
        return obj;
    }

}

修改AspectBiz中的代码：

public class AspectBiz {

    public void biz() {
        System.out.println("AspectBiz biz.");
    }
}

测试代码：

@RunWith(BlockJUnit4ClassRunner.class)
public class TestOneInterface extends UnitTestBase{

    public TestOneInterface() {
        super("classpath*:spring-ioc.xml");
    }

    @Test
    public void test() {
        AspectBiz aspectBiz=super.getBean("aspectBiz");
        aspectBiz.biz();
    }
}

运行结果：

MoocAspect around 1.
AspectBiz biz.
MoocAspect around 2.

配置带参数的Advice

我们的业务方法大部分都是有参数的，如果想要在切面方法中使用这些方法怎么办呢？下面介绍一下带参数的Advice：
其实带参数和不带参数的Advice只是切入点Pointcut配置不一样，下面看一个例子：

<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">
            <aop:pointcut expression="execution(* com.mss.aop.AspectBiz.*(..))"
                id="moocPiontcut" />
            <aop:around method="aroundInit"
                pointcut="execution(* com.mss.aop.AspectBiz.init(String, int)) and args(bizName, times)" />
        </aop:aspect>
    </aop:config>

</beans>

可以看到我们在Advice内配置了单独的pointcut，这个pointcut指定了具体的方法，以及方法的参数类型。下面在看一下这个方法：

public class AspectBiz {

    public void init(String bizName, int times) {
        System.out.println("AspectBiz init : " + bizName + "   " + times);
    }

}

public class MoocAspect {

    public Object aroundInit(ProceedingJoinPoint pjp, String bizName, int times) {
        System.out.println(bizName + "   " + times);
        Object obj = null;
        try {
            System.out.println("MoocAspect aroundInit 1.");
            obj = pjp.proceed();
            System.out.println("MoocAspect aroundInit 2.");
        } catch (Throwable e) {
            System.out.println("MoocAspect afterThrowing.");
        }
        return obj;
    }

}

切面方法除了必须的ProceedingJoinPoint 类型的参数之外，还添加了业务方法中的两个参数。下面看一下测试方法：

@RunWith(BlockJUnit4ClassRunner.class)
public class TestOneInterface extends UnitTestBase{

    public TestOneInterface() {
        super("classpath*:spring-ioc.xml");
    }

    @Test
    public void test() {
        AspectBiz aspectBiz=super.getBean("aspectBiz");
        aspectBiz.init("mss", 1);
    }
}

运行结果：

mss   1
MoocAspect aroundInit 1.
AspectBiz init : mss   1
MoocAspect aroundInit 2.

introduction

一个完整的introduction配置：

            <aop:declare-parents types-matching=""
                implement-interface="" 
                default-impl="" />

关于introduction的意思，我举一个例子：

有个类叫小明（biz），小明隔壁住着老王（FitImpl），老王实现了一个技能叫开豪车（Fit）

现在上帝声明了一个切面，这个切面给小明指定一个新的爹叫老王，于是小明每次叫爸爸的时候就能开豪车了~

类匹配（小明）：type-matching

接口（开豪车）：implement-interface

接口的实现类（老王）：default-impl

introduction的作用：小明干自己的事的时候（叫爸爸）能莫名其妙地开上豪车而不用做多余的工作，这些工作由上帝（AOP）帮他完成，这叫“解耦”

例子：
创建一个接口以及一个接口实现类：

public interface Fit {

    void filter();

}
public class FitImpl implements Fit {

    public void filter() {
        System.out.println("FitImpl filter.");
    }

}

在配置文件中配置introduction：

<?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: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">

    <bean id="moocAspect" class="com.mss.aop.MoocAspect"></bean>

    <bean id="aspectBiz" class="com.mss.aop.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="moocAspectAOP" ref="moocAspect">

            <aop:declare-parents 
                //匹配所有com.mss.aop包下的类
                types-matching="com.mss.aop.*(+)"
                //定义的接口
                implement-interface="com.mss.aop.Fit" 
                //定义的接口实现类
                default-impl="com.mss.aop.FitImpl" />

        </aop:aspect>
    </aop:config>

</beans>

测试类（将上一节中的类强转）：

@RunWith(BlockJUnit4ClassRunner.class)
public class TestOneInterface extends UnitTestBase{

    public TestOneInterface() {
        super("classpath*:spring-ioc.xml");
    }

    @Test
    public void test() {
        Fit fit=(Fit)super.getBean("aspectBiz");
        fit.filter();
    }
}

运行结果：

FitImpl filter.

重点内容：所有基于配置文件的aspect只支持singleton

mashanshui
关注
专栏目录
细说Spring——AOP详解（AOP概览）
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring——AOP原理及流程详解
共勉
11-28 9735
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
Spring——Spring AOP原理
庄小焱
03-30 3027
AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑.AOP是Spring提供的关键特性之一，本文深入剖析Spring AOP的原理。
spring —— AOP（各类通知）
firstgrass的博客
07-23 655
前置通知（Before）返回通知（AfterReturning）异常通知（AfterThrowing）后置通知（After）环绕通知（Around）
Spring——AOP基本概念的理解
★★光亭★★
03-10 9615
Spring——AOP基本概念的理解
spring —— AOP（前置通知）
firstgrass的博客
07-23 736
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>6.0.2</version> </dependency> <dependency> <groupId>org.springframework</groupId
Spring——AOP的JDK动态代理
chenxingxingxing的博客
03-24 965
文章目录一、AOP的概念二、AOP术语三、JDK动态代理1、利用Proxy 类创建代理对象2、实现newProxyInstance方法 一、AOP的概念 AOP：全称是Aspect Oriented Programming，翻译过来就是面向切面编程，它是OOP（面向对象编程）的延伸。AOP技术能在运行期间动态代理实现程序统一的维护。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 作用场景：可以不修改源代码，对总体业务逻辑里面添加
Spring AOP——基于XML的AOP实现
m0_72151428的博客
09-29 1958
Spring AOP——基于XML的AOP实现
Spring——AOP面向切面编程&SpringAOP与AspectJ比较
娜娜米的博客
07-09 981
​最近跟着源码研究了下Spring使用三级缓存处理循环依赖的原理，里面涉及到Spring AOP的概念；本篇介绍AOP相关的知识点，AOP下的概念名词比较多，尽量使用通俗的概念来逐个解释，内容包括：对AOP（面向切面编程）的理解、AOP下的名词概念、Spring AOP与AspectJ的比较等；这部分知识对于学习Spring框架或者面试，都非常重要，需要掌握； ​...
Spring AOP——基于注解的AOP实现
m0_72151428的博客
10-01 4208
Spring AOP——基于注解的AOP实现
Spring——aop
12-23
在Spring配置文件中，需要启用AOP代理： ```xml <aop:aspectj-autoproxy /> ``` 或者在Spring Boot项目中，由于已经默认启用，无需额外配置。 ### 6. 总结 Spring AOP使得我们可以将关注点分离，提升代码的...
完爆面试官的Spring——AOP详解（AOP概览）
m0_68850571的博客
04-09 506
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 然后我们举一个比较容易理解
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3819
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
spring-security（记住密码，CSRF）
最新发布
2302_79087378的博客
11-10 245
PersistentTokenRepository实现类InMemoryTokenRepositoryImpl基于内存实现JdbcTokenRepositoryImpl基于数据库实现@Bean。
后端SpringBoot及vue proxyTable解决跨域
qq_42059717的博客
11-06 327
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 429
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
SpringBoot后端解决跨域问题
theLuckyLong的博客
11-10 59
【代码】SpringBoot后端解决跨域问题。
SpringBoot助力的共享汽车业务优化系统
2402_85762143的博客
11-09 915
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。任务：消除软件故障，保证程序的可靠运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值