动态代理

静态代理的缺陷：

对于一个接口Myinterface，有N个实现类，我们想给接口的某个方法做加强，那么就要创建N个代理类来代理这N个实现类。

通过反射，根据实体类动态生成代理类，则为动态代理。静态代理(面向实现类)，动态代理(面向接口)

接口
public interface Myinterface {
    void myMethod();
}

//DP为动态代理
public class DP implements InvocationHandler {
    //代理接口
    private  Myinterface target;

    public Myinterface getTarget(Myinterface target){
        //往代理类传入实现类对象
        this.target=target;
        //获得实现类的反射
        Class<? extends Myinterface> aClass = target.getClass();
        //输入实现类的反射与代理类(代理类中的invoke方法对接口方法的增强)，得到具体代理类
        return (Myinterface) Proxy.newProxyInstance(aClass.getClassLoader(),aClass.getInterfaces(),this);
    }


    //用于提供信息，在反射时组装方法，入参Object[] args为方法的入参，method
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target, args);
        after();
        return result;
    }

    private void after() {
        System.out.println("增强2");
    }
    private void before() {
        System.out.println("增强1");
    }

}

实现类
public class MathTeacher implements Myinterface{

    @Override
    public void myMethod() {
        System.out.println("math teacher");
    }
}

测试
    public static void main(String[] args) {
        DP dp = new DP();
        Myinterface m1=new MathTeacher();
        Myinterface target = dp.getTarget(m1);
        target.myMethod();

    }

目前时会用动态代理和大致原理的状态，之后继续学习反射等底层实现，Proxy.newProxyInstance（），invoke方法具体干了什么。