Java 不确定类型的参数数量不确定

Question

我的公司有一个应用程序服务器，它接收采用自己定制的 XTML 语法的指令集。由于这是有限的，因此有一个特殊的“drop to Java”命令可以将参数发送到 JVM (1.6.0_39)。参数仅作为“输入”或“输入/输出”传递，其中特殊的“输入/输出”变量是用于此平台的可变库。

以前，接收外部配置的唯一方法是使用不同的特殊命令从 XTML 文件中读取。由于不值得深究的原因，这种配置方法很难扩展，因此我正在研究一种使用 Java 来实现此目的的方法。

此配置的语法是 (String,T) 的二元组，其中 String 是 XTML 文件中的属性名称，T 是应用程序服务器将向其分配属性值的输入/输出可变变量。

我试图使这种转换尽可能无缝，而不必在应用程序服务器中进行烦人的字符串解析。

我已经有一个函数

public String[] get(String ... keys)

从应用程序服务器的 key 中检索值，但我真正需要的是一个函数

public static void get(T ... args)

接受二元组。但是，请注意它需要是静态才能从应用程序服务器调用，我的理解是T不能在静态上下文中使用。

我不知道如何以不需要(至少)两个步骤的方式解决这个问题，并且无法循环应用程序服务器中的参数。

我知道我在这里工作受到严格的限制，所以如果答案是“你必须做一些困惑的事情”，那很好 - 我只是想了解另一种方式。

--编辑--

编辑一个更具体的示例。

配置是一组键值对，可以位于数据库或文件中。 get 函数是:

public JSONObject get(String ... keys) throws ClassNotFoundException, SQLException, KeyNotFoundException, FileNotFoundException, IOException {
JSONObject response = new JSONObject();
if(this.isDatabase) {
  for(int i=0;i<keys.length;i++){
    PreparedStatement statement = this.prepare("SELECT value FROM "+this.databaseSchema+"."+this.settingsTableName+" WHERE key = ? LIMIT 1");
    statement.setString(1, keys[i]);
    ResultSet results = statement.executeQuery();
    boolean found = false;
    while(results.next()){
      String value = results.getString("value");
      value = value.replace("\"","");
      response.put(keys[i], value);
      found = true;
    }
    if(!found){
      throw new KeyNotFoundException(keys[i]);
    }
  }   
} else if (this.isFile) {
  boolean[] found = new boolean[keys.length];
  BufferedReader br = new BufferedReader(new FileReader(this.settingsFile));
  String line;
  while((line = br.readLine()) != null ){
    String key;
    String value;
    for(int i=0;i<line.length();i++){
      if(line.charAt(i) == '='){
        key = line.substring(0,i);
        value = line.substring(i+1,line.length());
        if(indexOfString(keys,key) != -1){
          value = value.replace("\"","");
          found[indexOfString(keys,key)] = true;
          response.put(key,value);
          if(allFound(found)==-1){
            return response;
          }
        }
        break;
      }
    }
  }
  if(allFound(found)!=-1){
    throw new KeyNotFoundException(keys[allFound(found)]);
  }
}
return response;

如果我按照自己的方式行事，它看起来会像......

// ConfigurationReader.java
public class ConfigurationReader{
   public ConfigurationReader( ... ){}
   public static JSONObject get(String key){
       // Get the key
   }
}
// ConfigurationInterface.java
public static void get(T ... args){
   ConfigurationReader cfgReader = new ConfigurationReader( ... );
   for(var i=0;i<args.length;i+=2){
       in = args[i];
       out = args[i+1];
       out = cfgReader.get(in);
   }
}

Answer 1

您可以在静态上下文中使用泛型类型。您的问题对于您打算如何做到这一点有些模糊/不清楚，但请考虑下面的示例:

public class Example {

    public static void main(String[] args) {
        Type t1 = new Type("foo");
        Type t2 = new Type("bar");
        Type t3 = new Type("baz");

        Printer.<Type> printNames(t1, t2, t3);
    }

    public static class Printer {
        @SafeVarargs
        public static <T extends Type> void printNames(T... objs) {
            for (T obj : objs) {
                System.out.println(obj);
            }
        }
    }

    public static class Type {
        private final String name;

        public Type(String name) {
            this.name = name;
        }

        @Override
        public final String toString() {
            return name;
        }
    }
}

Printer.<Type> printNames(t1, t2, t3)对 printNames 进行静态引用方法，参数化为 Type泛型类型。

请注意，这是类型安全的。尝试将不同类型的对象传递到该参数化方法将在编译时失败(假设此时已知类型不同):

 Example.java:8: error: method printNames in class Printer cannot be applied to given types;
        Printer.<Type> printNames(t1, t2, t3, "test");
               ^
  required: T[]
  found: Type,Type,Type,String
  reason: varargs mismatch; String cannot be converted to Type
  where T is a type-variable:
    T extends Type declared in method <T>printNames(T...)

<小时/>

编辑

根据您的评论，问题不在于您尝试使用通用类型作为方法参数(无论如何，在Java意义上的通用一词)；您只是在寻找任何非特定的父类 String并且您的自定义类型继承自。只有一个这样的类:Object .

如果您有任何灵 active ，我强烈建议您重新考虑您的设计，因为这会导致 API 设计不佳。但是，您可以使用 Object... objs 让您的方法接受任意数量的任意类型的对象。 .

例如:

public class Example {

    public static void main(String[] args) {
        Printer.printNames("a", "b", new Type("foo"), new Type("bar"));
    }

    public static class Printer {
        public static void printNames(Object... objs) {
            for (Object obj : objs) {
                if (obj instanceof String) {
                    System.out.println(((String) obj).toUpperCase());
                }
                else if (obj instanceof Type) {
                    System.out.println(obj);
                }
            }
        }
    }

    public static class Type {
        private final String name;
        public Type(String name) { this.name = name; }
        public final String toString() { return name; }
    }
}