package com.ehi.pro.util;

public interface XmlDefinitionLoader {

  void loadXmlData(String fileName, boolean validating) throws XmlDefinitionException;

}

BeanDefinitionLoader.java

public interface BeanDefinitionLoader extends XmlDefinitionLoader{

BeanInfo getBeanInfo(String beanName) throws BeanInfoNotFoundException;

}

BeanInfo.java

public interface BeanInfo {

String getClassInfo();

BeanPropertyValue[] getPropertyValues();

boolean isSingleton();

}

public interface DynamicClassLoader {

  public Class loadClass(String className) throws ClassNotFoundException;

}

MethodInvoker.java

public class MethodInvoker {

    public static final VoidType VOID = new VoidType();

    private static Method validate(Object targetObject, String targetMethod, Object[] arguments) throws ClassNotFoundException, NoSuchMethodException

    {

        if (targetObject == null) {

            throw new IllegalArgumentException("Either targetClass or targetObject is required");

        }

        if (targetMethod == null) {

            throw new IllegalArgumentException("targetMethod is required");

        }

        if (arguments == null) {

            arguments = new Object[0];

        }

        Class[] types = new Class[arguments.length];

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

            types[i] = arguments[i].getClass();

        }

        // try to get the exact method first

        Class targetClass = targetObject.getClass();

        Method methodObject = null;

        try {

            methodObject = targetClass.getMethod(targetMethod, types);

        }

        catch (NoSuchMethodException ex) {

            int matches = 0;

            Method[] methods = targetClass.getMethods();

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

                Method method = methods[i];

                if (method.getName().equals(targetMethod) && method.getParameterTypes().length == types.length) {

                    methodObject = method;

                    ++matches;

                }

            }

            // just rethrow exception if we can't get a match

            if (methodObject == null || matches > 1) {

                throw ex;

            }

        }

        return methodObject;

    }

    public static Object invoke(Object clazz,String methodName,Object[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        Method methodObject = null;

        Object result = null;

        try{

            methodObject = validate(clazz, methodName, args);

        }

        catch(NoSuchMethodException ex){

            throw ex;

        }

        catch(ClassNotFoundException e){

            throw e;

        }

        if (Modifier.isStatic(methodObject.getModifiers())) {

            result = methodObject.invoke(null, args);

        }

        else{

            result = methodObject.invoke(clazz, args);

        }

        return (result == null ? VOID : result);

    }

}

BeanLoader.java

public interface BeanLoader {

  Object loadBean(String beanName) throws BeanLoadException;

}

public class DynamicBeanProxy extends DynamicProxy implements InvocationHandler{

  protected Object obj;

  private DynamicAopProxy(Object targetObject) {

    this.obj = targetObject;

  }

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

    Object result;   

    try{

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

    }

    catch (Exception e) {

      e.printStackTrace();

      throw new RuntimeException

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

    }

    finally {

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

    }

    return result;

  }

  public static Object newInstance(Object obj) throws FatalProxyException {

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

        obj.getClass().getInterfaces(),new DynamicBeanProxy(obj));

  }

}

public interface Application {

  Object getInstance(String beanName);

  Object getProxyInstance(String className);

  Context getContext();

}

public interface Config {

  public Object getValue(String key) throws ConfigException;

}

public abstract class Context {

  public static Application getAppliation(){

    return null;

  }

  public static Config getConfig(){

    return null;

  }

  public static Session getSession(){

    return null;  }

}

Around advice:

Advice that surrounds a joinpoint such as a method invocation. This is the most powerful kind of advice. Around advices will perform custom behaviour before and after the method invocation. They are responsible for choosing whether to proceed to the joinpoint or to shortcut executing by returning their own return value or throwing an exception.

Before advice:

Advice that executes before a joinpoint, but which does not have the ability to prevent execution flow proceeding to the joinpoint

Throws advice:

Advice to be executed if a method throws an exception.

After returning advice

Advice to be executed after a joinpoint completes normally: for example, if a method returns without throwing an exception.

a、类似AspectJ

使用特定的语法将代码插入到相应代码中的过程，一般是编译完成在编译时修改java类代码实现,interception and introduct 等；

b、类似JBossAOP

在类加载时利用反射机制实现AOP的功能；

c、类似nanning

使用java 动态代理。