• 每虚拟机(默认），只有一个实例，其生命周期从虚拟机启动开始，一直到虚拟机停止。
• 每对象，对于每一个对象都有一个方面实例，其生命周期跟随相关联的对象。
• 每控制流，对于每个controlFlow点，都会创建相应的方面实例，可以参考事务管理（对于事务，每个原子操作，都是一个控制流，方面的生命周期，从控制流开始，一直到控制流结束）。

1)   每虚拟机关联

默认方面，它的状态是共享的。

2)每对象关联

perthis()-与当前所匹配的连接点的执行对象，所关联

pertarget()—与当前所匹配的连接点的目标执行对象，所关联

3)每控制流关联

可以指定两种类型的每控制流对象关联：

percflow()­-对于在percflow()指定的pointcut所匹配的连接点，关联每一个独立的方面实例和控制流执行。

percflowbelow()，对于在prcflowbelow ()指定的pointcut所匹配的连接点，关联每一个独立的方面实例和控制流下的执行。

下面来看一个实例：来区别不同点：

声明必要的测试类

可以看到只是实例化了一次

只是增加了perthis(logMethod(TestBean))

输出时，可以看到创建了两个实例

2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@197d257
    object: bean1
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@197d257
    object: bean1
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@7259da
    object: bean2
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@7259da
    object: bean2

继续更改aspect，把perthis改为percflow

输出改为：

2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@eee36c
    object: bean1
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@194df86
    object: bean1
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@defa1a
    object: bean2
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@f5da06
    object: bean2

•    *  表示任何数量的字符，除了(.)
•     .. 表示任何数量的字符包括任何数量的(.)
•        + 描述指定类型的任何子类或者子接口

• 方法执行：execution(MethodSignature)
• 方法调用：call(MethodSignature)
• 构造器执行：execution(ConstructorSignature)
• 构造器调用：call(ConstructorSignature)
• 类初始化：staticinitialization(TypeSignature)
• 属性读操作：get(FieldSignature)
• 属性写操作：set(FieldSignature)
• 例外处理执行：handler(TypeSignature)
• 对象初始化：initialization(ConstructorSignature)
• 对象预先初始化：preinitialization(ConstructorSignature)
• Advice执行：adviceexecution()

    private static Log log = LogFactory.getLog(Logger.class);

    public void entry(String message) {
        log.info(message);
    }
}
这里只是简单的一个方法，当然实际情况可能不同。
由于xml配置需要一个方面的实现bean
所以创建一个简单的bean ：
public class LogBean {

    private Logger logger = new Logger();

    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}
这里采取简单的around advice，其他类型的advice 基本上都差不多

当然有了这两个核心的日志类，需要一个测试类，用于测试。
public class TestBean {

    public void method1() {
        System.out.println("in method1");
    }

    public void method2() {
        System.out.println("in method2");
    }
}
这就是需要测试的类了，需要记录日志的方法只有两个，这里用System.out.println，只是想显示方法的调用顺序。


然后关键的在于xml的配置了

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="
http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
 
 <aop:config>
    <!--  expression 表示要执行的匹配表达式，这里匹配所有的public方法，但是去除logger类的所有方法，防止无限调用-->

      <aop:pointcut id="loggableCalls"
          expression="execution(public * *(..)) and !execution(* org.spring.test.aop.log.Logger.*(..))"/>


  <aop:aspect id="logAspect" ref="logBean">
   <aop:around pointcut-ref="loggableCalls" method="aroundLogCalls"/>
  </aop:aspect>
 
 </aop:config>
 <bean id="logBean" class="org.spring.test.aop.log.LogBean" />
 <bean id="testBean" class="org.spring.test.aop.log.TestBean"/>
 
</beans>

现在写一个测试类：

public class LogXmlTest extends RootTest {

    @Override
    protected String getBeanXml() {
        return "org/spring/test/aop/log/bean.xml";
    }

    public void testLog() {
        TestBean bean = (TestBean) ctx.getBean("testBean");
        bean.method1();
        bean.method2();
    }

}

public abstract class RootTest extends TestCase {

    protected ApplicationContext  ctx;

    protected Log log = LogFactory.getLog(getClass());

    protected RootTest() {
        ctx = new ClassPathXmlApplicationContext(getBeanXml());
    }

    protected abstract String getBeanXml();

}

打印的消息如下：
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - before invoke method:method1
in method1
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - after invoke method:method1
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - before invoke method:method2
in method2
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - after invoke method:method2

第二种实现方式，采用注释方式：

Logger 类不变
创建一个LogAspect类
@Aspect
public class LogAspect {

    private Logger logger = new Logger();

    @Pointcut("execution(public * *(..))")
    public void publicMethods() {

    }

    @Pointcut("execution(* org.spring.test.aop.log.Logger.*(..))")
    public void logObjectCalls() {

    }

    @Pointcut("publicMethods()&&!logObjectCalls()")
    public void loggableCalls() {

    }

    @Around("loggableCalls()")
    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}

配置文件就简单多了
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xsi:schemaLocation="
http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">
 
 <aop:aspectj-autoproxy/>
 
 <!-- 或者使用以下定义
 
 
 
 <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />
 
 -->
 <bean id="logAspect" class="org.spring.test.aop.log.LogAspect"/>
 <bean id="testBean" class="org.spring.test.aop.log.TestBean"/>
 
</beans>

测试类：
跟上面的差不多
把xml文件换掉就行

打印的方式差不多

个人还是比较喜欢第二种实现。

<aop:aspectj-autoproxy/>

或者
在xml中加入
<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

声明 aspect

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">

   <!-- configure properties of aspect here as normal -->

</bean>

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect

public class NotVeryUsefulAspect {

}

声明 pointcut

@Pointcut("execution(* transfer(..))")

public void transfer() {}

声明 advice

Before advice:

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doAccessCheck() {

    // ...

  }

After returning advice:

@AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doAccessCheck() {

    // ...

  }

或者

@AfterReturning(
pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
returning="retVal")

public void doAccessCheck(Object retVal) {

    // ...

  }

After throwing advice：

@AfterThrowing("SystemArchitecture.dataAccessOperation()")

  public void doRecoveryActions() {

    // ...

  }

或者

@AfterThrowing(

    pointcut=" SystemArchitecture.dataAccessOperation()",

    throwing="ex")

  public void doRecoveryActions(DataAccessException ex) {

    // ...

  }

After (finally) advice：

@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

  public void doReleaseLock() {

    // ...

  }

Around advice：

@Around("com.xyz.myapp.SystemArchitecture.businessService()")

  public Object doBasicProfiling( ProceedingJoinPoint pjp) throws Throwable {

    // start stopwatch

    Object retVal = pjp.proceed();

    // stop stopwatch

    return retVal;

  }

Advice parameters：

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" + "args(account,..)" )

public void validateAccount(Account account) {

  // ...

}

声明参数名称：

@Before(

   value="com.xyz.lib.Pointcuts.anyPublicMethod() && " +

         "@annotation(auditable)",

   argNames="auditable" )

public void audit(Auditable auditable) {

  AuditCode code = auditable.value();

  // ...

} 

Advice 排序：

一般以声明的方法次序为先后

不同的 Advice ，通过实现 Ordered 接口，来排序

Introductions

用于引入新的接口

@Aspect

public class UsageTracking {

  @DeclareParents(value="com.xzy.myapp.service.*+",

                  defaultImpl=DefaultUsageTracked.class)

  public static UsageTracked mixin;

  @Before("com.xyz.myapp.SystemArchitecture.businessService() &&" +

          "this(usageTracked)")

  public void recordUsage(UsageTracked usageTracked) {

    usageTracked.incrementUseCount();

  }

}

public void doGet(JspImplicitObjects theObjects) throws ServletException
{
  logger.entry("doGet(...)");

  JspTestController controller = new JspTestController();
  controller.handleRequest(theObjects);

  logger.exit("doGet");
}

public aspect AutoLog{
  
  pointcut publicMethods() : execution(public * org.apache.cactus..*(..));

  pointcut logObjectCalls() :
    execution(* Logger.*(..));
    
  pointcut loggableCalls() : publicMethods() && ! logObjectCalls();
    
  before() : loggableCalls(){
    Logger.entry(thisJoinPoint.getSignature().toString());
  }
    
  after() : loggableCalls(){
    Logger.exit(thisJoinPoint.getSignature().toString());
  }
}

Pointcut 和 join point

要理解 Pointcut，必需知道 join point 是什么。join point 表示在程序执行中明确定义的点。AspectJ 中典型的 join point 包括方法调用、对类成员的访问以及异常处理程序块的执行。join point 可以包含其它 join point。例如，一个方法调用可能在它返回之前引起其它方法调用。那么，Pointcut 就是一种语言构造，这种构造根据已定义的标准挑选一组 join point。示例中的第一个 Pointcut 称为 publicMethods ，选择 org.apache.cactus 包中的所有公用（public）方法的执行。 execution 是一个原始的 Pointcut（就象 int 是一种原始的 Java 类型）。它选择与其括号中定义的方法说明匹配的任何方法的执行。方法说明允许包含通配符；示例中的一个方法说明包含了几个通配符。第二个名为 logObjectCalls 的 Pointcut 选择了 Logger 类中的所有方法的执行。第三个 Pointcut loggableCalls ，通过使用 && ! 合并了前两个 Pointcut，这意味着它选择了除 Logger 类中的公用方法以外， org.apache.cactus 中所有的公用方法。（记录 log 方法将导致无限递归。）

Advice

既然 Aspect 已经定义了它应该记录的点，它使用 Advice 来完成实际的日志记录。Advice 是在 join point 之前、之后或周围执行的代码。相对于 Pointcut 来定义 Advice，说类似于“在想要记录的每个方法调用之后运行这些代码”这样的话。因此 Advice 如下：

before() : loggableCalls(){
    Logger.entry(thisJoinPoint.getSignature().toString());
}

Advice 使用 Logger 类，其入口和出口方法类似于下列代码：

public static void entry(String message){
   System.out.println("entering method " + message);
}

在示例中，传递到记录器的 String 是从 thisJoinPoint 派生的，这是一个特殊的反射对象，它允许访问 join point 执行所处的运行时上下文。在 Cactus 实际使用的 Aspect 中，Advice 使用这种对象来检索传递到每个记录的方法调用中的方法参数。当日志记录 Aspect 应用于代码时，方法调用的结果如下：

清单 3. AutoLog Aspect 的输出

entering method: void test.Logging.main(String[])
entering method: void test.Logging.foo()
exiting method: void test.Logging.foo()
exiting method: void test.Logging.main(String[])

• 方面（aspect）类似于 Java 编程语言中的类。方面定义切入点和通知（advice），并由诸如 AspectJ 这样的方面编译器来编译，以便将横切（包括动态的和静态的）织入（interweave）现有的对象中。
  
  
• 一个 连接点（join point） 是程序执行中一个精确执行点，比如类中的一个方法。例如，对象 Foo 中的方法 bar() 就可以是一个连接点。 连接点是个抽象的概念；不用主动定义一个连接点。
  
  
• 一个 切入点（pointcut） 本质上一个用于捕捉连接点的结构。例如，可以定义一个切入点来捕捉对对象 Foo 中的方法 bar() 的所有调用。和连接点相反，切入点需要在方面中定义。
  
  
• 通知（advice） 是切入点的可执行代码。一个经常定义的通知是添加日志记录功能，其中切入点捕捉对对象 Foo 中的 bar() 的每个调用，然后该通知动态地插入一些日志记录功能，比如捕捉 bar() 的参数。

       这些概念是动态横切的核心，虽然正如我们即将看到的，它们并不全都是静态横切所必需的。

       静态横切

     静态横切 和动态横切的区别在于它不修改一个给定对象的执行行为。相反，它允许通过引入附加的方法字段和属性来修改对象的 结构。此外，静态横切可以把扩展和实现附加到对象的基本结构中。
    虽然现在还无法谈及静态横切的普遍使用——它看起来是 AOP 的一个相对未被探索（尽管非常具有吸引力）的特性——然而这一技术蕴含的潜力是巨大的。使用静态横切，架构师和设计者能用一种真正面向对象的方法有效地建立复杂系统的模型。静态横切允许您不用创建很深的层次结构，以一种本质上更优雅、更逼真于现实结构的方式，插入跨越整个系统的公共行为。