用java代码构造字符串的干净方法是什么？

我试图使用Java代理向每个方法注入一些额外的代码。到目前为止，我编写的代码如下：

String signature = method.getSignature();
method.insertBefore("System.err.println(\"" + signature + "\");");

有没有更干净的方法来编写Java语法？类似的东西会很有用

---

Update：例如，要创建

System.err.println

，类似于createClass（“系统”）.createField（“out”）.createMethod（“println”）。

我相信您正在寻找

method.insertBefore(String.format("System.err.println(\"%s\");", signature));

---

您可以作为一个实用程序自己完成：

package ramin;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import com.google.common.base.Joiner;

public class AraniUtil{

    private StringBuilder fullyQualifiedName = new StringBuilder("");//fully qualified name

    /*
     * Parameters :
     * List classes : a list of classes to build in String type
     * List fields : a list of fields to build in String type
     * HashMap<String, List> methodsAndSignatures (or "mas") : a hashmap where maps method name to a list of arguments in String Type
     */
    public AraniUtil(List classes, List fields, HashMap<String, List> mas)
    {
        //list of manipulated methods with their arguments
        List methods = new ArrayList();
        Iterator iterator = mas.keySet().iterator();//method names iterator
        for (Iterator i = iterator; iterator.hasNext(); ) {

            Object next = i.next();
            StringBuilder mapped = new StringBuilder("");
            mapped.append((String) next);


            Iterator signatures = mas.get(next).iterator();
            List tempSignature = new ArrayList();
            for (Iterator j = signatures; j.hasNext(); ) {
                next = j.next();
                if (next.getClass().equals(String.class))
                    //mapped.append("\"" + next + "\"");
                    tempSignature.add("\"" + next + "\"");
                else
                    tempSignature.add(next);
                    //mapped.append(next);
            }
            mapped.append("(" + Joiner.on(",").join(tempSignature) + ")");
            methods.add(mapped.toString());
        }
        fullyQualifiedName.append(Joiner.on(".").join(classes) + ".");
        fullyQualifiedName.append(Joiner.on(".").join(fields) + ".");
        fullyQualifiedName.append(Joiner.on(".").join(methods));
    }

    @Override
    public String toString(){
        return this.fullyQualifiedName.toString();
    }

    public static void main(String[] args) {
        //initializing classes to create
        List classes = new ArrayList<String>();
        classes.add("System");
        classes.add("System2");
        //initializing fields to create
        List fields = new ArrayList<String>();
        fields.add("out");
        fields.add("out2");
        HashMap methodsAndSignatures = new HashMap();
        //creating method signatures
        List tempList = new ArrayList();
        tempList.add("arg1");
        tempList.add(6956);
        //map a method to array of arguments
        methodsAndSignatures.put("println", tempList);
        //creating method signatures
        List tempList2 = new ArrayList();
        tempList2.add("arg2");
        tempList2.add(6956555);
        //map a method to array of arguments
        methodsAndSignatures.put("println2", tempList2);
        //actual utility function
        AraniUtil araniUtil = new AraniUtil(classes, fields, methodsAndSignatures);
        //and the result
        System.out.println(araniUtil);
    }
}

packageramin；
导入java.util.ArrayList；
导入java.util.HashMap；
导入java.util.Iterator；
导入java.util.List；
导入com.google.common.base.Joiner；
公共级AraniUtil{
私有StringBuilder fullyQualifiedName=新StringBuilder（“”；//完全限定名
/*
*参数：
*列表类：要在字符串类型中生成的类的列表
*列表字段：要在字符串类型中生成的字段列表
*HashMap methodsAndSignatures（或“mas”）：将方法名称映射到字符串类型的参数列表的HashMap
*/
公共AraniUtil（列表类、列表字段、HashMap mas）
{
//操纵方法及其参数的列表
列表方法=新的ArrayList（）；
迭代器迭代器=mas.keySet（）.Iterator（）；//方法名迭代器
for（迭代器i=Iterator；Iterator.hasNext（）；）{
Object next=i.next（）；
StringBuilder mapped=新StringBuilder（“”）；
append（（字符串）next）；
迭代器签名=mas.get（next.Iterator（）；
List tempSignature=newarraylist（）；
for（迭代器j=signatures；j.hasNext（）；）{
next=j.next（）；
if（next.getClass（）.equals（String.class））
//mapped.append（“\”+next+“\”）；
tempSignature.add（“\”+next+“\”）；
其他的
tempSignature.add（下一步）；
//append（下一步）；
}
mapped.append（“（“+Joiner.on（“，”）.join（tempSignature）+”）；
add（mapped.toString（））；
}
fullyQualifiedName.append（Joiner.on（“.”）.join（classes）+”）；
fullyQualifiedName.append（Joiner.on（“.”）.join（fields）+”）；
fullyQualifiedName.append（Joiner.on（“.”）.join（方法））；
}
@凌驾
公共字符串toString（）{
返回此.fullyQualifiedName.toString（）；
}
公共静态void main（字符串[]args）{
//初始化要创建的类
列表类=新的ArrayList（）；
类别。添加（“系统”）；
类别。添加（“系统2”）；
//初始化要创建的字段
列表字段=新的ArrayList（）；
字段。添加（“out”）；
字段。添加（“out2”）；
HashMap methodsAndSignatures=新HashMap（）；
//创建方法签名
List templast=new ArrayList（）；
添加（“arg1”）；
圣殿骑士（6956）；
//将方法映射到参数数组
方法和签名。放置（“println”，圣殿骑士）；
//创建方法签名
List tempList2=新建ArrayList（）；
模板2.添加（“arg2”）；
模板2.add（6956555）；
//将方法映射到参数数组
方法和签名。put（“println2”，templast2）；
//实际效用函数
AraniUtil AraniUtil=新的AraniUtil（类、字段、方法和签名）；
//结果呢
系统输出打印（araniUtil）；
}
}

我自己写的，并鼓励我的朋友重构/编辑它

这将输出

System.System2.out.out2.println（“arg1”，6956）.println（“arg2”，6956555）

---

这非常有效：）

类似的东西，但是能够去掉转义引号会更好。使用单引号（'）或尝试外部化，然后您可以在文本文件中定义消息，而不需要转义引号。在Java代码内部，您需要它们。@FlorianSchaetz我理解您的意思。我正在寻找的是一些实用程序库，为我处理这个。例如，defineClass（“系统”）.defineField（“输出”）.defineFunction（“println”）。像这样的东西会有用的