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 and consistent patterns. It follows a logical organization where mutating methods throw UnsupportedOperationException and read methods return unmodifiable views, making intent explicit. Nesting is minimal, with simple if-else caching logic. Each method performs one action per line, and method names clearly convey purpose. The class-level Javadoc explains the caching caveat. Minor deductions: some methods like headerSet() have slightly complex stream chains, and the forEach implementation has a ternary expression that could be extracted for clarity. Overall, the code is concise, well-structured, and easy to follow.
Run 3
The code demonstrates strong readability through clear class structure, consistent formatting, and a logical organization of methods. The intent is explicit—enforcing immutability on an HttpHeaders variant—with each mutating method throwing UnsupportedOperationException in a predictable pattern. Nesting is minimal; caching logic uses simple if-else blocks, and method bodies are generally flat. Action granularity is appropriate, with one operation per line in most cases. The code is concise, avoiding unnecessary verbosity while maintaining clarity. Minor deductions arise from the extensive list of override methods that add visual repetition, and the headerSet() method’s stream pipeline, while readable, introduces slightly more complexity. Inline comments like 'No-op.' and 'Retain original ordering of entries' aid comprehension. Overall, the code follows a natural reading flow and is easy to scan and understand.
Run 1
Code Structure: Well-organized class with short, focused overrides, though related read and mutation methods could be grouped more consistently. Nesting: Shallow conditionals and a single loop keep complexity low; the nested collector expression is slightly harder to parse. Clarity of intent: The class name, documentation, descriptive identifiers, and explicit mutation exceptions clearly communicate read-only behavior and caching limitations. Code length: Mostly concise; repetitive mutation overrides are justified by the interface, while cache getters could omit their else branches after early returns. Action granularity: Statements generally perform one action per line, with only stream chaining and the forEach ternary combining several operations. Reading flow: Consistent formatting and familiar delegation patterns support smooth reading, although scattered mutation methods and the headerSet collector briefly interrupt the flow.
Run 2
Code Structure: Well-organized class with small, focused overrides, though read methods and mutation-blocking methods are somewhat interleaved. Nesting: Shallow conditionals and a single loop keep complexity low; cache getters could omit else after returning. Clarity of intent: The class name, documentation, descriptive identifiers, and explicit unsupported operations clearly communicate its read-only purpose and caching caveat. Code length: Most methods are concise; repeated mutation-blocking overrides add length but serve the inherited API. Action granularity: Statements generally perform one action per line, although the stream collector and forEach callback combine several operations. Reading flow: Consistent formatting and predictable override patterns make scanning easy; the headerSet collector requires slightly more effort to follow.
Run 3
Code Structure: Well-organized class with focused overrides, though read-only accessors and rejected 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, descriptive identifiers, and consistent UnsupportedOperationException behavior clearly communicate its purpose. Code length: Most methods are concise; repeated mutator overrides add length but are justified by the inherited API. The cache getters could omit their else blocks after early returns. Action granularity: Statements generally perform one action per line, with only stream chaining and the forEach ternary combining several operations. Reading flow: Consistent formatting and annotations support easy reading, although the headerSet collector and switching between accessors and mutators mildly interrupt the flow.