动态代理的实现逻辑

public interface SayHelloService {
    // 定义一个方法对名字sayHello
    void sayHello(String name);
}

// 上述接口的实现类
class SayHellowServiceImpl implements SayHelloService {
    // 对上述接口进行实现
    @Override
    public void sayHello(String name) {
        System.out.println("hello" + name);
    }
}

// 该类其实就相当于执行完aop的约定方法后去执行原方法用的
class Invocation{
    Object target = null;
    Method method = null;
    Object[] args = null;

    public Invocation(Object target, Method method,Object[] args){
        this.args = args;
        this.method = method;
        this.target =target;
    }

    // 通过反射执行原有方法
    Object proceed() throws Exception{
        return method.invoke(target,args);
    }
}

// 现在我希望定义一个拦截器对sayHello方法进行拦截执行约定的相关操作
interface Interceptor {
    // 前置方法返回true才能继续执行下列操作
    boolean before();

    /*before是true后执行around方法该方法主要是执行
    希望调用某个实体类的指定方法,所以我们传入一个自定义
    Invocation用于调用原方法*/
    void around(Invocation invocation) throws Exception;

    // 后置方法
    void after();

    // 出现异常执行方法
    void throwException();

    // 一切正常后执行
    void keepRunning();
}

// 对上述拦截器进行实现
class MyInterceptor implements Interceptor{

    @Override
    public boolean before() {
        System.out.println("before执行了");
        return true;
    }

    @Override
    public void around(Invocation invocation) throws Exception{
        System.out.println("around准备执行了");
        // 通过invocation的proceed()方法执行原有方法
        invocation.proceed();
        System.out.println("around执行结束了");
    }

    @Override
    public void after() {
        System.out.println("after执行了");
    }

    @Override
    public void throwException() {
        System.out.println("throwException执行了");
    }

    @Override
    public void keepRunning() {
        System.out.println("keepRunning执行了");
    }
}

class ProxyBean implements InvocationHandler{
    // 这里定义被代理对象和拦截器方便下面调用
    Object target = null;
    Interceptor interceptor = null;

    // 这里自定义一个获取代理对象的静态方法,传入被代理对象
    static Object getProxyBean(Object target, Interceptor interceptor){
        ProxyBean proxyBean = new ProxyBean();
        proxyBean.interceptor = interceptor;
        proxyBean.target = target;

        /*获取代理对象的三个参数:
        1.被代理对象的类加载器,
        2.被代理对象实现所有接口的字节码文件,
        3.invocationHandler实现类,就是当前所在类*/
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
                , target.getClass().getInterfaces(),proxyBean);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 这里就是我们书中进行约定的aop先执行拦截器的前置方法
        boolean before = interceptor.before();
        boolean findExceotion = false;
        try{
            if(before){
                // 创建一个invocation的实现类用于拦截器里面调用原方法
                Invocation invocation = new Invocation(target,method,args);
                interceptor.around(invocation);
            }else{
                // 如果前置方法是false就是直接执行原方法
                method.invoke(target,args);
            }
        }catch (Exception e){
            // 如果出了异常就执行下列操作
            findExceotion = true;
            e.printStackTrace();
        }

        // 为了保证程序的完成运行所以这里如果出了异常不是直接执行拦截器的异常方法
        interceptor.after();
        if(findExceotion){
            interceptor.throwException();
        }else{
            interceptor.keepRunning();
        }
        return null;
    }

    public static void main(String[] args) {
        // 进行测试
        SayHellowServiceImpl sayHellowService = new SayHellowServiceImpl();
        SayHelloService proxyBean = (SayHelloService) ProxyBean
        				.getProxyBean(sayHellowService, new MyInterceptor());
        proxyBean.sayHello("world");
    }
}

为了方便理解通过流程图画出来正向的代码流程走向