Performance: Optimize toString() methods with StringBuilder

[cwangg897]

Expected Behavior

The toString() methods in ContainerProperties and ConsumerProperties should use StringBuilder for efficient string building, resulting in O(n) memory complexity and minimal temporary object creation during configuration debugging.

Current Behavior

Both ContainerProperties.toString() and ConsumerProperties.renderProperties() use extensive string concatenations (50+ total) with the + operator:

// ContainerProperties.toString() - 40+ concatenations
return "ContainerProperties [" + renderProperties() + "\n ackMode=" + this.ackMode + ...

// ConsumerProperties.renderProperties() - 10+ concatenations
return renderTopics() + "\n pollTimeout=" + this.pollTimeout + ...

This creates O(n²) memory complexity and excessive temporary String objects, causing performance issues during configuration logging and debugging.

Related Code Locations

• spring-kafka/src/main/java/org/springframework/kafka/listener/ContainerProperties.java:toString()
• spring-kafka/src/main/java/org/springframework/kafka/listener/ConsumerProperties.toString()

Context
This issue affects Spring Boot applications during:

• Container startup when configurations are logged
• Debugging sessions when examining container properties
• Troubleshooting scenarios requiring configuration dumps

The performance impact is noticeable in applications with frequent configuration logging or debug-level logging enabled.

I'm trying to improve the debugging experience for Spring Kafka users by eliminating unnecessary memory allocations and GC pressure.

Current workaround: Avoid calling toString() in production, but this limits debugging capabilities.

I have already implemented the StringBuilder solution and can provide a PR if this improvement is welcomed.

[artembilan]

Hm. I remember back in days Java compiler was smart enough to convert those string concatenation to StringBuilder.
Right, now this is what I see after decompilation of ConsumerProperties.class:

    public String toString() {
        return "ConsumerProperties [" + this.renderProperties() + "]";
    }

    protected final String renderProperties() {
        String var10000 = this.renderTopics();
        return var10000 + "\n pollTimeout=" + this.pollTimeout + (this.groupId != null ? "\n groupId=" + this.groupId : "") + (StringUtils.hasText(this.clientId) ? "\n clientId=" + this.clientId : "") + (this.consumerRebalanceListener != null ? "\n consumerRebalanceListener=" + String.valueOf(this.consumerRebalanceListener) : "") + (this.commitCallback != null ? "\n commitCallback=" + String.valueOf(this.commitCallback) : "") + (this.offsetAndMetadataProvider != null ? "\n offsetAndMetadataProvider=" + String.valueOf(this.offsetAndMetadataProvider) : "") + "\n syncCommits=" + this.syncCommits + (this.syncCommitTimeout != null ? "\n syncCommitTimeout=" + String.valueOf(this.syncCommitTimeout) : "") + (!this.kafkaConsumerProperties.isEmpty() ? "\n properties=" + String.valueOf(this.kafkaConsumerProperties) : "") + "\n authExceptionRetryInterval=" + String.valueOf(this.authExceptionRetryInterval) + "\n commitRetries=" + this.commitRetries + "\n fixTxOffsets" + this.fixTxOffsets;
    }

    private String renderTopics() {
        String var10000 = this.topics != null ? "\n topics=" + Arrays.toString(this.topics) : "";
        return var10000 + (this.topicPattern != null ? "\n topicPattern=" + String.valueOf(this.topicPattern) : "") + (this.topicPartitions != null ? "\n topicPartitions=" + Arrays.toString(this.topicPartitions) : "");
    }

Or am I just dreaming about compiler optimization: https://medium.com/javarevisited/java-compiler-optimization-for-string-concatenation-7f5237e5e6ed ?
Or our concatenations are too complex for compiler to outperform?

WDYT?

We will look into your contribution latter.
Thanks

[cwangg897]

@artembilan

Based on the Baeldung reference (https://www.baeldung.com/java-string-concatenation-methods), here are the Java Compiler String Concatenation Optimization Limitations:
Compiler Optimization Limitations:

Only simple concatenations are converted to StringBuilder
Conditional concatenations and method call inclusions are not optimized
Complex logic mixed in causes the compiler to give up optimization

[artembilan]

Love it!
I think I'll do a sticker for this somewhere to follow these rules for my toString() from now on.
Thank you!

[artembilan]

Does that mean that even this simple one is not optimized:

	@Override
	public String toString() {
		return super.toString() + " [record=" + this.record + "]";
	}

?
There is a method call inclusion and then simple concatenation without any conditions.

[cwangg897]

I believe there are no performance issues even if you use a lot of + operators in a single-line toString method, since everything is concatenated in one expression. However, I think it’s best to check by actually decompiling and analyzing the bytecode to be sure.

So, if there are more than 10 concatenations, I use StringBuilder to be on the safe side.

[cwangg897]

@artembilan
Hi, I submitted PR #4013 for this issue.
Are there any additional changes or improvements you'd like me to make?