Source code
package org.springframework.http;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import org.jspecify.annotations.Nullable;
import org.springframework.util.CollectionUtils;
import org.springframework.util.MultiValueMap;
/**
* {@code HttpHeaders} variant that can only be read, not written to.
*
* <p>This caches the parsed representations of the "Accept" and "Content-Type"
* headers and will get out of sync with the backing map if it is mutated at runtime.
*
* @author Brian Clozel
* @author Sam Brannen
* @since 5.1.1
*/
class ReadOnlyHttpHeaders extends HttpHeaders {
private static final long serialVersionUID = -8578554704772377436L;
private @Nullable MediaType cachedContentType;
@SuppressWarnings("serial")
private @Nullable List<MediaType> cachedAccept;
ReadOnlyHttpHeaders(MultiValueMap<String, String> headers) {
super(headers);
}
@Override
public @Nullable MediaType getContentType() {
if (this.cachedContentType != null) {
return this.cachedContentType;
}
else {
MediaType contentType = super.getContentType();
this.cachedContentType = contentType;
return contentType;
}
}
@Override
public List<MediaType> getAccept() {
if (this.cachedAccept != null) {
return this.cachedAccept;
}
else {
List<MediaType> accept = super.getAccept();
this.cachedAccept = accept;
return accept;
}
}
@Override
public void clearContentHeaders() {
// No-op.
}
@Override
public @Nullable List<String> get(String headerName) {
List<String> values = this.headers.get(headerName);
return (values != null ? Collections.unmodifiableList(values) : null);
}
@Override
public void add(String headerName, @Nullable String headerValue) {
throw new UnsupportedOperationException();
}
@Override
public void addAll(String key, List<? extends String> headerValues) {
throw new UnsupportedOperationException();
}
@Override
public void addAll(HttpHeaders values) {
throw new UnsupportedOperationException();
}
@Override
public void set(String headerName, @Nullable String headerValue) {
throw new UnsupportedOperationException();
}
@Override
public void setAll(Map<String, String> values) {
throw new UnsupportedOperationException();
}
@Override
public Map<String, String> toSingleValueMap() {
return Collections.unmodifiableMap(this.headers.toSingleValueMap());
}
@SuppressWarnings("removal")
@Override
@Deprecated(since = "7.0", forRemoval = true)
public Map<String, String> asSingleValueMap() {
return Collections.unmodifiableMap(this.headers.asSingleValueMap());
}
@SuppressWarnings("removal")
@Override
@Deprecated(since = "7.0", forRemoval = true)
public MultiValueMap<String, String> asMultiValueMap() {
return CollectionUtils.unmodifiableMultiValueMap(this.headers);
}
@Override
public Set<String> headerNames() {
return Collections.unmodifiableSet(super.headerNames());
}
@Override
public List<String> put(String key, List<String> value) {
throw new UnsupportedOperationException();
}
@Override
public @Nullable List<String> putIfAbsent(String headerName, List<String> headerValues) {
throw new UnsupportedOperationException();
}
@Override
public void putAll(@Nullable HttpHeaders values) {
throw new UnsupportedOperationException();
}
@Override
public void putAll(Map<? extends String, ? extends List<String>> headers) {
throw new UnsupportedOperationException();
}
@Override
public List<String> remove(String key) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
throw new UnsupportedOperationException();
}
@Override
public Set<Entry<String, List<String>>> headerSet() {
return super.headerSet().stream().map(SimpleImmutableEntry::new)
.collect(Collectors.collectingAndThen(
Collectors.toCollection(LinkedHashSet::new), // Retain original ordering of entries
Collections::unmodifiableSet));
}
@Override
public void forEach(BiConsumer<? super String, ? super List<String>> action) {
for (String name : this.headers.keySet()) {
List<String> values = this.headers.get(name);
action.accept(name, (values != null ? Collections.unmodifiableList(values) : Collections.emptyList()));
}
}
}
Run 1
This code is highly readable. Structure is logical, grouping mutating methods that throw exceptions and read methods that return unmodifiable views. Nesting is minimal, with simple if-else caching blocks and a small lambda pipeline. Intent is clear: a read-only wrapper offering cached parsed headers and defensive copies. Code length is appropriate, with small focused methods. Action granularity is mostly one action per line; the headerSet lambda and forEach expression are slightly denser but still understandable. Reading flow is natural, following class declaration, caching methods, no-op overrides, mutators, accessors, and iteration helpers.
Run 2
The code is highly readable due to its clear structure, flat nesting, and consistent patterns. Each method has a single responsibility, following the 'one action per line' principle well. The class purpose is clearly documented, and method names/intents are self-evident. Error handling for immutable operations is concise and uniform. The caching logic in getContentType() and getAccept() is straightforward, though slightly verbose—could be compacted with ternary or helper method but remains clear. headerSet() introduces moderate complexity with streams but is well-commented for ordering rationale. Imports are logical and no unnecessary length is present. Overall, the code reads naturally from top to bottom, with minimal nesting (only one level) and no tangled logic.
Run 3
The code is highly readable, well-structured, and follows consistent patterns. The class has a clear single responsibility (immutable HttpHeaders wrapper), with methods logically grouped by mutating vs non-mutating operations. Nesting is minimal—only simple if/else blocks for caching. Intent is explicit throughout: mutating methods throw UnsupportedOperationException, while read methods wrap returned collections in unmodifiable views. Code length is justified by the API surface required. Each method performs one action clearly. The only slightly complex method is headerSet(), which uses a stream pipeline with a comment clarifying ordering intent, but it remains readable. The class-level Javadoc appropriately documents the caching caveat. Naming follows standard Java/Spring conventions. Overall, the code is maintainable and self-explanatory.
Run 1
Code Structure: Well-organized class with short, focused overrides, though grouping all mutators together would improve organization. Nesting: Shallow conditionals and a single loop keep complexity low; redundant else blocks could be removed. Clarity of intent: The class name, documentation, descriptive identifiers, and consistent exceptions clearly communicate read-only behavior and caching limitations. Code length: Most methods are concise; repetitive mutation-blocking overrides add length but serve the interface contract. Action granularity: Statements generally perform one action each, although the headerSet stream pipeline combines several transformations. Reading flow: Consistent formatting and familiar override patterns make scanning easy. The nested collectors in headerSet and scattered read/write methods slightly interrupt an otherwise natural flow.
Run 2
Code Structure: Well-organized class with focused overrides, though read methods and prohibited mutators are somewhat interleaved. Nesting: Shallow conditionals and a single loop keep complexity low; the nested collector expression is slightly harder to scan. Clarity of intent: The class name, documentation, unmodifiable wrappers, and explicit exceptions clearly communicate read-only behavior and caching limitations. Code length: Most methods are concise; repeated exception-only overrides add length but are justified by the inherited API. The cache getters could omit their else branches after early returns. Action granularity: Statements generally perform one action per line, although stream chaining and the conditional argument in forEach combine several operations. Reading flow: Consistent formatting, annotations, and descriptive names support natural reading, with minor friction from method ordering and the headerSet collector.
Run 3
Code Structure: Well-organized class with short overrides, though read operations and mutation-blocking methods are somewhat interspersed. Nesting: Shallow conditionals and a single loop make control flow easy to follow; caching methods could omit their redundant else branches. Clarity of intent: The class name, documentation, descriptive identifiers, and consistent exceptions clearly express read-only behavior and caching limitations. Code length: Mostly concise; repeated exception-throwing overrides add length but are justified by the inherited API. Action granularity: Statements generally perform one action each, although headerSet combines several transformations in a denser stream pipeline. Reading flow: Consistent formatting and predictable method implementations support smooth reading, with minor interruptions from annotations, repeated boilerplate, and the collector expression.