java反射增加装饰模式的普适性

装饰模式（Decorator Pattern）的定义是：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象来包裹真实的对象。就增加功能来说，装饰模式相比于生成子类更为灵活。使用java的动态代理实现装饰模式会具有更强的灵活性、适应性。下面我们就来写一个使用java动态代理来实现装饰模式效果的例子。

定义一个职责的接口：

/**
 * 能力
 */
interface Feature{
    void ability();
}

/**
 * 读书的能力
 */
class ReadAbility implements Feature {

    @Override
    public void ability() {
        System.out.println("我会读书、、、");
    }
}

/**
 * 写字的能力
 */
class WriteAbility implements Feature {

    @Override
    public void ability() {
        System.out.println("我会写字。、、、、");
    }
}

/**
 * 有什么能力
 */
interface Ability {
    void sayYouAbility();
}

public class ReflectDecorateTest01 implements Ability{
    //用来包装真实对象
    private Ability ability;
    //下面要反射调用的Class对象。
    private Class<? extends Feature> clazz;

    @Override
    public void sayYouAbility() {
        /**
         * 动态代理
         */
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object obj = null;
                if(Modifier.isPublic(method.getModifiers())){
                    obj = method.invoke(clazz.newInstance(),args);
                }
                ability.sayYouAbility();//这个地方很重要，不能漏掉， 实现层层调用的功能。
                return obj;
            }
        };
	//生成动态代理对象
        Feature feature = (Feature) Proxy.newProxyInstance(getClass().getClassLoader(),clazz.getInterfaces(),invocationHandler);
        feature.ability();//代理类的调用方法
    }

    public ReflectDecorateTest01(Ability ability, Class<? extends Feature> clazz) {
        this.ability = ability;
        this.clazz = clazz;
    }

    public ReflectDecorateTest01() {
    }

    public static void main(String[] args){
        Ability ability = new Ability() {
            @Override
            public void sayYouAbility() {
                System.out.println("你有什么能力！");
            }
        };
        ability = new ReflectDecorateTest01(ability,ReadAbility.class);//给实现类增加读的能力
        ability = new ReflectDecorateTest01(ability,WriteAbility.class);//给实现类增加写的能力
        ability.sayYouAbility();
    }
}

1、装饰对象和真实对象有相同的接口。这样调用者就能以和真实对象相同的方式和装饰对象交互。

2、装饰对象包含一个真实对象的引用（即上面例子中的Ability接口）。

3、装饰对象接受所有来调用者的请求，并把这些请求转发给真实的对象。

4、装饰对象可以在调用者的方法以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。

那么在什么样的地方使用装饰模式呢？

1、需要动态扩展一个类的功能，或给一个类添加附加职责。

2、需要动态的给一个对象添加功能，这些功能可以再动态的撤销。

3、需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。

4、 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

下面再写一个不通过反射来实现装饰模式的例子：

/**
 * Created by zkn on 2016/11/14.
 * 测试装饰模式
 */
public class DecoratePatternTest01 implements DecorateInterface{

    private DecorateInterface decorateInterface;

    public DecoratePatternTest01(DecorateInterface decorateInterface) {
        this.decorateInterface = decorateInterface;
    }

    @Override
    public void read(){
        decorateInterface.read();
    }

    public static void main(String[] args){
        DecoratePatternTest01 decoratePatternTest01 = new DecoratePatternTest01(new DecorateTest02(new DecorateTest01()));
        decoratePatternTest01.read();
    }
}

/**
 * 装饰模式的接口
 */
interface DecorateInterface {

    void read();
}
/**
 * 装饰接口的第一个实现类
 */
class DecorateTest01 implements DecorateInterface {

    private DecorateInterface decorateInterface;

    @Override
    public void read() {

        System.out.println("我是第一个实现类");
    }

    public DecorateTest01(DecorateInterface decorateInterface) {
        this.decorateInterface = decorateInterface;
    }

    public DecorateTest01() {
    }
}