SpringAOP超详解！！！！

最新推荐文章于 2024-07-29 14:22:26 发布

酱紫学Java

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量749

点赞数 2

本文链接：https://blog.csdn.net/qq_52519008/article/details/127217860

版权

文章目录

一、什么是SpringAOP
二、SpringAOP的应用场景
三、Aop在 Spring 中的作用
四、AOP的实现方式

一、什么是SpringAOP

SpringAOP的全称是（Aspect Oriented Programming）中文翻译过来是面向切面编程，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
了开发的效率。

个人理解：主要意思是我们的传统架构至上而下，后期想要从中间切入写代码添加功能，比如日志、权限、事务等，这时候我们就需要写使用代理模式写，SpringAOP就是专门把这一块写代码的地方给抽象了出来称为切面，从而解决的代码混乱的问题，它的底层实现也是基于==代理模式（动态代理）==完成的。
在这里插入图片描述

在这里插入图片描述

二、SpringAOP的应用场景

日志记录
权限验证（SpringSecurity有使用）
事务控制（调用方法前开启事务，调用方法后提交关闭事务）
效率检查（检测方法运行时间）
数据源代理（seata里面，获取到数据源连接执行的sql）
缓存优化（第一次调用查询数据库，将查询结果放入内存对象，第二次调用，直接从内存对象返回，不需要查询数据库）

三、Aop在 Spring 中的作用

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

横切关注点：跨越应用程序多个横块的方法或功能，即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等．
切面（ ASPECT )：横切关注点被模块化的特殊对象，即，它是一个类。
通知（ Advice )：切面必须要完成的工作，即，它是类中的一个方法。
目标（ Target )：被通知象·代理（ Proxy )：向目标对象应用通知之后创建的对象
切入点（ PointCut )：切面通知执行的"地点的定义
连接点（ JointPoint )：与切入点匹配的执行点

在这里插入图片描述

四、AOP的实现方式

使用AOP织入，需要导入一个依赖包

<dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>

1、方式一：使用原生Spring API接口

applicationContext.xml

<?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="service.UserServiceImpl"/>
    <bean id="log" class="log.Log"/>
    <bean id="afterLog" class="log.AfterLog"/>
    <!--配置aop：需要导入aop的约束-->
    <aop:config>
        <!--切入点:expression:表达式，execution(要执行的位置! * * * *)-->

        <aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*(..))"></aop:pointcut>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

UserService接口

package service;

public interface UserService {
 public void add();
 public void delete();
 public void update();
 public void select();
}

UserServiceImpl实现类(切入点)

package service;

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

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

    }

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

    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");

    }
}

前置通知

package log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

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

后置通知

package log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {

    //returnValue：返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法返回结果为："+ returnValue);
    }
}

测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;
import service.UserServiceImpl;

import java.lang.annotation.Annotation;

public class MyTest {
    public static void main(String[]  args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口
        UserService userService = (UserService) context.getBean("userService");
        userService.select();

    }
}

测试结果
在这里插入图片描述

2、方式二：自定义类

applicationContext.xml

<?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="service.UserServiceImpl"/>
    <bean id="log" class="log.Log"/>
    <bean id="afterLog" class="log.AfterLog"/>
	<bean id="diy" class="diy.DiyPointCut"/>
    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after  method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
    </beans>

UserService接口

package service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

UserServiceImpl实现类（切入点）

package service;

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

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

    }

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

    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");

    }
}

自定义类

package diy;

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

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

测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;
import service.UserServiceImpl;

import java.lang.annotation.Annotation;

public class MyTest {
    public static void main(String[]  args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口
        UserService userService = (UserService) context.getBean("userService");
        userService.select();

    }
}

测试结果
在这里插入图片描述

方式三：注解

applicatonContext.xml

<?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="service.UserServiceImpl"/>
    <bean id="log" class="log.Log"/>
    <bean id="afterLog" class="log.AfterLog"/>

    <bean id="annotationPointCut" class="diy.AnnotationPointCut"/>
    <!--开启注解支持！JDK(默认 proxy-target-class = "false") cglib(proxy-target-class = "true")-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    </beans>

UserService接口

package service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

UserServiceImpl实现类（切入点）

package service;

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

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

    }

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

    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");

    }
}

切面类

package diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 AnnotationPointCut {
   @Before("execution(* service.UserServiceImpl.*(..))")
   public void before(){
       System.out.println("===========方法执行前===========");
   }

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

   //在环绕增强中，我们可以给定一个参数，代表我们要处理切入的点
   @Around("execution(* service.UserServiceImpl.*(..))")
   public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
       System.out.println("环绕前");

       Signature signature = proceedingJoinPoint.getSignature();
       System.out.println("signature:" + signature);
//        //执行方法

       Object proceed = proceedingJoinPoint.proceed();

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

测试结果
在这里插入图片描述

酱紫学Java

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
SpringAOP超详解！！！！

SpringAOP的全称是（Aspect Oriented Programming）中文翻译过来是面向切面编程，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
复制链接

扫一扫