java非常长的JSON字符串（>1G），带有Jackson令牌流
我正试图编写一些代码处理JSON文档，其中包含存储在文件中的非常长的字符串值（超过10亿个字符）。我不想把整个字符串保存在内存中（因为我可以在流中处理它们）。但我在Jackson解析器中找不到这样的选项。到目前为止，我所做的是使用Jackson令牌偏移量（第一轮读取文件）和随机访问文件来处理流中的字符串（第二轮读取文件）：
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.MappingJsonFactory;
public class LongStringJsonTest {
public static void main(String[] args) throws Exception {
File tempJson = new File("temp.json");
PrintWriter pw = new PrintWriter(tempJson);
pw.print("{\"k1\": {\"k11\": \"");
for (int i = 0; i < 1e8; i++)
pw.print("abcdefghij");
pw.print("\"}, \"k2\": \"klmnopqrst\", " +
"\"k3\": [\"uvwxyz\", \"0123\"]}");
pw.close();
searchForStrings(tempJson);
}
private static void searchForStrings(File tempJson) throws Exception {
JsonFactory f = new MappingJsonFactory();
JsonParser jp = f.createParser(tempJson);
Map<Long, Long> stringStartToNext = new HashMap<Long, Long>();
long lastStringStart = -1;
boolean wasFieldBeforeString = false;
while (true) {
JsonToken token = jp.nextToken();
if (token == null)
break;
if (lastStringStart >= 0) {
stringStartToNext.put(lastStringStart, (wasFieldBeforeString ? -1 : 1) *
jp.getTokenLocation().getByteOffset());
lastStringStart = -1;
wasFieldBeforeString = false;
}
if (token == JsonToken.FIELD_NAME) {
wasFieldBeforeString = true;
} else if (token == JsonToken.VALUE_STRING) {
lastStringStart = jp.getTokenLocation().getByteOffset();
} else {
wasFieldBeforeString = false;
}
}
jp.close();
jp = f.createParser(tempJson);
RandomAccessFile raf = new RandomAccessFile(tempJson, "r");
while (true) {
JsonToken token = jp.nextToken();
if (token == null)
break;
if (token == JsonToken.VALUE_STRING) {
long start = jp.getTokenLocation().getByteOffset();
long end = stringStartToNext.get(start);
// You are able to process stream without keeping all bytes in memory.
// Here you see strings including quotes around them.
final long[] length = new long[] {0};
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream os = new OutputStream() {
@Override
public void write(int b) throws IOException {
throw new IOException("Method is not supported");
}
@Override
public void write(byte[] b, int off, int len)
throws IOException {
if (baos.size() < 20) {
baos.write(b, off, Math.min(len, 20));
baos.write((int)'.');
baos.write((int)'.');
baos.write((int)'.');
}
if (len > 0)
length[0] += len;
}
};
processString(raf, start, end, os);
String text = new String(baos.toByteArray(), Charset.forName("utf-8"));
System.out.println("String: " + text + ", length=" + length[0]);
}
}
jp.close();
raf.close();
}
private static void processString(RandomAccessFile raf, long start, long end,
OutputStream os) throws Exception {
boolean wasFieldBeforeString = end < 0;
int quoteNum = wasFieldBeforeString ? 3 : 1;
end = Math.abs(end);
byte[] buffer = new byte[10000];
raf.seek(start);
boolean afterBackSlash = false;
int strLen = (int)(end - start);
for (int chunk = 0; strLen > 0; chunk++) {
int ret = raf.read(buffer, 0, Math.min(buffer.length, strLen));
if (ret < 0)
break;
if (ret > 0) {
int offset = 0;
if (chunk == 0) {
// Assumption that key string doesn't contain double quotes
// and it's shorter than buffer size (for simplicity)
for (int n = 0; n < quoteNum; n++) {
while (true) {
if (buffer[offset] == '\"' && !afterBackSlash) {
break;
} else if (buffer[offset] == '\\') {
afterBackSlash = !afterBackSlash;
} else {
afterBackSlash = false;
}
offset++;
}
offset++;
}
offset--;
ret -= offset;
}
// Searching for ending quote
int endQuotePos = offset + (chunk == 0 ? 1 : 0); // Skip open quote
while (endQuotePos < offset + ret) {
if (buffer[endQuotePos] == '\"' && !afterBackSlash) {
break;
} else if (buffer[endQuotePos] == '\\') {
afterBackSlash = !afterBackSlash;
} else {
afterBackSlash = false;
}
endQuotePos++;
}
if (endQuotePos < offset + ret) {
os.write(buffer, offset, endQuotePos + 1 - offset);
break;
}
os.write(buffer, offset, ret);
strLen -= ret;
}
}
}
}
这种方法根本不支持unicode。我很好奇，有没有办法做得更好（或者甚至有其他LIB的帮助）
# 1 楼答案
我觉得你问错问题了
与XML或CSV或任何其他结构化文本表示法一样，JSON有三个主要作用：使数据结构可人为解析，允许通用工具处理许多不同类型的数据，以及促进可能使用不同内部模型的系统之间的数据交换
如果不需要这些特定的特征，结构化文本可能是错误的解决方案。专用的二进制表示可能更有效，而且随着数据的大小/复杂性的增加，这种差异可能会变得巨大
支持从工具导入和导出的结构化文本格式。不过，在内部，您可能应该使用专门为特定任务的需要而调整的数据模型
# 2 楼答案
也许这是一个你自己编写解析器的有效案例
使用PushbackReader（）进行JSON解析应该相对简单
# 3 楼答案
现在我知道JSON格式并不是具有很长字符串值的文档的最佳解决方案。但以防有人面临类似的问题（例如，当已经有这样的JSON文件，需要将其转换为更好的格式时）。这意味着文档应该至少被解析一次。以下是我的调查：
1）FasterXML/Jackson token流不允许使用标准方式处理长字符串（按部分加载）。我发现处理它们的唯一方法是像我所做的那样，手动处理unicode
2）Google/Gson也有JsonReader，允许用户将JSON作为令牌蒸汽处理。还有nextString方法（https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/stream/JsonReader.java#L816）。但是没有办法按部分获取它，或者获取它在JSON文件中的位置的任何信息（除了两个私有方法：https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/stream/JsonReader.java#L1317-L1323）
3）fangyidong/Json simple使用SAX风格的推送接口。但是对于字符串只有一种方法：https://github.com/fangyidong/json-simple/blob/master/src/main/java/org/json/simple/parser/ContentHandler.java#L108
我唯一的希望是贝克尔/斯塔克森。因为它将JSON转换为XML，然后使用XMLStreamReader。有一种方法允许按部分读取字符串：http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/javax/xml/stream/XMLStreamReader.java#XMLStreamReader.getTextCharacters%28int%2Cchar%5B%5D%2Cint%2Cint%29。但不幸的是，OutOfMemoryError正好发生在转换期间的JSON解析中。这是我的代码：
错误堆栈跟踪是：
5）最终的希望是一些用C编写的工具，首先将我的JSON转换为BSON。有了BSON，我会尝试做一些更好的处理。这一条似乎最为人所知：https://github.com/dwight/bsontools。在我在1GB JSON文件上运行这个包中的“fromjson”命令行工具后，它将所有内容加载到内存中（这很糟糕），然后做了10分钟的事情。我没有等到最后，实际上是因为10分钟对1GB文件来说太多了，不是吗？（注意：我的java代码的工作时间不到半分钟）
因此，最终的答案是：（1）不，似乎没有标准的方法来实现所讨论的目标；（2）在这种情况下，使用FasterXML/Jackson可能是最好的Java解决方案