SpringAOP 通知类型

最新推荐文章于 2022-08-05 16:42:53 发布
最新推荐文章于 2022-08-05 16:42:53 发布
阅读量144 收藏
点赞数
分类专栏： Spring学习
原文链接：https://www.cnblogs.com/huangzhe1515023110/p/9276055.html
版权

AspectJ：Java社区中最完整、最流行的AOP框架。

在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

在Spring中2启用AspectJ注解支持：

1、要在 Spring应用中使用AspectJ注解，需要添加spring-aspect、aspectj-weaver、aopalliance依赖

2、将aop Schema添加到<beans>根元素

3、要在SpringIOC容器中启用AspectJ注解支持，只要在Bean配置文件中定义一个空的XML元素：<aop:aspectj-autoproxy>

4、在Spring IOC容器侦测到Bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动与AspectJ切面匹配的Bean创建代理

一、基于注解的方式

1、依赖

2、在配置中加入aop的命名空间

3、基于注解的方式：

①在配置文件中加入：<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: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">

    <!--配置自动扫描的包-->
    <context:component-scan base-package="com.aop.service,com.aop.notice,com.aop.test"/>

    <!--使AspectJ注解起作用：自动为匹配的类生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

②把横切关注点的代码抽象到切面的类中

切面首先是一个IOC容器中的Bean，即加入@Component注解

切面还需要加入@AspectJ注解

③在类中声明各种通知：

1、声明一个方法

2、在方法前加入通知

@AspectJ支持的5中通知：

—@Before：前置通知在方法执行前执行

—@After：最终通知，在方法执行后执行

—@AfterReturning：返回后通知（后置通知），在方法返回结果之后执行

—@AfterThrowing：异常通知，在方法抛出异常后执行

—@Around：环绕通知，围绕着方法执行

④我们可以在通知方法中声明一个类型为JoinPoint参数，然后就能访问链接细节，如方法名称和参数值

切面类：

package com.aop.notice;

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

import java.util.Arrays;
import java.util.List;

/**
 * 把这个类声明为一个切面:
 * 1、需要把该类放入到容器中（就是加上@Component注解）
 * 2、再声明为一个切面（加上@AspectJ注解）
 *
 * @author chenpeng
 * @date 2018/6/3 23:20
 */
@Aspect
@Component
public class LoggingAspect {

    //声明该方法为一个前置通知:在目标方法开始之前执行
    //execution中是AspectJ表达式
    @Before(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("beforeMethod "+methodName+" and "+args);
    }
}

在使用的时候报错：因为动态代理不能用接口的实现类来转换Proxy的实现类，它们是同级，应该用共同的接口来转换。

改为这样：

package com.aop.test;

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

import com.aop.service.UserService;

/**
 * AOPTest：测试代码
 */
public class AOPTest {
	@Test
    public void test01(){
		//1、创建SpringIOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
        //2、从IOC容器中获取Bean的实例
        UserService userService = (UserService) context.getBean("userService");
        //3、使用Bean
        userService.addUser("cjj"); // 一个连接点
    }
}

 其他通知：

package com.aop.notice;

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

import java.util.Arrays;
import java.util.List;

/**
 * 把这个类声明为一个切面:
 * 1、需要把该类放入到容器中（就是加上@Component注解）
 * 2、再声明为一个切面（加上@AspectJ注解）
 *
 * @author chenpeng
 * @date 2018/6/3 23:20
 */
@Aspect
@Component
public class LoggingAspect {

    //声明该方法为一个前置通知:在目标方法开始之前执行
    //execution中是AspectJ表达式
    @Before(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("beforeMethod "+methodName+" start with "+args);
    }

    //后置通知，就是在目标方法执行之后（无论是否发生异常）执行的通知
    //后置通知中不能访问目标方法的返回结果
    @After(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
    public void afterMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterMethod "+methodName+" end with "+args);
    }

    //返回通知，在方法正常结束之后执行的代码
    //返回通知是可以访问到方法的返回值的
    @AfterReturning(value = "execution(* com.aop.service.UserServiceImple.addUser(..))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterReturning "+methodName+" end with "+result);
    }

    //返回异常通知，返回抛出异常的时候执行的通知，可以获得返回的异常
    //可以访问到异常对象，且可以指定在出现特定异常的时候再执行通知代码
    @AfterThrowing(value = ""execution(* com.aop.service.UserServiceImple.addUser(..))",throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterThrowing "+methodName+" end with "+ ex );
    }

    //环绕通知需要携带ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全过程，这个类型ProceedingJoinPoint的参数可以决定是否执行目标方法
    //且环绕通知必须有返回值，返回值即为目标方法返回值
    @Around(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
    public  void around(ProceedingJoinPoint proceedingJoinPoint){
        Object result = null;
        String methodName = proceedingJoinPoint.getSignature().getName();
        Object[] args = proceedingJoinPoint.getArgs();

        //执行目标方法
        try {
            //前置通知
            System.out.println("beforeMethod "+methodName+" start with "+args);

            result = proceedingJoinPoint.proceed();

            //返回通知
            System.out.println("afterMethod "+methodName+" end with "+result);
        } catch (Throwable throwable) {
            //异常通知
            System.out.println("afterThrowing "+methodName+" exception with "+ throwable );
            throwable.printStackTrace();
        }

        //后置通知
        System.out.println("afterMethod "+methodName+" end with "+args);
        //System.out.println("around "+proceedingJoinPoint);
        return;
    }

}

对于切面的优先级

可以在类上使用注解@Order（1），括号中的数字越小，优先级越高

@Order(1)

重用切面的切点表达式：使用@Pointcut 

	/**
	 * 定义一个方法，用于声明切入点表达式
	 *一般的，该方法中不需要添加其他的代码
	 * 使用@Pointcut来声明切入点表达式
	 * 后面的其他通知直接使用方法名来引用切入点表达式
	 */
	@Pointcut(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
	public void declareJoinPointExpress(){ }
	
	//声明该方法为一个前置通知:在目标方法开始之前执行
	//execution中是AspectJ表达式
	@Before(value = "declareJoinPointExpress()")
	public void beforeMethod(JoinPoint joinPoint){
	    String methodName = joinPoint.getSignature().getName();
	    List<Object> args = Arrays.asList(joinPoint.getArgs());
	    System.out.println("beforeMethod "+methodName+" start with "+args);
	}

其他切面类中使用：

package com.aop.notice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 *
 */
//可以使用@Order指定切面的优先级，值越小优先级越高
@Order(1)
@Component
@Aspect
public class ValidationAspect {

    @Before(value = "FirstAspect.declareJoinPointExpress()")
    public void validateArgs(JoinPoint joinPoint){
        System.out.println("validateArgs"+ Arrays.asList(joinPoint.getArgs()));
    }
}

二、基于XML配置文件的方式

除了使用@AspectJ注解声明切面，Spring还支持在Bean的配置文件中声明切面，这种声明是通过aop Schema中的XML元素完成的。

正常情况下，基于注解的声明要优于基于XML的声明，通过@AspectJ注解，可以与Aspect切面相兼容，而基于XML配置则是Spring专有的。优于@AspectJ得到越来越多AOP框架支持，所以用的更多。

配置方式：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
    
    <context:annotation-config></context:annotation-config>
    <!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.aop.service,com.aop.notice,com.aop.test"></context:component-scan>
    
    
    <!--基于XML配置的AOP-->
    <aop:config proxy-target-class="true">
        <!-- 配置切入点  -->
        <aop:pointcut id="pc01" expression="execution(* com.aop.service.UserServiceImple.addUser(..))"/>
        
        <!-- 配置切面 -->
        <aop:aspect ref="firstAspect">
	        <aop:before method="beforeMethod" pointcut-ref="pc01"/> 
			<aop:around method="around" pointcut-ref="pc01"/>
			<aop:after method="afterMethod" pointcut-ref="pc01"/>
			<aop:after-returning method="afterReturning" pointcut-ref="pc01" returning="result"/> 
			<aop:after-throwing method="afterThrowing" pointcut-ref="pc01" throwing="ex"/> 
        </aop:aspect>
    </aop:config>
</beans>
package com.aop.service;

public interface UserService {
	 public void addUser(String name);
	 public void updateUser() ;
	 public void deleteUser() ;
	 public void query() ;
}
package com.aop.service;

import org.springframework.stereotype.Service;

/**
 * UserServiceImple:目标对象
 */
@Service("userService")
public class UserServiceImple implements UserService{

		@Override
	    public void addUser(String name) {
			//int i = 1/0;
	        System.out.println("增加用户。。");
	    }

	    @Override
	    public void updateUser() {
	        System.out.println("修改用户。。");
	    }

	    @Override
	    public void deleteUser() {
	        System.out.println("删除用户。。");
	    }

	    @Override
	    public void query() {
	        System.out.println("查询用户。。");
	    }

}
package com.aop.notice;

import java.util.Arrays;
import java.util.List;

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

/**
 * FirstAspect:切面代码
 * 把这个类声明为一个切面:
 * 1、需要把该类放入到容器中（就是加上@Component注解）
 */
@Component
public class FirstAspect {
	//声明该方法为一个前置通知:在目标方法开始之前执行
//	@Before(value = "execution(* com.aop.service.UserServiceImple.addUser(..))")
	public void beforeMethod(JoinPoint joinPoint){ // 可以选择额外的传入一个JoinPoint连接点对象，必须用方法的第一个参数接收。
		String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("beforeMethod "+methodName+" and "+args);
    }
	
	//后置通知，就是在目标方法执行之后（无论是否发生异常）执行的通知
    //后置通知中不能访问目标方法的返回结果
    public void afterMethod(JoinPoint joinPoint){
    	String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterMethod "+methodName+" and "+args);
    }
    
    //返回通知，在方法正常结束之后执行的代码
    //返回通知是可以访问到方法的返回值的
    public void afterReturning(JoinPoint joinPoint,Object result){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterReturning "+methodName+" end with "+result);
    }
    
    //返回异常通知，返回抛出异常的时候执行的通知，可以获得返回的异常
    //可以访问到异常对象，且可以指定在出现特定异常的时候再执行通知代码
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("afterThrowing "+methodName+" end with "+ ex );
    }
    
    //环绕通知需要携带ProceedingJoinPoint类型的参数
    //环绕通知类似于动态代理的全过程，这个类型ProceedingJoinPoint的参数可以决定是否执行目标方法
    //且环绕通知必须有返回值，返回值即为目标方法返回值
	public void around(ProceedingJoinPoint proceedingJoinPoint){
		Object result = null;
        String methodName = proceedingJoinPoint.getSignature().getName();
        Object[] args = proceedingJoinPoint.getArgs();

        //执行目标方法
        try {
            //前置通知
            System.out.println("beforeMethod "+methodName+" start with "+args);

            result = proceedingJoinPoint.proceed();

            //返回通知
            System.out.println("afterMethod "+methodName+" end with "+result);
        } catch (Throwable throwable) {
            //异常通知
            System.out.println("afterThrowing "+methodName+" exception with "+ throwable );
            throwable.printStackTrace();
        }

        //后置通知
        System.out.println("afterMethod "+methodName+" end with "+args);
        //System.out.println("around "+proceedingJoinPoint);
        return;
    }
}

package com.aop.test;

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

import com.aop.service.UserService;

/**
 * AOPTest：测试代码
 */
public class AOPTest {
	@Test
    public void test01(){
		//1、创建SpringIOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("aop.xml");
        //2、从IOC容器中获取Bean的实例
        UserService userService = (UserService) context.getBean("userService");
        //3、使用Bean
        userService.addUser("cjj"); // 一个连接点
    }
}

五种通知的执行顺序

1.在目标方法没有抛出异常的情况下

  前置通知  -> 

  环绕通知的调用目标方法之前的代码 -> 目标方法 -> 环绕通知的调用目标方法之后的代码 ->

  后置通知

  最终通知

2.在目标方法抛出异常的情况下

 前置通知

 环绕通知的调用目标方法之前的代码

 目标方法 抛出异常 异常通知

 最终通知

3.如果存在多个切面

 多切面执行时，采用了责任链设计模式。

 切面的配置顺序决定了切面的执行顺序，多个切面执行的过程，类似于方法调用的过程，在环绕通知的proceed()执行时，去执行下一个切面或如果没有下一个切面执行目标方法，从而达成了如下的执行过程：

 

五种通知的常见使用场景

环绕通知

控制事务 权限控制

后置通知

记录日志(方法已经成功调用)

异常通知

异常处理 控制事务

最终通知

记录日志(方法已经调用，但不一定成功)

 

 

Spring AOP SpringBoot集成

引入AOP依赖包后，不需要去做其他配置。AOP的默认配置属性中，spring.aop.auto属性默认是开启的，也就是说只要引入了AOP依赖后，默认已经增加了@EnableAspectJAutoProxy，不需要在程序主类中增加@EnableAspectJAutoProxy来启用。 

切点表达式用于描述切点的位置信息，在此简单描述文中切点表达式的含义。

推荐一个切点表达式总结的博客https://www.cnblogs.com/zhangxufeng/p/9160869.html

 

JHOHCBJka
关注
专栏目录
如何使用Spring AOP的通知类型及创建通知
08-25
本文将深入探讨Spring AOP中的通知类型及其创建方法，帮助你更好地理解和应用这一强大的功能。 在Spring AOP中，通知（Advice）是指在连接点（Joinpoint）执行前后插入的额外行为。连接点通常指的是方法调用，因为...
SpringAOP 前置通知、后置通知
weixin_33857230的博客
06-13 235
AspectJ：Java社区中最完整、最流行的AOP框架。在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。在Spring中2启用AspectJ注解支持：1、要在Spring应用中使用AspectJ注解，需要添加spring-aspect、aspectj-weaver、aopalliance依赖2、将aop Schema添加...
为什么要用IOC和AOP
桐花思雨
02-23 264
前言 作为一名 Java 开发，对 spring 框架是再熟悉不过的了。spring 支持的控制反转（Inversion of Control，缩写为IOC）和面向切面编程（Aspect-oriented programming，缩写为AOP）早已成为我们的开发习惯，仿佛 Java 开发天生就该如此。人总是会忽略习以为常的事物，所有人都熟练使用 IOC 和 AOP，却鲜有人说得清楚到底为什么要用 IOC 和 AOP spring IOC 我们现在假设回到了没有 IOC 的时代，用传统的 servlet 进行
spring AOP使用
abstruct01的博客
07-28 198
二、AOP A、AOP:Aspect Oriented Programming 引入aspectjweaver和aopalliance的包 JoinPoint 连接点 PointCut 切入点(连接点集合)(切入点一般是定义在方法上，其实也可以在属性甚至类上) Aspect 方面(切面类) Advice 切面对于某个“连接点”所产生的动作,before、after、around(切入点建议) ...
Spring加AOP全部注解配置
丑恐龙的博客
08-09 692
最经学习时,想实现把AOP的全部注解,全部都配置妥当 记过发现还是不行,最后emmmm…悲 总结一下 切面类要加的注解 @component 就是把当前类交给spring容器中,相当于配置文件中的 @Aspect 方法上 1.方法@PointCut(“execute(* *(…))”) 相当于执行范围 public void XXX(){} 2.@Before(“XXX()”) 还有...
AOP个人理解
weixin_45116566的博客
07-14 134
1.AOP 目录 1.AOP AOP是Aspect Oriented Programming，即面向切面编程。 那什么是AOP？ 我们先回顾一下OOP：Object Oriented Programming，OOP作为面向对象编程的模式，获得了巨大的成功，OOP的主要功能是数据封装、继承和多态。 而AOP是一种新的编程方式，它和OOP不同，OOP把系统看作多个对象的交互，AOP把系统分解为不同的关注点，或者称之为切面（Aspect）。 使用spring容器方式使用AOP注解： 引包 ..
spring aop jar 包
07-26
Spring AOP支持五种类型的通知：前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和环绕通知（Around）。 3. **切点（Pointcut）**：切点是程序执行过程中的...
Spring aop.docx
最新发布
12-14
`@Aspect`类通常会包含`@Before`, `@After`, `@Around`, `@AfterReturning`, 和 `@AfterThrowing`等通知类型的注解，这些注解定义了在特定方法执行前、后或发生异常时执行的代码。 **@Aspect Demo演示** 创建一个...
SpringAOP.rar_springAOP
09-23
2.2 通知类型 - 前置通知（Before Advice）：在目标方法执行之前运行。 - 后置通知（After Advice）：在目标方法执行之后运行，无论方法是否成功。 - 返回通知（After Returning Advice）：在目标方法正常返回后...
Spring AOP @Aspect用法
abcd1101的专栏
12-08 718
一概念 AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象...
SpringBoot使用Aop切面编程
Stars_Li的博客
08-05 901
SpringBoot使用Aop切面编程
spring之aop（前置通知，后置通知，环绕通知，过滤通知，异常通知）
m0_58525944的博客
10-25 3711
1、AOP中关键性概念 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出 目标(Target)：被通知(被代理)的对象 注1：完成具体的业务逻辑 通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理) 注2：完成切面编程 代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知) 例子：外科医生+护士 注3：只有代理对象才有AOP功能，而AOP的代码是写在通.
Spring AOP中的前置通知和后置通知详解
weixin_33923148的博客
05-19 921
不同版本的spring对AOP的支持有所不同，spring2.0之前，它主要针对不同类型的拦截器使用XML配置文件通过代理来实现。而spring2.0之后，它可以使用JDK5的注解来完成AOP的实现，只是几个简单标签就可以完成，使得开发更加简单，便捷。所以推荐使用后一种方法。但是很多旧的项目中使用了前一种实现方法，所以我们也应该对第一种方法有所掌握。 ...
Spring入门知识 ———— 实现AOP前置通知以及后置通知
贱男
11-04 1376
一、引言 什么是前置通知和后置通知？ 前置通知：调用方法之前，后置通知：调用方法之后。 那比如之前实现的日志记录功能，都是在调用方法之前记录的日志，AOP可以很灵活的控制，切点在什么时候执行。 二、功能需求 还是拿我们之前代理那一章节中的例子。有一个针对用户的增删改查的方法，需要做日志记录。 public interface UserMange { void insertU...
Spring知识整理（六）Spring之AOP的前置通知，后置通知，返回通知，异常通知，环绕通知
疯子.
04-11 836
1.（AspectJ） •AspectJ：Java 社区里最完整最流行的 AOP 框架. •在 Spring2.0以上版本中, 可以使用基于 AspectJ注解或基于 XML 配置的 AOP •要在 Spring 应用中使用 AspectJ注解, 必须在 classpath下包含 AspectJ类库: aopalliance.jar、aspectj.weaver.jar 和 sprin...
Spring-Aspect> 切面类(@Aspect)首先必须是bean
qq_28829553的博客
04-18 1397
@[TOC](Spring-Aspect> 切面类(@Aspect)首先必须是bean) 问题描述 今天发现老工程里有个日志切面但是总是也没有执行过。 问题解决 1)怀疑是execution表达式问题，先后改动了AspectJ表达式也不生效。 2）在idea里打断点调试，tomcat启动后发现断点红圈没有打勾（这种情况就表示代码永远不会走进来）。 最后一看，这个被标注了@Aspe...
spring03-aop之xml配置, 前置通知,后置通知,异常通知,最终通知,环绕通知
github_37217206的博客
07-05 698
接上一讲 第三方的动态代理: package com.hr.cglib; import com.hr.proxy.IProducer; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.InvocationHandler; import java.lang.ref
Spring AOP 面向切面编程 常见通知实现（前置，后置，环绕，异常）
航天飞哥的博客
04-14 2411
AOP(Aspect-Oriented Programming) 1.面向切面编程 2.对传统的oop的补充 3.不是取代oop，经常和oop一起使用 切面：需要实现的交叉功能 连接点：应用程序执行过程中插入切面的地点：此处可是方法调用、异常抛出甚至是要修改的字段 通知：通知切面的实际实现。他通知应用系统新的行为，通知在连接点插入到应用系统中 切入点：定义
spring aop 通知类型
05-30
Spring AOP 中的通知类型有以下几种： 1. 前置通知（Before Advice）：在目标方法执行之前执行通知。 2. 后置通知（After Advice）：在目标方法执行之后执行通知，不论目标方法是否发生异常。 3. 返回通知（After...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值