精华内容
下载资源
问答
  • aop注解

    2016-08-15 17:23:38
  • Spring AOP注解

    2019-07-13 17:30:48
    AOP注解AOP 相关术语注解配置@Aspect表明当前类是一个切面类@Before@AfterReturning@AfterThrowing@After在 spring 配置文件中开启 spring 对注解 AOP 的支持环绕通知注解配置@Around切入点表达式注解@Pointcut ...

    AOP 相关术语

    • Joinpoint(连接点):
      所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
    • Pointcut(切入点):
      所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
    • Advice(通知/增强):
      所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
      通知的类型:前置通知,后置通知,异常通知,最终通知,环绕通知。
    • Introduction(引介):
      引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方
      法或 Field。
    • Target(目标对象):
      代理的目标对象。
    • Weaving(织入):
      是指把增强应用到目标对象来创建新的代理对象的过程。
      spring 采用动态代理织入,而 AspectJ 采用编译期织入和类装载期织入。
    • Proxy(代理):
      一个类被 AOP 织入增强后,就产生一个结果代理类。
    • Aspect(切面):
      是切入点和通知(引介)的结合。

    注解配置

    @Aspect表明当前类是一个切面类

    @Before

    • 作用:
      把当前方法看成是前置通知。
    • 属性:
      value:用于指定切入点表达式,还可以指定切入点表达式的引用。
    //开启事务 
     @Before("execution(* com.dustdawn.service.impl.*.*(..))") 
     public void beginTransaction() { 
     try { 
     dbAssit.getCurrentConnection().setAutoCommit(false); 
     } catch (SQLException e) { 
     e.printStackTrace(); 
     } 
     } 
    

    @AfterReturning

    • 作用:
      把当前方法看成是后置通知。
    • 属性:
      value:用于指定切入点表达式,还可以指定切入点表达式的引用
    //提交事务 
     @AfterReturning("execution(* com.dustdawn.service.impl.*.*(..))") 
     public void commit() { 
     try { 
     dbAssit.getCurrentConnection().commit(); 
     } catch (SQLException e) { 
     e.printStackTrace(); 
     } 
     } 
    

    @AfterThrowing

    • 作用:
      把当前方法看成是异常通知。
    • 属性:
      value:用于指定切入点表达式,还可以指定切入点表达式的引用
    //回滚事务 
    @AfterThrowing("execution(* com.dustdawn.service.impl.*.*(..))") 
    public void rollback() { 
    try { 
    dbAssit.getCurrentConnection().rollback(); 
    } catch (SQLException e) { 
    e.printStackTrace(); 
    } 
    } 
    

    @After

    • 作用:
      把当前方法看成是最终通知。
    • 属性:
      value:用于指定切入点表达式,还可以指定切入点表达式的引用
    //释放资源 
    @After("execution(* com.dustdawn.service.impl.*.*(..))") 
    public void release() { 
    try { 
    dbAssit.releaseConnection(); 
    } catch (Exception e) { 
    e.printStackTrace(); 
    } 
    } 
    

    在 spring 配置文件中开启 spring 对注解 AOP 的支持

    <!-- 开启 spring 对注解 AOP 的支持 --> 
    <aop:aspectj-autoproxy/> 
    

    环绕通知注解配置

    @Around

    • 作用:
      把当前方法看成是环绕通知。
    • 属性:
      value:用于指定切入点表达式,还可以指定切入点表达式的引用。
    /** 
     * 环绕通知 
     * @param pjp 
     * @return 
     */ 
     @Around("execution(* com.dustdawn.service.impl.*.*(..))") 
     public Object transactionAround(ProceedingJoinPoint pjp) { 
     //定义返回值 
     Object rtValue = null; 
     try { 
     //获取方法执行所需的参数 
     Object[] args = pjp.getArgs(); 
     //前置通知:开启事务 
     beginTransaction(); 
     //执行方法 
     rtValue = pjp.proceed(args); 
     //后置通知:提交事务 
     commit(); 
     }catch(Throwable e) { 
     //异常通知:回滚事务 
     rollback(); 
     e.printStackTrace(); 
     }finally { 
     //最终通知:释放资源 
     release(); 
     } 
     return rtValue; 
     } 
    

    切入点表达式注解

    @Pointcut

    • 作用:
      指定切入点表达式
    • 属性:
    • value:指定表达式的内容
     
    @Pointcut("execution(* com.dustdawn.service.impl.*.*(..))") 
    private void pt1() {} 
     
    引用方式: 
     /** 
     * 环绕通知 
     * @param pjp 
     * @return 
     */ 
     @Around("pt1()")//注意:千万别忘了写括号 
     public Object transactionAround(ProceedingJoinPoint pjp) { 
     //定义返回值 
     Object rtValue = null; 
     try { 
     //获取方法执行所需的参数 
     Object[] args = pjp.getArgs(); 
     //前置通知:开启事务 
     beginTransaction(); 
     //执行方法 
     rtValue = pjp.proceed(args); 
     //后置通知:提交事务 
     commit(); 
     }catch(Throwable e) { 
     //异常通知:回滚事务 
     rollback(); 
     e.printStackTrace(); 
     }finally { 
     //最终通知:释放资源 
     release(); 
     } 
     return rtValue; 
     } 
    
    展开全文
  • AOP 注解使用

    2019-10-16 16:47:03
    因为是实战,所以就不说原理,直接使用注解直接使用,项目自然是要求spring项目,有applicationContext.xml文件,配配置AOP注解需要xml的开头配置使用aop的对应代码beans里配置 xmlns:aop=...

     

    AOP的使用分类调用顺序

    AOP实战

      因为是实战,所以就不说原理,直接使用注解直接使用,项目自然是要求spring项目,有applicationContext.xml文件,配配置AOP注解需要xml的开头配置使用aop的对应代码beans里配置

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

     置对应AOP注解

    <aop:aspectj-autoproxy proxy-target-class="true"/>

     新建一个类用作想要做aop的代码

    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    public class LogUtils {
    	
    	/**
    	 * 
    	 */
    	@AfterReturning("execution(* com.ligitalsoft.custom.action.CustomAction.test())")
    	//@AfterReturning("within(* com.ligitalsoft.custom.action.CustomAction)")
    	public void log1(){
    		System.out.println("调用log1()方法");
    	}
    	
    }

    这个方法直接关联到我的目录到CustomAction类下的test方法,做了环绕通知-后置

    附几种匹配类型方法

     

    展开全文
  • sping aop注解配置

    2014-04-29 16:52:06
    sping aop注解配置
  • Android AOP注解Annotation详解(一) Android AOP之注解处理解释器详解(二) Android AOP 注解详解及简单使用实例(三) Android AOP 等在Android上应用越来越广泛,例如框架ButterKnife,Dagger2,EventBus3等等...
  • Spring AOP源码学习:AOP 注解的解析

    千次阅读 2019-12-14 22:17:02
    上文介绍了 AOP的基本概念,本文开始进入 AOP的源码解析,本文仍以 AspectJ来进行介绍,首先是 AOP注解的解析。 正文 当使用<aop:aspectj-autoproxy />注解开启 AOP功能时。 Spring会从“META-INF/spring...

    微信搜索【程序员囧辉】,关注这个坚持分享技术干货的程序员。

    前言

    上文介绍了 AOP 的基本概念,本文开始进入 AOP 的源码解析,本文仍以 AspectJ 来进行介绍,首先是 AOP 注解的解析。

     

    正文

    当使用 <aop:aspectj-autoproxy /> 注解开启 AOP 功能时。

    Spring会从“META-INF/spring.handlers” 配置文件中拿到该注解对应的 NamespaceHandlerSupport:AopNamespaceHandler

    在 AopNamespaceHandler 的 init 方法会给该注解注册对应的解析器,aspectj-autoproxy 对应的解析器是:AspectJAutoProxyBeanDefinitionParser。

    @Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
    
        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

    我们知道,当解析到 <aop:aspectj-autoproxy /> 注解时,会调用 AspectJAutoProxyBeanDefinitionParser 的 parse方法。

    关于自定义注解的解析内容之前 IoC 的文章介绍过了,如果不了解的可以参考:Spring IoC:parseCustomElement 详解

     

    AspectJAutoProxyBeanDefinitionParser#parse

    @Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        // 1.注册AspectJAnnotationAutoProxyCreator
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        // 2.对于注解中子节点的处理
        extendBeanDefinition(element, parserContext);
        return null;
    }

    1.注册 AspectJAnnotationAutoProxyCreator,见代码块1。

     

    代码块1:AopNamespaceUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary

    public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {
        // 1.注册AspectJAnnotationAutoProxyCreator
        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        // 2.对于proxy-target-class以及expose-proxy属性的处理
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        // 3.注册组件并通知,便于监听器做进一步处理
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

    1.注册 AspectJAnnotationAutoProxyCreator,见代码块2。

    2.对于 proxy-target-class 以及 expose-proxy 属性的处理,见代码块3。

     

    代码块2:AopConfigUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary

    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }
    
    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        // 1.如果注册表中已经存在beanName=org.springframework.aop.config.internalAutoProxyCreator的bean,则按优先级进行选择。
        // beanName=org.springframework.aop.config.internalAutoProxyCreator,可能存在的beanClass有三种,按优先级排序如下:
        // InfrastructureAdvisorAutoProxyCreator、AspectJAwareAdvisorAutoProxyCreator、AnnotationAwareAspectJAutoProxyCreator
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            // 拿到已经存在的bean定义
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            // 如果已经存在的bean的className与当前要注册的bean的className不相同,则按优先级进行选择
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                // 拿到已经存在的bean的优先级
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                // 拿到当前要注册的bean的优先级
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) {
                    // 如果当前要注册的bean的优先级大于已经存在的bean的优先级,则将bean的className替换为当前要注册的bean的className,
                    apcDefinition.setBeanClassName(cls.getName());
                }
                // 如果小于,则不做处理
            }
            // 如果已经存在的bean的className与当前要注册的bean的className相同,则无需进行任何处理
            return null;
        }
        // 2.如果注册表中还不存在,则新建一个Bean定义,并添加到注册表中
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        // 设置了order为最高优先级
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        // 注册BeanDefinition,beanName为org.springframework.aop.config.internalAutoProxyCreator
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }

    org.springframework.aop.config.internalAutoProxyCreator 是内部管理的自动代理创建者的 bean 名称,可能对应的 beanClassName 有三种,对应的注解如下:

    InfrastructureAdvisorAutoProxyCreator:<tx:annotation-driven />

    AspectJAwareAdvisorAutoProxyCreator:<aop:config />

    AnnotationAwareAspectJAutoProxyCreator:<aop:aspectj-autoproxy />

    当同时存在多个注解时,会使用优先级最高的 beanClassName 来作为 org.springframework.aop.config.internalAutoProxyCreator 的 beanClassName。本系列文章暂不考虑同时存在其他注解的情况,所以在这边会注册的 beanClassName 为:AnnotationAwareAspectJAutoProxyCreator。

     

    代码块3:useClassProxyingIfNecessary

    private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
        if (sourceElement != null) {
            boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
            if (proxyTargetClass) {
                // 如果节点设置了proxy-target-class=true,则给beanName为org.springframework.aop.config.internalAutoProxyCreator
                // 的BeanDefinition添加proxyTargetClass=true的属性,之后创建代理的时候将强制使用Cglib代理
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
            if (exposeProxy) {
                // 如果节点设置了expose-proxy=true,则给beanName为org.springframework.aop.config.internalAutoProxyCreator
                // 的BeanDefinition添加exposeProxy=true的属性,之后创建拦截器时会根据该属性选择是否暴露代理类
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

     

    总结

    本文的内容比较简单,最重要的内容就是注册了内部管理的自动代理创建者的 bean:AnnotationAwareAspectJAutoProxyCreator,AOP 的大部分重要内容都在这个bean 里,之后会一一介绍。

     

    相关文章

    Spring AOP:基本概念

    展开全文
  • 1.先引入aop相关jar文件 spring-aop-3.2.5.RELEASE.jar aopalliance.jar aspectjweaver.jar aspectjrt.jar ...2.bean.xml中引入aop名称空间 和开启aop注解 xmlns:aop="http://www.springframework
  • 主要介绍了spring中AOP注解开发的相关资料,文中介绍的很详细,需要的朋友可以参考借鉴,下面来一起看看吧。
  • aop注解模式 applicationContext.xml 开启aop注解代理功能 <!--注解模式实现aop切面 开启aop注解功能 开启aop代理功能--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> @Component(value = ...
  • SpringAOP注解特棒例子

    2011-06-05 19:46:54
    SpringAOP注解方式.zip,SpringAOP注解特棒例子
  • spring aop注解失效之谜

    万次阅读 2017-08-18 00:53:26
    问题:在spring 中使用 @Transactional 、 @Cacheable 或 自定义 AOP 注解时,会发现个问题:在对象内部的方法中调用该对象的其他使用aop机制的方法,被调用方法的aop注解失效。 这句话可能说的有点拗口,那么我们来...
  • 主要介绍了Android AOP 注解详解及简单使用实例(三)的相关资料,需要的朋友可以参考下
  • AOP注解配置

    2012-08-25 17:09:15
    1) 在 xml 配置中启用 AoP 注解配置    2) 在切面组件中使用 Aop 注解  @Aspect 表示该组件是 AOP 组件 @Pointcut("within(tarena.service..*)") 用于指定切入点表达式  @Around("servicePointcut()") 为...
  • Aop注解示例

    2015-12-30 10:20:27
    spring中aop注解的使用开发,包括bean注解.rar
  • spring aop注解

    2019-03-26 17:03:08
    Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,AOP的原理就是java的动态代理机制
  • spring aop 注解例子

    2015-03-04 10:36:16
    spring aop 通过注解实现的项目,这只是一个简单的例子。运行环境也简单。
  • Spring AOP 注解方式

    2016-09-24 19:52:19
    spring AOP注解方式的实现! 内部方法的拦截
  • spring的aop注解含义及使用

    万次阅读 2018-07-27 15:42:24
    在了解和使用springAOP注解之前,我们有必要学习一下java5.0中新增的注解(Annotation)技术。 1.1、了解注解  注解遵循着一个基本原则:注解不能直接干扰代码运行,无论增加或删除注解,代码都能够正常运行。java...
  • druid多数据源 AOP注解切换数据源 GITEE代码
  • SpringMVC中使用aop注解无效的问题

    千次阅读 2016-10-03 00:10:56
    aop注解无效的问题
  • Spring-Aop注解形式案例<二>

    万次阅读 2015-12-13 21:11:57
    Spring-Aop注解形式案例 问题?Spring-Aop注解形式案例 我们知道,在spring中,spring提供了注解的形式,来达到对象的依赖注入。当然我们也可以直接用依赖注入将bean 这里写的是Spring-Aop注解...
  • SpringBoot配置AOP注解式环绕输出日志 一:添加依赖 创建好一个SpringBoot项目之后,添加aop依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-...
  • spingAOP注解方式

    2015-06-05 16:08:50
    springAOP,主要是用在日志的记录上等,这样开发人员只要专心的做业务上的功能开发。
  • Spring中AOP注解

    2014-10-12 21:23:25
    Spring中AOP注解使XML更简洁,在使用注解之前我们需要在XML中配置,表示启用注解。  具体看一个实例:  package aop;  public class People { private String name; public String getName() { return name; }  ...
  • spring AOP 注解实现登录权限拦截

    万次阅读 2017-05-04 15:15:48
    使用spring AOP实现登录的权限拦截,项目使用Maven进行依赖管理,spring+springMVC+Mybatis框架进行项目...本次使用的AOP注解来实现的1.springAOP依赖的jar包(spring的AOP jar包是必须的): &lt;dependency&gt;
  • Spring aop 注解方式

    2018-07-15 13:14:48
    1、注解方式需要在applicationContext.xml文件中配置启用aop注解模式;约束文件中添加xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation=...
  • spring aop注解所需要的三个jar包,aspectjrt.jar,aspectjweaver.jar,aopalliance.jar
  • Spring之AOP注解失效原因和解决方法

    万次阅读 2018-04-26 11:51:58
    问题:在spring 中使用 @Transactional 、 @Cacheable 或 自定义 AOP 注解时,会发现个问题:在对象内部的方法中调用该对象的其他使用AOP注解的方法,被调用方法的AOP注解失效。事物失效public class UserService{ ...
  • Spring AOP注释

    2019-09-24 15:25:31
    开启基于注解AOP模式 @Pointcut 定义切点 @Aspect 定义(说明)切面类 @Before 在目标方法运行前运行 @After 在目标方法运行后运行 @AfterReturning 在目标正常返回后运行 @AfterThrowing 在目标出现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 168,976
精华内容 67,590
关键字:

aop注解