public interface AopDefinitionLoader extends XmlDefinitionLoader{

   ArrayList getJoinpoints();

}

public interface Joinpoint {

  TargetObjectMatcher getTargetObjectMatcher(); 

  Interceptor getInterceptor(); 

  String getType();

}

public interface Pointcut { 

  String  getTargetClass();

  Advice[] getMatchAdvice(Method method);

}

public interface Advice {

  String getType();

  void proceed() throws AspectException;

}

public interface AfterAdvice extends Advice{

}

public interface BeforeAdvice extends Advice{

}

public interface ThrowsAdvice extends Advice{

}

public interface AroundAdvice extends Advice{

}

public class DynamicAopProxy extends DynamicProxy implements InvocationHandler{

  protected Object obj;

  protected Pointcut pointcut;

  private DynamicAopProxy(Object targetObject, Pointcut targetPointcut) {

    this.obj = targetObject;

    this.pointcut = targetPointcut;

  }

  public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {

    Object result;

    Advice advice;

    advice = this.getTargetAdvice(AdviceType.BEFOREADVICE, m);

    try{

        advice.proceed(obj,m,args);

    }

    catch(AspectException ex){

      ex.printStackTrace(System.out);

    }

    advice = this.getTargetAdvice(AdviceType.AROUNDADVICE, m);

    try{

        result = advice.proceed(obj,m,args);

    }

    catch (AspectException ex) {

       ex.printStackTrace();

    }

    catch (Exception e) {

      advice = this.getTargetAdvice(AdviceType.THROWSADVICE, m);

        try {

            advice.proceed(obj,m,args);

        } catch (AspectException e1) {

            e1.printStackTrace();

        }

        throw new RuntimeException

          ("unexpected invocation exception: " + e.getMessage());

    }

    finally {

      System.out.println("end method " + m.getName());

    }

    advice = this.getTargetAdvice(AdviceType.AFTERADVICE, m);

      try {

          advice.proceed(obj,m,args);

      } catch (AspectException e) {

          e.printStackTrace();  //To change body of catch statement use Options | File Templates.

      }

      return result;

  }

    public Advice getTargetAdvice(String type, Method m){

        Advice[] advices = pointcut.getMatchAdvice(m);

        for(int i=0; i<advices.length;i++){

            if(advices[i].getType() == type){

                return advices[i];

            }

        }

        return new DummyAdvice();

    }

  public static Object newInstance(Object obj) throws FatalProxyException {    

    return Proxy.newProxyInstance(obj.getClass().getClassLoader(),

             obj.getClass().getInterfaces(),

             new DynamicAopProxy(obj, null));

  }

}

public interface Interceptor{

   public Object invoke(Invocation invocation) throws InvocationException;

   public Interceptor getNext();

   public Interceptor setNext(final Interceptor interceptor);

}

public interface Invocation {

    Object getTargetObject();

    Method getTargetMethod();

    Object proceed();

}

SRP单一职责原则：

就一个类而言，应该仅有一个引起变化的原因

OCP开放－封闭原则：

软件实体应该可以扩展，但是不可修改

LSP Liskov替换原则：

子类型必须能够替换它们的基类型

DIP依赖倒置原则：

抽象不应该依赖于细节，细节应该依赖于抽象

ISP接口隔离原则：

不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于所在的类层次结构

REP重用发布等价原则：

重用的粒度就是发布的粒度

CCP共同封闭原则：

包中的所有类对于同一性质的变化应该是共同封闭。一个变化如果对一个包产生影响，则将对该包中的所有类产生影响，而对于其他包不造成任何影响。

CRP共同重用原则：

一个包中所有类应该是共同重用。如果重用了包中一个类，那么就要重用该包中的所有类。

ADP无环依赖原则：

在包中的依赖关系图中不允许存在环。

SDP稳定依赖原则：

朝着稳定的方向进行依赖

SAP稳定抽象原则：

包的抽象程度应该和其稳定程度一致。