AOP的理解

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量51 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/2309946/blog/391719
版权

在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。

如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放置到某个地方集中管理，然后在具体运行时，再由容器动态织入这些共有代码的话，最起码可以解决两个问题：

Java EE程序员在编写具体的业务逻辑处理方法时，只需关心核心的业务逻辑处理，既提高了工作效率，又使代码变更简洁优雅。

在日后的维护中由于业务逻辑代码与共有代码分开存放，而且共有代码是集中存放的，因此使维护工作变得简单轻松。

面向切面编程AOP技术就是为解决这个问题而诞生的，切面就是横切面，如图6-5所示，代表的是一个普遍存在的共有功能，例如，日志切面、权限切面及事务切面等。

下面我们以用户管理业务逻辑组件UserService的AOP实现过程（见图6-6）为例，深度剖析一下AOP技术的实现原理。AOP技术是建立在Java语言的反射机制与动态代理机制之上的。业务逻辑组件在运行过程中，AOP容器会动态创建一个代理对象供使用者调用，该代理对象已经按Java EE程序员的意图将切面成功切入到目标方法的连接点上，从而使切面的功能与业务逻辑的功能同时得以执行。从原理上讲，调用者直接调用的其实是AOP容器动态生成的代理对象，再由代理对象调用目标对象完成原始的业务逻辑处理，而代理对象则已经将切面与业务逻辑方法进行了合成。

现将图6-6中涉及到的一些概念解释如下。

切面（Aspect）：其实就是共有功能的实现。如日志切面、权限切面、事务切面等。在实际应用中通常是一个存放共有功能实现的普通Java类，之所以能被AOP容器识别成切面，是在配置中指定的。

通知（Advice）：是切面的具体实现。以目标方法为参照点，根据放置的地方不同，可分为前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）、最终通知（After）与环绕通知（Around）5种。在实际应用中通常是切面类中的一个方法，具体属于哪类通知，同样是在配置中指定的。

连接点（Joinpoint）：就是程序在运行过程中能够插入切面的地点。例如，方法调用、异常抛出或字段修改等，但Spring只支持方法级的连接点。

切入点（Pointcut）：用于定义通知应该切入到哪些连接点上。不同的通知通常需要切入到不同的连接点上，这种精准的匹配是由切入点的正则表达式来定义的。

目标对象（Target）：就是那些即将切入切面的对象，也就是那些被通知的对象。这些对象中已经只剩下干干净净的核心业务逻辑代码了，所有的共有功能代码等待AOP容器的切入。

代理对象（Proxy）：将通知应用到目标对象之后被动态创建的对象。可以简单地理解为，代理对象的功能等于目标对象的核心业务逻辑功能加上共有功能。代理对象对于使用者而言是透明的，是程序运行过程中的产物。

织入（Weaving）：将切面应用到目标对象从而创建一个新的代理对象的过程。这个过程可以发生在编译期、类装载期及运行期，当然不同的发生点有着不同的前提条件。譬如发生在编译期的话，就要求有一个支持这种AOP实现的特殊编译器；发生在类装载期，就要求有一个支持AOP实现的特殊类装载器；只有发生在运行期，则可直接通过Java语言的反射机制与动态代理机制来动态实现。

3.典型的Spring切面

场景：在一场表演中，表演前观众找位置，并关闭手机，表演精彩时观众鼓掌，表演槽糕的时候观众要求退票。现在在这个场景下使用Spring的切面
[java] view plain copy print ?
  1. package com.sin90lzc.test;  
  2. //观众类  
  3. public class Audience {  
  4.    public Audience() {  
  5.    }  
  6.    //表演前找座位  
  7.    public void takeSeats() {  
  8.        System.out.println("The audience is taking their seats.");  
  9.    }  
  10.    //找到座位后关掉手机  
  11.    public void turnOffCellPhones() {  
  12.        System.out.println("The audience is turning off their cellphones");  
  13.    }  
  14.    //表演精彩时鼓掌  
  15.    public void applaud() {  
  16.        System.out.println("CLAP CLAP CLAP CLAP CLAP");  
  17.    }  
  18.    //表演槽糕时要求退票  
  19.    public void demandRefund() {  
  20.        System.out.println("Boo!We want our money back!");  
  21.    }  
  22. }  
package com.sin90lzc.test;
//观众类
public class Audience {
	public Audience() {
	}
	//表演前找座位
	public void takeSeats() {
		System.out.println("The audience is taking their seats.");
	}
	//找到座位后关掉手机
	public void turnOffCellPhones() {
		System.out.println("The audience is turning off their cellphones");
	}
	//表演精彩时鼓掌
	public void applaud() {
		System.out.println("CLAP CLAP CLAP CLAP CLAP");
	}
	//表演槽糕时要求退票
	public void demandRefund() {
		System.out.println("Boo!We want our money back!");
	}
}
由Spring容器管理Audience:
[html] view plain copy print ?
  1. <bean id="audience" class="com.springinaction.springido1.Audience" />  
<bean id="audience" class="com.springinaction.springido1.Audience" />

3.1创建通知

Spring的AOP里有5种时间点的通知，分别由一个接口进行定义：

通知类型接口
Beforeorg.springframework.aop.MethodBeforeAdvice
After-returningorg.springframework.aop.AfterReturningAdvice
After-throwingorg.springframework.aop.ThrowsAdvice
Aroundorg.aopalliance.intercept.MethodInterceptor
Introductionorg.springframework.aop.IntroductionInterceptor

除了MethodInterceptor之外，这些接口都属于Spring框架。在定义周围通知时，Spring利用了由AOP Alliance提供的接口，这是一个开源项目，其宗旨在于AOP的简化及标准化。如果需要进一步了解AOP Alliance，可以访问其站点 http://aopalliance.sourceforge.net

现在就可以根据上面的场景建立一个通知（advice）了：
[java] view plain copy print ?
  1. package com.sin90lzc.test;  
  2.  
  3. import java.lang.reflect.Method;  
  4.  
  5. import org.springframework.aop.AfterReturningAdvice;  
  6. import org.springframework.aop.MethodBeforeAdvice;  
  7. import org.springframework.aop.ThrowsAdvice;  
  8.  
  9. public class AudienceAdvice implements MethodBeforeAdvice,  
  10.        AfterReturningAdvice, ThrowsAdvice {  
  11.  
  12.    private Audience audience;  
  13.  
  14.    public void afterReturning(Object arg0, Method arg1, Object[] arg2,  
  15.            Object arg3) throws Throwable {  
  16.        audience.applaud();  
  17.    }  
  18.  
  19.    public void before(Method arg0, Object[] arg1, Object arg2)  
  20.            throws Throwable {  
  21.        audience.takeSeats();  
  22.        audience.turnOffCellPhones();  
  23.    }  
  24.  
  25.    public void afterThrowing(Throwable throwable) {  
  26.  
  27.    }  
  28.  
  29.    public Audience getAudience() {  
  30.        return audience;  
  31.    }  
  32.  
  33.    public void setAudience(Audience audience) {  
  34.        this.audience = audience;  
  35.    }  
  36.  
  37. }  
package com.sin90lzc.test;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.ThrowsAdvice;

public class AudienceAdvice implements MethodBeforeAdvice,
		AfterReturningAdvice, ThrowsAdvice {

	private Audience audience;

	public void afterReturning(Object arg0, Method arg1, Object[] arg2,
			Object arg3) throws Throwable {
		audience.applaud();
	}

	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {
		audience.takeSeats();
		audience.turnOffCellPhones();
	}

	public void afterThrowing(Throwable throwable) {

	}

	public Audience getAudience() {
		return audience;
	}

	public void setAudience(Audience audience) {
		this.audience = audience;
	}

}

这里一个类中实现了3种不同类型的AOP通知。

前通知——MethodBeforeAdvice
在进入切入点（方法调用前）调用。MethodBeforeAdvice要求实现一个Before()方法：
[java] view plain copy print ?
  1. public void before(Method arg0, Object[] arg1, Object arg2)  
  2.            throws Throwable {}  
public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {}
第一个参数代表要使用这个通知的方法。第二个参数是方法被调用时要传递的参数。最后一个参数是方法调用的目标（也就是被调用方法所在的对象）。

返回后通知——AfterReturningAdvice
这个通知需要实现afterReturning()方法：
[java] view plain copy print ?
  1. public void afterReturning(Object arg0, Method arg1, Object[] arg2,  
  2.            Object arg3) throws Throwable {}  
public void afterReturning(Object arg0, Method arg1, Object[] arg2,
			Object arg3) throws Throwable {}
aferReturning方法的参数与MethodBeforeAdvice的before()方法的参数区别不大，只是第一个参数是从被调用方法返回的值。

抛出后通知——ThrowsAdvice
与MethodBeforeAdvice和AfterReturningAdvice不同的是，ThrowsAdvice不需要实现任何方法，它只是一个标记接口，告诉Spring相应的通知要求处理被抛出的异常。

对于ThrowsAdvice的实现可以是一个或多个afterThrowing()方法，其签名具有如下形式：
public void afterThrowing([method],[args],[target],throwable);

周围通知——MethodInterceptor
周围通知相当于前通知、返回后通知、抛出后通知的结合。AudienceAdvice类可以用周围通知来重写。如：
[java] view plain copy print ?
  1. package com.sin90lzc.test;  
  2.  
  3. import org.aopalliance.intercept.MethodInterceptor;  
  4. import org.aopalliance.intercept.MethodInvocation;  
  5.  
  6. public class AudienceAroundAdvice implements MethodInterceptor {  
  7.  
  8.    public Object invoke(MethodInvocation invocation) throws Throwable {  
  9.        try {  
  10.            audience.takeSeats();  
  11.            audience.turnOffCellPhones();  
  12.            Object returnValue = invocation.proceed();  
  13.            audience.applaud();  
  14.            return returnValue;  
  15.        } catch (Exception e) {  
  16.            audience.demandRefund();  
  17.            throw e;  
  18.        }  
  19.    }  
  20.  
  21.    public Audience getAudience() {  
  22.        return audience;  
  23.    }  
  24.  
  25.    public void setAudience(Audience audience) {  
  26.        this.audience = audience;  
  27.    }  
  28.  
  29.    private Audience audience;  
  30. }  
package com.sin90lzc.test;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AudienceAroundAdvice implements MethodInterceptor {

	public Object invoke(MethodInvocation invocation) throws Throwable {
		try {
			audience.takeSeats();
			audience.turnOffCellPhones();
			Object returnValue = invocation.proceed();
			audience.applaud();
			return returnValue;
		} catch (Exception e) {
			audience.demandRefund();
			throw e;
		}
	}

	public Audience getAudience() {
		return audience;
	}

	public void setAudience(Audience audience) {
		this.audience = audience;
	}

	private Audience audience;
}
使用周围通知的好处之一是能以简洁的方式在一个方法里定义前通知和后通知。 利用周围通知还可以检查和修改被通知方法的返回值，让我们可以在把方法的返回值传递给调用者之前对其进行一些后处理。AfterReturningAdvice只能对返回值进行检查，但不能修改它。

3.2 定义切入点和通知者

Advice（通知）已经解决了切面“做什么”和“何时”的问题。接下来就要解决“在哪里”的问题了。也就是切入点的定义。

Spring提供了几种不同类型的切点，其中两种最有用的是正则表达式切点和AspectJ表达式切点。
3.2.1声明正则表达式切点
使用org.springframework.aop.supprot.JdkRegexpMethodPointcut类来定义正则表达式切点：
[html] view plain copy print ?
  1. <bean id="performancePointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">  
  2.    <property name="pattern" value=".*perform" />  
  3. </bean>  
<bean id="performancePointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
	<property name="pattern" value=".*perform" />
</bean>

接下来需要把切入点与通知关联起来，可以用类org.springframework.aop.support.DefaultPointcutAdvisor把这种关系关联起来。
[html] view plain copy print ?
  1. <bean id="audienceAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">  
  2.    <property name="advice" ref="audienceAdvice" />  
  3.    <property name="pointcut" ref="performancePointcut" />  
  4. </bean>  
<bean id="audienceAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
	<property name="advice" ref="audienceAdvice" />
	<property name="pointcut" ref="performancePointcut" />
</bean>

DefaultPointcutAdvisor是个通知者类，它只是把通知关联到切点。

联合切点与通知
RegexpMethodPointcutAdvisor是个特殊的通知者类，可以在一个Bean里定义切点和通知：
[html] view plain copy print ?
  1. <bean id="audienceAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
  2.    <property name="advice" ref="audienceAdvice" />  
  3.    <property name="pattern" value=".*perform" />  
  4. </bean>  
<bean id="audienceAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
	<property name="advice" ref="audienceAdvice" />
	<property name="pattern" value=".*perform" />
</bean>
3.2.2定义AspectJ切点
正则表达式虽然可以作为切点定义语言来使用，但它并不是针对切点而创建的，其主要用途还是文本解析。与之相比，从AspectJ里定义切点的方式就可以看出AspectJ的切点语言是一种真正的切点表达语言。
Spring使用类org.springframework.aop.aspectj.AspectJExpressionPointcut来定义AspectJ切点表达式：
[html] view plain copy print ?
  1. <bean id="performancePointcut" class="org.springframework.aop.aspectj.AspectJExpressionPointcut">  
  2.    <property name="expression" value="execution(* Performer+.perform(..))" />  
  3. </bean>  
<bean id="performancePointcut" class="org.springframework.aop.aspectj.AspectJExpressionPointcut">
	<property name="expression" value="execution(* Performer+.perform(..))" />
</bean>

为了把AspectJ表达式切点与通知关联起来，可以使用DefaultPointcutAdvisor，就像正则表达式切点一样。同样的，我们可以利用特殊的通知者，把切点表达式定义为通知者的一个属性。对于AspectJ表达式来说，使用的通知者类是org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor:
[html] view plain copy print ?
  1. <bean id="audienceAdvisor" class="org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor">  
  2.    <property name="advice" ref="audienceAdvice" />  
  3.    <property name="expression" value="execution(* Performer+.perform(..))" />  
  4. </bean>  
<bean id="audienceAdvisor" class="org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor">
	<property name="advice" ref="audienceAdvice" />
	<property name="expression" value="execution(* Performer+.perform(..))" />
</bean>

通知者把通知与切点关联起来，从而完整地定义一个切面。但是，切面在Spring里是以代理方式实现的，所以仍然需要代理目标Bean才能让通知者发挥作用。

3.3 使用ProxyFactoryBean

Spring的ProxyFactoryBean是个工厂Bean，用于生成一个代理，把一个或多个通知者应用到Bean。示例：
[html] view plain copy print ?
  1. <bean id="duke" class="org.springframework.aop.framework.ProxyFactoryBean">  
  2.    <property name="target" ref="dukeTarget" />  
  3.    <property name="interceptorNames">  
  4.        <list>  
  5.            <value>audienceAdvisor</value>  
  6.        </list>  
  7.    </property>  
  8.    <property name="proxyInterfaces">  
  9.        <list>  
  10.            <value>com.springinaction.springido1.Performer</value>  
  11.        </list>  
  12.    </property>  
  13. </bean>  
<bean id="duke" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="target" ref="dukeTarget" />
	<property name="interceptorNames">
		<list>
			<value>audienceAdvisor</value>
		</list>
	</property>
	<property name="proxyInterfaces">
		<list>
			<value>com.springinaction.springido1.Performer</value>
		</list>
	</property>
</bean>

当然，当有多个Bean都需要代理相同的接口或通知者时，可以抽象ProxyFactoryBean，达到简化配置的目的。

转载于:https://my.oschina.net/u/2309946/blog/391719

chiyan0018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解Spring AOP
08-31
主要介绍了深入理解Spring AOP，详细的介绍了spring aop的具体实现与理论
深入理解Android之AOP
01-26
深入理解Android之AOP；深入理解Android之AOP；深入理解Android之AOP
AOP理解
分享Android开发知识
03-25 810
一、什么是AOP？ 我们先回顾一下OOP：Object Oriented Programming，OOP作为面向对象编程的模式，获得了巨大的成功，OOP的主要功能是数据封装、继承和多态。 而AOP是一种新的编程方式，它和OOP不同，OOP把系统看作多个对象的交互，AOP把系统分解为不同的关注点，或者称之为切面（Aspect）。 要理解AOP的概念，我们先用OOP举例，比如一个业务组件BookService，它有几个业务方法： createBook：添加新的Book； updateBook：修改Book； d
Spring AOP理解
I_m_j的博客
06-10 1451
Spring AOP基础解读
aop理解
qq_36522865的博客
03-04 342
将不同业务需求的接口所需要通用的部分，单拎出来成为一个公用切面代码，无论哪个接口需要都去单独调用该切面，不去重复多次的写，就是aop。概括来讲就是不重复造轮子。
Spring的AOP理解
红目香薰
03-08 253
OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。 AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。 AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动态.
对AOP理解
weixin_50932484的博客
03-19 99
aop主要实现在是bean的后置处理器，使用jdk动态代理或者是cglib动态代理给原本的代码进行业务增强。
Spring Aop理解
时间在流
02-07 123
AOP是Spring框架面向切面的编程思想，AOP采用动态代理的技术，将涉及多业务流程的通用功能抽取并单独封装，形成独立的切面，在合适的时机将这些切面横向切入到业务流程指定的位置中。本篇结合实际案例详细讲述AOP的原理及实现过程。通过本篇的学习，可以达成如下目标。 理解AOP的编程思想及原理 掌握AOP的实现技术 ...
【Spring】谈谈你对IOC和AOP理解(2024最新)
酷酷的馫博客
02-26 7176
谈谈你对IOC和AOP理解(2023最新)
SpringIOC和AOP理解之深入浅出（建议收藏）
weixin_45105261的博客
01-13 6801
Spring框架介绍 概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架 前身：interface21是他的前身 Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架 优点： 方便解耦，简化开发 （高内聚低耦合） Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理 spring工厂是用于生成bean AOP编程的支持 Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支
Spring AOP 理解
头好重好重的博客
04-19 366
对Spring AOP 的一些简简单单的理解
Spring核心IoC和AOP的理解
08-31
本文主要介绍了Spring核心IoC和AOP的相关知识。具有很好的参考价值，下面跟着小编一起来看下吧
SpringAop的简单理解.pdf
02-28
SpringAop的简单理解.pdf
理解Spring AOP实现与思想 案例代码
06-06
博客《理解Spring AOP实现与思想》案例代码，对Java技术感兴趣的朋友可以关注一下我，我在csdn为您准备了很多Java干货。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1010
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 808
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 300
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 263
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
spring aop理解
09-12
Spring AOP（面向切面编程）是Spring框架的一个重要特性，它允许我们通过在应用程序中定义切入点和切面来实现横切关注点的模块化。 在传统的面向对象编程中，业务逻辑散布在应用程序的各个模块中，例如数据访问、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值