手动实现AOP：动态代理+反射

本文内容，如果通过动态代理+反射的方式，手动实现AOP。

静态代理
动态代理

动态代理实现主要是实现InvocationHandler，并且将目标对象注入到代理对象中，利用反射机制来执行目标对象的方法。

接口实现与静态代理相同，代理类代码：

public class DynaProxyHello implements InvocationHandler{
    
    private Object target;//目标对象
    /**
     * 通过反射来实例化目标对象
     * @param object
     * @return
     */
    public Object bind(Object object){
        this.target = object;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        Logger.start();//添加额外的方法
        //通过反射机制来运行目标对象的方法
        result = method.invoke(this.target, args);
        Logger.end();
        return result;
    }
    
}

测试类代码：

public class DynaTest {
    public static void main(String[] args) {
        IHello hello = (IHello) new DynaProxyHello().bind(new Hello());//如果我们需要日志功能，则使用代理类
        //IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
        hello.sayHello("明天");
    }
}

看完上面的代码可能和Spring AOP相比有一个问题，日志类只能在方法前后打印，但是AOP应该是可以在满足条件就可以执行，所以是否可以将ProxyHandler对象和日志操作对象(Logger)解耦呢？

看下面代码实现，将ProxyHandler对象和日志操作对象(Logger)解耦：

我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码)，那么，我们可以抽象出一个接口，这个接口里就只有两个方法：一个是在被代理对象要执行方法之前执行的方法,我们取名为start，第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end。

Logger的接口：

public interface ILogger {
     void start(Method method);
     void end(Method method);
}

Logger的接口实现：

public class DLogger implements ILogger{
    @Override
    public void start(Method method) {
        System.out.println(new Date()+ method.getName() + " say hello start...");
    }
    @Override
    public void end(Method method) {
        System.out.println(new Date()+ method.getName() + " say hello end");
    }
}

动态代理类：

public class ProxyHandler implements InvocationHandler {
    //增强类 实例
    private Object enhanceObject;
    //目标对象
    private Object target;

    public Object bind(Object target, Object enhanceObject) {
        this.target = target;
        this.enhanceObject = enhanceObject;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(),
            this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //反射得到增强类的实例
        Class clazz = this.enhanceObject.getClass();

        //反射得到增强类的Start方法
        Method start = clazz.getDeclaredMethod("start", new Class[] {Method.class});
        //反射执行start方法
        start.invoke(this.enhanceObject, method);

        //执行要处理对象的原本方法
        method.invoke(this.target, args);
        // 打印：Method:public abstract void com.alibaba.polystar.service.intelligent.test.IHello.sayHello(java.lang.String)
        System.out.println("Method:" + method);

        //反射得到增强类的end方法
        Method end = clazz.getDeclaredMethod("end", new Class[] {Method.class});
        //反射执行end方法
        end.invoke(this.enhanceObject, new Object[] {method});

        return result;
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        IHello hello = (IHello) new ProxyHandler().bind(new Hello(),new DLogger());//如果我们需要日志功能，则使用代理类

        //IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
        hello.sayHello("明天");

        // 打印 com.sun.proxy.$Proxy0
        System.out.println(hello.getClass().getName());
        // 打印 com.sun.proxy.$Proxy0
        System.out.println(hello.getClass().getTypeName());
        // 打印 $Proxy0
        System.out.println(hello.getClass().getSimpleName());
    }
}

打印结果

Sat Jan 08 21:33:48 CST 2022sayHello say hello start...
hello 明天
Method:public abstract void com.alibaba.polystar.service.intelligent.test.IHello.sayHello(java.lang.String)
Sat Jan 08 21:33:48 CST 2022sayHello say hello end
com.sun.proxy.$Proxy0
com.sun.proxy.$Proxy0
$Proxy0

通过上面例子，可以发现通过动态代理和反射技术，已经基本实现了AOP的功能，如果我们只需要在方法执行前打印日志，则可以不实现end()方法，这样就可以控制打印的时机了。如果我们想让指定的方法打印日志，我们只需要在invoke（）方法中加一个对method名字的判断。