静态代理&动态代理

静态代理

静态代理通常用于对原有业务逻辑的扩充。
接口：

public interface Duck {
    public void fly(int height);
}

实现类：

public class BeijingDuck implements Duck {
    @Override
    public void fly(int height) {
        System.out.println("我是北京烤鸭,我能飞"+height+"米高");
    }
}

代理类：

public class DuckProxy implements Duck {

    Duck duck = null;

    public DuckProxy(Duck duck) {
        this.duck = duck;
    }

    @Override
    public void fly(int height) {
        System.out.println("先脱毛");
        duck.fly(height);
        System.out.println("后吃掉");
    }

}

---

测试

public class MyTest {

    public static void main(String[] args) {
        DuckProxy proxy = new DuckProxy(new BeijingDuck());
        proxy.fly(100);
    }

}

优点：方便好理解，扩展原功能，不侵入原代码。
缺点：当多了几个实现类的时候，代理每个都要重写。

动态代理

优点：解决了静态代理多个实现类重复写的问题。

接口：

public interface Duck {
    /**
     * 制作烤鸭
     * @param weigth 鸭子重量
     */
    public void create(int weigth);
}

实现类:

public class BeijingDuck implements Duck {
    @Override
    public void create(int weigth) {
        System.out.println("制作"+weigth+"斤重的北京烤鸭");
    }
}

代理类：

public class DuckProxy implements InvocationHandler {

    Duck duck = null;

    public DuckProxy(Duck duck) {
        this.duck = duck;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object object = null;
        // 验证调用方法一致
        if ("create".equals(method.getName())) {
            System.out.println("杀鸭脱毛");
            object = method.invoke(duck, args);
            System.out.println("愉快的吃鸭子");
        }
        return object;
    }
}

测试：

public class Test {

    public static void main(String[] args) {
        Duck duck = (Duck) Proxy.newProxyInstance(Duck.class.getClassLoader(),
                new Class[] { Duck.class }, new DuckProxy(new BeijingDuck()));
        duck.create(5);

    }
}

结果：

杀鸭脱毛
制作5斤重的北京烤鸭
愉快的吃鸭子