什么是AOP？

    一个方面（aspect)就是一个共有的特性，具有此代表性的有：横向分离的方法，类，对象层次或者实体对象模型。它们看起来应该是组合在一起的，但是在AOP里面你不用像以前面对对象（OO）那样来组织它们了。

    在传统JAVA中要加入计算时间的代码到你的应用中，你必须按以下方式：

public class BankAccountDAO{

 public void withdraw(double amount){

  long startTime = System.currentTimeMillis();

  try  {

    // Actual method body...

  }

  finally  {

    long endTime = System.currentTimeMillis() - startTime;

    System.out.println("withdraw took: "   endTime);

  }

 }

}

    我们可以列举这里面存在的几个问题：

    1。如果你要在每个你的方法中都加入这样的代理，无疑是十分糟糕的，特别是有try/catch这样的语句。

    2。这里有很多代码都不是你真实需要用到的，这样就使你的程序代码十分臃肿，读起来也十分困难。而且你不得不把你的代码放在try里面......
   
    3。如果你要扩展这段代码，我们可以遇见到那将是十分困难的工作。

    所以可见，这样的代码是十分难于维护，扩展和继承的，因为在这里面有很多东西分散了你对你这段代码真正要实现的东西的注意力。而且这只不过是一段最简单的例子，在真正的OOP中是很难实现对以上代码更好的表现方法的。

    面对方面编程可以分离你的这些功能性，可以让你增加行为来围绕你的功能代码。例如上面的，AOP就可以使在执行你自己的代码前你可以控制执行其它的功能。

    所有实现AOP的框架都有两种方式：组装关注点 和 a programmatic construct(编程实现)

    JBOSS的一个横向切入关注点

01. public class Metrics implements org.jboss.aop.Interceptor

02. {

03.   public Object invoke(Invocation invocation) throws Throwable

04.   {

05.   long startTime = System.currentTimeMillis();

06.   try

07.   {

08.     return invocation.invokeNext();

09.   }

10.   finally

11.   {

12.     long endTime = System.currentTimeMillis() - startTime;

13.     java.lang.reflect.Method m = ((MethodInvocation)invocation).method;

14.     System.out.println("method "   m.toString()   " time: "   endTime   "ms");

15.   }

16.  }

17. }

    真正实现的功能代码是在8行调用了，这就是实现了组装关注点，使之成为了一个方面。这让我们在以后扩展实际功能的时候就十分方便了，只需要去修改具体的实现方法，而不用去关心其它关注点了。

    JBOOS中具体应用这个方面

    需要定义一个切入点(pointcuts)，全部通过政则表达式来实现。

    Listing Three: Defining a pointcut in JBoss AOP

1. <bind pointcut="public void com.mc.BankAccountDAO->withdraw(double amount)">

2.     <interceptor class="com.mc.Metrics"/>

3. </bind >

4. <bind pointcut="* com.mc.billing.*->*(..)">

5.     <interceptor class="com.mc.Metrics"/>

6. </bind >

    1-3定义的一个切入点的方法就是 BankAccountDAO->withdraw(double amount)

    4-6定义的是一个通用的，它的切入点是所有的com.mc.billing.下面的类的方法。

    既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。以下是这个before advice的实现代码：

    代码:
package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

public void before(Method m, Object[] args, Object target)
throws Throwable {
  System.out.println("Hello world! (by "
    + this.getClass().getName()
    + ")");
}
}

    接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。

    在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

    代码:
package com.company.springaop.test;

public class BeanImpl implements Bean {

public void theMethod() {
  System.out.println(this.getClass().getName()
    + "." + new Exception().getStackTrace()[0].getMethodName()
    + "()"
    + " says HELLO!");
}
}

    类BeanImpl实现了下面的接口Bean：

    代码:
package com.company.springaop.test;

public interface Bean {
public void theMethod();
}

    虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。

    pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：

    代码:

package com.company.springaop.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

public static void main(String[] args) {

  //Read the configuration file
  ApplicationContext ctx = new FileSystemXmlApplicationContext("springconfig.xml");

  //Instantiate an object
  Bean x = (Bean) ctx.getBean("bean");

  //Execute the public method of the bean (the test)
  x.theMethod();
}
}

    我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

    仅仅用配置文件便可把程序的每一部分组装起来。

    代码:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<!--CONFIG-->
<bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="proxyInterfaces">
    <value>com.company.springaop.test.Bean</value>
  </property>
  <property name="target">
    <ref local="beanTarget"/>
  </property>
  <property name="interceptorNames">
    <list>
    <value>theAdvisor</value>
    </list>
  </property>
</bean>

<!--CLASS-->
<bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>

<!--ADVISOR-->
<!--Note: An advisor assembles pointcut and advice-->
<bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  <property name="advice">
    <ref local="theBeforeAdvice"/>
  </property>
  <property name="pattern">
    <value>com\.company\.springaop\.test\.Bean\.theMethod</value>
  </property>
</bean>

<!--ADVICE-->
<bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
</beans>

    四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor，一个主程序类和一个配置好的接口，通过工厂ctx，这个接口返回自己本身实现的一个引用。

    BeanImpl和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这就是全部的工作。

    advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我们用advisor的一个属性来指定它所需的 advice-bean。第二个属性则用正则表达式定义了pointcut，确保良好的性能和易读性。

    最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要复杂。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过一下的三个属性来定义：

      * 属性proxyInterface定义了接口类。
      * 属性target指向本地配置的一个bean，这个bean返回一个接口的实现。
      * 属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。注意，advisor列表的次序是非常重要的。

    Spring工具

    虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。然后，你只需在你的project上右击鼠标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons- logging.jar，jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

    ... (logging information)
    Hello world! (by com.company.springaop.test.TestBeforeAdvice)
    com.company.springaop.test.BeanImpl.theMethod() says HELLO!

    优点和缺点

    Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。作为一个轻型framework，它在J2EE 不同的部分都可以发挥作用。因此，即使不想使用Spring AOP，你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档。

AspectWerkz 主要特性：

    1．运行时和加载时字节码修正：你可以在运行时或编译时轻松的改造任何（旧）应用程序或除了rt.jar以外的外部类库

    2．支持join point模型

    3．支持Annotation：匹配JavaDoc和JSR-175，支持用户自定义Annotation

    4．支持部署多个Aspect定义文件到部署的应用程序（WEB-INF/aop.xml、META-INF/aop.xml）

    5．Introduction/内类型声明（也称Mixin），也就是具有添加接口和实现到已存在的类中的能力

    6．Annotation定义：定义Aspect使用的运行时Annotation（为JSR-175准备）

    7．XML定义：定义Aspect使用的XML；XML可以用来精炼、改写和解析Annotation定义

    8．插件式Aspect管理器能够和IoC框架（如Spring或PicoContainer）一起工作

    9．四种不同的Advice和Introduction部署模型（范围）：perJVM（单模式）、 perClass、perInstance 和perThread

    10．Advice和Introduction能够动态部署、反部署或重新部署

    11．高性能，使用JIT编译

    12．使用Fine-grained模式语言选择join point

    13．所有Advice能够和所有的join point和各种混合类型的pointcut

    14．脱机变换（可以用作后处理器）

    15．Aspect、Advice和Introduction使用POJO编码

    16．目标类可以是正规的POJO，也就是不需要接口

    17．支持通过定义传递参数给Advice和定义可重用的Advice堆栈

    18．元数据被加到类中

    19．简单的用法和配置

开始AOP

1）这里我们要在屏幕打印出“Hello AOP!”，看如下代码：

//HelloAOP.java

public class HelloAOP {

    public static void main(String args[]) {

        HelloAOP ha = new HelloAOP();

        ha.test();

    }

    public void test() {

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

    }

}

编译HelloAOP.java文件：javac HelloAOP.java

2）现在我要在输出“Hello AOP!”前后做一些工作，这些工作在运行时会得到调用机会，如果使用AOP术语，我们可以说我们要编写我们的aspect，这个aspect会在运行时被weave into （织入）HelloAOP class。

//MyAspect.java

import org.codehaus.aspectwerkz.joinpoint.JoinPoint;

public class MyAspect {

    public void beforeTesting(JoinPoint joinPoint) {

        System.out.println("before testing...");

    }

    public void afterTesting(JoinPoint joinPoint) {

        System.out.println("after testing...");

    }

}

javac MyAspect.java

3）织入过程并不简单，我们需要撰写一个描述文件来将aspect和其织入的class中的信息联系起来。

//aop.xml

<aspectwerkz>

    <system id="AspectWerkzExample">

        <aspect class="MyAspect">

                <pointcut name="testMethod" expression="execution(* HelloAOP.test(..))"/>

                <advice name="beforeTesting" type="before" bind-to="testMethod"/>

                <advice name="afterTesting" type="after" bind-to="testMethod"/>

        </aspect>

    </system>

</aspectwerkz>

4)run it

aspectwerkz -Daspectwerkz.definition.file=aop.xml HelloAOP

//output:

before testing...

Hello AOP!

after testing...