Spring AOP Sample Code

[b]Before Advice[/b]

[code]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();
}
}[/code]

[b]AfterReturningAdvice[/b]

[code]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();
}
}[/code]

[b]Around Advice[/b]

[code]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();
}
}[/code]

[b]ThrowsAdvice[/b]

[code]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");
}
}[/code]

[b]StaticPointcut[/b]

[code]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();
}
}[/code]

[b]Dynamic pointcut[/b]

[code]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();
}
}[/code]

[b]NamePointcut[/b]

[code]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();
}
}[/code]

[b]NamePointcutAdvisor[/b]

[code]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();
}
}[/code]

[b]RegexpPointcut[/b]

[code]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();
}
}[/code]

[b]ControlFlow Pointcut[/b]

[code]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();
}
}[/code]

[b]ComposablePointcut[/b]

[code]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"));
}
}
}[/code]

[b]Introduction[/b]

[code]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());
}
}[/code]