Spring-AOP的详解

最新推荐文章于 2023-12-22 17:30:31 发布

你的笑容灿烂了这个夏天

最新推荐文章于 2023-12-22 17:30:31 发布

阅读量111

点赞数 1

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/weixin_44823472/article/details/98080041

版权

SpringBoot 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

什么是AOP

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

在这里插入图片描述

AOP核心概念

提供声明式事务； 允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …

1、横切关注点

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

2、切面（aspect）

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

3、连接点（joinpoint）

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

4、切入点（pointcut）

对连接点进行拦截的定义

5、通知（advice）

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

6、目标对象

代理的目标对象

7、织入（weave）

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

8、引入（introduction）

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

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 aop 在不改变原有代码的情况下 , 去增加新的功能 .

Spring对AOP的支持

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：

1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了

2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

使用SpringAPI实现AOP

编写业务类

接口

package com.kuang.service;

public interface UserService {

    void add();
    void delete();
    void update();
    void query();

}

实现类

package com.kuang.service;

public class UserServiceImpl implements UserService {

    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }

}

定义日志增加类实现

package com.kuang.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    //method:要执行的目标对象的方法
    //objects：要被调用的方法的参数
    //o：目标对象
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"被执行了");
    }

}

package com.kuang.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {

    //returnValue ： 返回值
    //method : 被调用的方法
    //args ： 被调用的方法对象的参数
    //target : 被调用的目标对象
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+target.getClass().getName()
        +"的"+method.getName()+"方法"
        +"返回值"+returnValue);
    }

}

编写Spring核心配置文件

【导入约束】

<?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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>

    <!--注册日志类的bean-->
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--使用spring的aop切入
    1.导入约束：
        xmlns:aop="http://www.springframework.org/schema/aop"
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
    2.aop:config


    -->
    <aop:config>
        <!--切入点
        expression 表达式，表示要切入的位置
        语法：execution([类的修饰符] [类的全路径] [方法] [参数])
        -->
        <aop:pointcut id="pointcut" expression
                ="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--执行通知,增强-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>


</beans>

测试类

【需要导入aop的织入包】

https://mvnrepository.com/artifact/org.aspectj/aspectjweaver/1.8.9

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.9</version>
</dependency>

编写测试类

package com.kuang.service;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAopTest {
    @Test
    public void test(){

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) context.getBean("userService");
        /*
        问题：报错，没有aspectjweaver包
        使用aop需导入一个包
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
        问题：spring调用的是真实对象userService
        暗箱中： 动态的修改userService，在方法的前后或者其他通知的地方增加了我们的切入代码。
        我们就可以实现依旧调用原来的对象，产生增加新的业务的功能；
         */
        userService.add();

    }
  
}

总结

Spring的AOP就是将公共业务代码（日志，事务，安全…），和业务类（真实对象）结合起来，实现公共业务的重复利用，解耦，本质还是动态代理。

自定义类实现AOP

真实对象和之前的一样
自定一个Aop增强类：也就是所谓的切面

package com.kuang.diy;

public class Diy {

    public void before(){
        System.out.println("===================方法执行前===================");
    }

    public void after(){
        System.out.println("===================方法执行后===================");
    }

}

3 注入bean

<!--自定义的AOP增强类-->
<bean id="diy" class="com.kuang.diy.Diy"/>

4.使用aop进行增强

<!--编写aop配置文件-->
    <aop:config>

        <!--切面-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="diyPointCut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="diyPointCut"/>
            <aop:after method="after" pointcut-ref="diyPointCut"/>

        </aop:aspect>

    </aop:config>



</beans>

<?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对象-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>

    <!--自定义的AOP增强类-->
    <bean id="diy" class="com.kuang.diy.Diy"/>

    <!--编写aop配置文件-->
    <aop:config>

        <!--切面-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="diyPointCut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="diyPointCut"/>
            <aop:after method="after" pointcut-ref="diyPointCut"/>

        </aop:aspect>

    </aop:config>
    
</beans>

5.测试类

@Test
public void test2(){

    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    UserService userService = (UserService) context.getBean("userService");

    userService.add();

}

使用注解实现AOP

@before @after…

目标对象不变
编写增强的类,写注解
- 注意点:需要将类注解为切面
- 方法上就是,切入点,增强

package com.kuang.anno;

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;


//必须要写切面注解,否则就无法切入;
@Aspect
public class Anno {


    //切入点可以直接写到增强上面
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====================方法执行前=====================");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("=====================方法执行后=====================");
    }

    //环绕增加
    //切入点参数 : ProceedingJoinPoint
    //环绕增强本质:
    /*
    将目标对象作为参数传递进方法中,
    在方法执行的前后,增加一些操作,仅此而已
    但是可以拿到一些目标对象的东西;
     */

    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());//获得执行的切入点

        //执行目标方法
        Object proceed = jp.proceed();

        System.out.println("环绕后");
        System.out.println(proceed); //null

    }
    
}

配置文件

<?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对象-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>

    <!--注解实现AOP的类-->
    <bean id="anno" class="com.kuang.anno.Anno"/>
    <!--识别注解,自动代理-->
    <aop:aspectj-autoproxy/>


</beans>

测试类

@Test
public void test3(){

    ApplicationContext context = new ClassPathXmlApplicationContext("anno.xml");

    UserService userService = (UserService) context.getBean("userService");

    userService.add();

}

AOP小结

本质就是动态代理
需要到一个包,用来进行aop织入的包: aspectjweaver
注意别遗漏了切面;
三种实现AOP的方法
- 使用SpringAPI来实现AOP
- 使用自定义类来实现AOP
- 使用注解实现AOP

你的笑容灿烂了这个夏天

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring-AOP的详解

什么是AOPAOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与...
复制链接

扫一扫

专栏目录