深入理解面向切面的编程AOP、AspectJ、Spring

最新推荐文章于 2024-02-28 09:45:13 发布

苍痕

最新推荐文章于 2024-02-28 09:45:13 发布

阅读量3.6k

点赞数 1

本文链接：https://blog.csdn.net/wangbaochu/article/details/53504269

版权

Spring：是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架。Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

AspectJ：是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件.

一、AOP介绍

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

2.为什么用aop

就是为了方便，因为他把自己做的事情都让程序做了。用了aop能让你少写很多代码，就是为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，这些其他的事情包括：安全，事物，日志等。

3.那些aop的术语

（1）.通知（Advice）

就是你想要的功能，也就是上面说的安全，事物，日志等。通知是在切面的某个特定的连接点（Joinpoint）上执行的代码。通知共有5种类型：

前置通知（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。
后通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。

（2).连接点（JoinPoint）

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

（3).切入点（Pointcut）

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

（4).切面（Aspect）

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

（5).引入（introduction）

允许我们向现有的类添加额外的方法或者某个类型的字段。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

（6).目标（target）

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

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织入通知，并且把对这个子类的调用委托到目标类。相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

二、Android AspectJ实例讲解
1、如何织入代码：MethedTrace.java是AspectJ代码，需要织入切面代码到MainActivity.java

// MainActivity.java
package org.sdet.aspectj;

public class MainActivity extends Activity {
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  }  
}

// MethodTracer.java
package org.sdet.aspectj;

import android.util.Log;

@Aspect
public class MethodTracer {

  private static final String TAG = MethodTracer.class.getSimpleName();

  @Before("execution (protected void org.sdet.aspectj.MainActivity.onCreate(android.os.Bundle))")
  public void adviceOnCreate(JoinPoint joinPoint) {
    Log.v(TAG, joinPoint.toString());
  }
}

执行下面的命令行：

java -cp <classpath> org.aspectj.tools.ajc.Main -inpath <MainActivity.class path> -aspectpath <MethodTracer.class path>

新生成的MainActivity.class，用Java bytecode decompile工具打开，如下：

import org.sdet.aspectj.MethodTracer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.JoinPoint.StaticPart;
import org.aspectj.runtime.reflect.Factory;

public class MainActivity extends Activity {

  private static final JoinPoint.StaticPart ajc$tjp_0;

  private static void ajc$preClinit() {
    Factory localFactory = new Factory("MainActivity.java", MainActivity.class);
    ajc$tjp_0 = localFactory.makeSJP("method-execution", localFactory.makeMethodSig("4", "onCreate", "org.sdet.aspectj.MainActivity", "android.os.Bundle", "savedInstanceState", "", "void"), 13);   
  }

  protected void onCreate(Bundle savedInstanceState) {
    Bundle localBundle = savedInstanceState;
    // BEGIN - 织入的代码
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, this, localBundle);
    MethodTracer.aspectOf().adviceOnCreate(localJoinPoint);
    // END - 织入的代码
    super.onCreate(savedInstanceState);
    setContentView(2130903040);
  }
}

相关API解读：

//  org.aspectj.runtime.reflect.Factory.java
public MethodSignature makeMethodSig(
  java.lang.String modifiers,        // public: 1, private: 2, protected: 4
  java.lang.String   methodName,     // 函数名: onCreate
  java.lang.String   declaringType,  // 类名: org.sdet.aspectj.MainActivity
  java.lang.String[] paramTypes,     // 参数类型: [android.os.Bundle, ]
  java.lang.String[] paramNames,     // 参数名: [savedInstanceState,]
  java.lang.String[] exceptionTypes, // 异常类型: ""
  java.lang.String   returnType)     // 返回类型: void
)

public JoinPoint.StaticPart makeSJP(
  java.lang.String kind,           //
  Signature sig,                   //
  int l                            // 代码行号
 )

call和execution的区别：

// MethodTracer.java
@Aspect
public class MethodTracer {

  @Before("execution (private void org.sdet.aspectj.MainActivity.method4Execution(..))")
  public void adviceOnExecution(JoinPoint joinPoint) {
    Log.v(TAG, joinPoint.toString());
  }

  @Before("call (private void org.sdet.aspectj.MainActivity.method4Call(..))")
  public void adviceOnCall(JoinPoint joinPoint) {
    Log.v(TAG, joinPoint.toString());
  }
}

public class MainActivity extends Activity {

  private static final JoinPoint.StaticPart ajc$tjp_0;
  private static final JoinPoint.StaticPart ajc$tjp_1;

  private static void ajc$preClinit() {
    Factory localFactory = new Factory("MainActivity.java", MainActivity.class);
    ajc$tjp_0 = localFactory.makeSJP("method-call", localFactory.makeMethodSig("2", "method4Call", "org.sdet.aspectj.MainActivity", "", "", "", "void"), 16);
    ajc$tjp_1 = localFactory.makeSJP("method-execution", localFactory.makeMethodSig("2", "method4Execution", "org.sdet.aspectj.MainActivity", "", "", "", "void"), 42);
  }

  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(2130903040);
    method4Execution();
    // call织入的位置
    MainActivity localMainActivity = this;
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, localMainActivity);
    MethodTracer.aspectOf().adviceOnCall(localJoinPoint);
    localMainActivity.method4Call();
  }

  private void method4Execution() {
    // execution织入的位置
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_1, this, this);
    MethodTracer.aspectOf().adviceOnExecution(localJoinPoint);
    System.out.println("in method method4Execution");
  }

  private void method4Call() {
    System.out.println("in method method4Call");
  }
}

withincode
假设方法functionA, functionB都调用了dummy，但只想在functionB调用dummy时织入代码。

//  MainActivity.java
public class MainActivity extends Activity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    functionA();
    functionB();
  }

  private void functionA() { dummy(); }
  private void functionB() { dummy(); }
  private void dummy() { }
}

// MethodTracer.java
@Aspect
public class MethodTracer {
  // withincode: 在functionB方法内
  @Pointcut("withincode(void org.sdet.aspectj.MainActivity.functionB(..))")
  public void invokeFunctionB() {}

  // call: 调用dummy方法
  @Pointcut("call(void org.sdet.aspectj.MainActivity.dummy(..))")
  public void invokeDummy() {}

  // 在functionB内调用dummy方法
  @Pointcut("invokeDummy() && invokeFunctionB()")
  public void invokeDummyInsideFunctionB() {}

  @Before("invokeDummyInsideFunctionB()")
  public void beforeInvokeDummyInsideFunctionB(JoinPoint joinPoint) {
    System.out.printf("Before.InvokeDummyInsideFunctionB.advice() called on '%s'", joinPoint);
  }
}

// MainActivity.java

public class MainActivity extends Activity {

  private static final JoinPoint.StaticPart ajc$tjp_0;

  private static void ajc$preClinit() {
    Factory localFactory = new Factory("MainActivity.java", MainActivity.class);
    ajc$tjp_0 = localFactory.makeSJP("method-call", localFactory.makeMethodSig("2", "dummy", "org.sdet.aspectj.MainActivity", "", "", "", "void"), 56);
  }

  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(2130903040);    
    functionA();
    functionB();
  }

  private void functionA() {
    dummy();
  }

  // 只有functionB调用dummy时才会织入代码
  private void functionB() {
    MainActivity localMainActivity = this;
    JoinPoint localJoinPoint = Factory.makeJP(ajc$tjp_0, this, localMainActivity);
    MethodTracer.aspectOf().beforeInvokeDummyInsideFunctionB(localJoinPoint);
    localMainActivity.dummy();
  }

苍痕

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
深入理解面向切面的编程AOP、AspectJ、Spring

Spring：是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架。Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。AspectJ：是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件.一、AOP介
复制链接

扫一扫