有效地解析巨大的字符串響應

Question

我有一個服務，它返回以下格式的數據。 我已將其縮短以便理解，但總的來說這是一個非常大的反應。 格式總是一樣的。

process=true
version=2
DataCenter=dc2
    Total:2
    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2}
    obvious:{0=6, 1=7, 2=8, 3=5, 4=6}
    mapping:{3=machineA.dc2.com, 2=machineB.dc2.com}
    Machine:[machineA.dc2.com, machineB.dc2.com]
DataCenter=dc1
    Total:2
    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2, 6=3}
    obvious:{0=6, 1=7, 2=8, 3=5, 4=6, 5=7}
    mapping:{3=machineP.dc1.com, 2=machineQ.dc1.com}
    Machine:[machineP.dc1.com, machineQ.dc1.com]
DataCenter=dc3
    Total:2
    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2}
    obvious:{0=6, 1=7, 2=8, 3=5, 4=6}
    mapping:{3=machineO.dc3.com, 2=machineR.dc3.com}
    Machine:[machineO.dc3.com, machineR.dc3.com]

我試圖解析上面的數據並將其存儲在三個不同的地圖中。

• Prime map： Map<String, Map<Integer, Integer>> prime = new HashMap<String, Map<Integer, Integer>>();
• 明顯的map： Map<String, Map<Integer, Integer>> obvious = new HashMap<String, Map<Integer, Integer>>();
• 映射映射： Map<String, Map<Integer, String>> mapping = new HashMap<String, Map<Integer, String>>();

以下是描述：

• 在Prime映射中，鍵為dc2 ，值為{0=1, 1=2, 2=3, 3=4, 4=1, 5=2} 。
• 在Obvious map中，key為dc2 ，值為{0=6, 1=7, 2=8, 3=5, 4=6} dc2 {0=6, 1=7, 2=8, 3=5, 4=6} dc2 {0=6, 1=7, 2=8, 3=5, 4=6} dc2 {0=6, 1=7, 2=8, 3=5, 4=6} dc2 {0=6, 1=7, 2=8, 3=5, 4=6} 。
• 在Mapping map中，key為dc2 ，值為{3=machineA.dc2.com, 2=machineB.dc2.com} 。

同樣對於其他數據中心也是如此。

解析上述字符串響應的最佳方法是什么？ 我應該在這里使用正則表達式還是簡單的字符串解析？

public class DataParser {
    public static void main(String[] args) {
        String response = getDataFromURL();
        // here response will contain above string
        parseResponse(response);            
    }

    private void parseResponse(final String response) {
        // what is the best way to parse the response?
    }   
}

任何例子都會有很大的幫助。

Answer 1

您可以像ShellFish一樣建議並按'\\ n'拆分響應，然后處理每一行。

一個正則表達式的方法如下（它不完整，但足以讓你開始）：

public static void main(String[] args) throws Exception {
    String response = "process=true\n" +
        "version=2\n" +
        "DataCenter=dc2\n" +
        "    Total:2\n" +
        "    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2}\n" +
        "    obvious:{0=6, 1=7, 2=8, 3=5, 4=6}\n" +
        "    mapping:{3=machineA.dc2.com, 2=machineB.dc2.com}\n" +
        "    Machine:[machineA.dc2.com, machineB.dc2.com]\n" +
        "DataCenter=dc1\n" +
        "    Total:2\n" +
        "    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2, 6=3}\n" +
        "    obvious:{0=6, 1=7, 2=8, 3=5, 4=6, 5=7}\n" +
        "    mapping:{3=machineP.dc1.com, 2=machineQ.dc1.com}\n" +
        "    Machine:[machineP.dc1.com, machineQ.dc1.com]\n" +
        "DataCenter=dc3\n" +
        "    Total:2\n" +
        "    prime:{0=1, 1=2, 2=3, 3=4, 4=1, 5=2}\n" +
        "    obvious:{0=6, 1=7, 2=8, 3=5, 4=6}\n" +
        "    mapping:{3=machineO.dc3.com, 2=machineR.dc3.com}\n" +
        "    Machine:[machineO.dc3.com, machineR.dc3.com]";

    Map<String, Map<Integer, Integer>> prime = new HashMap();
    Map<String, Map<Integer, Integer>> obvious = new HashMap();
    Map<String, Map<Integer, String>> mapping = new HashMap();

    String outerMapKey = "";
    int findCount = 0;
    Matcher matcher = Pattern.compile("(?<=DataCenter=)(.*)|(?<=prime:)(.*)|(?<=obvious:)(.*)|(?<=mapping:)(.*)").matcher(response);
    while(matcher.find()) {
        switch (findCount) {
            case 0:
                outerMapKey = matcher.group();
                break;
            case 1:
                prime.put(outerMapKey, new HashMap());
                String group = matcher.group().replaceAll("[\\{\\}]", "").replaceAll(", ", ",");
                String[] groupPieces = group.split(",");
                for (String groupPiece : groupPieces) {
                    String[] keyValue = groupPiece.split("=");
                    prime.get(outerMapKey).put(Integer.parseInt(keyValue[0]), Integer.parseInt(keyValue[0]));
                }
                break;
            // Add additional cases for obvious and mapping
        }

        findCount++;
        if (findCount == 4) {
            findCount = 0;
        }
    }

    System.out.println("Primes:");
    prime.keySet().stream().forEach(k -> System.out.printf("Key: %s Value: %s\n", k, prime.get(k)));
    // Add additional outputs for obvious and mapping
}

結果：

Primes:
Key: dc2 Value: {0=0, 1=1, 2=2, 3=3, 4=4, 5=5}
Key: dc1 Value: {0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6}
Key: dc3 Value: {0=0, 1=1, 2=2, 3=3, 4=4, 5=5}

參考解釋正則表達式模式： http ： //docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

http://www.regular-expressions.info/lookaround.html

Answer 2

答案取決於您對格式的確定程度和確切程度。 一個非常簡單的方法解析字符串並進行最小字符串比較以確定鍵值：

private static final String DATA_CENTER = "DataCenter=";
private static final int DATA_CENTER_LEN = DATA_CENTER.length();
private static final String PRIME = "    prime:";
private static final int PRIME_LEN = PRIME.length();
// etc.
Map<String, Map<Integer, Integer>> prime = new HashMap<>();
// etc.
String response = "...";
Scanner scanner = new Scanner( response );
while(scanner.hasNextLine()){
    String line = scanner.nextLine();
    if( line.startsWith( DATA_CENTER ) ){
        String dc = line.substring( DATA_CENTER_LEN );
        line = scanner.nextLine(); // skip Total 
        prime.put( dc, str2map(scanner.nextLine().substring(PRIME_LEN)) );
        obvious.put( dc, str2map(scanner.nextLine().substring(OBVIOUS_LEN)) );
        mapping.put( dc, str2mapis(scanner.nextLine().substring(MAPPING_LEN)) );
    }
}

更明確的nextLine（）調用甚至可以避免對“DataCenter”的測試。

這里有幾個幾乎相同的方法來分割大括號並創建一個地圖：

private static Map<Integer,Integer> str2map( String str ){
    Map<Integer,Integer> map = new HashMap<>();
    str = str.substring( 1, str.length()-1 );
    String[] pairs = str.split( ", " );
    for( String pair: pairs ){
        String[] kv = pair.split( "=" );
        map.put( Integer.parseInt(kv[0]),Integer.parseInt(kv[1]) );
    }
    return map;
}

private static Map<Integer,String> str2mapis( String str ){
    Map<Integer,String> map = new HashMap<>();
    //...
        map.put( Integer.parseInt(kv[0]),kv[1] );
    }
    return map;
}

如果白色空間有可能發生變化，您可以保持安全，使用

private static final String PRIME = "prime:";
// ...
prime.put( dc, str2map(scanner.nextLine().trim().substring( PRIME_LEN )) );

如果無法保證線路的順序或完整性，則可能需要進行測試：

line = scanner.nextLine().trim();
if( line.startsWith( PRIME ) ){
     prime.put( dc, str2map(scanner.nextLine().substring( PRIME_LEN )) );
}

通過更少的穩定性/信任，可以指示正則表達式解析。

Answer 3

在這種情況下，我會做簡單的字符串解析，為每一行應用正則表達式 。 在偽代碼中，這樣的事情：

for line in response
    if line matches /^DataCenter/
         key = datacenter name
    else if line matches / *prime/
         prime.put(key, prime value)
    else if line matches / *obvious/
         obvious.put(key, obvious value)
    else if line matches / *mapping/
         mapping.put(key, mapping value)
    else
         getline

您可以通過首先檢查該行的第一個字符來優化此處。 如果它是除了空格或D之外的任何東西，你可以轉到下一行。 如果格式始終相同，您甚至可以對要解析的行進行硬編碼。 在您提供的示例中，您可以：

skip 2 lines
repeat
    extract datacenter name
    skip 1 line
    extract prime
    extract obvious
    extract mapping
    add above stuff to the maps
    skip 1 line
until EOF

這將快得多，但如果格式改變則會失敗。

Answer 4

您可以使用諸如ANTLR之類的解析器生成器，或者您可以手動編寫解析器代碼。 根據您需要處理的輸出量和頻率，您可能會發現遇到這樣的麻煩並不值得，並且只需遍歷每一行並手動解析它（例如，正則表達式或indexOf）就足夠了足夠。