SpringBoot Rest：Post请求Payload与Get响应的大小限制及配置

Great question! Let's break this down clearly—there's a common confusion between multipart file upload limits and raw JSON payload limits, so I'll cover both your main concerns step by step.

First off: yes, POST payloads do have default size limits, but they're controlled by your web server (not the spring.http.multipart.* config you mentioned). Those multipart settings are exclusively for multipart/form-data requests (direct file uploads), so they don't apply to your JSON payload with encoded file strings.

Spring Boot Configuration for JSON Payloads #

By default, servers like Tomcat (Spring Boot's default) set a 2MB limit for request bodies. If your encoded file pushes the JSON beyond this, you'll hit a SizeLimitExceededException or similar error. Here's how to adjust it:

Universal Spring Boot 2.0+ Config #

These settings work for most embedded servers (Tomcat, Jetty, Undertow):

# Disable multipart if you don't need file upload functionality
spring.servlet.multipart.enabled=false

# Set maximum size for the entire request body
server.max-http-request-size=50MB

# Tomcat-specific: explicitly set max POST size (matches above for consistency)
server.max-post-size=50MB

Or in YAML:

server:
  max-http-request-size: 50MB
  max-post-size: 50MB
spring:
  servlet:
    multipart:
      enabled: false

Server-Specific Fine-Tuning #

If you need more control for your specific server:

• Tomcat: Add server.tomcat.max-swallow-size=50MB to prevent Tomcat from truncating large request bodies.
• Jetty: Use server.jetty.max-http-post-size=50MB instead of server.max-post-size.

Adjust the 50MB value to match your maximum expected encoded file size—just make sure your server has enough memory to handle large payloads.

GET responses don't have a strict default size limit from most web servers, but there are a few things to watch out for:

• Server Memory: Large responses will consume server memory, so if you're returning huge payloads, consider using streaming (e.g., StreamingResponseBody in Spring Boot) to avoid out-of-memory errors.
• Client-Side Limits: Browsers have traditional URL length limits (2KB-8KB), but this doesn't apply to microservice-to-microservice calls (like using RestTemplate or WebClient).
• Client Configuration: If you're using Spring's RestTemplate to receive large responses, disable request body buffering to avoid memory issues:

  RestTemplate restTemplate = new RestTemplate();
  SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
  factory.setBufferRequestBody(false); // Stream large responses instead of buffering
  restTemplate.setRequestFactory(factory);
  

  For WebClient, use streaming to process chunks incrementally:

  WebClient.create()
    .get()
    .uri("your-microservice-url")
    .retrieve()
    .bodyToFlux(String.class)
    .subscribe(chunk -> {
      // Process each chunk of the large response
    });
  

• Use server.max-http-request-size (and server-specific settings) to adjust JSON POST payload limits—ignore the multipart config for this use case.
• GET responses have no hard default limit, but optimize with streaming for large payloads to avoid memory problems.

内容的提问来源于stack exchange，提问作者Baba