精华内容
下载资源
问答
  • Spring 配置AOP Spring注解配置AOP Spring XML 配置AOP Spring Aspect AOP

    一、前言

        Spring的特性之一AOP,老生常谈的问题,今天来记录下,Spring 框架中如何配置AOP的问题,注意下哈,非Spring Boot哈; 同时本文以 AOP切面中的表达式 @annotation 为准,还有其他多种类型,请自行了解。

     

    二、依赖pom 和 基础配置

        1、Sping 和 Aspect

    <dependency>
    	    <groupId>org.springframework</groupId>
    	    <artifactId>spring-webmvc</artifactId>
    	    <version>4.3.20.RELEASE</version>
    	</dependency>
     
      <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    	<dependency>
    	    <groupId>org.aspectj</groupId>
    	    <artifactId>aspectjweaver</artifactId>
    	    <version>1.9.0</version>
    	</dependency>
    	
    	<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    	<dependency>
    	    <groupId>org.aspectj</groupId>
    	    <artifactId>aspectjweaver</artifactId>
    	    <version>1.9.0</version>
    	</dependency>

     

        2、springmvc.xml 中增加文件头

     xmlns:aop="http://www.springframework.org/schema/aop"
    
    xsi:schemaLocation="http://www.springframework.org/schema/aop
    		http://www.springframework.org/schema/aop/spring-aop.xsd"

    <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:mvc="http://www.springframework.org/schema/mvc"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd

    http://www.springframework.org/schema/aop

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

     

    三、AOP xml形式配置

        1、创建 Log注解

    /**
     * description: Log 注解 
     * @version v1.0
     * @author w
     * @date 2021年5月12日上午9:45:15
     **/
    @Target(value = { ElementType.METHOD })
    @Retention(value = RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Log {
    
    	String name() default "";
    }

     

        2、创建 LogAspect 类, 配置相关切点和增加方法

    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    
    /**
     * description: AOP xml形式配置
     * @version v1.0
     * @author w
     * @date 2021年5月12日上午9:47:04
     **/
    @Component
    public class LogAspect {
    	
    	/**
    	 * description: 切点
    	 * @return void
    	 * @version v1.0
    	 * @author w
    	 * @date 2021年5月12日 上午9:47:52
    	 */
    	public void pointCut() {
    		
    	}
    	
    	public Object arounds(ProceedingJoinPoint joinPoint) {
    		Signature signature = joinPoint.getSignature();
    		MethodSignature methodSignature = (MethodSignature)signature;
    		Log log = methodSignature.getMethod().getAnnotation(Log.class);
    		// 方法执行前 
    		System.out.println("开始日志记录:" + log.name());
    		// 方法执行
    		try {
    			return joinPoint.proceed();
    		} catch (Throwable e) {
    			return e ;
    		}finally {
    			// 方法执行后
    			System.out.println("日志记录执行完毕 ===== ");
    		}
    		
    	}
    }

     

        3、springmvc.xml 中配置AOP 使用

     <!-- 配置AOP xml 形式 -->
        <aop:config>
        	<aop:pointcut expression="@annotation(com.runcode.aspect.Log)" id="point"/>
        	<aop:aspect ref="logAspect" order="10">
        		<aop:around method="arounds" pointcut-ref="point"/>
        	</aop:aspect>
        </aop:config>
    	<!-- 配置AOP xml end -->

     

        4、创建 AspectController

        @Log(name="web层")
    	@RequestMapping(value= "/aspectController")
    	@ResponseBody
    	public String test(String name) {
    		System.out.println("AspectController : "+ name);
    		return "AspectController : "+ name;
    	}

     

        5、请求测试,查看控制台输出值情况; 方法得到增强,AOP 成功

    开始日志记录:web层
    AspectController : null
    日志记录执行完毕 ===== 

     

    四、AOP 注解形式配置

        1、创建 LogAnon 注解

    /**
     * description: LogAnon 注解 
     * @version v1.0
     * @author w
     * @date 2021年5月12日上午9:45:15
     **/
    @Target(value = { ElementType.METHOD })
    @Retention(value = RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface LogAnon {
    
    	String name() default "";
    }

     

        2、创建 LogAspectAnon 类,使用注解形式配置切点和增强方法

    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    /**
     * description: AOP 注解形式配置
     * @version v1.0
     * @author w
     * @date 2021年5月12日上午10:07:24
     **/
    @Aspect
    @Component
    // 有多个AOP配置,可使用order来确定执行顺序
    @Order(value = 1)
    // 可以在xml配置文件中,去掉 <aop:aspectj-autoproxy/> 标签,使用 该注解
    // @EnableAspectJAutoProxy
    public class LogAspectAnon {
    	
    	/**
    	 * description: 配置切点 
    	 * @return void
    	 * @version v1.0
    	 * @author w
    	 * @date 2021年5月12日 上午10:15:20
    	 */
    	@Pointcut(value = "@annotation(com.runcode.aspect.LogAnon)")
    	public void pointCuts() {
    		
    	}
    	
    	@Around(value = "pointCuts()")
    	public Object arounds(ProceedingJoinPoint joinPoint) {
    		Signature signature = joinPoint.getSignature();
    		MethodSignature methodSignature = (MethodSignature)signature;
    		LogAnon log = methodSignature.getMethod().getAnnotation(LogAnon.class);
    		// 方法执行前 
    		System.out.println("【注解】开始日志记录:" + log.name());
    		// 方法执行
    		try {
    			return joinPoint.proceed();
    		} catch (Throwable e) {
    			return e ;
    		}finally {
    			// 方法执行后
    			System.out.println("【注解】日志记录执行完毕 ===== ");
    		}
    		
    	}
    	
    }
    

     

        3、springmvc.xml 中配置 AOP 启用注解形式实现 (没错,就一行代码)

    <!-- 配置AOP 注解形式 -->
    <!-- 在类上面使用 @EnableAspectJAutoProxy 注解,可以去掉该标签配置 -->
    	<aop:aspectj-autoproxy/>

     

        4、使用 AspectController 进行测试

        @LogAnon(name = "web层 注解")
    	@RequestMapping(value= "/aspectController")
    	@ResponseBody
    	public String test(String name) {
    		System.out.println("AspectController : "+ name);
    		return "AspectController : "+ name;
    	}

        5、请求测试,查看控制台输出值情况; 方法得到增强,AOP 成功

    【注解】开始日志记录:web层 注解
    AspectController : null
    【注解】日志记录执行完毕 ===== 

     

    五、总结

        1、本文简单的记录了,Spring 实现AOP的过程;基于注解的形式实现。(Spring 切点

     

        2、若使用注解的形式实现AOP,且在传统SSM项目中,需要分别在 spring.xml 和springmvc.xml 配置文件中,启用注解(spring 和 springMVC的容器问题) ; 使用配置文件形式,则不需要区分。

     

        3、在Spring Boot项目中,使用注解实现AOP,不需要启用注解的步骤。

     

     

    展开全文
  • Spring实现AOP的三种方法 Spring实现AOP的三种方法 使用原生的Spring API接口 自定义类实现AOP 使用注解实现AOP 第一种方式:使用原生的Spring API接口 创建测试接口 public interface UserService { ...

    Spring实现AOP的三种方法

     

    Spring实现AOP的三种方法

    使用原生的Spring API接口

    自定义类实现AOP

    使用注解实现AOP


     

    第一种方式:使用原生的Spring API接口

    • 创建测试接口
    public interface UserService {
        public void add();
        public int delete();
        public void update();
        public void select();
    }
    • 实现测试接口
    
    public class UserServiceImpl implements UserService {
        public void add() {
            System.out.println("执行了add 方法");
        }
    
        public int delete() {
            System.out.println("执行了delete方法");
            return 10;
        }
    
        public void update() {
            System.out.println("执行了更新方法");
        }
    
        public void select() {
            System.out.println("执行了查询操作");
        }
    }
    • 配置application.xml
         <!--注册bean到Spring容器中-->
            <bean id="userService" class="com.wangjw.service.UserServiceImpl"/>
            <bean id="log" class="com.wangjw.log.Log"/>
            <bean id="afterLog" class="com.wangjw.log.AfterLog"/>
    
            <aop:config>
                <!--切入点-->
                <aop:pointcut id="pointcut" expression="execution(* com.wangjw.service.UserServiceImpl.*(..))"/>
                <!--执行环绕增强-->
                <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
                <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
            </aop:config>
    • 实现AOP接口

    根据需要,实现相关的接口的方法即可,此处只列举AfterReturningAdviceMethodBeforeAdvice

    import org.springframework.aop.AfterReturningAdvice;
    
    import java.lang.reflect.Method;
    
    public class AfterLog implements AfterReturningAdvice {
    
        public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
            System.out.println("执行了"+method.getName()+"返回结果:0"+o);
        }
    }
    
    
    /**各参数含义
    	 * Callback after a given method successfully returned.
    	 * @param returnValue the value returned by the method, if any
    	 * @param method the method being invoked
    	 * @param args the arguments to the method
    	 * @param target the target of the method invocation. May be {@code null}.
    	 * @throws Throwable if this object wishes to abort the call.
    	 * Any exception thrown will be returned to the caller if it's
    	 * allowed by the method signature. Otherwise the exception
    	 * will be wrapped as a runtime exception.
    	 */
    
    
    import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    
    public class Before implements MethodBeforeAdvice {
        public void before(Method method, Object[] target, Object o) throws Throwable {
            System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
        }
    }
    
    /** 各参数含义
    	 * Callback before a given method is invoked.
    	 * @param method the method being invoked
    	 * @param args the arguments to the method
    	 * @param target the target of the method invocation. May be {@code null}.
    	 * @throws Throwable if this object wishes to abort the call.
    	 * Any exception thrown will be returned to the caller if it's
    	 * allowed by the method signature. Otherwise the exception
    	 * will be wrapped as a runtime exception.
    	 */
    • 测试
    public class MyTest {
    
        @Test
        public void test1(){
            ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
            UserService userService = context.getBean("userService", UserService.class);
            userService.add();
            System.out.println("*********************");
            userService.delete();
        }
    }
    /** 结果输出
    [Ljava.lang.Object;的add被执行了
    执行了add 方法
    执行了add返回结果:0null
    *********************
    [Ljava.lang.Object;的delete被执行了
    执行了delete方法
    执行了delete返回结果:010
    **/

    第二种方式:自定义类实现AOP

    • 自定义类
    public class Diy {
        public void before(){
            System.out.println("方法执行前");
        }
    
        public void after(){
            System.out.println("方法执行后");
        }
    }
    • 配置application.xml
        <!--注册bean到Spring容器中-->
        <bean id="diy" class="com.wangjw.diy.Diy"/>
        <aop:config>
            <!--配置切面-->
            <aop:aspect id="" ref="diy">
    
                <!--切入点-->
                <aop:pointcut id="pointcut" expression="execution(* com.wangjw.service.UserServiceImpl.*(..))"/>
                <!--通知-->
                <aop:before method="before" pointcut-ref="pointcut"/>
                <aop:after method="after" pointcut-ref="pointcut"/>
    
            </aop:aspect>
    
        </aop:config>
    • 测试
    public class MyTest {
    
        @Test
        public void test1(){
            ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
            UserService userService = context.getBean("userService", UserService.class);
            userService.add();
            System.out.println("*********************");
            userService.delete();
        }
    }
    
    /** 结果输出
    方法执行前
    执行了add 方法
    方法执行后
    *********************
    方法执行前
    执行了delete方法
    方法执行后
    **/
    

    第三种方式:基于注解实现AOP

    • 自定义切面
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    
    @Aspect
    public class AnnotationAop {
    
        
        @Before("execution(* com.wangjw.service.UserServiceImpl.*(..))")
        public void before(){
            System.out.println("使用注解实现AOP之方法执行前");
        }
    
    
        @After("execution(* com.wangjw.service.UserServiceImpl.*(..))")
        public void after(){
            System.out.println("使用注解实现AOP之方法执行后");
        }
    }
    • 配置application.xml
        <!--注册切面到Spring容器中-->
        <bean class="com.wangjw.diy.AnnotationAop" id="annotationAop"/>
        <!--开启aop注解的支持-->
        <aop:aspectj-autoproxy/>
    • 测试
    public class MyTest {
    
        @Test
        public void test1(){
            ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
            UserService userService = context.getBean("userService", UserService.class);
            userService.add();
            System.out.println("*********************");
            userService.delete();
        }
    }
            /** 结果输出 
            使用注解实现AOP之方法执行前
            执行了add 方法
            使用注解实现AOP之方法执行后
            *********************
            使用注解实现AOP之方法执行前
            执行了delete方法
            使用注解实现AOP之方法执行后
            **/

     

    展开全文
  • spring aop的jar包依赖

    2021-05-25 22:11:23
    跟着尚硅谷的spring5,aop配置时,jar包一些用了老师提供的5.2.6,一些用了自己下载的5.3.6,出现了方法找不到的错误,知道是jar包问题,不知道是哪个jar包的问题。 错误提示如下: 空指针异常,Error creating bean...

    跟着尚硅谷的spring5,aop配置时,jar包一些用了老师提供的5.2.6,一些用了自己下载的5.3.6,出现了方法找不到的错误,知道是jar包问题,不知道是哪个jar包的问题。
    错误提示如下:
    空指针异常,Error creating bean with name ‘org.springframework.aop.config.internalAutoProxyCreator’;
    caused by java.lang.NoSuchMethodError: org.springframework.util.ReflectionUtils;
    此处略去一万字的调试找错过程。
    最终发现老师的其他依赖没问题,主要是spring的一些包不能混用版本,都改成5.3.6后,终于可以了。就这破玩意儿导致我近乎一周没心思专心学习,我可能真的是耐心不大够叭,以后切记,以此文为记录这个破烂但很恶心的问题。
    有需要jar包的链接放下面了,好像不能设置免费下载,就把积分设成了最低,方便有缘人路过自取叭。
    https://download.csdn.net/download/forthefuture_/19067331

    展开全文
  • Spring中的AOP AOP(Aspect Oriented Programming)面向切面编程。 通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术 AOP是OOP(面向对象编程)的补充。 AOP可以将我们重复的代码抽取出来,在...

    Spring中的AOP

    AOP(Aspect Oriented Programming)面向切面编程

    通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术

    AOP是OOP(面向对象编程)的补充。

    AOP可以将我们重复的代码抽取出来,在需要执行的时候,使用动态代理技术,在不修改源代码的基础上,对我们的方法进行增强

    通俗的讲:将通用的功能(权限、日志、事务···)封装起来,作为一个切面,在类的执行中,找一个合适的时机,将我们的切面切入到执行流程中。

    在这里插入图片描述

    AOP中的名词和通知

    SpringAOP的名词

    • 切面(Aspect):被抽取的公共模块,可能会横切多个对象。 在Spring AOP中,切面可以使用通用类(基于模式的风格) 或者在普通类中以 @AspectJ 注解来实现。
    • 连接点(Join point):指方法,在Spring AOP中,一个连接点 总是 代表一个方法的执行。
    • 通知(Advice):在切面的某个特定的连接点(Join point)上执行的动作。通知有各种类型,其中包括“around”、“before”和“after”等通知。许多AOP框架,包括Spring,都是以拦截器做通知模型, 并维护一个以连接点为中心的拦截器链。
    • 切点(Pointcut):切入点是指 我们要对哪些连接点(Join point)进行拦截的定义。通过切入点表达式,指定拦截的方法,比如指定拦截add、search。
    • 引入(Introduction):(也被称为内部类型声明(inter-type declaration))。声明额外的方法或者某个类型的字段。Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。例如,你可以使用一个引入来使bean实现 IsModified 接口,以便简化缓存机制。
    • 织入(Weaving):指把增强应用到目标对象来创建新的代理对象的过程。Spring是在运行时完成织入。
    • 目标对象(Target Object): 被一个或者多个切面(aspect)所通知(advise)的对象。也有人把它叫做 被通知(adviced) 对象。 既然Spring AOP是通过运行时代理实现的,这个对象永远是一个 被代理(proxied) 对象。

    切入点(pointcut)和连接点(join point)匹配的概念是AOP的关键,这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知(advice)可独立于OO层次。 例如,一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上(例如服务层的所有业务操作)。

    Spring中通知的类型

    • 前置通知(Before advice):在某连接点(join point)之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。

    • 返回后通知(After returning advice):在某连接点(join point)正常完成后执行的通知:例如,一个方法没有抛出任何异常,正常返回。

    • 抛出异常后通知(After throwing advice):在方法抛出异常退出时执行的通知。

    • 后置通知(After (finally) advice):当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。

    • 环绕通知(Around Advice):包围一个连接点(join point)的通知,就是将目标方法封装起来。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。 环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架,例如Nanning和JBoss4,都只提供环绕通知。

    切入点表达式

    execution:匹配连接点的执行方法

    语法:

    execution([修饰符] 返回值类型 包名.类名.方法名(参数列表))
    
    • 修饰符可以省略
    • 使用*表示任意类型
    • 参数列表使用 .. 表示任意参数类型,有参无参都可以

    举例:

    execution(* com.zxy.service.impl.*.*(..))
    // 任意修饰符 com.zxy.service.impl包下的 任意子包 下的 任意参数列表的任意方法
    

    (Spring AOP还支持很多的AspectJ 切点指示器,自行了解,本篇就使用了一个execution)

    AOP的使用示例:

    了解了基本的基础知识后,就到了AOP的使用

    (AOP最常见的使用场景就是日志、事务等)

    根据上一篇的学习(动态代理两种实现),我们使用自己写的动态代理来完成了事务的处理。现在使用spring的aop就可以用更简单的方式完成事务的处理

    添加依赖:

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

    准备一个事务的切面类

    package com.zxy.aspect;
    
    import com.zxy.tx.MyTransactionManager;
    import org.aspectj.lang.annotation.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    /**
     * @author ZXY
     * @version 1.0
     * @date 2020/12/19 17:32
     * 日志切面类
     */
    @Component
    @Aspect
    public class TransactionAspect {
    
        @Autowired
        private MyTransactionManager transactionManager;// 引入自定义事务类
    
        // 配置切入点
        @Pointcut("execution(* com.zxy.service.impl.*.*(..))")
        private void pointcut(){}
    
        @Before("pointcut()")
        public void beforeAdvice(){
            System.out.println("**************** 开启事务!***************");
            transactionManager.begin();
        }
    
        @AfterReturning("pointcut()")
        public void afterReturning(){
            System.out.println("**************** 提交事务***************");
            transactionManager.commit();
        }
    
        @AfterThrowing("pointcut()")
        public void afterThrowing(){
            System.out.println("**************** 回滚事务***************");
            transactionManager.rollback();
        }
    
        @After("pointcut()")
        public void afterAdvice(){
            System.out.println("**************** 释放资源!***************");
            transactionManager.close();
        }
    
    }
    

    为启动类添加注解@EnableAspectJAutoProxy开启Spring对AOP的支持:

    @EnableAspectJAutoProxy
    @Configuration
    @ComponentScan({"com.zxy"})
    @Import({MybatisConfig.class,DataSourceConfig.class})
    public class SpringConfig {}
    

    测试:

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration( classes = {SpringConfig.class})
    public class Test1 {
    
        @Autowired
        @Qualifier("accountServiceImpl")
        private IAccountService accountService;
    
        @Test
        public void test1(){
            // 张三转账给李四1000元
            accountService.transfer("zhangsan","lisi",1000.0);
        }
    }
    

    正常情况:

    在这里插入图片描述

    发生异常,事务回滚:

    在这里插入图片描述

    使用xml配置文件的方式配置aop:

    引入约束:

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

    aop配置:

        <bean id="loggerAspect" class="com.zxy.aspect.TransactionAspect"/>
    
        <!-- aop配置-->
        <aop:config>
            <!-- 配置切面类-->
            <aop:aspect id="lAspect" ref="loggerAspect">
                <!-- 配置切入点-->
                <aop:pointcut id="pointcut1" expression="execution(* com.zxy.service.impl.*.*(..))"/>
                <aop:before method="beforeAdvice" pointcut-ref="pointcut1"/>
                <aop:after-returning method="afterReturning" pointcut-ref="pointcut1"/>
                <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut1"/>
                <aop:after method="afterAdvice" pointcut-ref="pointcut1"/>
            </aop:aspect>
        </aop:config>
    

    环绕通知

    它是Spring框架为我们提供的一种可以在代码中手动控制增强代码功能的执行方式。能够全面的控制连接点,甚至可以控制是否执行连接点

    环绕通知需要再添加一个依赖:

    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt --> 
    <dependency> 
        <groupId>org.aspectj</groupId> 
        <artifactId>aspectjrt</artifactId> 
        <version>1.9.6</version>
    </dependency>
    

    Spring提供了一个接口ProceedingJoinPoint:他可以作为环绕通知方法的参数,在环绕通知执行时,可以通过该接口的实例获取目标类的对象,直接执行目标类中的方法。

    我们要做的就是调用ProceedingJoinPoint中的proceed()方法来执行被代理的方法。(如果没有这步操作,就会导致通知得到执行而目标方法不会得到执行)

    然后就可以在在目标方法的执行前后执行我们的其他增强操作

    使用环绕通知时,目标方法的返回值只能是引用类型(基本数据类型要使用对应的包装类))

    使用这一个方法即可完成前面四个方法的任务:

        @Around("pointcut()")
        public void aroundAdvice(ProceedingJoinPoint joinPoint) {
            Object[] args = joinPoint.getArgs();
            System.out.println("**************** 开启事务!***************");
            transactionManager.begin();
            try {
                joinPoint.proceed(args);
                System.out.println("**************** 提交事务***************");
                transactionManager.commit();
            } catch (Throwable throwable) {
                System.out.println("**************** 回滚事务***************");
                transactionManager.rollback();
                throwable.printStackTrace();
            }finally {
                System.out.println("**************** 释放资源!***************");
                transactionManager.close();
            }
        }
    

    使用xml配置(不使用@Around注解):

        <!-- aop配置-->
        <aop:config>
            <!-- 配置切面类-->
            <aop:aspect id="lAspect" ref="loggerAspect">
                <!-- 配置切入点-->
                <aop:pointcut id="pointcut1" expression="execution(* com.zxy.service.impl.*.*(..))"/>
                <aop:around method="aroundAdvice" pointcut-ref="pointcut1"/>
            </aop:aspect>
        </aop:config>
    

    学习到这里,我们已经使用自己的多种方式手动的完成了事务的控制,在Spring框架中,还有更简单的方式来完成我们对事务的需求,下一篇 Spring中的事务控制 ※

    展开全文
  • 文章目录三、SpringAOP(面向切面编程)3.1 概念3.2 底层原理3.3 JDK动态代理实现3.4 Spring实现AOP操作3.4.1 AOP的准备工作3.4.2 切入点表达式3.4.3 基于注解的形式实现AOP3.4.4 提取切入点(@Pointcut)3.4.5 ...
  • Spring AOP 1.转账案例中的事务问题 图中每一个操作都有一个connection,程序无错,就提交,但是回滚各操作间不影响。 所以要使用ThreadLocal对象把Connction和当前线程绑定,从而使一个线程中只有一个类控制事务的对象...
  • AOPSpring中的作用

    2021-10-19 15:37:09
    1.AOP的使用,导入织入包 <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver<...
  • SpringAOP的实现原理

    2021-03-11 14:00:39
    一、什么是 AOPAOP(Aspect-Oriented Programming,面向方面编程),对 OOP(Object-Oriented Programming,面向对象编程) 【OOP与AOP】 概念 AOP(Aspect-Oriented Programming,面向方面编程) OOP...
  • 深入理解Spring IOC和AOP

    2021-02-16 16:16:54
    1. 什么是 Spring 框架? 1.1Spring简介 Spring 是一种轻量级开发...这些模块是:核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。比如:Core Container 中的 Core 组件是Spring 所有组件
  • Spring-AOPAOP获取request各项参数 AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等待。 一、AOP的基本概念 Aspect(切面):通常是一个类,里面可以定义切入点和...
  • spring5之AOP详解

    2021-03-12 19:25:27
    AOP术语: 针对方法的: 1.连接点:(可 连接/增强 的 点/方法) 类里面哪些方法可以被增强,这些方法 2.切入点:实际被真正增强的方法 针对部分代码逻辑的: 3.通知(增强) (1)实际增强的逻辑部分称为通知(增强...
  • 第一种使用Spring的API接口实现 写在前头:要实现AOP第一需要做的就是需要导入织入依赖包 <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> ...
  • Spring4和Spring5的AOP顺序Spring4的AOP顺序正常情况异常情况结论Spring5的AOP顺序正常情况异常情况结论Spring4和Spring5的对比Spring4和Spring5测速的小不同Spring4的测试如下:Spring5的测试如下: Spring4的AOP...
  • 从 AbstractPointcutAdvisor 开始: Spring AOP 之 Advisor、PointcutAdvisor 介绍 从AOP开始说起 为了能够更好地将系统级别的代码抽离出来,去掉与对象的耦合,就产生了面向AOP(面向切面)。AOP全称 Aspect-Oriented...
  • 前面两篇文章记录了 Spring IOC 的相关知识,本文记录 Spring 中的另一特性 AOP 相关知识。 部分参考资料: 《Spring实战(第4版)》 《轻量级 JavaEE 企业应用实战(第四版)》Spring 官方文档W3CSchool Spring...
  • Spring 之啥是AOP

    2021-02-02 11:54:59
    文章目录一、AOP 简介二、AOP 相关术语三、AOPSpring 中的作用 一、AOP 简介 AOP全称(Aspect Oriented Programming)意味:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护技术。 简单点...
  • 题目要求 有VisitService接口和它的实现类,作为切入类 ... 而配置类中只有简短的两行扫包配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop=...
  • 1. 什么是AOP AOP(Aspect Oriented Programming):面向切面编程,指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的操作。如:性能监控、日志记录、权限控制等,通过AOP解决代码耦合问题,让...
  • Spring AOP 和 AspectJ AOP 有什么区别? Spring AOP 属于运行时增强,而 AspectJ 是编译时增强。 Spring AOP 基于代理(Proxying),而 AspectJ 基于字节码操作(Bytecode Manipulation)。 Spring AOP 已经集成了 ...
  • #第一种方式:通过Spring中的API接口实现。 ##①首先编写接口文件和实现类 UserService接口: package com.xkl.Service; public interface UserService { public void Add(); public void Delete(); public void...
  • 前文对AOP做了介绍,实际项目中,一般不会直接上手手动实现aop,而是使用一些高级封装的aop实现,如SpringAOPSpring是一个广泛应用的框架,SpringAOP则是Spring提供的一个标准易用的aop框架,依托Spring的IOC容器...
  • 我们在spring概述中曾经说过,程序中的耦合一般有类之间的耦合,和方法之间的耦合。我们通过Spring提供的Ioc容器降低了类之间的依赖关系。今天我们来了解一下方法之间的依赖,我们通过一个模拟业务代码案例来分析...
  • SpringAOP是啥,怎么用?

    万次阅读 2020-12-26 13:46:44
    SpringAOP是啥,怎么用? 一、面试问题:什么是SpringAOPSpringAOP的全称是(Aspect Oriented Programming)中文翻译过来是面向切面编程,个人理解:主要意思是我们的传统架构至上而下,后期想要从中间切入写...
  • Spring Aop

    2021-03-26 08:16:23
    Spring Aop动态代理 AOP:面向切面编程,在不影响核心代码的前提下,可以在任意位置添加非核心代码 使用springaop完成动态代理实现核心业务和非核心业务的一种抽取 步骤: 1.在pom.xml配置中引入依赖 <...
  • Spring AOP 之 BeanPostProcessor 我们都知道spring支持AOP编程。无论是基于JDK动态代理,还是基于字节码增强技术,要在Spring 中使用AOP,那么我们的关注的主要问题就是: 我们是如何从IOC中获取到代理对象的? ...
  • Spring核心之AOP

    2021-09-21 21:10:54
    SpringAOP Spring AOP相关概念 SpringAOP实现底层就是对上面的动态代理的代码进行了封装,封装后我们只需要对需要关注的部分进行代码编写,并通过配置的方式完成指定目标的方法增强。 Target(目标对象) 要被增强...
  • Spring AOP 详解与实现

    2021-03-30 17:48:50
    Spring Aop 详解AOP的概念AOP基础知识Spring实现AOPSpring API 实现自定义切面类实现注解实现 AOP的概念 AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一...
  • SpringAop 实现记录操作日志

    千次阅读 2021-12-03 15:01:55
    SpringAop 实现记录操作日志
  • Spring AOP详解

    2021-09-05 14:20:14
    AOP的作用AOP框架AOP术语AOP的优点SpringAOP AspectJ开发AOP基于XML开发自定义类开发AOP使用Spring的API接口开发AOP基于注解开发 什么是AOPAOP 的全称是“Aspect Oriented Programming”,即面向切面编程,和 OOP...
  • Spring AOP介绍及其原理

    2021-01-17 22:30:57
    一、Spring AOP是什么 AOP:面向切面,是一种编程思想,OOP的延续。 将系统中非核心的业务提取出来,进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。 二、Spring ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390,994
精华内容 156,397
关键字:

aopspring

spring 订阅