DataBufferLimitException: Limit für maximale Bytes zum Puffern des Webflux-Fehlers überschritten

Beim Senden einer Datei erhalte ich ein Array von Bytes. Ich habe immer ein Problem mit Webflux ein Array zu erhalten. Der Fehler wird wie folgt ausgelöst:

org.springframework.core.io.buffer.DataBufferLimitException: Exceeded limit on max bytes to buffer : 262144
    at org.springframework.core.io.buffer.LimitedDataBufferList.raiseLimitException(LimitedDataBufferList.java:101)
    Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException

Weißt du jetzt, wie man das in Webflux löst?

Das hat bei mir funktioniert:

1. Ein … kreieren @Bean in einer Ihrer Konfigurationsklassen oder der main SpringBootApplication Klasse:

   @Bean
   public WebClient webClient() {
       final int size = 16 * 1024 * 1024;
       final ExchangeStrategies strategies = ExchangeStrategies.builder()
           .codecs(codecs -> codecs.defaultCodecs().maxInMemorySize(size))
           .build();
       return WebClient.builder()
           .exchangeStrategies(strategies)
           .build();
   }
   

2. Gehen Sie als Nächstes zu Ihrer gewünschten Klasse, in der Sie die verwenden möchten WebClient:

   @Service
   public class TestService {
   
       @Autowired
       private WebClient webClient;
   
       public void test() {
           String out = webClient
               .get()
               .uri("/my/api/endpoint")
               .retrieve()
               .bodyToMono(String.class)
               .block();
   
           System.out.println(out);
       }
   }
   

Ich nehme an, bei diesem Problem geht es darum, eine neue hinzuzufügen spring.codec.max-in-memory-size Konfigurationseigenschaft in Spring Boot. Fügen Sie es hinzu application.yml Datei wie:

spring:
  codec:
    max-in-memory-size: 10MB

Stellen Sie das Maximum ein Byte (in Megabyte) in deiner Frühlingsstiefel application.properties Konfigurationsdatei wie unten:

spring.codec.max-in-memory-size=20MB

Ich habe diesen Fehler für einen einfachen RestController erhalten (ich poste eine große JSON-Zeichenfolge).

Hier ist, wie ich die erfolgreich geändert habe maxInMemorySize

import org.springframework.context.annotation.Configuration;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.config.ResourceHandlerRegistry;
import org.springframework.web.reactive.config.WebFluxConfigurer;

@Configuration
public class WebfluxConfig implements WebFluxConfigurer {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {

        registry.addResourceHandler("/swagger-ui.html**")
            .addResourceLocations("classpath:/META-INF/resources/");

        registry.addResourceHandler("/webjars/**")
            .addResourceLocations("classpath:/META-INF/resources/webjars/");
    }

    @Override
    public void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
        configurer.defaultCodecs().maxInMemorySize(16 * 1024 * 1024);
    }
}

das war überraschend schwer zu finden

hat bei mir funktioniert

webTestClient.mutate().codecs(configurer -> configurer
  .defaultCodecs()
  .maxInMemorySize(16 * 1024 * 1024)).build().get()
  .uri("/u/r/l")
  .exchange()
  .expectStatus()
  .isOk()

Anstatt Daten sofort abzurufen, können Sie Folgendes streamen:

Mono<String> string = webClient.get()
    .uri("end point of an API")
    .retrieve()
    .bodyToFlux(DataBuffer.class)
    .map(buffer -> {
        String string = buffer.toString(Charset.forName("UTF-8"));
        DataBufferUtils.release(buffer);
        return string;
    });

Alternativ in Stream umwandeln:

    .map(b -> b.asInputStream(true))
    .reduce(SequenceInputStream::new)
    .map(stream -> {
        // consume stream
        stream.close();
        return string;
    });

In den meisten Fällen möchten Sie den Stream nicht wirklich aggregieren, sondern ihn direkt verarbeiten. Die Notwendigkeit, große Datenmengen in den Speicher zu laden, ist meistens ein Zeichen dafür, den Ansatz zu einem reaktiveren zu ändern. JSON- und XML-Parser haben Streaming-Schnittstellen.

Das hat bei mir funktioniert

val exchangeStrategies = ExchangeStrategies.builder()
                .codecs { configurer: ClientCodecConfigurer -> configurer.defaultCodecs().maxInMemorySize(16 * 1024 * 1024) }.build()
        return WebClient.builder().exchangeStrategies(exchangeStrategies).build()