精华内容
下载资源
问答
  • 切面编程的作用
    千次阅读
    2017-05-27 17:36:23

    一 为什么会出现面向切面的编程

        面向切面编程(AOP是Aspect Oriented Program的首字母缩写) ,我们知道,面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去,这在软件设计中往往称为职责分配。实际上也就是说,让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度,使类可重用。 

        但是人们也发现,在分散代码的同时,也增加了代码的重复性。什么意思呢?比如说,我们在两个类中,可能都需要在每个方法中做日志。按面向对象的设计方法,我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的,但就是因为面向对象的设计让类与类之间无法联系,而不能将这些重复的代码统一起来。 

        也许有人会说,那好办啊,我们可以将这段代码写在一个独立的类独立的方法里,然后再在这两个类中调用。但是,这样一来,这两个类跟我们上面提到的独立的类就有耦合了,它的改变会影响这两个类。那么,有没有什么办法,能让我们在需要的时候,随意地加入代码呢?这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

    二 面向切面编程的实现

        一般而言,我们管切入到指定类指定方法的代码片段称为切面,而切入到哪些类、哪些方法则叫切入点。有了AOP,我们就可以把几个类共有的代码,抽取到一个切片中,等到需要时再切入对象中去,从而改变其原有的行为。 
        这样看来,AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来,而AOP则从纵向上向对象中加入特定的代码。有了AOP,OOP变得立体了。如果加上时间维度,AOP使OOP由原来的二维变为三维了,由平面变成立体了。从技术上来说,AOP基本上是通过代理机制实现的。 
        AOP在编程历史上可以说是里程碑式的,对OOP编程是一种十分有益的补充。
    更多相关内容
  • AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是...
  • 面向切面编程

    2018-09-09 20:44:41
    这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程
  • 主要介绍了SpringBoot整合aop面向切面编程过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 本文介绍Spring AOP,面向切面编程。在权限验证、保存日志、安全检查和事务控制等多个应用场景之下都会依赖该技术。以下是在自己学习过程中的一些总结,如有错误,还望指正。 面向切面的定义  面向切面编程(AOP)...
  • 切面编程听起来可能有点陌生,不过现在越来越多的开发团队正在使用上这种技术。 先说熟悉的面向对象编程 OOP,通常都是用各种对象/模块来负责具体的功能,互相之间尽量不耦合。 切面编程AOP(aspect-priented ...
  • 主要介绍了Javascript面向切面编程,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP:--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
  • 2、面向切面编程AOP 在实现过程中,我尽量贴近实际开发与场景,麻雀虽小,五脏俱全,个人感觉这个项目是web框架搭建的一个极简之道实践。 项目中可能还存在很多的问题,希望大家不吝赐教,谢谢。
  • 主要介绍了面向切面编程(AOP)的理解,需要的朋友可以参考下
  • AOP(面向切面编程)的介绍与作用

    千次阅读 2018-03-06 15:15:11
    AOP,国内大致译作“面向切面编程”。“面向切面编程”,这样的名字并不是非常容易理解,且容易产生一些误导。笔者不止一次听到类似“OOP/OOD11即将落伍,AOP是新一代软件开发方式”这样的发言。而在AOP中,Aspect的...

    AOP

    Aspect Oriented Programming(AOP)是较为热门的一个话题。AOP,国内大致译作“面向切面编程”。

    • “面向切面编程”,这样的名字并不是非常容易理解,且容易产生一些误导。
    • 笔者不止一次听到类似“OOP/OOD11即将落伍,AOP是新一代软件开发方式”这样的发言。而在AOP中,Aspect的含义,可能更多的理解为“切面”比较合适。所以笔者更倾向于“面向切面编程”的译法。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。
    • AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性,AOP可以说也是这种目标的一种实现。
      应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。

    AOP主要功能

    日志记录,性能统计,安全控制,事务处理,异常处理等等wn及扩展

    AOP主要意图

    将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。arkdown Extra** 定义列表语法:

    代码块

    假设在一个应用系统中,有一个共享的数据必须被并发同时访问,首先,将这个数据封装在数据对象中,称为Data Class,同时,将有多个访问类,专门用于在同一时刻访问这同一个数据对象。
    为了完成上述并发访问同一资源的功能,需要引入锁Lock的概念,也就是说,某个时刻,当有一个访问类访问这个数据对象时,这个数据对象必须上锁Locked,用完后就立即解锁unLocked,再供其它访问类访问。
    使用传统的编程习惯,我们会创建一个抽象类,所有的访问类继承这个抽象父类,如下:
    abstract class Worker {
    abstract void locked();
    abstract void accessDataObject();
    abstract void unlocked();
    }
    accessDataObject()方法需要有“锁”状态之类的相关代码。

    Java只提供了单继承,因此具体访问类只能继承这个父类,如果具体访问类还要继承其它父类,比如另外一个如Worker的父类,将无法方便实现。

    重用被打折扣,具体访问类因为也包含“锁”状态之类的相关代码,只能被重用在相关有“锁”的场合,重用范围很窄。

    仔细研究这个应用的“锁”,它其实有下列特性:
    “锁”功能不是具体访问类的首要或主要功能,访问类主要功能是访问数据对象,例如读取数据或更改动作。
    “锁”

    这里写图片描述

    “锁”功能其实是这个系统的一个纵向切面,涉及许多类、许多类的方法。如上图:

    因此,一个新的程序结构应该是关注系统的纵向切面,例如这个应用的“锁”功能,这个新的程序结构就是aspect(方面)
    在这个应用中,“锁”方面(aspect)应该有以下职责:
    
    • 1
    • 2
    • 3

    提供一些必备的功能,对被访问对象实现加锁或解锁功能。以保证所有在修改数据对象的操作之前能够调用lock()加锁,在它使用完成后,调用unlock()解锁。

    AOP应用范围

    很明显,AOP非常适合开发J2EE容器服务器,JBoss 4.0正是使用AOP框架进行开发。
    具体功能如下:
    Authentication 权限
    Caching缓存
    Context passing内容传递
    Error handling 错误处理
    Lazy loading 延时加载
    Debugging 调试
    logging, tracing, profiling and monitoring 记录跟踪 优化 校准
    Performance optimization性能优化
    Persistence 持久化
    Resource pooling资源池
    Synchronization 同步
    Transactions事务
    【AOP有必要吗?】

              当然,上述应用范例在没有使用AOP情况下,也得到了解决,例如JBoss 3.XXX也提供了上述应用功能,并且没有使用AOP。
    
              但是,使用AOP可以让我们从一个更高的抽象概念来理解软件系统,AOP也许提供一种有价值的工具。可以这么说:因为使用AOP结构,JBoss 4.0的源码要比JBoss 3.X容易理解多了,这对于一个大型复杂系统来说是非常重要的。
    
               从另外一个方面说,好像不是所有的人都需要关心AOP,它可能是一种架构设计的选择,如果选择J2EE系统,AOP关注的上述通用方面都已经被J2EE容器实现了,J2EE应用系统开发者可能需要更多地关注行业应用方面aspect。
    
               传统的程序通常表现出一些不能自然地适合单一的程序模块或者是几个紧密相关的程序模块的行为,AOP 将这种行为称为横切,它们跨越了给定编程模型中的典型职责界限。横切行为的实现都是分散的,软件设计师会发现这种行为难以用正常的逻辑来思考、实现和更改。最常见的一些横切行为如下面这些:
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    1、日志记录,跟踪,优化和监控
    2、事务的处理
    3、持久化
    4、性能的优化
    5、资源池,如数据库连接池的管理
    6、系统统一的认证、权限管理等
    7、应用系统的异常捕捉及处理
    8、针对具体行业应用的横切行为

                前面几种横切行为都已经得到了密切的关注,也出现了各种有价值的应用,但也许今后几年,AOP 对针对具体行业应用的贡献会成为令人关注的焦点。
    
    • 1
    • 2

    AOP实现项目

    AOP是一个概念,并没有设定具体语言的实现,它能克服那些只有单继承特性语言的缺点(如Java),AOP具体实现有以下几个项目:

    →AspectJ (TM): 创建于Xerox PARC. 有近十年历史,成熟;
    →缺点:过于复杂;破坏封装;需要专门的Java编译器;
    →动态AOP:使用JDK的动态代理API或字节码Bytecode处理技术;
    →基于动态代理API的具体项目有:
    JBoss 4.0 JBoss 4.0服务器;
    →基于字节码的项目有:
    aspectwerkz ,spring。

    AOP作用

             面向过程编程离我们已经有些遥远,面向对象编程正主宰着软件世界。当每个新的软件设计师都被要求掌握如何将需求功能转化成一个个类,并且定义它们的数据成员、行为,以及它们之间复杂的关系的时候,面向切面编程(Aspect-Oriented Programming,AOP)为我们带来了新的想法、新的思想、新的模式。
    
             如果说面向对象编程是关注将需求功能划分为不同的并且相对独立,封装良好的类,并让它们有着属于自己的行为,依靠继承和多态等来定义彼此的关系的话;那么面向切面编程则是希望能够将通用需求功能从不相关的类当中分离出来,能够使得很多类共享一个行为,一旦发生变化,不必修改很多类,而只需要修改这个行为即可。
    
             面向切面编程是一个令人兴奋不已的新模式。就开发软件系统而言,它的影响力必将会和有着数十年应用历史的面向对象编程一样巨大。面向切面编程和面向对象编程不但不是互相竞争的技术而且彼此还是很好的互补。面向对象编程主要用于为同一对象层次的公用行为建模。
    
             它的弱点是将公共行为应用于多个无关对象模型之间。而这恰恰是面向切面编程适合的地方。有了 AOP,我们可以定义交叉的关系,并将这些关系应用于跨模块的、彼此不同的对象模型。AOP 同时还可以让我们层次化功能性而不是嵌入功能性,从而使得代码有更好的可读性和易于维护。它会和面向对象编程合作得很好。
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。
    这里写图片描述
    1、面向切面编程(AOP)
      面向切面编程(AOP)就是对软件系统不同关注点的分离,开发者通过拦截方法调用并在方法调用前后添加辅助代码。
      AOP利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多了类的公共行为封装到一个可重用的模块,并将其命名为“Aspect”,即切面。
    这里写图片描述
      所谓“切面”,简单地说,就是将那些于业务无关,却为月舞模块所共同调用的逻辑或责任封装起来。
      ①切面就是横切面,代表的是一个普遍存在的共有功能。
      ②AOP代表的是一个横向关系
      ③AOP吧软件系统分为两个部分:核心关注点和横切关注点。
      ④业务出路的主要流程是核心关注点,与之关系不大的部分是横切关注点。
      横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。
    2、AOP的作用在与分离系统中各个关注点,将核心关注点和横切关注点分离开来。
    java代码:
    public class BusinessLogic{
      public voidSomeOPration(){
        //日志记录;
        //权限验证;
        DoSomething();
        //失误控制;
      }
    }
    3、AOP技术的实现
    AOP技术是建立在JAVA语言的反射机制与动态代理机制之上的。

    业务逻辑组件在运行过程中,AOP容器动态创建一个代理对象供使用者调用。该代理对象已经按程序员的意图将切面成功切入到目标方法的连接点上,从而切面的功能与业务逻辑的功能同时的以执行。

    AOP是一种编程概念,因此他并未绑定带任何特定的语言。事实上,他对所有单独的、垂直的分解式(AOP通常被认为是横向分解)的语言(不仅是OO语言)都有帮助。AOP在不同语言都有实现(如C++,Smalltalk,C#,C,Java)。
    4、拦截器的设计原理
      Struts2.0的拦截器的设计体现了一种编程的设计理念,即面向切面编程AOP。
      拦截是AOP的一种实现策略,在AOP中某个方法或字段被访问,可以进行拦截,然后在其之前或其之后加入某些操作。
    5、什么是拦截器(Interceptor)?
      拦截器是动态拦截Action调用的对象。他提供了中机制是开发者可以在一个Action执行之前或执行之后插入需要的代码。
    6、理解DRY(Don’t Repeat Yourself)规则
      在软件开发领域,有一个非常重要的规则:Don’t Repeat Yourself,就是所谓的DRY规则,意思就是不要写重复代码。
    这里写图片描述
    这里写图片描述
    为什么要使用方法调用呢?而不是在三个地方使用重复的代码呢?
      很多初学者认为是为了编程的简单,代码简洁。实际上,这是次要的,最重要的原因是为了软件后期的升级及维护。
      
    7、拦截器的意义
      拦截器是对调用方法的改进。我们说某个实例是一个拦截器时,这是从行为上来说的,如果从代码的角度来看,拦截器也是一个类,类中包含有方法,知识这个方法比较特殊,他会在目标方法调用之前“自动”执行。
      进一步改进,如下:
    作用: (1)提供可更高层次的解耦
         (2)允许改变被调用方法的方法体
           (3)可以改变调用的目标方法
        
    8、实现原理
      如何自动的调用拦截器,而且知道到底调用呢个拦截器的方法?大部分的时候,拦截器方法都是通过JDK的动态代理来调用的,AOP的实现机制。
      
    9、拦截器在Struts2.0中的角色
    作用:(1)拦截器是通过struts.xml文件配置的,从而实现了对Action通用操作的可插拨式管理。
      (2)降低了Action与特定代码的耦合性
      (3)提高了ACtion的复用性
      (4)吧多个Action中需要重复指定的代码取出,放在拦截器类中定义,从而提供更好地代码重用。
    10、Struts2中的拦截器
      在Struts2中已经在struts-default.xml中预定义了一些自带的拦截器,如timer、params等。
      如果在struts.xml中配置标签中继承struts-default,则当前package就会自动拥有struts-default.xml中的所有配置。代码如下:
      
    <package name="xxx" extends="struts-default" > ... </package>
    11、拦截器的定义
      在struts.xml文件中定义拦截器语法格式:
      <interceptor name="拦截器名" class=“拦截器实现类/”>
    12、应用定义好的拦截器
      <interceptor-ref name="拦截器名/">
    在struts-default.xml中有一个默认的引用,在默认情况下(也就是未引用拦截器时)会自动引用一些拦截器。
      <default-interceptor-ref name="defaultStack/">
    上面在defaultStack中引用的拦截器都可以不经过引用可以使用
    注意:如果在引用了任何拦截器后,要使用在defaultStack中定义的拦截器,需要重新引用。
    13、params拦截器使用
      当客户端的一个form想服务器端提交请求时,如有textfield,代码如下:
    这里写图片描述
    这里写图片描述
    在提交后,Struts2将会自动调用login动作类中的setXX方法,并将文本框中的值通过setXXX方法的参数传入。
    实际上,这个操作是由params拦截器完成的,params对应的类是com.opensymphony.xwork2.interception.Parameterslnterceptor.
    由于params已经在defaultStack中定义,因此,在未引用拦截器的是会自动引用params的。
    如下面的配置代码,在访问login动作时,Struts是会自动执行相应的setter方法的。
    这里写图片描述
    这样,登陆表单中的用户名,密码参数就会在Action类中被set进去,完成登陆功能。
    但如果在action中引用了其他拦截器,就必须显示的引用params拦截器,Struts2不能调用相应的setter方法来初始化参数。如下面的配置代码所示:
    这里写图片描述
    这里写图片描述
    我们可以不去配置params拦截器,配置timer和logger或任意一个,测试参数username、password的值,应该是没有得到表单提交的值,因为params拦截器已经不起作用了。
    14、使用拦截器栈
    为了能在多个动作中方便的引用同一个或几个拦截器,可以使用拦截器栈将这些拦截器当个整体来引用。
    拦截器栈要在 package 标签中使用 interceptors 和子标签interceptor-stack来定可以像使用拦截器一样使用拦截器栈。

    展开全文
  • 面向切面编程(AOP)及其作用 在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。 1、面向切面编程(AOP)  面向切面编程(AOP)就是对软件系统不同关注点的分离,开发者通过拦截方法调用并在方法...

    面向切面编程(AOP)及其作用

    在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。

    1、面向切面编程(AOP)

      面向切面编程(AOP)就是对软件系统不同关注点的分离,开发者通过拦截方法调用并在方法调用前后添加辅助代码。

      AOP利用一种称为“横切”的技术,剖解开封装的对象内部,并将那些影响了多了类的公共行为封装到一个可重用的模块,并将其命名为“Aspect”,即切面。

      所谓“切面”,简单地说,就是将那些于业务无关,却为月舞模块所共同调用的逻辑或责任封装起来。

      切面就是横切面,代表的是一个普遍存在的共有功能。

      AOP代表的是一个横向关系

      AOP吧软件系统分为两个部分:核心关注点和横切关注点。

      业务出路的主要流程是核心关注点,与之关系不大的部分是横切关注点。

      横切关注点的一个特点是,他们经常发生在核心关注点的多处,而各处都基本相似。比如权限认证、日志、事务处理。

    2、AOP的作用在与分离系统中各个关注点,将核心关注点和横切关注点分离开来。

    java代码:

    public class BusinessLogic{

      public voidSomeOPration(){

        //日志记录;

        //权限验证;

        DoSomething();

        //失误控制;

      }

    }

    3、AOP技术的实现

    AOP技术是建立在JAVA语言的反射机制与动态代理机制之上的。

    业务逻辑组件在运行过程中,AOP容器动态创建一个代理对象供使用者调用。该代理对象已经按程序员的意图将切面成功切入到目标方法的连接点上,从而切面的功能与业务逻辑的功能同时的以执行。

    AOP是一种编程概念,因此他并未绑定带任何特定的语言。事实上,他对所有单独的、垂直的分解式(AOP通常被认为是横向分解)的语言(不仅是OO语言)都有帮助。AOP在不同语言都有实现(如C++,Smalltalk,C#,C,Java)。

    4、拦截器的设计原理

      Struts2.0的拦截器的设计体现了一种编程的设计理念,即面向切面编程AOP。

      拦截是AOP的一种实现策略,在AOP中某个方法或字段被访问,可以进行拦截,然后在其之前或其之后加入某些操作。

    5、什么是拦截器(Interceptor)?

      拦截器是动态拦截Action调用的对象。他提供了中机制是开发者可以在一个Action执行之前或执行之后插入需要的代码。

    6、理解DRY(Don't Repeat Yourself)规则

      在软件开发领域,有一个非常重要的规则:Don't Repeat Yourself,就是所谓的DRY规则,意思就是不要写重复代码。

    为什么要使用方法调用呢?而不是在三个地方使用重复的代码呢?

      很多初学者认为是为了编程的简单,代码简洁。实际上,这是次要的,最重要的原因是为了软件后期的升级及维护。

    7、拦截器的意义

      拦截器是对调用方法的改进。我们说某个实例是一个拦截器时,这是从行为上来说的,如果从代码的角度来看,拦截器也是一个类,类中包含有方法,知识这个方法比较特殊,他会在目标方法调用之前“自动”执行。

      进一步改进,如图:

    作用:(1)提供可更高层次的解耦

        (2)允许改变被调用方法的方法体

        (3)可以改变调用的目标方法

    8、实现原理

      如何自动的调用拦截器,而且知道到底调用呢个拦截器的方法?大部分的时候,拦截器方法都是通过JDK的动态代理来调用的,AOP的实现机制。

    9、拦截器在Struts2.0中的角色

      

    作用:(1)拦截器是通过struts.xml文件配置的,从而实现了对Action通用操作的可插拨式管理。

      (2)降低了Action与特定代码的耦合性

      (3)提高了ACtion的复用性

      (4)吧多个Action中需要重复指定的代码取出,放在拦截器类中定义,从而提供更好地代码重用。

    10、Struts2中的拦截器

      在Struts2中已经在struts-default.xml中预定义了一些自带的拦截器,如timer、params等。

      如果在struts.xml中配置<package>标签中继承struts-default,则当前package就会自动拥有struts-default.xml中的所有配置。代码如下:

      

    <package name="xxx" extends="struts-default" > ... </package>

    11、拦截器的定义

      在struts.xml文件中定义拦截器语法格式:

      <interceptor name="拦截器名" class=“拦截器实现类/”>

    12、应用定义好的拦截器

      <interceptor-ref name="拦截器名/">

    在struts-default.xml中有一个默认的引用,在默认情况下(也就是<action>中未引用拦截器时)会自动引用一些拦截器。

      <default-interceptor-ref name="defaultStack/">

    上面在defaultStack中引用的拦截器都可以<action>中不经过引用可以使用

    注意:如果在<action>中引用了任何拦截器后,要使用在defaultStack中定义的拦截器,需要在<action>中重新引用。

    13、params拦截器使用

      当客户端的一个form想服务器端提交请求时,如有textfield,代码如下:

    <s:form action="login" >

      username <s:textfield name="username"/> <br>

      password <s:password name="password" /> <br>

     <s:submit/>

    </s:form>

    在提交后,Struts2将会自动调用login动作类中的setXX方法,并将文本框中的值通过setXXX方法的参数传入。

    实际上,这个操作是由params拦截器完成的,params对应的类是com.opensymphony.xwork2.interception.Parameterslnterceptor.

    由于params已经在defaultStack中定义,因此,在未引用拦截器的<action>中是会自动引用params的。

    如下面的配置代码,在访问login动作时,Struts是会自动执行相应的setter方法的。

    <action name="login" class=“com.ascent.action.LoginAction">   <result>/success.jsp</result>

      <result name="input">/login.jsp</result>

    </action>

    这样,登陆表单中的用户名,密码参数就会在Action类中被set进去,完成登陆功能。

    但如果在<action>中引用了其他拦截器,就必须显示的引用params拦截器,Struts2不能调用相应的setter方法来初始化参数。如下面的配置代码所示:

    <action name="login" class=“com.ascent.action.LoginAction">

      <interceptor-ref name="timer" />

      <interceptor-ref name="logger"/>  

      <interceptor-ref name="params"/>

      <result>/success.jsp</result>

      <result name="input">/login.jsp</result>

    </action>

    我们可以不去配置params拦截器,配置timer和logger或任意一个,测试参数username、password的值,应该是没有得到表单提交的值,因为params拦截器已经不起作用了。

    14、使用拦截器栈

    为了能在多个动作中方便的引用同一个或几个拦截器,可以使用拦截器栈将这些拦截器当个整体来引用。

    拦截器栈要在<package>标签中使用<interceptors>和子标签<interceptor-stack>来定可以像使用拦截器一样使用拦截器栈。

    <package name="demo" extends="struts-default" >

      <interceptors>

        <interceptor-stack name="mystack">

          <interceptor-ref name="timer" />

          <interceptor-ref name="logger" />

          <interceptor-ref name="params" />

        </interceptor-stack>

      </interceptors>

      <action name="login" class="com.ascent.action.LoginAction">

       <interceptor-ref name="mystack"/>

      </action>

    </package>

    展开全文
  • aop.rar_面向切面编程

    2022-09-24 22:52:04
    通过注解的方式,实现切面编程,快速入门,是学习更有乐趣
  • java面向切面编程

    2019-03-26 02:24:52
    NULL 博文链接:https://zhaoshijie.iteye.com/blog/1179594
  • 切面编程听起来可能有点陌生,不过现在越来越多的开发团队正在用上这种技术。 先说熟悉的面向对象编程 OOP,通常都是用各种对象/模块来负责具体的功能,互相之间尽量不耦合。 切面编程AOP(aspect-priented ...
  • 下面小编就为大家分享一篇JavaScript实现AOP的方法(面向切面编程,装饰者模式),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 面向切面编程 1

    2022-08-08 20:12:57
    2.背景假设本章概述编程语言和软件设计过程之间的关系,此关系亦即本篇论文所述内容的基础。软件设计过程和编程语言相互支持。设计过程把系统分解为越来越小的部件。编程
  • Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9,实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包,工程目录如下:
  • 易于理解的说明, 简单明了的DEMO,从正常的编程方式,演变到依赖注入,再演变到AOP切面编程。 描述了什么是反转控制,什么是容器
  • CrossCuttingConcern_Scala 在 Scala 中使用面向切面编程 (AOP) 实现横切关注
  • 面向切面编程(AOP)初探

    千次阅读 2021-04-17 09:13:33
    面向切面编程(AOP)被认为是一项有前途的新技术,它通过对交叉业务的分隔来实现,而这在面向对象编程里很难做到。本文通过一个新的范例介绍AOP的基本概念。面向对象编程 Object Oriented Programming今天,面向对象...

    面向对象编程通过设计和语言本身提供的模块化、封装、继承、多态来实现软件复用。尽管OOP在建模以及实现复杂软件方面非常成功,它仍然有一些问题。面向切面编程(AOP)被认为是一项有前途的新技术,它通过对交叉业务的分隔来实现,而这在面向对象编程里很难做到。本文通过一个新的范例介绍AOP的基本概念。

    面向对象编程 Object Oriented Programming

    今天,面向对象编程已经成为主流的编程模式,在这里,现实问题被分解为一个个的包含数据和行为的对象。

    在大型工程实践中,程序员发现在模块中越来越难以分离交叉业务,他们的代码也变得更加难维护。对程序设计的一丝改动都会引发大量不相关模块的改动。

    交叉业务 Crosscutting Concerns

    一个交叉业务的例子是“日志”,日志在分布式系统中经常被用来记录方法调用,以辅助调试。假设我们在每个函数开始前和结束后都写日志,这会使我们对所有包含方法的类做“横切”(crosscutting)。其他典型的交叉业务包括:上下文敏感的错误处理,性能优化,以及设计模式。

    交叉业务可能出现在某些程序中,尤其是那些大型程序中。然而另一方面,对系统的重新设计可以将交叉业务转换成对象。AOP假定交叉业务会出现在程序中,并无法从重构中被剔除出去。

    面向切面编程 Aspect Oriented Programming

    面向切面的编程AOP是一项新的技术,它将交叉业务分离出来,作为独立单元——切面——处理。切面即是交叉业务的模块化实现,它封装了对各个类都有影响的行为,作为新的可重用的模块。利用AOP,我们可以用OO编程语言(如Java)开始项目,然后我们单独使用切面处理交叉业务。最后,代码和切面一起通过编织器(aspect weaver)组织成最终可执行文件。图1说明了"编织器"工作过程。注意,原始的代码不需要知道切面的任何功能;只要除去切面代码并重新编译,就能得到初始代码的功能。

    AOP是一种编程概念,因此它并未绑定到任何特定的语言。事实上,它对所有单独的、垂直分解式(译注:AOP通常被认为是横向分解)的语言(不仅是OO语言)都有帮助。AOP在不同语言都有实现(如 C++, Smalltalk, C#, C, Java).

    当然,受益最大的还是Java语言。下面是一些支持Java AOP的工具:

    ◆AspectJ

    ◆AspectWerkz

    ◆Hyper/J

    ◆JAC

    ◆JMangler

    ◆MixJuice

    ◆PROSE

    ◆ArchJava

    由Xerox PARC所创建的AspectJ被认为是Java语言在AOP方面的一个扩展,是专门为面向切面的编程而生的。本文下面部分主要涉及AspectJ.

    连接点,切入点,通知和引入 Join points, Pointcut, Advice, and Introduction

    就如OOP的概念包含继承、封装、多态一样,组成AOP的概念是连接点,切入点,通知和引入(Join points, Pointcut, Advice, and Introduction)。为更好的理解这些术语,我们看一下下面的例子。public class TestClass {

    public void sayHello () {

    System.out.println ("Hello, AOP");

    }

    public void sayAnyThing (String s) {

    System.out.println (s);

    }

    public static void main (String[] args) {    sayHello ();

    sayAnyThing ("ok");

    }

    }

    我们的Java代码保存在TestClass.java,假设我们想用切面做如下修改:

    在对TestClass.sayHello()方法调用之前和之后,都打印一行信息;检查TestClass.sayAnyThing() 方法的参数,至少3个字符才能执行

    下面就是AspectJ 的实现。public aspect MyAspect {

    public pointcut sayMethodCall (): call (public void

    TestClass.say*() );

    public pointcut sayMethodCallArg (String str): call

    (public void TestClass.sayAnyThing (String))

    && args(str);

    before(): sayMethodCall() {

    System.out.println("\n TestClass." +

    thisJoinPointStaticPart.getSignature().getName() +

    "start..." );

    }

    after(): sayMethodCall() {

    System.out.println("\n TestClass." +

    thisJoinPointStaticPart.getSignature().getName() +

    " end...");

    }

    before(String str): sayMethodCallArg(str) {

    if (str .length() 

    System.out.println ("Error: I can't say words less than 3

    characters");

    return;

    }

    }

    }

    Line 1 定义了一个aspect,就像我们定义Java 类。跟任何Java类一样,aspect也可以拥有成员变量和方法,另外它还可以包含切入点(pointcuts),通知(advices)和引入(introductions).

    Lines 2和Line 3指定我们的修改在TestClass什么地方起作用。按AspectJ术语,我们定义了2个切入点(pointcuts)。为了弄清楚切入点(pointcut)是什么意思,我们需要先定义连接点(join points).

    连接点(join points)表示在程序执行过程中预先定义的“点”,AspectJ 中典型的连接点包括:方法或构造器的调用,方法或构造器的执行,字段的读取,异常处理,以及静态或动态的初始化。本文例子中,我们定义了2处连接点:对TestClass.sayHello方法的调用及对TestClass.sayAnyThing方法的调用。

    切入点(Pointcut)是符合预定义规范的连接点(a set of join points)的集合,这是一个语言上的构造概念。 规范可以是明确的的函数名,也可以是包含通配符的函数名。

    public pointcut sayMethodCall (): call (public void

    TestClass.say*() );

    上面一行,我们定义了一个切入点(pointcut),叫做 sayMethodCall,它会检查所有对TestClass.sayHello方法的调用。另外,它同样会检查TestClass 类里所有以"say"开头,参数为空的公共方法(举个例子:TestClass.sayBye).

    切入点(Pointcuts)用来定义“通知” (advice). AspectJ 的advice用来定义在连接点执行之前、之中、之后的额外代码。在我们的例子中,line 4-6 和line7-9 分别定义了对第一个切入点执行之前和之后的通知。Lines10-15定义了对第二个切入点的通知,即设置TestClass.sayAnyThing 方法执行的一个前置条件。

    切入点pointcuts和通知advice能让你影响程序的动态执行部分,与此不同,引入(introduction)允许切面修改程序中静态的部分。通过引入(introduction), 切面可以为类添加新的方法及变量,声明类实现的接口,或将捕获的异常转为未捕获的异常。 Introduction和一个更为实用的AOP的例子是我未来一篇文章的主题。

    AspectJ 编译器

    回到开头,你需要从AspectJ 的官方网站上下载它的最新版本并安装它(免费的),编译和运行我们的例子非常简单:

    ajc MyAspect.aj TestClass.java

    java TestClass

    值得注意的是,Java源代码TestClass.java 没有任何改动。你只要使用Java编译器重新编译它就能得到最初的原始程序功能。

    展开全文
  • #aspectjs切面编程 aspectjs是一个给JavaScript增加切面功能的强大组件。这个项目起源于ecojs切面功能,但是为了让切面编程更好的发展,所以决定把这部分单独拿出来,让你可以单独使用切面功能。当然你在ecojs可以...
  • AOP面向切面编程

    2022-02-04 16:19:36
    AOP(Aspect Orient Programming): 面向切面编程 Aspect :表示切面,给业务方法增加的功能,叫做切面。 切面一般都是非业务功能, 而且切面功能一般都是可以复用的。 例如 日志功能, 事务功能, 权限检查,参数...
  • 实现spring的aop的操作,采用AspectJ技术,通过xml的配置来实现,本人亲自测试过,aop相关架包已引入
  • 学习Spring开发的AOP面向切面编程时所需要的jar包,包括com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
  • AoP面向切面编程

    2022-04-15 09:54:51
    AoP:面向切面编程,对业务逻辑的各个部分进行隔离,使得业务逻辑的各个部分之间的耦合度降低。 通俗来讲:不修改源码的方式,在主干功能里添加新功能。 例如: 1、AoP底层使用动态代理 有两种动态代理情况: (1)...
  • AOP,百度一下就知道,是 Aspect Oriented Programming,面向切面编程。怎么理解面向切面编程呢? 我用一个场景来解释一下: 我们在一个项目中会有很多模块或者函数(在图中统称为任务,下同)要使用,而在进行某些...
  • AOP面向切面编程的JavaScript实现
  • 九、面向切面编程AOP

    千次阅读 2022-04-02 19:58:55
    文章目录Spring 的 AOP 简介什么是 AOPAOP 的作用及其优势AOP 的底层实现AOP 的动态代理技术JDK 的动态代理cglib 的动态代理AOP 相关概念AOP 开发明确的事项1. 需要编写的内容2. AOP 技术实现的内容3. AOP 底层使用...
  • springboot切面编程基础实践

    千次阅读 2022-03-25 10:39:59
    org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-aop com.alibaba fastjson 1.2.79 二、定义切面 定义步骤: (1)、切面类加@Aspect 、@Service注解,告诉...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,773
精华内容 49,509
关键字:

切面编程的作用