Spring Framework中的面向方面编程

public interface ibusinesslogic
{
　public void foo();
}

public class businesslogic
implements ibusinesslogic
{
　public void foo()
　{
　　system.out.println("inside businesslogic.foo()");
　}
}

import org.springframework.context.applicationcontext;
import org.springframework.context.support.filesystemxmlapplicationcontext;

public class mainapplication
{
　public static void main(string [] args)
　{
　　// read the configuration file
　　applicationcontext ctx =new filesystemxmlapplicationcontext("springconfig.xml");

　　//instantiate an object
　　ibusinesslogic testobject =(ibusinesslogic) ctx.getbean("businesslogicbean");

　　// execute the public
　　// method of the bean
　　testobject.foo();
　}
}

＜?xml version="1.0" encoding="utf-8"?＞
＜!doctype beans public
"-//spring//dtd bean//en"
"http://www.springframework.org/dtd/spring-beans.dtd"＞

＜beans＞

　＜!-- bean configuration --＞
　＜bean id="businesslogicbean" class="org.springframework.aop.framework.proxyfactorybean"＞
　　＜property name="proxyinterfaces"＞
　　　＜value＞ibusinesslogic＜/value＞
　　＜/property＞
　　＜property name="target"＞
　　　＜ref local="beantarget"/＞
　　＜/property＞
　＜/bean＞
　＜!-- bean classes --＞
　＜bean id="beantarget" class="businesslogic"/＞
　＜/beans＞
＜/beans＞

　　该配置文件，即springconfig.xml，指定要加载一个接口与ibusinesslogic相匹配的bean。该bean随后被关联到businesslogic实现类。看起来好像是费了很大力气只为了加载一个简单的bean并调用一个方法，但是您要知道，这个配置文件只是使spring框架可以透明地对应用程序应用其组件的众多特性的一个体现。

　　图1显示了基本的顺序图：mainapplication原样执行，没有应用方面。





图1.没有对businesslogic bean应用方面时的顺序图

　　应用方法跟踪（method tracing）方面

　　可能最基本的方面就是方法跟踪方面了。这可能是您找得到的最简单的方面了，因此它是研究新的aop实现的一个很好的起点。

　　方法跟踪方面在一个目标应用程序内捕获对所跟踪的方法的调用以及方法的返回值，并以某种方式显示这种信息。在aop中，通知的before和after类型用于捕获这些类型的联结点，因为这两种通知可以在方法调用联结点之前或之后触发。使用spring框架，方法跟踪方面的before通知是在tracingbeforeadvice类中声明的。

import java.lang.reflect.method;
import org.springframework.aop. methodbeforeadvice;

public class tracingbeforeadvice
implements methodbeforeadvice
{
　public void before(method m,object[] args,object target)
　throws throwable
　{
　　system.out.println("hello world! (by " +this.getclass().getname() +")");
　}
}

import java.lang.reflect.method;
import org.springframework.aop.afterreturningadvice;

public class tracingafteradvice
implements afterreturningadvice
{
　public void afterreturning(object object,method m,object[] args,object target)
　throws throwable
　{
　　system.out.println("hello world! (by " +this.getclass().getname() +")");
　}
}

＜?xml version="1.0" encoding="utf-8"?＞
＜!doctype beans public
"-//spring//dtd bean//en"
"http://www.springframework.org/dtd/spring-beans.dtd"＞

＜beans＞

＜!-- bean configuration --＞
＜bean id="businesslogicbean" class="org.springframework.aop.framework.proxyfactorybean"＞
　＜property name="proxyinterfaces"＞
　　＜value＞ibusinesslogic＜/value＞
　＜/property＞
　＜property name="target"＞
　　＜ref local="beantarget"/＞
　＜/property＞
　＜property name="interceptornames"＞
　　＜list＞
　　　＜value＞thetracingbeforeadvisor＜/value＞
　　　＜value＞thetracingafteradvisor＜/value＞
　　＜/list＞
　＜/property＞
＜/bean＞
＜!-- bean classes --＞
＜bean id="beantarget"
class="businesslogic"/＞

＜!-- advisor pointcut definition for before advice --＞
＜bean id="thetracingbeforeadvisor" class="org.springframework.aop.support.regexpmethodpointcutadvisor"＞
　＜property name="advice"＞
　　＜ref local="thetracingbeforeadvice"/＞
　＜/property＞
　＜property name="pattern"＞
　　＜value＞.*＜/value＞
　＜/property＞
＜/bean＞

＜!-- advisor pointcut definition for after advice --＞
＜bean id="thetracingafteradvisor" class="org.springframework.aop.support.regexpmethodpointcutadvisor"＞
　＜property name="advice"＞
　　＜ref local="thetracingafteradvice"/＞
　＜/property＞
　＜property name="pattern"＞
　　＜value＞.*＜/value＞
　＜/property＞
＜/bean＞

＜!-- advice classes --＞
＜bean id="thetracingbeforeadvice" class="tracingbeforeadvice"/＞
＜bean id="thetracingafteradvice" class="tracingafteradvice"/＞
＜/beans＞

　　方面的重用

　　可以对方法跟踪方面进行扩展，提供一个稍微复杂的记录（logging）方面。记录方面提供了一个很不错的重用例子，因为记录方面所需的许多特性都已经包含在方法跟踪方面中了。

　　在本例中，记录方面扩展了方法跟踪方面，以便显示附加的与（在应用程序的执行过程中）所引发的异常有关的信息。

　　要完全使用记录方面，需要对应用程序做一些更改。businesslogicexception异常类提供了一个可以由ibusinesslogicinterface接口和businesslogic实现类新增的void bar()方法引发的异常。

public class businesslogicexception
extends exception
{}

public interface ibusinesslogic
{
　public void foo();

　public void bar()
　throws businesslogicexception;
}

public class businesslogic
implements ibusinesslogic
{
　public void foo()
　{
　　system.out.println("inside businesslogic.foo()");
　}

　public void bar()
　throws businesslogicexception
　{
　　system.out.println("inside businesslogic.bar()");
　　throw new businesslogicexception();
　}
}

import org.springframeworkcontext.applicationcontext;
import org.springframework.context.support.filesystemxmlapplicationcontext;

public class mainapplication
{
　public static void main(string [] args)
　{
　　// read the configuration file
　　applicationcontext ctx = new filesystemxmlapplicationcontext( "springconfig.xml");

　　//instantiate an object
　　ibusinesslogic testobject =(ibusinesslogic) ctx.getbean("businesslogicbean");

　　//execute the public methods of the bean
　　testobject.foo();

　　try
　　{
　　　testobject.bar();
　　}
　　catch(businesslogicexception ble)
　　{
　　　system.out.println( "caught businesslogicexception");
　　}
　}
}

import org.springframework.aop.throwsadvice;
import java.lang.reflect.method;

public class loggingthrowsadvice
implements throwsadvice
{
　public void afterthrowing(method method,object[] args,object target,throwable subclass)
　{
　　system.out.println("logging that a " +subclass +"exception was thrown.");
　}
}

　　此处的记录方面清楚地说明了如何重用现有方面以及如何在spring框架中使用通知的throws形式。通过为before和after通知声明新的通知来重写现有的方法跟踪方面实现，可以实现更复杂的记录方面，记录到更复杂的记录框架，比如log4j。

　　结束语

　　本文展示了使用spring框架中的基本aop结构所应用的一些简单方面。在本系列的下一篇文章中，我们将介绍一些更实用的方面，探讨方面的生命周期，使用spring框架的around通知，并使用spring来应用aop模式。