Spring:AOP&XML配置&注解开发

最新推荐文章于 2023-06-08 10:03:35 发布
最新推荐文章于 2023-06-08 10:03:35 发布
阅读量267 收藏
点赞数
分类专栏： SSM框架 文章标签： AOP XML 注解开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/at10090/article/details/100880033
版权

1.Spring 的 AOP 简介

1.1 什么是 AOP

  • AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

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

1.2 AOP 的作用及其优势

  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

  • 优势：减少重复代码，提高开发效率，并且便于维护

1.3 AOP 的底层实现

  • 实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

1.4 AOP 的动态代理技术

  • 常用的动态代理技术

    • JDK 代理 : 基于接口的动态代理技术(必须有接口)

    • cglib 代理：基于父类的动态代理技术(不是继承)

在这里插入图片描述

1.5 JDK 的动态代理

  • 目标类接口

    public interface TargetInterface {
   public void method();
}

  • 目标类

    public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

  • 动态代理代码

    Target target = new Target(); //创建目标对象
Advice advice=new Advice(); //获得增强对象
//创建代理对象 
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
.getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
			//调用代理对象的如何方法,实质的都是invoke方法
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
                System.out.println("前置增强代码...");
                Object invoke = method.invoke(target, args);
                System.out.println("后置增强代码...");
                return invoke;
            }
        }
);

    生成的代理类与目标类的关系是兄弟关系,所以不能转换为目标类型,使用多态接收即可.
    在打印增强的位置使用增强对象进行增强即可,在AOP中是动态生成的.

  • 调用代理对象的方法测试

    // 测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

    在这里插入图片描述

1.6 cglib 的动态代理

  • 目标类

    public class Target {
  public void method() {
      System.out.println("Target running....");
  }
}

  • 动态代理代码

    Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

    cglib代理:目标对象一定不能用final修饰

  • 调用代理对象的方法测试

    //测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

    在这里插入图片描述

1.7 AOP 相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

  • 在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

    • Target（目标对象）：代理的目标对象

    • Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

    • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点(即所有可以被增强的方法)

    • Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义(要被增强的方法)

    • Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知(增强所进行的操作)

    • Aspect（切面）：是切入点和通知（引介）的结合(存放)

    • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

      后四个为重点
      切面与织入的区别:一个是存放切点和通知结合,而织入是实际进行通知与切点的结合的执行.就如中央下达文件,而地方执行文件一样.

1.8 AOP 开发明确的事项

1)需要编写的内容

  • 编写核心业务代码（目标类的目标方法）

  • 编写切面类，切面类中有通知(增强功能方法)

  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2）AOP 技术实现的内容
  • Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
3）AOP 底层使用哪种代理方式
  • 在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.9 知识要点

  • aop：面向切面编程

  • aop底层实现：基于JDK的动态代理 和 基于Cglib的动态代理

  • aop的重点概念：

    • Pointcut（切入点）：被增强的方法

    • Advice（通知/ 增强）：封装增强业务逻辑的方法

    • Aspect（切面）：切点+通知(存储)

    • Weaving（织入）：将切点与通知结合的过程

  • 开发明确事项：

    • 谁是切点（切点表达式配置）

    • 谁是通知（切面类中的增强方法）

    • 将切点和通知进行织入配置

2. 基于 XML 的 AOP 开发

2.1 快速入门

  • 流程

    • 导入 AOP 相关坐标

    • 创建目标接口和目标类（内部有切点）

    • 创建切面类（内部有增强方法）

    • 将目标类和切面类的对象创建权交给 spring

    • 在 applicationContext.xml 中配置织入关系

    • 测试代码

  • 导入 AOP 相关坐标

    <!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->8
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

    使用SpirngJuint测试Juint需要4.12以上

  • 创建目标接口和目标类（内部有切点）

    public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

  • 创建切面类（内部有增强方法）

    public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

  • 将目标类和切面类的对象创建权交给 spring

    <!--配置目标类-->
<bean id="target" class="com.itheima.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.itheima.aop.MyAspect"></bean>

  • 在 applicationContext.xml 中配置织入关系

    导入aop命名空间

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

  • 在 applicationContext.xml 中配置织入关系

    配置切点表达式和前置增强的织入关系

    <aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.method())"></aop:before>
    </aop:aspect>
</aop:config>

    <aop:config>:aop配置(织入)
    <aop:aspect >:配置切面
    ref="myAspect":指定切面类
    <aop:before>:配置切入方式(增强\通知 类型)
    method="before":配置增强方法(增强\通知)
    pointcut="execution(public void com.itheima.aop.Target.method())":配置切点表达式(切入点)

  • 测试代码

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

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

2.2 XML 配置 AOP 详解

1) 切点表达式的写法

表达式语法：

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

  • 访问修饰符可以省略

  • 返回值类型、包名、类名、方法名可以使用星号* 代表任意

  • 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类

  • 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.itheima.aop.Target.method())	//指定单个method方法
execution(void com.itheima.aop.Target.*(..))	//指定Target类下的任意方法
execution(* com.itheima.aop.*.*(..))	//指定aop包下的任意类的任意方法
execution(* com.itheima.aop..*.*(..))	//指定aop包下和子包下的任意方法
execution(* *..*.*(..))	//任意包下的任意类的任意方法
2) 通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>
名称标签说明
前置通知< aop:before >用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知< aop:after-returning>用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知< aop:around >用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知< aop:throwing >用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知< aop:after >用于配置最终通知。无论增强方式执行是否有异常都会执行

  • 执行顺序

    前置增强.......
环绕增强
seve running....
最终增强...............
环绕增强
后置增强.......

    异常抛出通知在异常位置进行抛出之前执行

  • 切面类

    public class MyAspect {
    //前置通知
    public void before() {
        System.out.println("前置增强.......");
    }

    //后置通知
    public void afterReturning() {
        System.out.println("后置增强.......");
    }

    //环绕通知
    //ProceedingJoinPoint:正在执行的连接点===切点
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强....");
        //切入点
        Object proceed = pjp.proceed();
        System.out.println("环绕后增强....");
        return proceed;
    }

    //抛出异常通知
    public void afterThrowing() {
        System.out.println("异常抛出增强...............");
    }

    //最终通知
    public void after() {
        System.out.println("最终增强...............");
    }

  • 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 id="target" class="com.itheima.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.itheima.aop.MyAspect"/>

    <!--配置织入,告诉Spring框架,那些方法(切入点)需要进行那些增强(前置,后置)-->
    <aop:config>
        <aop:aspect ref="myAspect">
            <!--切面:切入点+通知-->
            <!--<aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.save())"/>-->
            <!--前置通知-->
            <aop:before method="before" pointcut="execution( * com.itheima.aop.*.*(..))"/>
            <!--后置通知-->
            <aop:after-returning method="afterReturning" pointcut="execution( * com.itheima.aop.*.*(..))"/>
            <!--环绕通知-->
            <aop:around method="around" pointcut="execution( * com.itheima.aop.*.*(..))"/>
            <!--抛出异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut="execution(* com.itheima.aop.*.*(..))"/>
            <!--最终通知-->
            <aop:after method="after" pointcut="execution(* com.itheima.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>
3) 切点表达式的抽取

  • 当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

    <aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
    	<!--抽取切点表达式-->
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <!--切面:通知+切点-->
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

    <aop:pointcut >:切点表达式 expression表达式
    pointcut-ref:引用切点

2.3 知识要点

  • aop织入的配置
<aop:config>
    <aop:aspect ref=“切面类”>
        <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
    </aop:aspect>
</aop:config>
  • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知
  • 切点表达式的写法：
execution([修饰符] 返回值类型 包名.类名.方法名(参数))

3.基于注解的 AOP 开发

3.1 快速入门

  • 基于注解的aop开发步骤：

    • 创建目标接口和目标类（内部有切点）

    • 创建切面类（内部有增强方法）

    • 将目标类和切面类的对象创建权交给 spring

    • 在切面类中使用注解配置织入关系

    • 在配置文件中开启组件扫描和 AOP 的自动代理

    • 测试

  • 创建目标接口和目标类（内部有切点）

    public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

  • 创建切面类（内部有增强方法)

    public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

  • 将目标类和切面类的对象创建权交给 spring

    @Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

  • 在切面类中使用注解配置织入关系

    @Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

    @Aspect标志切面类
    @Bofore配置切入方式和切点(切点表达式)

  • 在配置文件中开启组件扫描和 AOP 的自动代理

    <!--组件扫描-->
<context:component-scan base-package="com.itheima.aop"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    注意必须在配置文件中编写<aop:aspectj-autoproxy>aop的自动代理,aop才有效果

  • 测试代码

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

  • 测试结果

    在这里插入图片描述

3.2 注解配置 AOP 详解

1) 注解通知的类型
  • 通知的配置语法：@通知注解(“切点表达式")
名称标签说明
前置通知@Before用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知@AfterReturning用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知@Around用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
常用抛出通知@AfterThrowing用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知@After用于配置最终通知。无论增强方式执行是否有异常都会执行

  • 执行顺序

    环绕通知
前置增强.......
seve running....
环绕通知
最终增强...............
后置增强.......

    异常抛出通知在异常位置进行抛出之前执行\

2) 切点表达式的抽取

  • 同 xml配置 aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

    @@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

提取的@Pointcut必须在空实现的方法上,因为注解必须寄生在方法或类一样
在调用时使用类名.方法名()进行引用

3.3 知识要点

  • 注解aop开发步骤

    • 使用@Aspect标注切面类

    • 使用@通知注解标注通知方法

    • 在配置文件中配置aop自动代理< aop:aspectj-autoproxy />
      建议先理解 XML配置后再学习注解

  • 通知注解类型

名称标签说明
前置通知@Before用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知@AfterReturning用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知@Around用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
常用抛出通知@AfterThrowing用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知@After用于配置最终通知。无论增强方式执行是否有异常都会执行
嘿嘿嘿1212
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring的AOP技术小结——基于xml和基于注解的两种方式
qq_35227352的博客
02-02 1077
AOP简介 重点概念： Pointcut（切入点）：被增强的方法 Advice（通知/增强）：封装增强业务逻辑的方法 Aspect（切面）：切点+通知 Weaving（织入）：将切点与通知结合的过程 基于xml的AOP开发： 步骤如下： 1、导入AOP的相关坐标：aspectjweaver 2、创建目标接口和目标类，即切点（被增强的方法） 3、创建切面类（内部由增强方法即通知） 4、在applicationContext.xml中配置目标对象和切面对象 5、在applicationConte
【Java学习笔记（四十五）】之AOP，基于XML的AOP，基于注解的AOP
开发小鸽
09-22 509
本文章由公号【开发小鸽】发布！欢迎关注！！！ 老规矩–妹妹镇楼： 一． AOP （一） 概述 &nbsp; &nbsp; &nbsp; &nbsp;Aspect Oriented Programming,面向切面编程，是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。动态代理的优点是不改变源码，进而增强代码的功能，它具有松耦合的优点。因此AOP可以对业务逻辑的各个部分进行松耦合，提高代码的可重用性。 （二） AOP的作用 &nbsp; &nbsp; &nbsp; &nb
AspectJ AOP的使用(@Before、@PointCut、@Around等)
qq_1763467007的博客
08-01 4806
最近在看一个项目中使用到AOP的功能，现在将自己过去所学的知识梳理一下。AspectJ AOP的使用(@Before、@PointCut、@Around等)
Spring AOP基础
c243311364的博客
04-29 653
目录 1.AspectJ注解驱动 2.编程方式实现AspectJ代理 3.@AspectJ PointCut指令与表达式 4.API实现Pointcut 5.@Around和@Pointcut有区别吗？ 6.@AspectJ后置动作 7.XML配置After Advice 8.API实现三种After Advice 1.AspectJ注解驱动 激活AspectJ模块 1.注解激活：@EnableAspectJAutoProxy 2.XML配置: &lt;aop:aspect.
java pointcut_Aspectj @Around pointcut Java中的所有方法
weixin_33421411的博客
02-16 596
我正在编写一个简单的计时器方面,以检测属于我的项目的所有程序包中的所有方法.但是,这些类中各种方法的返回类型不同,并且出现以下错误：它仅适用于二传手,而不适用于吸气剂.Error: applying to joinpoint that doesn’t return void这是我的时间.@Around("execution(* com.myproject..*(..))")public void ...
Spring使用AspectJ注解和XML配置实现AOP
09-01
本主题将深入探讨如何使用AspectJ注解和XML配置在Spring中实现AOP。 首先，我们要了解AOP的基本概念。AOP的核心是切面（Aspect），它将分散在多个对象中的横切关注点（如日志、性能监控）提取出来，形成独立的模块...
spring中AOP 注解开发示例详解
08-31
在Spring框架中，AOP...总之，Spring AOP的注解开发使得切面的定义和应用更加简洁，无需编写XML配置。通过这种方式，我们可以更轻松地实现如日志记录、事务管理等跨功能的需求，从而提高代码的可维护性和模块化程度。
spring aop注解配置代码实例
08-26
Spring AOP注解配置是Spring框架提供的一种便捷的面向切面编程的方式，它允许开发者在不使用XML配置的情况下，直接通过注解实现切面的功能。本文将深入探讨Spring AOP的注解配置，并通过具体的代码实例来阐述其使用...
Spring的注解配置与XML配置之间的比较
09-05
Spring框架的注解配置与XML配置是两种不同的配置方式，它们各自有其优势和适用场景。随着Spring框架的发展，注解配置逐渐成为主流，尤其是在Spring 2.5版本之后，其功能得到了极大的增强。 注解配置的优势在于它...
spring aop两种配置方式
09-03
} } 配置AOP在Spring配置文件中启用基于注解的AOP支持，并配置自动扫描的包，使得Spring能找到切面类 `&lt;aop:aspectj-autoproxy/&gt;` `&lt;context:component-scan base-package=&quot;com.bjsxt&quot;/&gt;` 第二种：XML配置第二种：...
Spring AOP使用@Around环绕切面，我sb地竟然影响实际业务了
史莱克小怪物们的博客
06-08 4185
切面把与第三方交互的信息写进ES日志，需要用到环绕增强，但是由于切面出错，竟然把实际业务给影响了，做下笔记，以免后犯。 1、切面中如以下方法，由于要获取请求方法参数，但是未处理参数中有request或者response或者其它的特别请求，在 JSON.toJSONString(“日志写请求参数”)时报错 ava.lang.IllegalStateException: It is illegal to call this method if the current request is not in asyn
基于@Aspectj使用Spring aop @Around进行权限拦截
coffeehot的专栏
01-07 780
转自：http://zhanghua.1199.blog.163.com/blog/static/464498072011111393634448/ 1 首先这是切面类，实现对所有action方法进行拦截   @Aspect@Componentpublic class PrivilegeInterceptor { @Pointcut(&quot;execution(java.lang.String ...
Spring Aop
YZR的博客
03-22 299
spring框架具有面向切面编程，即aop的功能，有两种方式可以实现，一种是基于XML配置aop，另外一种是使用注解。 除了spring框架的核心jar包之外，还需要导入以下jar包： aopalliance.jar    aspectjrt.jar    aspectjweaver.jar    spring-aop-3.2.5.RELEASE.jar 基于XML方式，需要导入aop命名空间
@Around简单使用示例——SpringAOP增强处理
别抢我蓝buff
05-23 1578
@Around的作用 既可以在目标方法之前织入增强动作，也可以在执行目标方法之后织入增强动作； 可以决定目标方法在什么时候执行，如何执行，甚至可以完全阻止目标目标方法的执行； 可以改变执行目标方法的参数值，也可以改变执行目标方法之后的返回值； ...
切换数据源的注解失效--代理对象冲突
最新发布
technology_tyro的博客
06-08 1256
将@Transactional注解添加到Service接口中的方法上的方式，避免在Controller类上添加@Transactional注解，在Service实现类上添加@DataSource注解，这样可以避免代理对象的冲突，也可以保证切面类可以正确的切入到被切方法中。controller上的@Transactional会生成一个代理对象，会包裹service实现类中的方法，而aspectj也是基于spring aop实现的，他生成的代理对象也会包裹service方法，这时就会导致代理对象冲突。
动态数据源切换
知行
04-11 2170
1.创建一个springboot项目 2.添加maven依赖 &lt;dependencies&gt; &lt;!-- SpringBoot AOP --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;/de
@Aspect AOP总结 @Pointcut @Around@Before@After 简单示例 以及对某一方法或者拥有某一注解的方法进行增强写法
weixin_44131922的博客
05-27 791
Maven &lt;dependency&gt; &lt;groupId&gt;org.aspectj&lt;/groupId&gt; &lt;artifactId&gt;aspectjrt&lt;/artifactId&gt; &lt;version&gt;1.7.4&lt;/version&gt; &lt;/dependency&gt; &lt;dependency&gt;
SpringBoot的AOP中PointCut表达式详解以及使用
China_C_boss的博客
02-24 4837
首先，在pom.xml中添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;/dependency&gt; 1.相关注解 @Before ...
springAOP.docx
04-16
在 Spring 中，AOP 的实现主要有两种方式：基于 XML 配置和基于注解配置。在 XML 配置中，我们通过定义切面、切入点、通知等元素来实现对代码的切面管理；而在注解配置中，我们通过注解的方式来表达切面和通知，使得...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嘿嘿嘿1212

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

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

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

打赏作者

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

抵扣说明：

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

余额充值