Spring AOP Sample Code

Before Advice

package test3;
public class MessageWriter {
	public void writeMessage()	{
		System.out.print("World");
	}
}

package test3;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;
public class SimpleBeforeAdvice implements MethodBeforeAdvice{
	public void before(Method method,Object[] args,Object target) throws Throwable{
		System.out.println("Before method:"+method.getName());
	}
	public static void main(String[] args){
		MessageWriter target = new MessageWriter();
		ProxyFactory pf = new ProxyFactory();
		pf.addAdvice(new SimpleBeforeAdvice());
		pf.setTarget(target);
		MessageWriter proxy = (MessageWriter)pf.getProxy();
		proxy.writeMessage();
	}
}

AfterReturningAdvice

package test3;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.framework.ProxyFactory;
public class SimpleAfterReturningAdvice implements AfterReturningAdvice{
	public void afterReturning(Object returnValue,Method method,Object[] args,Object target){
		System.out.println("");
		System.out.println("After method:"+method.getName());
	}
public static void main(String[] args) {
		MessageWriter target = new MessageWriter();
		ProxyFactory pf = new ProxyFactory();
		pf.addAdvice(new SimpleAfterReturningAdvice());
		pf.setTarget(target);
		MessageWriter proxy = (MessageWriter)pf.getProxy();
		proxy.writeMessage();
	}
}

Around Advice

package test3;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class MessageDecorator implements MethodInterceptor{
	public Object invoke(MethodInvocation invocation) throws Throwable{
		System.out.print("Hello");
		Object retVal = invocation.proceed();
		System.out.println("!");
		return retVal;
	}	
}

package test3;
import org.springframework.aop.framework.ProxyFactory;
public class HelloWorldAOPExample {
	public static void main(String[] args) {
		MessageWriter target=new MessageWriter();
		ProxyFactory pf = new ProxyFactory();
		pf.addAdvice(new MessageDecorator());
		pf.setTarget(target);
		MessageWriter proxy = (MessageWriter)pf.getProxy();
		target.writeMessage();
		System.out.print(" ");
		proxy.writeMessage();
	}
}

ThrowsAdvice

package test3;
public class ErrorBean {
	public void errorProneMethod() throws  Exception{
		throw new  Exception("Foo");
	}
	public void otherErrorProneMethod() throws IllegalArgumentException{
		throw new IllegalArgumentException("Bar");
	}
}

package test3
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
import org.springframework.aop.framework.ProxyFactory;

public class SimpleThrowsAdvice implements ThrowsAdvice{
	public static void main(String[] args) throws Exception {
		ErrorBean errorBean = new ErrorBean();
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(errorBean);
		pf.addAdvice(new SimpleThrowsAdvice());
		ErrorBean proxy = (ErrorBean)pf.getProxy();
		try
		{
			proxy.errorProneMethod();
		}catch(Exception ignored)
		{
			//ignored.printStackTrace();
		}
		try
		{
			proxy.otherErrorProneMethod();
		}catch(Exception ignored)
		{
			//ignored.printStackTrace();
		}		
	}
	public void afterThrowing(Exception ex) throws Throwable{
		System.out.println("***");
		System.out.println("Generic Exception Capture");
		System.out.println("Caught: "+ex.getClass().getName());
		System.out.println("***\n");
	}
	public void afterThrowing(Method method,Object[] args,Object target,IllegalArgumentException ex) throws Throwable{
		System.out.println("***");
		System.out.println("IllegalArgumentException Capture");
		System.out.println("Caught: "+ex.getClass().getName());
		System.out.println("***\n");		
	}
}

StaticPointcut

package test3;
public class BeanOne {
	public void foo() {
		System.out.println("foo");
	}
	public void bar() {
		System.out.println("bar");
	}
}

package test3;
public class BeanTwo {
	public void foo() {
		System.out.println("foo");
	}
	public void bar() {
		System.out.println("bar");
	}
}

package test3;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class SimpleAdvice implements MethodInterceptor{
	public Object invoke(MethodInvocation invocation) throws Throwable
	{
		System.out.println(">> Invoking "+invocation.getMethod().getName());
		Object retVal = invocation.proceed();
		System.out.println(">> Done");
		return retVal;
	}
}

package test3;

import java.lang.reflect.Method;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.StaticMethodMatcherPointcut;
public class SimpleStaticPointcut extends StaticMethodMatcherPointcut {
	public boolean matches(Method method, Class cls) {
		return ("foo".equals(method.getName()));
	}
	public ClassFilter getClassFilter() {
		return new ClassFilter() {
			public boolean matches(Class cls) {
				return (cls == BeanOne.class);
			}
		};
	}
}

package test3;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

public class StaticPointcutExample {
	public static void main(String[] args) {
		BeanOne one = new BeanOne();
		BeanTwo two = new BeanTwo();
		
		BeanOne proxyOne;
		BeanTwo proxyTwo;
		
		Pointcut pc = new SimpleStaticPointcut();
		Advice advise = new SimpleAdvice();
		Advisor advisor = new DefaultPointcutAdvisor(pc,advise);
		
		ProxyFactory pf = new ProxyFactory();
		pf.addAdvisor(advisor);
		pf.setTarget(one);
		proxyOne = (BeanOne)pf.getProxy();
		
		pf = new ProxyFactory();
		pf.addAdvisor(advisor);
		pf.setTarget(two);
		proxyTwo = (BeanTwo)pf.getProxy();
		
		proxyOne.foo();
		proxyTwo.foo();
	
		proxyOne.bar();
		proxyTwo.bar();
	}
}

Dynamic pointcut

package test3;
public class SampleBean {
	public void foo(int x){
		System.out.println("Invoked foo() with: "+x);
	}
	public void bar(){
		System.out.println("Invoked bar()");
	}
}

package test3;

import java.lang.reflect.Method;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.DynamicMethodMatcherPointcut;
public class SimpleDynamicPointcut extends DynamicMethodMatcherPointcut{
	public boolean matches(Method method, Class cls) {
		System.out.println("Static check for " + method.getName());
		return ("foo".equals(method.getName()));
	}
	public boolean matches(Method method, Class cls, Object[] args) {
		System.out.println("Dynamic check for " + method.getName());
		int x = ((Integer) args[0]).intValue();
		return (x != 100);
	}
	public ClassFilter getClassFilter() {
		return new ClassFilter() {
			public boolean matches(Class cls) {
				return (cls == SampleBean.class);
			}
		};
	}
}

package test3;

import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
public class DynamicPointcutExample {
	public static void main(String[] args) {
		SampleBean target = new SampleBean();
		Advisor advisor = new DefaultPointcutAdvisor(new SimpleDynamicPointcut(),new SimpleAdvice());
		
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		SampleBean proxy = (SampleBean)pf.getProxy();
		
		proxy.foo(1);
		proxy.foo(10);
		proxy.foo(100);
		
		proxy.bar();
		proxy.bar();
		proxy.bar();
	}
}

NamePointcut

package test3;
public class NameBean {
	public void foo() {
		System.out.println("foo");
	}
	public void foo(int x) {
		System.out.println("foo " + x);
	}
	public void bar() {
		System.out.println("bar");
	}
	public void yup() {
		System.out.println("yup");
	}
}

package test3;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class SimpleAdvice implements MethodInterceptor{
	public Object invoke(MethodInvocation invocation) throws Throwable
	{
		System.out.println(">> Invoking "+invocation.getMethod().getName());
		Object retVal = invocation.proceed();
		System.out.println(">> Done");
		return retVal;
	}
}

package test3;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;

public class NamePointcutExample {
	public static void main(String[] args) {
		NameBean target = new NameBean();
		NameMatchMethodPointcut pc = new NameMatchMethodPointcut();
		pc.addMethodName("foo");
		pc.addMethodName("bar");
		Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleAdvice());
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		NameBean proxy = (NameBean)pf.getProxy();
		
		proxy.foo();
		proxy.foo(999);
		proxy.bar();
		proxy.yup();
	}
}

NamePointcutAdvisor

package test3;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.NameMatchMethodPointcutAdvisor;

public class NamePointcutUsingAdvisor {
	public static void main(String[] args) {
		NameBean target = new NameBean();
		
		NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor(new SimpleAdvice());
		
		advisor.addMethodName("foo");
		advisor.addMethodName("bar");
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		NameBean proxy = (NameBean)pf.getProxy();
		proxy.foo();
		proxy.foo(999);
		proxy.bar();
		proxy.yup();
	}
}

RegexpPointcut

package test3;
public class RegexpBean {
	public void foo1() {
		System.out.println("foo1");
	}
	public void foo2() {
		System.out.println("foo2");
	}
	public void bar() {
		System.out.println("bar");
	}
}

package test3;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.JdkRegexpMethodPointcut;
public class RegexpPointcutExample {
	public static void main(String[] args) {
		RegexpBean target = new RegexpBean();
		JdkRegexpMethodPointcut pc = new JdkRegexpMethodPointcut();
		pc.setPattern(".*foo.*");
		Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleAdvice());
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		RegexpBean proxy = (RegexpBean)pf.getProxy();
		proxy.foo1();
		proxy.foo2();
		proxy.bar();
	}
}

ControlFlow Pointcut

package test4;

public class TestBean {
	public void foo() {
		System.out.println("foo()");
	}
}

package test4;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class SimpleBeforeAdvice implements MethodBeforeAdvice {
	public void before(Method method,Object[] args,Object target) throws Throwable
	{
		System.out.println("before method: "+method);
	}
}

package test4;
import org.springframework.aop.Advisor;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.ControlFlowPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;

public class ControlFlowExample {

	public static void main(String[] args) {
		ControlFlowExample ex = new ControlFlowExample();
		ex.run();
	}
	public void run()
	{
		TestBean target = new TestBean();
		Pointcut pc = new ControlFlowPointcut(ControlFlowExample.class,"test");
		Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleBeforeAdvice());
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		TestBean proxy = (TestBean)pf.getProxy();
		System.out.println("Trying normal invoke");
		proxy.foo();
		System.out.println("Trying under ControlFlowExample.test()");
		test(proxy);
	}
	private void test(TestBean bean){
		bean.foo();
	}
}

ComposablePointcut

package test4;
public class SampleBean {
	public String getName()	{
		return "Rob Harrop";
	}
	public void setName(String abc)	{
	}
	public int getAge()
	{
		return 100;
	}
}

package test4;
import java.lang.reflect.Method;
import org.springframework.aop.Advisor;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.ComposablePointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.StaticMethodMatcher;
public class ComposablePointcutExample {
	public static void main(String[] args) {
		SampleBean target = new SampleBean();
		ComposablePointcut pc = new ComposablePointcut(ClassFilter.TRUE,new GetterMethodMatcher());
		System.out.println("Test 1");
		SampleBean proxy = getProxy(pc,target);
		testInvoke(proxy);
		
		System.out.println("Test 2");
		pc.union(new SetterMethodMatcher());
		proxy = getProxy(pc,target);
		testInvoke(proxy);
		
		System.out.println("Test 3");
		pc.intersection(new GetAgeMethodMatcher());
		proxy = getProxy(pc,target);
		testInvoke(proxy);
	}
	
	private static SampleBean getProxy(ComposablePointcut pc,SampleBean target)
	{
		Advisor advisor = new DefaultPointcutAdvisor(pc,new SimpleBeforeAdvice());
		
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		
		return (SampleBean)pf.getProxy();
	}
	
	private static void testInvoke(SampleBean proxy)
	{
		proxy.getAge();
		proxy.getName();
		proxy.setName("Rob Harrop");
	}
	
	private static class GetterMethodMatcher extends StaticMethodMatcher{
		public boolean matches(Method method,Class cls)
		{
			return (method.getName().startsWith("get"));
		}
	}
	
	private static class GetAgeMethodMatcher extends StaticMethodMatcher{
		public boolean matches(Method method,Class cls)
		{
			return "getAge".equals(method.getName());
		}
	}
	
	private static class SetterMethodMatcher extends StaticMethodMatcher{
		public boolean matches(Method method,Class cls)
		{
			return (method.getName().startsWith("set"));
		}
	}
}

Introduction

package test4;
public class TargetBean {
	private String name;
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

package test4;
public interface IsModified {
	public boolean isModified();
}

package test4;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;

public class IsModifiedMixin extends DelegatingIntroductionInterceptor implements IsModified {
	private boolean isModified=false;
	private Map methodCache = new HashMap();
	public boolean isModified()
	{
		return isModified;
	}
	public Object invoke(MethodInvocation invocation) throws Throwable
	{
		if (!isModified)
		{
			if ((invocation.getMethod().getName().startsWith("set"))&&(invocation.getArguments().length==1))
			{
				
				Method getter = getGetter(invocation.getMethod());
				
				if (getter!=null)
				{
					Object newVal = invocation.getArguments()[0];
					Object oldVal = getter.invoke(invocation.getThis(),null);
					if ((newVal == null)&&(oldVal == null))
					{
						isModified = false;
					}else if ((newVal == null)&&(oldVal!=null))
					{
						isModified = true;
					}else if ((newVal!=null)&&(oldVal==null))
					{
						isModified = true;
					}else
					{
						isModified = (!newVal.equals(oldVal));
					}
				}
			}
		}
		return super.invoke(invocation);
	}

		private Method getGetter(Method setter)
		{
			Method getter = null;
			
			getter = (Method)methodCache.get(setter);
			
			if (getter!=null)
			{
				return getter;
			}
			
			String getterName = setter.getName().replaceFirst("set","get");
			try
			{
				getter = setter.getDeclaringClass().getMethod(getterName,null);
				synchronized(methodCache)
				{
					methodCache.put(setter,getter);
				}
				return getter;
			}catch(NoSuchMethodException ex)
			{
				return null;
			}
		}
}

package test4;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
public class IsModifiedAdvisor extends DefaultIntroductionAdvisor{

	public IsModifiedAdvisor(){
		super(new IsModifiedMixin());
	}
}

package test4;

import org.springframework.aop.IntroductionAdvisor;
import org.springframework.aop.framework.ProxyFactory;

public class IntroductionExample {

	public static void main(String[] args) {
		TargetBean target = new TargetBean();
		target.setName("Rob Harrop");
		
		IntroductionAdvisor advisor = new IsModifiedAdvisor();
		
		ProxyFactory pf = new ProxyFactory();
		pf.setTarget(target);
		pf.addAdvisor(advisor);
		pf.setOptimize(true);
		
		TargetBean proxy = (TargetBean)pf.getProxy();
		IsModified proxyInterface = (IsModified)proxy;
		
		System.out.println("Is TargetBean?: "+(proxy instanceof TargetBean));
		System.out.println("Is IsModified?: "+(proxy instanceof IsModified));
		
		System.out.println("Has been Modified?: "+proxyInterface.isModified());
		proxy.setName("Rob Harrop");
		System.out.println("Has been Modified?: "+proxyInterface.isModified());
		proxy.setName("Joe Schmoe");
		System.out.println("Has been Modified?: "+proxyInterface.isModified());
	}
}