为您推荐:
精华内容
最热下载
问答
  • 5星
    8.2MB Yao__Shun__Yu 2021-08-11 16:32:43
  • AOP-面向切面编程 切面包括Advice和Pointcut Spring Aop属于方法级别的Aop,即在方法执行前、方法执行后、方法抛出异常执行切面代码 AOP两个关注点 核心关注点 横切关注点 Advice指通知,前置通知、后置通知、异常...

    AOP-面向切面编程

    切面包括AdvicePointcut

    Spring Aop属于方法级别的Aop,即在方法执行前、方法执行后、方法抛出异常执行切面代码

    AOP两个关注点

    • 核心关注点
    • 横切关注点

    Advice指通知,前置通知、后置通知、异常通知这些,也称为横切关注点

    Pointcut指在哪些方法加入横切关注点,侧重是哪些方法,定义核心关注点的范围

    JoinPoint是符合Pointcut定义的核心关注点范围中的一个,在Spring Aop指某个具体的方法

    切面包括Advice和Pointcut,即切面定义了若干个通知和要作用的范围

    展开全文
    weixin_42002747 2020-09-20 11:46:22
  • Spring AOC和AOP概念详解AOCAOP------------------------------------------------------以下是写博客文档的用法功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的...

    AOC

    依赖注入:就是通过容器来控制业务对象之间的依赖关系。也就是把需要的业务对象都放入容器中,需要注入时,通过反射技术来动态获取指定的对象,装配到当前使用对象。代替了原始的 new 来实现对象的实例化。从而实现 AOC 的依赖注入。

    控制反转概念:就是通过容器来控制业务对象之间的依赖关系,而非传统实现中,由代码直接控制。这也就是“控制反转”概念所在;控制权由应用代码转到了外部容器,控制权的转移,就是反转。控制权转移带来的好处就是降低了业务对象之间的依赖程度。

    AOP

    Aspect-OrientedProgramming,面向方面编程,可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。
    实现AOP的技术,主要分为两大类:一是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行;二是采用静态织入的方式,引入特定的语法创建“方面”,从而使得编译器可以在编译期间织入有关“方面”的代码。

    ------------------------------------------------------

    以下是写博客文档的用法

    1. 全新的界面设计 ,将会带来全新的写作体验;
    2. 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示;
    3. 增加了 图片拖拽 功能,你可以将本地的图片直接拖拽到编辑区域直接展示;
    4. 全新的 KaTeX数学公式 语法;
    5. 增加了支持甘特图的mermaid语法1 功能;
    6. 增加了 多屏幕编辑 Markdown文章功能;
    7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能,功能按钮位于编辑区域与预览区域中间;
    8. 增加了 检查列表 功能。

    功能快捷键

    撤销:Ctrl/Command + Z
    重做:Ctrl/Command + Y
    加粗:Ctrl/Command + B
    斜体:Ctrl/Command + I
    标题:Ctrl/Command + Shift + H
    无序列表:Ctrl/Command + Shift + U
    有序列表:Ctrl/Command + Shift + O
    检查列表:Ctrl/Command + Shift + C
    插入代码:Ctrl/Command + Shift + K
    插入链接:Ctrl/Command + Shift + L
    插入图片:Ctrl/Command + Shift + G
    查找:Ctrl/Command + F
    替换:Ctrl/Command + G

    合理的创建标题,有助于目录的生成

    直接输入1次#,并按下space后,将生成1级标题。
    输入2次#,并按下space后,将生成2级标题。
    以此类推,我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

    如何改变文本的样式

    强调文本 强调文本

    加粗文本 加粗文本

    标记文本

    删除文本

    引用文本

    H2O is是液体。

    210 运算结果是 1024.

    插入链接与图片

    链接: link.

    图片: Alt

    带尺寸的图片: Alt

    居中的图片: Alt

    居中并且带尺寸的图片: Alt

    当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。

    如何插入一段漂亮的代码片

    博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片.

    // An highlighted block
    var foo = 'bar';
    

    生成一个适合你的列表

    • 项目
      • 项目
        • 项目
    1. 项目1
    2. 项目2
    3. 项目3
    • 计划任务
    • 完成任务

    创建一个表格

    一个简单的表格是这么创建的:

    项目Value
    电脑$1600
    手机$12
    导管$1

    设定内容居中、居左、居右

    使用:---------:居中
    使用:----------居左
    使用----------:居右

    第一列第二列第三列
    第一列文本居中第二列文本居右第三列文本居左

    SmartyPants

    SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:

    TYPEASCIIHTML
    Single backticks'Isn't this fun?'‘Isn’t this fun?’
    Quotes"Isn't this fun?"“Isn’t this fun?”
    Dashes-- is en-dash, --- is em-dash– is en-dash, — is em-dash

    创建一个自定义列表

    Markdown
    Text-to- HTML conversion tool
    Authors
    John
    Luke

    如何创建一个注脚

    一个具有注脚的文本。2

    注释也是必不可少的

    Markdown将文本转换为 HTML

    KaTeX数学公式

    您可以使用渲染LaTeX数学表达式 KaTeX:

    Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n1)!nN 是通过欧拉积分

    Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t   . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=0tz1etdt.

    你可以找到更多关于的信息 LaTeX 数学表达式here.

    新的甘特图功能,丰富你的文章

    Mon 06 Mon 13 Mon 20 已完成 进行中 计划一 计划二 现有任务 Adding GANTT diagram functionality to mermaid
    • 关于 甘特图 语法,参考 这儿,

    UML 图表

    可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图:

    张三 李四 王五 你好!李四, 最近怎么样? 你最近怎么样,王五? 我很好,谢谢! 我很好,谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五

    这将产生一个流程图。:

    链接
    长方形
    圆角长方形
    菱形
    • 关于 Mermaid 语法,参考 这儿,

    FLowchart流程图

    我们依旧会支持flowchart的流程图:

    Created with Raphaël 2.2.0 开始 我的操作 确认? 结束 yes no
    • 关于 Flowchart流程图 语法,参考 这儿.

    导出与导入

    导出

    如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。

    导入

    如果你想加载一篇你写过的.md文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
    继续你的创作。


    1. mermaid语法说明 ↩︎

    2. 注脚的解释 ↩︎

    展开全文
    SDS_JDK 2020-10-12 10:38:05
  • 23KB qq_39292819 2018-11-21 23:51:13
  • 1.概念  AspectOriented Programing,面向切面编程。  利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。  AOP主要用于日志...

    1.概念

            AspectOriented Programming,面向切面编程。

            利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

            AOP主要用于日志记录,性能统计,安全控制(权限控制),事务处理,异常处理等。将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。

            如:AOP做权限控制的时候。首先拦截所有业务Bean时面的所有方法,判断用户是否有权限,有权限才能执行这些方法。而判断是否有权限这个功能就是一个切面。   



    2. AOP术语


    2.1:连接点(Joinpoint)


               程序执行的某个特定位置:如类开始初始化前,类初始化后,类某个方法调用前。一个类或一段代码拥有一些边界性质的特定点,这些代码中的特定点就被称为“连接点”。Spring仅支持方法的连接点,既仅能在方法调用前,方法调用后,方法抛出异常时等这些程序执行点进行织入增强。我们知道黑客攻击系统需要找到突破口,否则无法进行攻击,从某种程度上说AOP是一个黑客,连接点就是攻击的突破口。

             连接点由两个信息确定:第一是用方法表示的程序执行点;第二是用相对点表示的方位。如在Test.foo()方法执行前的连接点,执行点为Test.foo(),方位为该方法执行前的位置。Spring使用切点对执行点进行定位,而方位则在增强类型中定义。


    2.2:切点(Pointcut

            每个程序类都拥有多个连结点,如一个拥有两个方法的类,这两个方法都是连接点,既连接点是程序中客观存在的事务。但在这为数众多的连接点中,如何定位到某个感兴趣的连接点上呢?AOP通过“切点”定位特定的连接点。通过数据库查询的概念来理解切点和连接点的关系再适合不过了:连接点相当于数据库中的记录,而切点相当于查询条件。切点和连接点不是一对一的关系,一个切点可以匹配多个连接点。

            在Spring中,切点通过org.springframework.aop.Pointcut接口进行描述它使用类和方法作为连接点的查询条件SpringAOP的规则解析引擎负责解析切点所设定的查询条件,找到对应的连接点。其实确切的说,应该是执行点而非连接点,因为连接点是方法执行前,执行后等包含方位信息的具体程序执行点,而切点只定位到某个方法上,所以说如果希望定位到某个连接点上,还需要提供方位信息。


    2.3:增强(Advice

            增强是织入到目标类连接点上的一段程序代码。在Spring中,增强除了用于描述一段程序代码外,还拥有另一个和连接点相关的信息,这便是执行点的方位。结合执行点方位信息和切点信息,我们就可以找到特定的连接点了。正因为增强即包含了用于添加到目标链接点上的一段执行逻辑,又包含了用于定位连接点的方位信息,所以Spring所提供的增强接口都是带方位名的:BeforeAdvice等。所以只有结合切点和增强两者一齐上阵才能确定特定的连接点并实施增强逻辑。


    2.4:目标对象(Target

           增强逻辑的织入目标类。如果没有AOP,目标业务类需要自己实现所有逻辑,如ForumService所示。在AOP的帮助下,ForumService只实现了那些非横切逻辑的程序逻辑,而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。


    2.5:引介(Introduction)

            引介是一种特殊的增强,它为类添加一些属性和方法。这样,即使一个业务类原本没有实现某个接口,通过AOP的引介功能,我们可以动态的为该事务添加接口的实现逻辑,让业务类成为这个接口的实现类。


    2.6:织入(Weaving)

             织入是将增强添加对目标类具体连接点上的过程,AOP象一台织布机,将目标类增强或引介AOP这台织布机天衣无缝的编织在一起。


    2.7:代理(Proxy

            一个类被AOP织入增强后,就产生了一个结果类,它是融合了原类和增强逻辑的代理类。根据不同的代理方式,代理类及可能是和原类具有相同的接口的类,也可能是原类的子类,所以我们可以采用调用原类得相同方式调用代理类。


    2.8:切面(Aspect

            切面由切点和增强(引介)组成,它既包括了横切逻辑的定义,也包括了连接点的定义,SpringAOP就是负责实施切面的框架,它将切面所定义的横切逻辑织入到切面所指定的链接点中。


    注意

             AOP的工作重心在于如何将增强应用于目标对象的连接点上,这里首先包括两个工作:第一:如何通过切点和增强定位到连接点上;第二:如何在增强中编写切面的代码。

    展开全文
    Yjie_92 2017-11-08 17:02:30
  • 100KB qq_43371778 2020-02-17 02:41:19
  • 33KB u014427391 2017-05-25 08:55:00
  • 1.我所知道的aop 初看aop,上来就是一大堆术语,而且还有个拉风的名字,面向切面编程,都说是OOP的一种有益补充等等。一下子让你不知所措,心想着:怪不得很多人都和我说aop多难多难。当我看进去以后,我才发现:它...

    AOP详细全面的知乎讲解:https://zhuanlan.zhihu.com/p/25522841

    1.我所知道的aop

      初看aop,上来就是一大堆术语,而且还有个拉风的名字,面向切面编程,都说是OOP的一种有益补充等等。一下子让你不知所措,心想着:怪不得很多人都和我说aop多难多难。当我看进去以后,我才发现:它就是一些java基础上的朴实无华的应用,包括ioc,包括许许多多这样的名词,都是万变不离其宗而已。

      2.为什么用aop

      1就是为了方便,看一个国外很有名的大师说,编程的人都是“懒人”,因为他把自己做的事情都让程序做了。用了aop能让你少写很多代码,这点就够充分了吧

      2就是为了更清晰的逻辑,可以让你的业务逻辑去关注自己本身的业务,而不去想一些其他的事情,这些其他的事情包括:安全,事物,日志等。

     3.那些aop的术语

      初看这么多术语,一下子都不好接受,慢慢来,很快就会搞懂。

        1.通知(Advice)

      就是你想要的功能,也就是上面说的 安全,事物,日志等。你给先定义好把,然后在想用的地方用一下。

        2.连接点(JoinPoint)

      这个更好解释了,就是spring允许你使用通知的地方,那可真就多了,基本每个方法的前,后(两者都有也行),或抛出异常时都可以是连接点,spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行,不过那不是咱关注的,只要记住,和方法有关的前前后后(抛出异常),都是连接点。

        3.切入点(Pointcut)

      上面说的连接点的基础上,来定义切入点,你的一个类里,有15个方法,那就有几十个连接点了对把,但是你并不想在所有方法附近都使用通知(使用叫织入,以后再说),你只想让其中的几个,在调用这几个方法之前,之后或者抛出异常时干点什么,那么就用切点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法。

        4.切面(Aspect)

      切面是通知和切入点的结合。现在发现了吧,没连接点什么事情,连接点就是为了让你好理解切点,搞出来的,明白这个概念就行了。通知说明了干什么和什么时候干(什么时候通过方法名中的before,after,around等就能知道),而切入点说明了在哪干(指定到底是哪个方法),这就是一个完整的切面定义。

        5.引入(introduction)

      允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗

        6.目标(target)

      引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被咱们织入切面。而自己专注于业务本身的逻辑。

        7.代理(proxy)

      怎么实现整套aop机制的,都是通过代理,这个一会给细说。

        8.织入(weaving)

      把切面应用到目标对象来创建新的代理对象的过程。有3种方式,spring采用的是运行时,为什么是运行时,后面解释。

      关键就是:切点定义了哪些连接点会得到通知

      4.我所理解的aop原理

      spring用代理类包裹切面,把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类,它会截取对目标类中方法的调用,让调用者对目标类的调用都先变成调用伪装类,伪装类中就先执行了切面,再把调用转发给真正的目标bean。

      现在可以自己想一想,怎么搞出来这个伪装类,才不会被调用者发现(过JVM的检查,JAVA是强类型检查,哪里都要检查类型)。

      1.实现和目标类相同的接口,我也实现和你一样的接口,反正上层都是接口级别的调用,这样我就伪装成了和目标类一样的类(实现了同一接口,咱是兄弟了),也就逃过了类型检查,到java运行期的时候,利用多态的后期绑定(所以spring采用运行时),伪装类(代理类)就变成了接口的真正实现,而他里面包裹了真实的那个目标类,最后实现具体功能的还是目标类,只不过伪装类在之前干了点事情(写日志,安全检查,事物等)。

      这就好比,一个人让你办件事,每次这个时候,你弟弟就会先出来,当然他分不出来了,以为是你,你这个弟弟虽然办不了这事,但是他知道你能办,所以就答应下来了,并且收了点礼物(写日志),收完礼物了,给把事给人家办了啊,所以你弟弟又找你这个哥哥来了,最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了,你只是专心把这件事情做好。

      顺着这个思路想,要是本身这个类就没实现一个接口呢,你怎么伪装我,我就压根没有机会让你搞出这个双胞胎的弟弟,那么就用第2种代理方式,创建一个目标类的子类,生个儿子,让儿子伪装我

      2.生成子类调用,这次用子类来做为伪装类,当然这样也能逃过JVM的强类型检查,我继承的吗,当然查不出来了,子类重写了目标类的所有方法,当然在这些重写的方法中,不仅实现了目标类的功能,还在这些功能之前,实现了一些其他的(写日志,安全检查,事物等)。

      这次的对比就是,儿子先从爸爸那把本事都学会了,所有人都找儿子办事情,但是儿子每次办和爸爸同样的事之前,都要收点小礼物(写日志),然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说,某些本事是爸爸独有的(final的),儿子学不了,学不了就办不了这件事,办不了这个事情,自然就不能收人家礼了。

      前一种兄弟模式,spring会使用JDK的java.lang.reflect.Proxy类,它允许Spring动态生成一个新类来实现必要的接口,织入通知,并且把对这些接口的任何调用都转发到目标类。

      后一种父子模式,spring使用CGLIB库生成目标类的一个子类,在创建这个子类的时候,spring织入通知,并且把对这个子类的调用委托到目标类。

      相比之下,还是兄弟模式好些,他能更好的实现松耦合,尤其在今天都高喊着面向接口编程的情况下,父子模式只是在没有实现接口的时候,也能织入通知,应当做一种例外。


    简单例子:

        可能直接说会很模糊,这里我先做了一个小例子:直接上代码

        

    复制代码
    //描述切面类
    @Aspect
    @Configuration
    public class TestAop {
    
        /*
         * 定义一个切入点
         */
        // @Pointcut("execution (* findById*(..))")
        @Pointcut("execution(* com.test.service.CacheDemoService.find*(..))")
        public void excudeService(){}
        /*
         * 通过连接点切入
         */
        @Before("execution(* findById*(..)) &&" + "args(id,..)")
        public void twiceAsOld1(Long id){
            System.err.println ("切面before执行了。。。。id==" + id);
    
        }
    
        @Around("excudeService()")
        public Object twiceAsOld(ProceedingJoinPoint thisJoinPoint){
            System.err.println ("切面执行了。。。。");
            try {
                Thing thing = (Thing) thisJoinPoint.proceed ();
                thing.setName (thing.getName () + "=========");
                return thing;
            } catch (Throwable e) {
                e.printStackTrace ();
            }
            return null;
        }
    
    }
    复制代码

      看上面的例子就是实现了一个切面,其中有一些特殊的东西,下面一一解释:

    6.使用的注解:

       @Aspect:描述一个切面类,定义切面类的时候需要打上这个注解

       @Configuration:spring-boot配置类

       1. @Pointcut:声明一个切入点,切入点决定了连接点关注的内容,使得我们可以控制通知什么时候执行。Spring AOP只支持Spring bean的方法执行连接点。所以你可以把切入点看做是Spring bean上方法执行的匹配。一个切入点声明有两个部分:一个包含名字和任意参数的签名,还有一个切入点表达式,该表达式决定了我们关注那个方法的执行。

      注:作为切入点签名的方法必须返回void 类型

      Spring AOP支持在切入点表达式中使用如下的切入点指示符:    

      • execution - 匹配方法执行的连接点,这是你将会用到的Spring的最主要的切入点指示符。

      • within - 限定匹配特定类型的连接点(在使用Spring AOP的时候,在匹配的类型中定义的方法的执行)。

      • this - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中bean reference(Spring AOP 代理)是指定类型的实例。

      • target - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中目标对象(被代理的应用对象)是指定类型的实例。

      • args - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中参数是指定类型的实例。

      • @target - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中正执行对象的类持有指定类型的注解。

      • @args - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中实际传入参数的运行时类型持有指定类型的注解。

      • @within - 限定匹配特定的连接点,其中连接点所在类型已指定注解(在使用Spring AOP的时候,所执行的方法所在类型已指定注解)。

      • @annotation - 限定匹配特定的连接点(使用Spring AOP的时候方法的执行),其中连接点的主题持有指定的注解。

             其中execution使用最频繁,即某方法执行时进行切入。定义切入点中有一个重要的知识,即切入点表达式,我们一会在解释怎么写切入点表达式。

       切入点意思就是在什么时候切入什么方法,定义一个切入点就相当于定义了一个“变量”,具体什么时间使用这个变量就需要一个通知。

       即将切面与目标对象连接起来。

      如例子中所示,通知均可以通过注解进行定义,注解中的参数为切入点。

      spring aop支持的通知:

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

      @AfterReturning :后置通知:在某连接点正常完成后执行的通知,通常在一个匹配的方法返回的时候执行。

          可以在后置通知中绑定返回值,如:        

    复制代码
    @AfterReturning(
        pointcut=com.test.service.CacheDemoService.findById(..))",
        returning="retVal"public void doFindByIdCheck(Object retVal) {
        // ...
      }
    复制代码

       @AfterThrowing:异常通知:在方法抛出异常退出时执行的通知。       

       @After 最终通知。当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)

       @Around:环绕通知:包围一个连接点的通知,如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它自己的返回值或抛出异常来结束执行。

       环绕通知最麻烦,也最强大,其是一个对方法的环绕,具体方法会通过代理传递到切面中去,切面中可选择执行方法与否,执行方法几次等。

       环绕通知使用一个代理ProceedingJoinPoint类型的对象来管理目标对象,所以此通知的第一个参数必须是ProceedingJoinPoint类型,在通知体内,调用ProceedingJoinPointproceed()方法会导致后台的连接点方法执行。proceed 方法也可能会被调用并且传入一个Object[]对象-该数组中的值将被作为方法执行时的参数。


    7.通知参数

      任何通知方法可以将第一个参数定义为org.aspectj.lang.JoinPoint类型(环绕通知需要定义第一个参数为ProceedingJoinPoint类型,它是 JoinPoint 的一个子类)。JoinPoint接口提供了一系列有用的方法,比如 getArgs()(返回方法参数)、getThis()(返回代理对象)、getTarget()(返回目标)、getSignature()(返回正在被通知的方法相关信息)和 toString()(打印出正在被通知的方法的有用信息)

      有时候我们定义切面的时候,切面中需要使用到目标对象的某个参数,如何使切面能得到目标对象的参数。

      从例子中可以看出一个方法:

      使用args来绑定。如果在一个args表达式中应该使用类型名字的地方 使用一个参数名字,那么当通知执行的时候对应的参数值将会被传递进来。

      

     @Before("execution(* findById*(..)) &&" + "args(id,..)")
        public void twiceAsOld1(Long id){
            System.err.println ("切面before执行了。。。。id==" + id);
    
        }

        

    复制代码
    @Around("execution(List<Account> find*(..)) &&" +
            "com.xyz.myapp.SystemArchitecture.inDataAccessLayer() && " +
            "args(accountHolderNamePattern)"public Object preProcessQueryPattern(ProceedingJoinPoint pjp, String accountHolderNamePattern)
    throws Throwable {
      String newPattern = preProcess(accountHolderNamePattern);
      return pjp.proceed(new Object[] {newPattern});
    }        
    复制代码

     

    8.切入点表达式

      现在我们介绍一下最重要的切入点表达式:

      如上文所说,定义切入点时需要一个包含名字和任意参数的签名,还有一个切入点表达式,就是* findById*(..)这一部分。

      切入点表达式的格式:execution([可见性] 返回类型 [声明类型].方法名(参数) [异常])

      其中【】中的为可选,其他的还支持通配符的使用:

        *:匹配所有字符
          ..:一般用于匹配多个包,多个参数
          +:表示类及其子类

      运算符有:&&、||、!

      

    切入点表达式关键词:   

        1)execution:用于匹配子表达式。

                //匹配com.cjm.model包及其子包中所有类中的所有方法,返回类型任意,方法参数任意
                @Pointcut("execution(* com.cjm.model..*.*(..))")

                public void before(){}


          2)within:用于匹配连接点所在的Java类或者包。

                //匹配Person类中的所有方法
                @Pointcut("within(com.cjm.model.Person)")
                public void before(){}

     

                //匹配com.cjm包及其子包中所有类中的所有方法

                @Pointcut("within(com.cjm..*)")
                public void before(){}

     

         3) this:用于向通知方法中传入代理对象的引用。
                @Before("before() && this(proxy)")
                public void beforeAdvide(JoinPoint point, Object proxy){
                      //处理逻辑
                }

     

          4)target:用于向通知方法中传入目标对象的引用。
                @Before("before() && target(target)
                public void beforeAdvide(JoinPoint point, Object proxy){
                      //处理逻辑
                }

     

          5)args:用于将参数传入到通知方法中。
                @Before("before() && args(age,username)")
                public void beforeAdvide(JoinPoint point, int age, String username){
                      //处理逻辑
                }
     
          6)@within :用于匹配在类一级使用了参数确定的注解的类,其所有方法都将被匹配。 

                @Pointcut("@within(com.cjm.annotation.AdviceAnnotation)") - 所有被@AdviceAnnotation标注的类都将匹配
                public void before(){}

      

          7)@target :和@within的功能类似,但必须要指定注解接口的保留策略为RUNTIME。
                @Pointcut("@target(com.cjm.annotation.AdviceAnnotation)")
                public void before(){}

     

          8)@args :传入连接点的对象对应的Java类必须被@args指定的Annotation注解标注。
                @Before("@args(com.cjm.annotation.AdviceAnnotation)")
                public void beforeAdvide(JoinPoint point){
                      //处理逻辑
                }

      

          9)@annotation :匹配连接点被它参数指定的Annotation注解的方法。也就是说,所有被指定注解标注的方法都将匹配。
                @Pointcut("@annotation(com.cjm.annotation.AdviceAnnotation)")
                public void before(){}

          10)bean:通过受管Bean的名字来限定连接点所在的Bean。该关键词是Spring2.5新增的。
                @Pointcut("bean(person)")
                public void before(){}







    展开全文
    changudeng1992 2018-06-08 16:42:47
  • TomasEdision 2017-11-07 10:24:32
  • m0_53708566 2021-06-20 19:36:37
  • wqh8522 2017-06-06 20:32:34
  • weixin_38071136 2018-10-15 21:51:11
  • yuemingyang7010 2020-12-13 15:17:54
  • 9KB weixin_38669628 2019-07-03 02:41:22
  • qukaiwei 2015-12-21 00:50:07
  • 7KB weixin_38669628 2019-05-24 01:50:30
  • 16KB weixin_38669628 2019-07-30 02:08:27
  • wuxioqian0634 2020-01-15 10:53:38
  • oFengFengFeng 2016-08-05 17:44:47
  • weixin_34217773 2019-06-14 12:55:00
  • qq_44645822 2020-12-31 10:31:44
  • a657281084 2017-11-13 11:10:30
  • wang489687009 2021-10-20 17:04:02
  • ssllkkyyaa 2019-11-25 11:31:43
  • 4KB jingang_19121212 2012-04-10 00:18:51
  • qq_36109528 2021-10-21 13:41:53

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,631
精华内容 30,252
关键字:

aop概念

友情链接: 花样五子棋.zip