[Java] spring aop之链式调用的实现

public interface methodinterceptor {
 
  object invoke(methodinvocation invocation) throws throwable;
}

public interface methodinvocation {
 
  object proceed() throws throwable;
}

public abstract class abstractaspectjadvice implements methodinterceptor{
 
  private method advicemethod;
 
  private object adviceobject;
 
  public abstractaspectjadvice(method advicemethod, object adviceobject) {
  this.advicemethod = advicemethod;
  this.adviceobject = adviceobject;
  }
 
  public method getadvicemethod() {
  return this.advicemethod;
  }
 
  public void invokeadvicemethod() throws throwable {
  advicemethod.invoke(adviceobject);
  }
}

public class aspectjbeforeadvice extends abstractaspectjadvice {
 
  public aspectjbeforeadvice(method method, object adviceobject) {
  super(method, adviceobject);
  }
 
  @override
  public object invoke(methodinvocation invocation) throws throwable{
  this.invokeadvicemethod();
  object o = invocation.proceed();
  return o;
  }
}

public class aspectjafterreturningadvice extends abstractaspectjadvice {
 
  public aspectjafterreturningadvice(method method, object adviceobject) {
  super(method, adviceobject);
  }
 
  @override
  public object invoke(methodinvocation invocation) throws throwable{
  object o = invocation.proceed();
  this.invokeadvicemethod();
  return o;
  }
}

public class reflectivemethodinvocation implements methodinvocation {
 
  private final object targetobject;
 
  private final method targetmethod;
 
  private final list<methodinterceptor> interceptorlist;
 
  private int currentinterceptorindex = -1;
 
  public reflectivemethodinvocation(object targetobject, method targetmethod, list<methodinterceptor> interceptorlist) {
  this.targetobject = targetobject;
  this.targetmethod = targetmethod;
  this.interceptorlist = interceptorlist;
  }
 
  @override
  public object proceed() throws throwable {
 
  if (this.currentinterceptorindex == this.interceptorlist.size() - 1) {
    return invokejoinpoint();
  }
 
  this.currentinterceptorindex++;
 
  methodinterceptor interceptor =
    this.interceptorlist.get(this.currentinterceptorindex);
  return interceptor.invoke(this);
  }
 
  private object invokejoinpoint() throws throwable {
 
  return this.targetmethod.invoke(this.targetobject);
  }
}

public class niocoderservice {
 
  public void testaop() {
  system.out.println("http://niocoder.com/");
  }
}

public class transactionmanager {
  public void start() {
  system.out.println("start tx");
  }
 
  public void commit() {
  system.out.println("commit tx");
  }
 
  public void rollback() {
  system.out.println("rollback tx");
  }
 
}

public class reflectivemethodinvocationtest {
 
  private aspectjbeforeadvice beforeadvice = null;
 
  private aspectjafterreturningadvice afterreturningadvice = null;
 
  private niocoderservice niocoderservice;
 
  private transactionmanager tx;
 
  public void setup() throws exception {
  niocoderservice = new niocoderservice();
  tx = new transactionmanager();
  beforeadvice = new aspectjbeforeadvice(transactionmanager.class.getmethod("start"), tx);
  afterreturningadvice = new aspectjafterreturningadvice(transactionmanager.class.getmethod("commit"), tx);
  }
 
  public void testmethodinvocation() throws throwable {
  method method = niocoderservice.class.getmethod("testaop");
  list<methodinterceptor> interceptorlist = new arraylist<>();
  interceptorlist.add(beforeadvice);
  interceptorlist.add(afterreturningadvice);  
 
  reflectivemethodinvocation mi = new reflectivemethodinvocation(niocoderservice, method, interceptorlist);
 
  mi.proceed();
  }
 
 
  public static void main(string[] args) throws throwable {
  reflectivemethodinvocationtest reflectivemethodinvocationtest = new reflectivemethodinvocationtest();
  reflectivemethodinvocationtest.setup();
  reflectivemethodinvocationtest.testmethodinvocation();
  }
}

start tx
http://niocoder.com/
commit tx

public void testmethodinvocation() throws throwable {
  method method = niocoderservice.class.getmethod("testaop");
  list<methodinterceptor> interceptorlist = new arraylist<>();
  interceptorlist.add(afterreturningadvice);
   interceptorlist.add(beforeadvice);
 
  reflectivemethodinvocation mi = new reflectivemethodinvocation(niocoderservice, method, interceptorlist);
 
  mi.proceed();
  }

start tx
http://niocoder.com/
commit tx