Spring AOP

最新推荐文章于 2024-04-29 17:13:16 发布
最新推荐文章于 2024-04-29 17:13:16 发布
阅读量179 收藏 1
点赞数 1
分类专栏： 笔记 Spring AOP 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43894816/article/details/119535142
版权

Spring AOP

什么是AOP

AOP：面向切面编程，功能是在不改变源代码的前提下，给核心业务添加功能

Aop的分类

AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理(AspectJ)和动态代理(Spring AOP)两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

使用Spring AOP

与 AspectJ 相同的是，Spring AOP 同样需要对目标类进行增强，也就是生成新的 AOP 代理类；与 AspectJ 不同的是，Spring AOP 无需使用任何特殊命令对 Java 源代码进行编译，它采用运行时动态地、在内存中临时生成“代理类”的方式来生成 AOP 代理。

Spring 允许使用 AspectJ Annotation 用于定义方面（Aspect）、切入点（Pointcut）和增强处理（Advice），Spring 框架则可识别并根据这些 Annotation 来生成 AOP 代理。Spring 只是使用了和 AspectJ 5 一样的注解，但并没有使用 AspectJ 的编译器或者织入器（Weaver），底层依然使用的是 Spring AOP，依然是在运行时动态生成 AOP 代理，并不依赖于 AspectJ 的编译器或者织入器。
简单地说，Spring 依然采用运行时生成动态代理的方式来增强目标对象，所以它不需要增加额外的编译，也不需要 AspectJ 的织入器支持；而 AspectJ 在采用编译时增强，所以 AspectJ 需要使用自己的编译器来编译 Java 文件，还需要织入器。

开启@Aspect注解

为了启用 Spring 对 @AspectJ 方面配置的支持，并保证 Spring 容器中的目标 Bean 被一个或多个切面类自动增强，必须在 Spring 配置文件中配置如下片段

<?xml version="1.0" encoding="GBK"?> 
 <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-3.0.xsd"> 
 <!-- 启动 @AspectJ 支持 --> 
 <aop:aspectj-autoproxy/> 
 </beans>

当启动了 @AspectJ 支持后，只要我们在 Spring 容器中配置一个带 @Aspect 注释的 Bean，Spring 将会自动识别该 Bean，并将该 Bean 作为方面 Bean 处理。

使用 @Aspect 标注一个 Java 类，该 Java 类将会作为方面 Bean，如下面代码片段所示：

// 使用 @Aspect 定义一个方面类
 @Aspect 
 public class LogAspect 
 { 
 // 定义该类的其他内容
 ... 
 }

AOP的底层原理

AOP底层使用的是动态代理

	动态代理有两种情况：
	
		1. 有接口，使用JDK动态代理，创建接口实现类对象，增强类的方法
		2. 没接口，使用CGLIB动态代理，创建子类的代理对象，增强类的方法
	
	eg.JDK动态代理，使用Proxy类里面的方法创建代理对象

	1.创建接口，定义方法
public interface UserDao {
 public int add(int a,int b);
 public String update(String id);
}

	2.创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
 @Override
 public int add(int a, int b) {
 return a+b;
 }
 @Override
 public String update(String id) {
 return id;
 } }

	3.创建增强类，实现InvocationHandler接口
		class UserDaoProxy implements InvocationHandler {
 //1 把创建的是谁的代理对象，把谁传递过来
 //有参数构造传递
 private Object obj;
 public UserDaoProxy(Object obj) {
 this.obj = obj;
 }
 //增强的逻辑
 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws 
Throwable {
 //方法之前
 System.out.println("方法之前执行...."+method.getName()+" :传递的参
数..."+ Arrays.toString(args));
 //被增强的方法执行
 Object res = method.invoke(obj, args);
 //方法之后
 System.out.println("方法之后执行...."+obj);
 return res;
 } }

4.使用Proxy类创建接口代理对象
public class JDKProxy {
 public static void main(String[] args) {
 //创建接口实现类代理对象
 Class[] interfaces = {UserDao.class};
 UserDaoImpl userDao = new UserDaoImpl();
 UserDao dao = 
(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
new UserDaoProxy(userDao));
int result = dao.add(1, 2);
 System.out.println("result:"+result);
 } }

相关解释：
jdk动态代理是通过反射来实现的，通过反射可以动态的创建对象，调用方法，创建对象的首先要获取类的class对象，再通过class对象的getConstructor（）创建对象

@Test
    public void test07()throws  Exception {
        Class classType=UserDaoImpl.class;
        Constructor constructor=classType.getConstructor(new Class[]{});
        UserDao userDaoImpl=(UserDaoImpl) constructor.newInstance(new Class[]{});

        int sum=userDaoImpl.add(1,9);
        System.out.println(sum);
    }

Proxy是java中的一个类

//创建代理对象
UserDao dao = 
(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
new UserDaoProxy(userDao));

nexProxyInstance有三个参数，类加载器（谁便一个类都行），包含接口的class数组，增强类（实现了invocationHandler接口的对象）
返回的dao对象就是一个代理对象

//创建增强类
public class UserDaoProxy implements InvocationHandler {
    private Object obj;

    public UserDaoProxy(Object obj) {
        this.obj = obj;
        System.out.println("增强类");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(Arrays.toString(args));
        Object res=method.invoke(obj,args);
        System.out.println("invoke被调用");
        return res;
    }
}

创建代理对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)：直接创建一个动态代理对象，该代理对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法，相当于把增强类的invoke方法嵌入到接口的所有方法中。所以使用代理对象调用方法就会调用增强类的invoke方法，这时可以在invoke方法中’method.invoke(obj,args)'调用被增强的方法。注意这和method.invoke()是没有关系的。proxy是Proxy的实例对象，method是被调用的方法的method对象，args是调用方法时传进来的参数。调用代理对象的方法相当于调用增强类的invoke方法，在增强类的invoke()中调用method的invoke（obj,args）才是调用被增强类的方法，obj是被增强类的实例对象。

Spring AOP的相关术语

  1. 连接点：类中可以被增强的方法，这些方法称为连接点。

  2. 切入点：被增强的方法，称为切入点

  3. 通知（增强）：实际增强的逻辑部分称为通知（增强）

  4. 通知的类型：

    @Before 前置通知 被增强类方法执行前执行
    @AfterReturning 返回通知 方法后执行(5个常用通知中最后执行)
    @Around 环绕通知 方法前执行。方法后结束
    @AfterThrowing 异常通知
    @After 最终通知 方法后执行，如果有环绕通知后于环绕通知执行

  5. 切面：把通知应用到切入点的过程，注意是一个过程

  6. 切面类：把通知应用到切入点的类，我习惯把他称为增强类

  7. 切入点表达式：用于确定切面类中的通知应该增强哪个类的哪个方法

切入点表达式execution的语法规则

execution（注解？修饰符？返回值类型 类型声明？方法名（参数）异常？）

  1. 注解：可选，如要hock注解，则必须添加。例如execution(@java.lang.Override * *(. .))
  2. 修饰符：可选，如public，protected，写在返回值前；
  3. 返回值类型：必选，可以使用 * 来代表任意返回值；
  4. 类型声明：可选，可以是任意类型；
  5. 方法名：必选，可以用*来代表任意方法；
  6. 参数：()代表是没有参数，(. .)代表是匹配任意数量，任意类型的参数，当然也可以指定类型的参数进行匹配，如要接受一个String类型的参数，则(java.lang.String)；任意数量的String类型参数：(java.lang.String. .)；第一个是任意类型，第二个是String的参数匹配：(*,java.lang.String)等等；
  7. 异常：可选，语法：“throws 任意异常类型”，可以是多个，用逗号分隔，例如：throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException。

注意：问号前面的都是可写可不写，没有问号的都是必写，例如返回值类型，和方法名。以上所有的类都需要是全类名写入，不能简写（就是你不能模糊用 * 代替）。
举几个例子：
execution(* *(. .)) 这是最基本的，意思是切点为所有返回值类
型，对所有包下的类的方法，因为就算你可选的不写，但是这两个必须写

execution(public * *(. .)) 可选的加进去后，可任意加都可识别，但是返回值和方法必须有，这里切点范围就为public类型，任意返回值，任意包下所有类的方法。

execution(void com.csdn.*(. .)) 对返回值为void，在包com.csdn下的所有类方法设置为切点（不包含子包，就是这个包下面没有包了，全是类）

execution(void com.csdn. .*(. .)) 对返回值为void，在包com.csdn下的子孙包和自身下的所有类方法设置为切点(这里两个点，上面那个一个点)

execution(* com.csdn.User.*(. .)) 对返回值类型任意，在com.csdn下具体类User里的方法设置为切点

所以execution里面必须有返回值类型，和方法名俩个筛选的基础，那些其余可以加上，将筛选条件范围减小。

切面类

切面类（用 @Aspect 修饰的类）和其他类一样可以有方法、属性定义，还可能包括切入点、增强处理定义。

当我们使用 @Aspect 来修饰一个 Java 类之后，Spring 将不会把该 Bean 当成组件 Bean 处理，因此负责自动增强的后处理 Bean 将会略过该 Bean，不会对该 Bean 进行任何增强处理。

开发时无须担心使用 @Aspect 定义的方面类被增强处理，当 Spring 容器检测到某个 Bean 类使用了 @Aspect 标注之后，Spring 容器不会对该 Bean 类进行增强。

注解如何实现切面

1.设置切面类，用@org.aspectj.lang.annotation.Aspect在类前申明该类为切面类（这样在bean配置时候，扫描注解可以节省时间）
2.在切面里设置通知方法，这里不像传统aop需要实现某个接口
3.在方法前面设置注解，什么类型的注解，最上面有解释，这里就是通知
4.在通知注解里使用execution设置切点范围
在一个类里面就实现了通知和切点，该类就成了切面类
5.在配置文件里申明bean，那么这个类里面的注解就被激活了，因为被aop:aspectj-autoproxy/扫描了，实现了功能。

基于@AspectJ注解实现AOP操作

//定义接口
public interface UserDao {
    public  int add(int a,int b);
    public String update(String id);
}

//创建接口实现类
@Component
public class UserDaoImpl implements UserDao{
    public UserDaoImpl() {
        System.out.println("无参构造方法调用");
    }

    public int add(int a, int b) {
        System.out.println("add方法调用");
        return a+b;
    }

    public String update(String id) {
        return id;
    }
}

//创建切面类
@Component
@Aspect
public class UserDaoProxy02 {

    @AfterReturning(value = "execution(* com.cailibin.UserDaoImpl.add(..))",returning = "returnValue")
    public void afterReturning(JoinPoint joinPoint,Object returnValue){
//        System.out.println(Arrays.toString(joinPoint.getArgs()));

        System.out.println("AfterReturning获得的值："+returnValue);
        System.out.println("AfterReturning返回通知.....");
    }
   @After("execution(* com.cailibin.UserDaoImpl.add(..))")
    public void after(JoinPoint joinPoint){

        System.out.println("After最终通知.....");
    }
    @Around("execution(* com.cailibin.UserDaoImpl.add(..))")
    public int around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        System.out.println("AroundStart环绕开始.....");
       Object[] arr= proceedingJoinPoint.getArgs();//proceedingJoinPoint可以获取方法参数
       //System.out.println(Arrays.toString(arr));
       int returnValue=(int)proceedingJoinPoint.proceed(arr);//执行方法
        System.out.println("环绕通知获得原方法的返回值："+returnValue);
        System.out.println("Aroundend环绕结束...");
        returnValue=0;//修改原方法的返回值，测试方法和AfterReturning通知获得的值就是该值
        return returnValue;
    }
    @Before("execution(public int com.cailibin.UserDaoImpl.add(..))")
    public void before(JoinPoint joinPoint){

//        System.out.println(Arrays.toString(joinPoint.getArgs()));
        System.out.println("before开始通知.....");
    }
}

//spring的配置文件，component-scan扫描注解，aspectJ-autoproxy启用@AspectJ注解
<?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.cailibin"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

//测试方法
@Test
    public  void test05(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        UserDao userDao=context.getBean("userDaoImpl",UserDao.class);
        System.out.println("代理类对象："+userDao.getClass());
        int s=userDao.add(1,3);
      System.out.println("测试方法获得的值："+s);
    }

执行结果：

构造方法执行了
无参构造方法调用
代理类对象：class com.sun.proxy.$Proxy25
AroundStart环绕开始…
before开始通知…
add方法调用
环绕通知获得原方法的返回值：4
Aroundend环绕结束…
After最终通知…
AfterReturning获得的值：0
AfterReturning返回通知…
测试方法获得的值：0

Process finished with exit code 0

UserDao userDao=context.getBean(“userDaoImpl”,UserDao.class);由名称和类型或名称可以获取Spring AOP动态生成的AOP代理类对象userDao，但是由名获取到的对象要进行强制类型转换。userDao对象是userDao接口的实现类的实例。Spring AOP 框架对 AOP 代理类的处理原则是：如果目标对象的实现类实现了接口，Spring AOP 将会采用 JDK 动态代理来生成 AOP 代理类；如果目标对象的实现类没有实现接口，Spring AOP 将会采用 CGLIB 来生成 AOP 代理类——不过这个选择过程对开发者完全透明、开发者也无需关心。AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异：AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。
所以，
有接口用jdk动态代理，代理对象是接口的实现类的实例。
无接口用cglib代理，代理对象是原类的子类的实例。
该代理对象的实现类实现了接口或原类的全部方法，执行代理对象的每个方法都会替换成InvocationHandler的invoke方法。

抽取相同切入点

//创建一个新的类，并添加@Pointcut注解和通知要注入的方法的全类名
 @Pointcut(value ="execution(* com.cailibin.UserDaoImpl.add())")
    public void pointcut(){}

//直接在通知注解中写入pointcut的全类名
@After("com.cailibin.UserDaoImpl.pointcut()")
    public void after(JoinPoint joinPoint){

        System.out.println("After最终通知.....");
    }

增强类的优先级

有多个增强类对同一个方法进行增强，可以设置增强类优先级
在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy{}

完全注解开发

//创建配置类
@Configuration
//注解扫描
@ComponentScan(basePackages ={"com.cailibin"})
//自动创建代理对象
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ComfigAop {
}

@Test
    public void test08(){
    //从java类中获取应用上下文
        ApplicationContext context=new AnnotationConfigApplicationContext(ComfigAop.class);
        UserDao userDao=context.getBean("userDaoImpl",UserDao.class);
        System.out.println("代理类对象："+userDao.getClass());
        int s=userDao.add(1,3);
        System.out.println("测试方法获得的值："+s);
    }

基于XML的Spring AOP开发

<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"
       xmlns:context="http://www.springframework.org/schema/context"
       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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--<context:component-scan base-package=""-->

    <!-- 定义目标对象 -->
    <bean name="productDao" class="com.zejian.spring.springAop.dao.daoimp.ProductDaoImpl" />

    <!-- 定义切面 -->
    <bean name="myAspectXML" class="com.zejian.spring.springAop.AspectJ.MyAspectXML" />
    <!-- 配置AOP 切面 -->
    <aop:config>
        <!-- 定义切点函数 -->
        <aop:pointcut id="pointcut" expression="execution(* com.zejian.spring.springAop.dao.ProductDao.add(..))" />

        <!-- 定义其他切点函数 -->
        <aop:pointcut id="delPointcut" expression="execution(* com.zejian.spring.springAop.dao.ProductDao.delete(..))" />

        <!-- 定义通知 order 定义优先级,值越小优先级越大-->
        <aop:aspect ref="myAspectXML" order="0">
            <!-- 定义通知
            method 指定通知方法名,必须与MyAspectXML中的相同
            pointcut 指定切点函数
            -->
            <aop:before method="before" pointcut-ref="pointcut" />

            <!-- 后置通知  returning="returnVal" 定义返回值 必须与类中声明的名称一样-->
            <aop:after-returning method="afterReturn" pointcut-ref="pointcut"  returning="returnVal" />

            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pointcut"  />

            <!--异常通知 throwing="throwable" 指定异常通知错误信息变量,必须与类中声明的名称一样-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="throwable"/>

            <!--
                 method : 通知的方法(最终通知)
                 pointcut-ref : 通知应用到的切点方法
                -->
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
菜里都傻
关注
专栏目录
面向切面的Spring(一) AOP术语、AspectJ表达式说明，execution表达式含有注解写法
z1340954953
05-31 1558
AOP术语 如果要重用通用功能的话，常见的面向对象技术是继承或委托，但是如果在整个应用中都是用相同的基类，继承往往会导致一个脆弱的体系，而使用委托则有比较复杂的调用 切面，就是将关注的功能模块化为特殊的类，这类就是切面。 通知Advice: 切面中具体要做的事情，分为前置、后置、返回、异常、环绕通知。 连接点(Joint point): 执行过程中能够插入切面的一个点。 切点(Poi...
Pointcut注解表达式execution、@target、@annotation、@within等
HD243608836的博客
08-31 9134
简介 在Spring AOP概述中我们重点注意的是AOP的整体流程和Advice，简化了一些其他的东西，其中就有一些对灵活应用Spring AOP很重要的知识点，例如Pointcut表达式，下面就介绍一下Spring AOP的Pointcut表达式。 如果你对Pointcut表达式的作用还不是很了解，可以先看一下Spring AOP概述，也可以先了解一下匹配规则，后面会有一些具体的例子来帮助理...
Spring AOP相关注解与execution 切点表达式概述
最新发布
ZhShH0413的博客
04-29 1101
Spring AOP（面向切面编程）通过一系列注解来实现切面的定义和织入，从而达到将横切关注点（比如日志记录、事务管理、安全性检查等）与核心业务逻辑分离的目的。以下是Spring AOP中一些关键的注解及其用途切入点声明，即切入到哪些目标类的目标方法。既可以用 execution 切点表达式, 也可以是 annotation 指定拦截拥有指定的方法.value 属性指定切入点表达式，默认为 ""，用于被通知注解引用，这样通知注解只需要关联此切入点声明即可，无需再重复写切入点表达式。
springboot下的spring aop注解实现和execution正则实现
奔跑的菜鸡
08-23 2811
先上maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 一个简单的增删改查service(被切入的类) package com.fchan.layui.service; import com.fasterxml.jackson.
Spring 自定义注解
yghandsome的博客
08-31 760
Java 注解是JDK5.0引入的一种注释机制，它可以用在类、方法、变量、参数上，注解是通过Java反射机制获取标注的内容，从而供指定的工具类或者框架使用。
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
spring AOP 引入jar包，spring IOC 引入Jar包
09-07
Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...
(基于注解方式)AOP断言表达式execution
CW_SZDX的博客
11-24 993
【代码】AOP断言表达式execution。
Spring学习之使用注解配置AOP
曾经沧海难为水，除却巫山不是云
07-15 849
Spring学习之使用注解配置AOP前言在前面的学习中，基本了解了AOP的概念，以及在使用原始的方法在Spring中配置AOP，不过在前面我们也看到了，通过编程的方式来实现AOP是比较繁琐，而且扩展性比较低了，所以Spring对AOP的配置方式进行了很大的改进，并且提供了更加方便的配置方式，本小节主要来学习使用注解进行配合，这是在使用Spring AOP中最常使用的方式了。切点函数在前面的内容中，我
@annotation切点表达式和@execution切点表达式的区别和联系？
gb4215287的博客
12-15 901
@annotation切点表达式和@execution切点表达式的区别和联系？
spring aop 中@annotation()的使用，关于自定义注解，绝壁原创的文章
热门推荐
请叫我大师兄
12-14 1万+
在自定义个注解之后，通过这个注解，标注需要切入的方法，同时把需要的参数传到切面去。那么我们怎么在切面使用这个注解。 我们使用这个自定义注解一方面是为了传一些参数，另一方面也是为了省事。 具体怎么省事，看我下面的例子就造啦。 一般，别人的切面都是这么写的 先声明一个切入点。 //切入点签名 @Pointcut("execution(* com.lxk.spring.aop
AOP源码分析三：pointcut的配置说明
qq_28825857的博客
09-02 701
aop配置中有如下一行： <aop:pointcut expression="execution(* com.aop.service..*(..))" 其中expression="execution(* com.aop.service..*(..))"的配置规则如下： execution(modifiers-pattern? ret-type-pattern declaring-...
Spring @Pointcut
FREEDOM
01-27 5036
AOP的基本概念 Advice(通知、切面)： 某个连接点所采用的处理逻辑，也就是向连接点注入的代码， AOP在特定的切入点上执行的增强处理。 @Before：标识一个前置增强方法，相当于BeforeAdvice的功能. @After：final增强，不管是抛出异常或者正常退出都会执行. @AfterReturning： 后置增强，似于AfterReturningAdvice, ...
@DisallowConcurrentExecution 注解
winwinwin99的博客
05-18 4005
Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。 在Spring中这时需要设置concurrent的值为false, 禁止并发执行。 <property name="concurrent" value="true" /> 当不使用spring的时候就需要在Job的实现类上加@DisallowConcurrentExecution的注释 @DisallowConcurrentExecu.
Spring AOP execution表达式，拦截 参数被注解注释了的方法
蛋壳城堡
10-30 7867
问题描述：        项目中碰到一个需求，希望所有“存在参数被自定义注解@RequestModel注释”了的方法都被切面拦截，在实际逻辑执行前，先进行参数验证。 @RequestMapping(value = "list", method = {RequestMethod.GET}) public ResultModel list(@RequestModel RoleLi...
spring AspectJ的Execution表达式-备忘笔记(转)
zhuchengzzcc的专栏
04-28 2288
Aspectj切入点语法定义 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如定义切入点表达式  execution (* com.sample.service.impl..*.*(..)) execution()是最常用的切点函数，其语法如下所示：  整个表达式可以分为五个部分：  1、execution():...
spring aop
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中、具有共同逻辑的行为，例如日志记录、事务管理、安全检查等。 通过使用Spring AOP，开发者可以将这些横切关注点从业务逻辑代码中剥离出来，以便于在不同模块中重复使用，并且能够更好地实现模块化开发。Spring AOP基于AOP的思想，通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了与业务代码的解耦。 Spring AOP主要通过定义切面（Aspect）和连接点（Join Point）来实现，其中切面定义了横切关注点的逻辑，而连接点则指定了在目标对象中哪些方法需要织入切面逻辑。Spring AOP支持多种类型的通知（Advice），包括前置通知（Before Advice）、后置通知（After Advice）、异常通知（After-Throwing Advice）、返回通知（After-Returning Advice）和环绕通知（Around Advice），开发者可以根据需要选择合适的通知类型。 总的来说，Spring AOP是Spring框架中的一个重要特性，它通过在运行时动态地将横切关注点织入到目标对象的方法中，实现了对应用程序中横切关注点的解耦，提高了代码的可维护性和可重用性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜里都傻

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

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

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

打赏作者

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

抵扣说明：

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

余额充值