While going through some code earlier today, I encountered a method that attempted to escape quotes and back slashes in a poor way. The author of that method presumably thought that it’d be way faster than Jackson’s ObjectMapper.

Here’s what they wrote:

	public static String escapeString(Object o) {
	if (o == null) {
	return null;
	}
	String str = o.toString();
	if (str.contains("\\")) {
	str = str.replace("\\", "\\\\");
	}
	if (str.contains("\"")) {
	str = str.replace("\"", "\\\"");
	}
	return str;
	}

view raw A.java hosted with ❤ by GitHub

This produced illegal JSON strings, especially when the input string had new lines and carriage returns in it.

Here’s what I replaced it with:

	private static final ObjectMapper OM = new ObjectMapper();
	public static String escapeString(Object o) {
	if (o == null) {
	return null;
	}
	try {
	// The string is automatically quoted. Therefore, return a new string that
	// doesn't contain those quotes (since the caller appends quotes themselves).
	val bytes = OM.writeValueAsBytes(o.toString());
	return new String(bytes, 1, bytes.length – 2, StandardCharsets.UTF_8);
	} catch (JsonProcessingException e) {
	return "";
	}
	}

view raw A.java hosted with ❤ by GitHub

At first, I was uncertain about the efficiency of either approaches. Let’s JMH it:

	private static final ObjectMapper OM = new ObjectMapper();
	private static final String STR = "hello world – the quick brown fox jumps over "
	+ "the lazy dog\r\n\r\nand here's "
	+ "a random slash\\, and some \"s";
	@Benchmark
	public void jsonStringSerialization(final Blackhole blackhole) throws Exception {
	byte[] obj = OM.writeValueAsBytes(STR);
	blackhole.consume(new String(obj, 1, obj.length – 2, StandardCharsets.UTF_8));
	}
	@Benchmark
	public void jsonStringManual(final Blackhole blackhole) {
	String str = STR;
	if (str.contains("\\")) {
	str = str.replace("\\", "\\\\");
	}
	if (str.contains("\"")) {
	str = str.replace("\"", "\\\"");
	}
	blackhole.consume(str);
	}

view raw A.java hosted with ❤ by GitHub

The results were quite astounding. I hadn’t expected something like the following:

Benchmark                            Mode  Cnt        Score   Error  Units
Benchmarks.jsonStringManual         thrpt    2    83301.447          ops/s
Benchmarks.jsonStringSerialization  thrpt    2  4171309.830          ops/s

There must be something wrong, right? Perhaps it’s because of the static string. Let’s replace our static string with a random one generated for each iteration:

	private static final ObjectMapper OM = new ObjectMapper();
	@Benchmark
	public void jsonStringSerialization(final Blackhole blackhole) throws Exception {
	byte[] obj = OM.writeValueAsBytes(randomString());
	blackhole.consume(new String(obj, 1, obj.length – 2, StandardCharsets.UTF_8));
	}
	@Benchmark
	public void jsonStringManual(final Blackhole blackhole) {
	String str = randomString();
	if (str.contains("\\")) {
	str = str.replace("\\", "\\\\");
	}
	if (str.contains("\"")) {
	str = str.replace("\"", "\\\"");
	}
	blackhole.consume(str);
	}
	private static String randomString() {
	return RandomStringUtils.random(75,
	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
	'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
	'y', 'z',
	'\\', '\r', '\n', '\"', '\'', ' ');
	}
	@Benchmark
	public void randomString(final Blackhole blackhole) {
	blackhole.consume(randomString());
	}

view raw A.java hosted with ❤ by GitHub

Here’s the JMH report:

Benchmark                            Mode  Cnt        Score   Error  Units
Benchmarks.jsonStringManual         thrpt    2   133432.951          ops/s
Benchmarks.jsonStringSerialization  thrpt    2  1535802.541          ops/s
Benchmarks.randomString             thrpt    2  2871443.990          ops/s

Conclusion

KISS. Premature optimisations are harmful. Not only can they introduce bugs, but they could be slower than the industry standard. Benchmark everything carefully.