官網地址：https://fernandocejas.com/2014/08/03/aspect-oriented-programming-in-android/

OOP

（面向物件程式設計）針對業務處理過程的實體及其屬性和行為進行抽象封裝，以獲得更加清晰高效的邏輯單元劃分。

AOP

 （面向切面變成）針對業務處理過程中的切面進行提取，它所面對的是    處理過程中的某個步驟或階段，以獲得邏輯過程中各部分之間低耦合性的隔離效果。

這兩種設計思想在目標上有著本質的差異。

AOP是對OOP的補充，不是替代。

幾個概念（來自http://blog.csdn.net/a1314517love/article/details/11847087）

1. Cross Cutting Concern:是一種獨立服務，它會遍佈在系統的處理流程之中
2. Aspect 對橫切行關注點的模組化
3. Advice對橫切行關注點的具體實現（有分類的概念，之前，之後，throw）
4. Pointcut 它定義了Advice應用到哪些JoinPoint上，對spring來說是方法呼叫
5. Weave 將Advice應用target Object上的過程叫織入，Spring支援的是動態織入
6. Target Object  Advice被應用的物件
7. Proxy:Spring AOP預設使用JDK的動態代理，它的代理是執行時建立，也可以使用CGLIB代理
8.Introduction 可以動態的為類新增方法   
9.JoinPoint:Advice在應用程式上執行的點或時機,Spring只支援方法的JointPoint
這些概念聽上去還是比較抽象的，下面我們通過AOP的原理圖和例項來具體看一下這些概念具體指的是什麼。

下面同過demo來演示AOP的使用：

github上有篇文章介紹的挺詳細：https://github.com/hehonghui/android-tech-frontier/blob/master/issue-22/Android%E4%B8%AD%E7%9A%84AOP%E7%BC%96%E7%A8%8B.md

 AOP涉及到反射和註解的知識

反射：http://blog.csdn.net/whitepony/article/details/23096845

註解：http://blog.csdn.net/whitepony/article/details/23099541

關於AOP 中execution

內容來源：http://www.it610.com/article/256837.htm

表示com.xy.service包下的所有方法為為事務管理。

execution(* com.aptech.jb.epet.dao.hibimpl.*.*(..)) 

這樣寫應該就可以了 這是com.aptech.jb.epet.dao.hibimpl 包下所有的類的所有方法。。

第一個*代表所有的返回值型別 

第二個*代表所有的類

第三個*代表類所有方法 最後一個..代表所有的引數。

下面給出一些常見切入點表示式的例子：

任意公共方法的執行：

execution(public * *(..))

任何一個以“set”開始的方法的執行：

execution(* set*(..))

AccountService 介面的任意方法的執行：

execution(* com.xyz.service.AccountService.*(..))

定義在service包裡的任意方法的執行：

execution(* com.xyz.service.*.*(..))

定義在service包或者子包裡的任意類的任意方法的執行：

execution(* com.xyz.service..*.*(..))

下面分兩個小Demo，一個直接應用在Android專案中，一個座位Android Library使用

Android專案：

專案結構

需要使用的aspectjrt.jar包，原始碼同官網（build.gradle檔案的配置需要注意）

MainActivity.java類

package cn.edu.sxu.www.aopdemo;

import android.os.Bundle;
import android.os.SystemClock;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private Button button;
    private Button button2;
    private String TAG="cn.edu.sxu.www.aopdemo.MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button= (Button) findViewById(R.id.button);
        button2= (Button) findViewById(R.id.button2);
        button.setOnClickListener(this);
        button2.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {

        switch (view.getId())
        {
            case R.id.button:
                commonTest();
                break;
            case R.id.button2:
                aopTest();
                break;
        }

    }

    /**
     * 普通統計
     */

    private void  commonTest()
    {
        final StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        SystemClock.sleep(2000);
        stopWatch.stop();

        DebugLog.log(TAG, "所用時長："+stopWatch.getTotalTimeMillis());

    }

    /**
     * aop 統計
     */
    @DebugTrace
    private void aopTest()
    {
        SystemClock.sleep(3000);
    }
}

DebugTrace.java 類

package cn.edu.sxu.www.aopdemo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.CLASS)
@Target({ ElementType.CONSTRUCTOR, ElementType.METHOD })
public @interface DebugTrace {}

TraceAspect.java類

package cn.edu.sxu.www.aopdemo;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;

/**
 * Aspect representing the cross cutting-concern: Method and Constructor Tracing.
 */
@Aspect
public class TraceAspect {

  private static final String POINTCUT_METHOD =
      "execution(@cn.edu.sxu.www.aopdemo.DebugTrace * *(..))";

  private static final String POINTCUT_CONSTRUCTOR =
      "execution(@cn.edu.sxu.www.aopdemo *.new(..))";

  @Pointcut(POINTCUT_METHOD)
  public void methodAnnotatedWithDebugTrace() {}

  @Pointcut(POINTCUT_CONSTRUCTOR)
  public void constructorAnnotatedDebugTrace() {}

  @Around("methodAnnotatedWithDebugTrace() || constructorAnnotatedDebugTrace()")
  public Object weaveJoinPoint(ProceedingJoinPoint joinPoint) throws Throwable {
    MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
    String className = methodSignature.getDeclaringType().getSimpleName();
    String methodName = methodSignature.getName();

    final StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    Object result = joinPoint.proceed();
    stopWatch.stop();

    DebugLog.log(className, buildLogMessage(methodName, stopWatch.getTotalTimeMillis()));

    return result;
  }

  /**
   * Create a log message.
   *
   * @param methodName A string with the method name.
   * @param methodDuration Duration of the method in milliseconds.
   * @return A string representing message.
   */
  private static String buildLogMessage(String methodName, long methodDuration) {
    StringBuilder message = new StringBuilder();
    message.append("Gintonic --> ");
    message.append(methodName);
    message.append(" --> ");
    message.append("[");
    message.append(methodDuration);
    message.append("ms");
    message.append("]");

    return message.toString();
  }
}

package cn.edu.sxu.www.aopdemo;

import java.util.concurrent.TimeUnit;

/**
 * Class representing a StopWatch for measuring time.
 */
public class StopWatch {
  private long startTime;
  private long endTime;
  private long elapsedTime;

  public StopWatch() {
    //empty
  }

  private void reset() {
    startTime = 0;
    endTime = 0;
    elapsedTime = 0;
  }

  public void start() {
    reset();
    startTime = System.nanoTime();
  }

  public void stop() {
    if (startTime != 0) {
      endTime = System.nanoTime();
      elapsedTime = endTime - startTime;
    } else {
      reset();
    }
  }

  public long getTotalTimeMillis() {
    return (elapsedTime != 0) ? TimeUnit.NANOSECONDS.toMillis(endTime - startTime) : 0;
  }
}

DebugLog.java類

package cn.edu.sxu.www.aopdemo;

import android.util.Log;

/**
 * Wrapper around {@link android.util.Log}
 */
public class DebugLog {

  private DebugLog() {}

  /**
   * Send a debug log message
   *
   * @param tag Source of a log message.
   * @param message The message you would like logged.
   */
  public static void log(String tag, String message) {
    Log.d(tag, message);
  }
}

activity_main.xml檔案

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="cn.edu.sxu.www.aopdemo.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="官網demo，統計方法執行時間"
        android:id="@+id/textView" />

    <Button
        android:text="普通方式"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView"
        android:layout_alignParentLeft="true"
        android:layout_alignParentStart="true"
        android:layout_marginTop="42dp"
        android:id="@+id/button" />

    <Button
        android:text="aop方式"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/button"
        android:layout_alignRight="@+id/button"
        android:layout_alignEnd="@+id/button"
        android:layout_marginTop="87dp"
        android:id="@+id/button2" />
</RelativeLayout>

build.gradle檔案

apply plugin: 'com.android.application'

import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.aspectj:aspectjtools:1.8.9'
        classpath 'org.aspectj:aspectjweaver:1.8.9'
    }
}
android {
    compileSdkVersion 25
    buildToolsVersion "25.0.2"
    defaultConfig {
        applicationId "cn.edu.sxu.www.aopdemo"
        minSdkVersion 15
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

final def log = project.logger
final def variants = project.android.applicationVariants

variants.all { variant ->
    if (!variant.buildType.isDebuggable()) {
        log.debug("Skipping non-debuggable build type '${variant.buildType.name}'.")
        return;
    }

    JavaCompile javaCompile = variant.javaCompile
    javaCompile.doLast {
        String[] args = ["-showWeaveInfo",
                         "-1.8",
                         "-inpath", javaCompile.destinationDir.toString(),
                         "-aspectpath", javaCompile.classpath.asPath,
                         "-d", javaCompile.destinationDir.toString(),
                         "-classpath", javaCompile.classpath.asPath,
                         "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)]
        log.debug "ajc args: " + Arrays.toString(args)

        MessageHandler handler = new MessageHandler(true);
        new Main().run(args, handler);
        for (IMessage message : handler.getMessages(null, true)) {
            switch (message.getKind()) {
                case IMessage.ABORT:
                case IMessage.ERROR:
                case IMessage.FAIL:
                    log.error message.message, message.thrown
                    break;
                case IMessage.WARNING:
                    log.warn message.message, message.thrown
                    break;
                case IMessage.INFO:
                    log.info message.message, message.thrown
                    break;
                case IMessage.DEBUG:
                    log.debug message.message, message.thrown
                    break;
            }
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })
    compile 'com.android.support:appcompat-v7:25.1.0'
    testCompile 'junit:junit:4.12'
}

build.gradle檔案的配置方式官網上有，只不過官網提供的是作為依賴庫使用的

驗證：

原始碼地址：http://download.csdn.net/detail/huohacker/9761873