静态代理和动态代理

静态代理方式是为每个被代理的对象构造对应的代理类，例如我们有一个计算器的接口以及一个具体实现

public interface Calculator {
    int add(int a, int b);
}
public class CalculatorImpl implements Calculator {
    public int add(int a, int b) {
        return a+b;
    }
}

//静态代理
public class CalculatorProxy implements Calculator {
    private Calculator calculator;

    CalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }
    public int add(int a, int b) {
            //dobefore 代理的作用，前后可以插入代码
            int result = calculator.add(a, b);
            //doafter
            return result;
    }
}

如果对多个类进行代理，并且前后插入的代码都是一致的，那么dobefore和doafter就要写很多次，这非常麻烦，所以引入动态代理

动态代理是动态的生成具体委托类的代理类实现对象，同样的事情的代理只需实现一遍，就可以提供给多个不同的委托类使用了。

public void testDynamicProxy() {
    Calculator calculator = new CalculatorImpl();
    LogHandler lh = new LogHandler(calculator);
    Calculator proxy = (Calculator) Proxy.newProxyInstance(calculator.getClass().getClassLoader(), 
            calculator.getClass().getInterfaces(), lh);
    proxy.add(1, 2);
}
public class LogHandler implements InvocationHandler {

    Object obj;
    LogHandler(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        this.doBefore(); //这个只需要写一次
        Object o = method.invoke(obj, args); //真正实现逻辑
        this.doafter();
        return o;
    }
    private void doafter() {
        // TODO Auto-generated method stub
    }
    private void doBefore() {
        // TODO Auto-generated method stub
    }
    
}