【Spring第九篇】AOP

最新推荐文章于 2024-09-09 17:27:01 发布
最新推荐文章于 2024-09-09 17:27:01 发布
阅读量869 收藏 5
点赞数 3
分类专栏： Spring 文章标签： Spring 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50569789/article/details/124157590
版权

文章目录


导包 

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.16</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.8</version>
    </dependency>
</dependencies>

AOP核心概念

  • Joinpoint（连接点）：所谓连接点是指那些可以被增强到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
  • Pointcut（切入点）：所谓切入点是指被增强的连接点（方法）
  • Advice（通知/ 增强）：所谓通知是指具体增强的代码
  • Target（目标对象）：被增强的对象就是目标对象
  • Aspect（切面）：是切入点和通知（引介）的结合
  • Proxy （代理）：一个类被 AOP 增强后，就产生一个结果代理类

切入点、通知以及切面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mLoX0cAO-1649854382253)(C:\Users\30666\AppData\Roaming\Typora\typora-user-images\image-20220410113317803.png)]

目标对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z5laCKmS-1649854382257)(C:\Users\30666\AppData\Roaming\Typora\typora-user-images\image-20220410113428937.png)]

AOP:切点表达式

​ 可以使用切点表达式来表示要对哪些方法进行增强。

写法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

  • 访问修饰符可以省略，大部分情况下省略
  • 返回值类型、包名、类名、方法名可以使用星号* 代表任意
  • 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
  • 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(* com.sangeng.service.*.*(..))   表示com.sangeng.service包下任意类，方法名任意，参数列表任意，返回值类型任意
   
execution(* com.sangeng.service..*.*(..))   表示com.sangeng.service包及其子包下任意类，方法名任意，参数列表任意，返回值类型任意
    
execution(* com.sangeng.service.*.*())     表示com.sangeng.service包下任意类，方法名任意，要求方法不能有参数，返回值类型任意
    
execution(* com.sangeng.service.*.delete*(..))     表示com.sangeng.service包下任意类，要求方法不能有参数，返回值类型任意,方法名要求已delete开头

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zKqI4xOm-1649854382258)(C:\Users\30666\AppData\Roaming\Typora\typora-user-images\image-20220410152342191.png)]

在resouces目录下创建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: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-3.0.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">

   <!--    指定要扫描的包-->
   <context:component-scan base-package="com.kk"/>

   <!--    开启注解的支持-->
   <context:annotation-config/>

   <!--   开启aop注解支持-->
   <aop:aspectj-autoproxy/>


</beans>

创建MyAspect.java类

package com.kk.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author :
 * @Date : 2022/4/9
 * @Desc :
 */
@Component
@Aspect
public class MyAspect {

//    @Pointcut("execution(* com.kk.service.*.*(..))")
//    public void pt(){
//
//    }

    
//    @Before("pt()")
//    public void methodbefore(){
//        System.out.println("方法被调用了");
//    }
      
    //需要无参才生效
//    @Pointcut("execution(* com.kk.service..*.*())")
//    public void ptt(){
//
//    }

    
    @Pointcut("execution(* com.kk.service.*.delete*(..))")
    public void ptt(){

    }

    @Before("ptt()")
    public void methodbeforeppt(){
        System.out.println("方法被调用了");
    }

}

创建service层，在service层创建UserService和PhoneService

UserService

package com.kk.service;

import com.kk.aspect.InvokeLog;
import org.springframework.stereotype.Service;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
@Service
public class UserService {

    @InvokeLog
    public void qx(){
        System.out.println("UserService中qx的核心代码");
    }



    public void deleteAll(){
        System.out.println("以delete开头的");
    }
}

PhoneService

package com.kk.service;

import com.kk.aspect.InvokeLog;
import org.springframework.stereotype.Service;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
@Service
public class PhoneService {

    @InvokeLog
    public void qx(){
        System.out.println("PhoneService中qx的核心代码");
    }
}

测试：

package com.kk;

import com.kk.service.PhoneService;
import com.kk.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
public class Demo {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        PhoneService phoneService = context.getBean(PhoneService.class);
        UserService userService = context.getBean(UserService.class);
        phoneService.qx();
        userService.qx();
        userService.deleteAll();
    }
}

AOP:使用切点表达式@annotation

我们也可以在要增强的方法上加上注解。然后使用@annotation来表示对加了什么注解的方法进行增强。

写法：@annotation(注解的全类名)

例如：

创建一个注解类InvokeLog

package com.kk.aspect;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author : k
 * @Date : 2022/4/10
 * @Desc :
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface InvokeLog {
}

在MyAspect类中使用此注解类

@Pointcut("@annotation(com.kk.aspect.InvokeLog)")

package com.kk.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author :
 * @Date : 2022/4/9
 * @Desc :
 */
@Component
@Aspect
public class MyAspect {

    @Pointcut("@annotation(com.kk.aspect.InvokeLog)")
    public void ptt(){

    }

    @Before("ptt()")
    public void methodbeforeppt(){
        System.out.println("方法被调用了");
    }

}

UserSerice以及PhoneService

若哪个类的哪个方法需要使用aop，则在方法上面加 @InvokeLog 即可

UserSerice

package com.kk.service;

import com.kk.aspect.InvokeLog;
import org.springframework.stereotype.Service;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
@Service
public class UserService {

    @InvokeLog
    public void qx(){
        System.out.println("UserService中qx的核心代码");
    }



    public void deleteAll(){
        System.out.println("以delete开头的");
    }
}

PhoneService

package com.kk.service;

import com.kk.aspect.InvokeLog;
import org.springframework.stereotype.Service;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
@Service
public class PhoneService {

    @InvokeLog
    public void qx(){
        System.out.println("PhoneService中qx的核心代码");
    }
}

测试:

package com.kk;

import com.kk.service.PhoneService;
import com.kk.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author : k
 * @Date : 2022/4/9
 * @Desc :
 */
public class Demo {
    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        PhoneService phoneService = context.getBean(PhoneService.class);
        UserService userService = context.getBean(UserService.class);
        phoneService.qx();
        userService.qx();
        userService.deleteAll();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZMZZKeWP-1649854382260)(C:\Users\30666\AppData\Roaming\Typora\typora-user-images\image-20220410152958561.png)]

通知分类

  • @Before：前置通知,在目标方法执行前执行
  • @AfterReturning： 返回后通知，在目标方法执行后执行，如果出现异常不会执行
  • @After：后置通知，在目标方法之后执行，无论是否出现异常都会执行
  • @AfterThrowing：异常通知，在目标方法抛出异常后执行
  • @Around：环绕通知，围绕着目标方法执行

其他代码不变，只需修改MyAspect中的代码即可

package com.kk.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author :
 * @Date : 2022/4/9
 * @Desc :
 */
@Component
@Aspect
public class MyAspect {



    @Pointcut("execution(* com.kk.service..*.*(..))")
    public void ptt(){
    }


    @Before("ptt()")
    public void methodbeforeppt(){
        System.out.println("before");
    }
    
    
    @AfterReturning("ptt()")
    public void afterReturning(){
        System.out.println("afterReturning");
    }


    @After("ptt()") 
    public void after(){
        System.out.println("after");
    }


    @AfterThrowing("ptt()")
    public void afterThrowing(){
        System.out.println("after");
    }

    
    //环绕通知非常特殊，它可以对目标方法进行全方位的增强。
    @Around("ptt()")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("around目标方法前");

        try {
            pjp.proceed();//目标方法执行
            System.out.println("around目标方法后");
        } catch (Throwable e) {
            e.printStackTrace();
        }finally {
            System.out.println("finally中进行增强");
        }
    }


}

获取被增强方法相关信息

​ 我们实际对方法进行增强时往往还需要获取到被增强代码的相关信息，比如方法名，参数，返回值，异常对象等。

​ 我们可以在除了环绕通知外的所有通知方法中增加一个JoinPoint类型的参数。这个参数封装了被增强方法的相关信息。我们可以通过这个参数获取到除了异常对象和返回值之外的所有信息。

例如：

@Before("pt()")
public void methodbefore(JoinPoint jp){
    Object[] args = jp.getArgs();//方法调用时传入的参数
    Object target = jp.getTarget();//被代理对象
    MethodSignature signature = (MethodSignature) jp.getSignature();//获取被被增强方法签名封装的对象
    System.out.println("Before方法被调用了");
}

案例：

需求：要求让所有service包下类的所有方法被调用前都输出全类名，方法名，以及调用时传入的参数

package com.kk.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author : k
 * @Date : 2022/4/13
 * @Desc :
 */
@Component
@Aspect
public class PrintLogAspect {


    //对哪些方法增强
    @Pointcut("execution(* com.kk.service..*.*(..))")
    public void  pt(){

    }

    //怎么增强
    @Before("pt()")
    public void printLog(JoinPoint joinPoint){
        //输出 被调用的方法所在的类名  方法名 调用时传入的参数
        MethodSignature  signature = (MethodSignature) joinPoint.getSignature();

        String classMethod = joinPoint.getSignature().getDeclaringTypeName();//类名 com.kk.service.UserService
        String methodName = signature.getName();//方法名   updateById
        Object[] args = joinPoint.getArgs();//调用时传入的参数 556688

        System.out.println(classMethod+"=="+methodName+"=="+Arrays.toString(args));
    }
}

​ 果需要获取被增强方法中的异常对象或者返回值则需要在方法参数上增加一个对应类型的参数，并且使用注解的属性进行配置。这样Spring会把你想获取的数据赋值给对应的方法参数。

例如：

package com.kk.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author :
 * @Date : 2022/4/9
 * @Desc :
 */
@Component
@Aspect
public class MyAspect {




    @Pointcut("execution(* com.kk.service..*.*(..))")
    public void ptt(){
    }


    @Before("ptt()")
    public void methodbeforeppt(JoinPoint joinPoint){

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println(method);//public void com.kk.service.UserService.updateById(java.lang.Integer)
//        method.invoke();



        System.out.println("before");
    }

    @AfterReturning(value = "ptt()", returning = "ret")
    public void afterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("afterReturning");
    }

    @After("ptt()")
    public void after(JoinPoint joinPoint){
        System.out.println("after");
    }


    @AfterThrowing(value = "ptt()", throwing ="t")
    public void afterThrowing(JoinPoint joinPoint,Throwable t){
        System.out.println("after");
    }


}

​ 相信你肯定觉得上面的获取方式特别的麻烦难以理解。就可以使用下面这种万能的方法。

​ 直接在环绕通知方法中增加一个ProceedingJoinPoint类型的参数。这个参数封装了被增强方法的相关信息。

该参数的proceed()方法被调用相当于被增强方法被执行，调用后的返回值就相当于被增强方法的返回值。

例如：

package com.kk.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author :
 * @Date : 2022/4/9
 * @Desc :
 */
@Component
@Aspect
public class MyAspect {

    @Pointcut("execution(* com.kk.service..*.*(..))")
    public void ptt(){
    }

    @Around("ptt()")
    public void around(ProceedingJoinPoint pjp) {

        Object[] args = pjp.getArgs(); //获取方法参数
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Object target = pjp.getTarget(); //获取被增强的对象

        try {
            Object ret = pjp.proceed();//目标方法的执行

            //ret就是被增强方法的返回值
            System.out.println(ret);
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }

        System.out.println(pjp);
    }


}

【不使用自动注入】AOP方式一：使用配置文件方法

功能：要求代码在执行的时候添加日志并且打印出日志信息，当不改变业务的源代码

编写两个日志类

Log 实现MethodBeforeAdvice

public class Log implements MethodBeforeAdvice {

 /**
     *	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
     * @param method 要执行的目标对象的方法，获取实现类的名字  target.getClass().getName() ,获取方法的名字method.getName()
     * @param args  参数
     * @param target   目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

After_Log 实现 AfterReturningAdvice

public class After_Log implements AfterReturningAdvice {

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

applicationContext.xml

将实现类以及两个自定义的log类注入到spring IoC容器中，由spring托管

<!--    注册bean-->
    <bean id="userService" class="com.kk.service.UserServiceImpl"/>
    <bean id="log" class="com.kk.log.Log"/>
    <bean id="afterLog" class="com.kk.log.After_Log"/>

注意点：需要导入aop的约束：

xmlns:aop=“http://www.springframework.org/schema/aop”

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

<?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-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">


<!--    注册bean-->
    <bean id="userService" class="com.kk.service.UserServiceImpl"/>
    <bean id="log" class="com.kk.log.Log"/>
    <bean id="afterLog" class="com.kk.log.After_Log"/>



<!--    方式一：使用原生的Spring API接口-->

        <aop:config>
<!--            切入点     expression表达式   execution 要执行的位置 就是这个切入点要在哪里执行 -->
            <aop:pointcut id="pointcut" expression="execution(* com.kk.service.UserServiceImpl.*(..))"/>

<!--            这句话的意思就是 我们把这个log类 （ <bean id="log" class="com.kk.log.Log"/>） 切入到这个pointcut 方法里边-->
<!--       		advice-ref引用哪一个类进行切入    pointcut-ref将这个类切入到哪里-->            
            <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
            <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        </aop:config>

</beans>

【不使用自动注入】AOP方式二：自定义切点

自定义类 DiyPointCut

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

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

}

applicationContext.xml

将自定义类 DiyPointCut注入到spring IoC容器中，由spring托管

<!--    方式二：自定义类-->
    <bean id="diy" class="com.kk.diy.DiyPointCut"/>

<?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-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    注册bean-->
    <bean id="userService" class="com.kk.service.UserServiceImpl"/>
<!--    方式二：自定义类-->
    <bean id="diy" class="com.kk.diy.DiyPointCut"/>
    
    
    
    <aop:config>
<!--        自定义切面 ref 要引用的类-->
        <aop:aspect ref="diy">
<!--            切入点,就是在哪个地方使用aop,就是这个切入点要在哪里执行-->
            <aop:pointcut id="point" expression="execution(* com.kk.service.UserServiceImpl.*(..))"/>

<!--            通知   method 就是要使用的方法（自定义类 DiyPointCut里边的方法） pointcut-ref这个方法要在哪里执行-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

【不使用自动注入】AOP方式三:使用注解方法

通过注解编写切面

注意：需要使用@Aspect这个注解标注这个类是一个切面

自定义类 AnnotationPointCut

@Aspect  //标注这个类是一个切面
public class AnnotationPointCut {


    @Before("execution(* com.kk.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=======方法执行前======");
    }


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


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

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

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

}

applicationContext.xml

注意：需要开启注解支持

<!--开启注解支持 -->
        <aop:aspectj-autoproxy/>

<?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-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">


<!--    注册bean-->
    <bean id="userService" class="com.kk.service.UserServiceImpl"/>

<!--    方式三：-->
        <bean id="annotationPointCut" class="com.kk.diy.AnnotationPointCut"/>
<!--开启注解支持 -->
        <aop:aspectj-autoproxy/>


</beans>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nnZ10q3S-1649854382262)(C:\Users\30666\AppData\Roaming\Typora\typora-user-images\image-20220310174116535.png)]

不易撞的网名
关注
专栏目录
Spring AOP定义AfterReturning增加实例分析
08-25
主要介绍了Spring AOP定义AfterReturning增加,结合实例形式分析了Spring面相切面AOP定义AfterReturning增加相关操作技巧与使用注意事项,需要的朋友可以参考下
4.spring的aop之@After
u013571243的专栏
12-15 656
定义一个切面 @Aspect public class AfterAdviceTest { // 匹配org.crazyit.app.service包下所有类的、 // 所有方法的执行作为切入点 @After("execution(* org.crazyit.app.service.*.*(..))") public void release() { System.out.print
AOP之后置通知@After、返回通知@AfterReturning、异常通知@AfterThrowing
最新发布
忽胖忽瘦的博客
09-09 487
以上两种写法都表明监听com.example.demo.service.impl.AccountServiceImpl类下的aopBeforeMsg函数。需要注意的是，该注解只能抓捕未被自己代码处理的异常，加入在业务逻辑中对代码进行了try…以上写法表示监听AccountServiceImpl类与OrderService类中get开头的函数。以上写法表明监听AccountServiceImpl类下所有get开头函数。以上表明监听AccountServiceImpl类下的所有函数。
Spring Spring AOP的@After方法
qq_35677589的博客
03-10 1285
@After 最终通知，在源代码方法的后面执行
Spring AOP
m0_37637141的博客
08-30 210
通知：通知定义了切面是什么以及何时使用，除了描述切面要完成的工作，还解决了何时执行这个工作的问题，Spring切面定义了5中通知类型： 前置通知（Before）：在目标方法被调用之前调用通知功能 后置通知（After）：在目标方法完成之后调用通知功能，此时不会关心方法的输出是什么 返回通知（AfterReturning）：在目标方法成功执行之后调用通知 异常通知（AfterThrowing...
关于spring aop 中的 after thowing
weixin_34007879的博客
08-20 124
前几天想做一个异常的处理机制,就自定义了一些异常,然后在service层中使用aop中的after thowing来截取自定义的异常,处理之后在抛出,(因为开始以为,只是想截取service中的异常所以没有必要使用aop中的环绕),处理之后会把所有的异常都整合掉一个总的异常类中再抛给controller层在做返回视图操作. 但最近发现这个 after thowi...
第四章：Spring AOP API 设计模式1
08-03
9. **享元模式（Flyweight）**：享元模式在Spring AOP中不太直接体现，但在Spring框架的其他部分，如缓存管理，可能会用到此模式来减少内存消耗，通过共享大量细粒度对象的内部状态来降低内存占用。 10. **代理模式...
Spring的AOP（整合第三方框架）
qq_64268646的博客
09-21 608
spring整合第三方框架
第九章 Spring4 AOP
04-30
标题 "第九章 Spring4 AOP" 指的是Spring框架中的面向切面编程（Aspect-Oriented Programming，简称AOP）部分。AOP是Spring框架的核心特性之一，它允许开发者在不修改原有业务代码的情况下，对系统进行横切关注点的...
Spring-AOP工作流程
qq_53098203的博客
03-10 637
Spring-AOP工作流程
《深入浅出Spring》SpringAOP 详解AspectJ
ysj_2021的博客
07-22 617
Spring AOP AspectJ
Spring AOP(四)之After增强处理
owen_william的博客
03-06 5056
Spring还提供了一个After增强处理，它与AfterReturning增强处理有点相似，但也有区别： 1)        AfterReturing增强处理只有在目标方法成功完成后才会被织入。 2)        After增强处理不管目标方法如何结束（包括成功完成和遇到异常中止两种情况），它都会被织入。 下面的程序，我们定义一个After增强处理。 // 定义一个切面 @Aspec
Spring AOP详解
~ Caesar's wish书屋 ~
11-30 369
AOP      AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层
Java练习（十）：Spring应用之AOP的@Before, @After操作（简单工程示例）
sulia1234567890的博客
09-18 8700
目录 1. 背景概念 1.1 定义 1.2 AOP的本质 1.3 AOP的实现 1.4各个名称的概念详解 2. 示例工程 2.1 maven的配置文件： pom.xml 2.2 bean配置文件： bean_aop.xml 2.3 接口和类的代码 2.3.1 接口：UserService 2.3.2实现接口的类：UserServiceImpl 2.3.3Before类：BeforeLog 2.3.4After类：AfterLog 2.4 测试类 1. 背景概念 1....
Spring面试（三）AOP
weixin_45773632的博客
03-16 1111
文章目录1. 什么是AOP？2. Spring AOP术语3. advice(增强)的类型4. @Pointcut() 的execution表达式 1. 什么是AOP？ AOP (Aspect Oriented Programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一一个热点，也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度
浅谈Spring AOP
小白成长记录
09-22 990
浅谈Spring AOP介绍AOP(Aspect Oriented Programming)即面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程.面向切面编程（AOP）是从动态角度考虑程序运行过程. 举例: 遍布在整个系统的权限校验、日志输出这两种服务其实和我们开发的功能是相互独立的，不存
Spring AOP切面执行顺序深度解析：@Before, @After, @Around的协同作战
fudaihb的博客
04-25 3871
Aspect-Oriented Programming（AOP）是一种编程范式，它旨在解决传统面向对象编程（OOP）中难以处理的问题，特别是那些横跨多个模块或层的横切关注点。这些关注点，如日志记录、事务管理和安全检查，通常散布在应用程序的多个部分中，导致代码重复和难以维护。AOP的核心思想是通过将这些横切关注点从业务逻辑中分离出来，封装成单独的模块，这些模块被称为“切面”（Aspect）。通过这种方式，我们可以将横切关注点的实现从核心业务逻辑中解耦，使得代码更加模块化、清晰和易于维护。
Spring AOP @After,@Around,@Before执行的顺序以及可能遇到的问题
热门推荐
lmx125254的博客
11-23 7万+
AOP中有@Before，@After，@Around，@AfterRunning注解等等。 首先上下自己的代码，定义了切点的定义 @Aspect @Component public class LogApsect { private static final Logger logger = LoggerFactory.getLogger(LogApsect.class); ...
Spring AOP入门与实战：日志拦截与项目实战
第1章：Spring AOP 入门 1. AOP是什么 AOP是一种编程技术，它通过引入"切面"（Aspect）的概念，使得原本分散在各个模块中的共享行为，如日志记录、性能监控等，可以集中管理并以跨模块的方式应用。这有助于减少...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不易撞的网名

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值