Java Code Examples for reactor.core.publisher.Mono#flatMapMany()

The following examples show how to use reactor.core.publisher.Mono#flatMapMany() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example 1

Source Project: alibaba-rsocket-broker File: RSocketBrokerResponderHandler.java License: Apache License 2.0

6 votes

public Flux<Payload> requestChannel(Payload signal, Publisher<Payload> payloads) {
    BinaryRoutingMetadata binaryRoutingMetadata = binaryRoutingMetadata(signal.metadata());
    GSVRoutingMetadata gsvRoutingMetadata;
    if (binaryRoutingMetadata != null) {
        gsvRoutingMetadata = GSVRoutingMetadata.from(new String(binaryRoutingMetadata.getRoutingText(), StandardCharsets.UTF_8));
    } else {
        RSocketCompositeMetadata compositeMetadata = RSocketCompositeMetadata.from(signal.metadata());
        gsvRoutingMetadata = compositeMetadata.getRoutingMetaData();
        if (gsvRoutingMetadata == null) {
            return Flux.error(new InvalidException(RsocketErrorCode.message("RST-600404")));
        }
    }
    Mono<RSocket> destination = findDestination(gsvRoutingMetadata);
    return destination.flatMapMany(rsocket -> {
        recordServiceInvoke(principal.getName(), gsvRoutingMetadata.gsv());
        metrics(gsvRoutingMetadata, "0x07");
        return rsocket.requestChannel(payloads);
    });
}

Example 2

Source Project: alibaba-rsocket-broker File: UpstreamForwardRSocket.java License: Apache License 2.0

6 votes

@Override
public @NotNull Flux<Payload> requestStream(@NotNull Payload payload) {
    BinaryRoutingMetadata binaryRoutingMetadata = binaryRoutingMetadata(payload.metadata());
    GSVRoutingMetadata gsvRoutingMetadata;
    if (binaryRoutingMetadata != null) {
        gsvRoutingMetadata = GSVRoutingMetadata.from(new String(binaryRoutingMetadata.getRoutingText(), StandardCharsets.UTF_8));
    } else {
        RSocketCompositeMetadata compositeMetadata = RSocketCompositeMetadata.from(payload.metadata());
        gsvRoutingMetadata = compositeMetadata.getRoutingMetaData();
        if (gsvRoutingMetadata == null) {
            return Flux.error(new InvalidException(RsocketErrorCode.message("RST-600404")));
        }
    }
    Mono<RSocket> destination = findDestination(gsvRoutingMetadata);
    if (this.filterChain.isFiltersPresent()) {
        RSocketExchange requestContext = new RSocketExchange(FrameType.REQUEST_STREAM, gsvRoutingMetadata, payload, this.upstreamBrokerMetadata);
        destination = filterChain.filter(requestContext).then(destination);
    }
    return destination.flatMapMany(rsocket -> {
        metrics(gsvRoutingMetadata, "0x06");
        return rsocket.requestStream(payload);
    });
}

Example 3

Source Project: alibaba-rsocket-broker File: UpstreamForwardRSocket.java License: Apache License 2.0

6 votes

public Flux<Payload> requestChannel(Payload signal, Publisher<Payload> payloads) {
    BinaryRoutingMetadata binaryRoutingMetadata = binaryRoutingMetadata(signal.metadata());
    GSVRoutingMetadata gsvRoutingMetadata;
    if (binaryRoutingMetadata != null) {
        gsvRoutingMetadata = GSVRoutingMetadata.from(new String(binaryRoutingMetadata.getRoutingText(), StandardCharsets.UTF_8));
    } else {
        RSocketCompositeMetadata compositeMetadata = RSocketCompositeMetadata.from(signal.metadata());
        gsvRoutingMetadata = compositeMetadata.getRoutingMetaData();
        if (gsvRoutingMetadata == null) {
            return Flux.error(new InvalidException(RsocketErrorCode.message("RST-600404")));
        }
    }
    Mono<RSocket> destination = findDestination(gsvRoutingMetadata);
    return destination.flatMapMany(rsocket -> {
        metrics(gsvRoutingMetadata, "0x07");
        return rsocket.requestChannel(payloads);
    });
}

Example 4

Source Project: staccato File: GrpcApiService.java License: Apache License 2.0

6 votes

@Override
public Flux<ApiItemBytes> search(Mono<ApiRequest> request) {
    log.debug("Incoming gRPC api request.");

    return request
            //double[] bbox, String datetime, String query, Integer limit, Integer next, FieldsExtension fields, String[] ids, String[] collections, Object intersects
            .flatMapMany(r -> {
                        try {
                            return apiService.getItemsFlux(SearchRequestUtils.generateSearchRequest(Doubles.toArray(r.getBboxList()),
                                    r.getTime(), r.getSearch(), r.getLimit(), r.getNext(),
                                    mapper.readValue(r.getFields(), FieldsExtension.class),
                                    r.getIdsList().toArray(new String[r.getIdsCount()]),
                                    r.getCollectionsList().toArray(new String[r.getCollectionsCount()]),
                                    r.getIntersects(), null))
                                    .map(item -> SerializationUtils.serializeItem(item, mapper))
                                    .map(item -> ApiItemBytes.newBuilder().setItem(ByteString.copyFrom(item)).build());
                        } catch (IOException e) {
                            return Mono.error(new RuntimeException("Error deserializing fields property.", e));
                        }
                    }
            );
}

Example 5

Source Project: reactive-grpc File: ClientCalls.java License: BSD 3-Clause "New" or "Revised" License

6 votes

/**
 * Implements a unary → stream call as {@link Mono} → {@link Flux}, where the server responds with a
 * stream of messages.
 */
public static <TRequest, TResponse> Flux<TResponse> oneToMany(
        Mono<TRequest> monoSource,
        BiConsumer<TRequest, StreamObserver<TResponse>> delegate,
        CallOptions options) {
    try {

        final int prefetch = ReactorCallOptions.getPrefetch(options);
        final int lowTide = ReactorCallOptions.getLowTide(options);

        return monoSource
                .flatMapMany(request -> {
                    ReactorClientStreamObserverAndPublisher<TResponse> consumerStreamObserver =
                        new ReactorClientStreamObserverAndPublisher<>(null, null, prefetch, lowTide);

                    delegate.accept(request, consumerStreamObserver);

                    return consumerStreamObserver;
                });
    } catch (Throwable throwable) {
        return Flux.error(throwable);
    }
}

Example 6

Source Project: sdn-rx File: Neo4jQueryExecution.java License: Apache License 2.0

5 votes

@Override
public Object execute(PreparedQuery preparedQuery, boolean asCollectionQuery) {

	Mono<ReactiveNeo4jOperations.ExecutableQuery> executableQuery = neo4jOperations
		.toExecutableQuery(preparedQuery);
	if (asCollectionQuery) {
		return executableQuery.flatMapMany(q -> q.getResults());
	} else {
		return executableQuery.flatMap(q -> q.getSingleResult());
	}
}

Example 7

Source Project: light-security File: ReactivePreAuthorizeAspect.java License: Apache License 2.0

5 votes

/**
 * 参考了org.springframework.security.access.prepost.PrePostAdviceReactiveMethodInterceptor#invoke的写法
 *
 * @param point 切点
 * @return obj
 */
@Around("@annotation(com.itmuch.lightsecurity.annotation.PreAuthorize) ")
public Object preAuth(ProceedingJoinPoint point) {
    MethodSignature signature = (MethodSignature) point.getSignature();
    Method method = signature.getMethod();
    if (method.isAnnotationPresent(PreAuthorize.class)) {
        PreAuthorize preAuthorize = method.getAnnotation(PreAuthorize.class);

        String expression = preAuthorize.value();
        Mono<Boolean> mono = ReactiveSpringElCheckUtil.check(
                new StandardEvaluationContext(reactivePreAuthorizeExpressionRoot),
                expression)
                .filter(t -> t)
                .switchIfEmpty(Mono.defer(() -> Mono.error(new LightSecurityException("Access Denied."))));

        Class<?> returnType = method.getReturnType();

        if (Mono.class.isAssignableFrom(returnType)) {
            return mono
                    .flatMap(
                            auth -> this.proceed(point)
                    );
        }

        if (Flux.class.isAssignableFrom(returnType)) {
            return mono
                    .flatMapMany(
                            auth -> this.<Flux<?>>proceed(point)
                    );
        }

        return mono
                .flatMapMany(auth -> Flux.from(
                        this.proceed(point))
                );

    }
    return this.proceed(point);
}

Example 8

Source Project: redisson File: RedissonReactiveSetCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<ByteBuffer> sPop(SPopCommand command) {
    Assert.notNull(command.getKey(), "Key must not be null!");
    
    byte[] keyBuf = toByteArray(command.getKey());
    Mono<Set<byte[]>> m = write(keyBuf, ByteArrayCodec.INSTANCE, RedisCommands.SPOP, keyBuf, command.getCount());
    return m.flatMapMany(v -> Flux.fromIterable(v).map(e -> ByteBuffer.wrap(e)));
}

Example 9

Source Project: java-technology-stack File: XmlEventDecoder.java License: MIT License

5 votes

@Override
@SuppressWarnings({"rawtypes", "unchecked"})  // on JDK 9 where XMLEventReader is Iterator<Object>
public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType,
		@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {

	Flux<DataBuffer> flux = Flux.from(inputStream);
	if (this.useAalto) {
		AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent();
		return flux.flatMap(aaltoMapper)
				.doFinally(signalType -> aaltoMapper.endOfInput());
	}
	else {
		Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux);
		return singleBuffer.
				flatMapMany(dataBuffer -> {
					try {
						InputStream is = dataBuffer.asInputStream();
						Iterator eventReader = inputFactory.createXMLEventReader(is);
						return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader)
								.doFinally(t -> DataBufferUtils.release(dataBuffer));
					}
					catch (XMLStreamException ex) {
						return Mono.error(ex);
					}
				});
	}
}

Example 10

Source Project: feign-reactive File: ReactiveHttpClient.java License: Apache License 2.0

5 votes

default Publisher<Object> executeRequest(ReactiveHttpRequest request, Type returnPublisherType) {
  Mono<ReactiveHttpResponse> response = executeRequest(request);
  if (returnPublisherType == Mono.class) {
    return response.flatMap(resp -> (Mono<Object>) resp.body());
  } else {
    return response.flatMapMany(ReactiveHttpResponse::body);
  }
}

Example 11

Source Project: reactive-grpc File: EndToEndIntegrationTest.java License: BSD 3-Clause "New" or "Revised" License

5 votes

@Override
public Flux<HelloResponse> sayHelloRespStream(Mono<HelloRequest> reactorRequest) {
    return reactorRequest.flatMapMany(protoRequest -> Flux.just(
            greet("Hello", protoRequest),
            greet("Hi", protoRequest),
            greet("Greetings", protoRequest)));
}

Example 12

Source Project: reactor-netty File: WebsocketFinalizer.java License: Apache License 2.0

5 votes

@Override
public <V> Flux<V> handle(BiFunction<? super WebsocketInbound, ? super WebsocketOutbound, ? extends Publisher<V>> receiver) {
	@SuppressWarnings("unchecked")
	Mono<WebsocketClientOperations> connector = (Mono<WebsocketClientOperations>) connect();
	return connector.flatMapMany(c -> Flux.from(receiver.apply(c, c))
	                                      .doFinally(s -> HttpClientFinalizer.discard(c)));
}

Example 13

Source Project: redisson File: RedissonReactiveClusterServerCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}

Example 14

Source Project: redisson File: RedissonReactiveSetCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<ByteBuffer> sPop(SPopCommand command) {
    Assert.notNull(command.getKey(), "Key must not be null!");
    
    byte[] keyBuf = toByteArray(command.getKey());
    Mono<Set<byte[]>> m = write(keyBuf, ByteArrayCodec.INSTANCE, RedisCommands.SPOP, keyBuf, command.getCount());
    return m.flatMapMany(v -> Flux.fromIterable(v).map(e -> ByteBuffer.wrap(e)));
}

Example 15

Source Project: redisson File: RedissonReactiveClusterServerCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}

Example 16

Source Project: redisson File: RedissonReactiveSetCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<ByteBuffer> sPop(SPopCommand command) {
    Assert.notNull(command.getKey(), "Key must not be null!");
    
    byte[] keyBuf = toByteArray(command.getKey());
    Mono<Set<byte[]>> m = write(keyBuf, ByteArrayCodec.INSTANCE, RedisCommands.SPOP, keyBuf, command.getCount());
    return m.flatMapMany(v -> Flux.fromIterable(v).map(e -> ByteBuffer.wrap(e)));
}

Example 17

Source Project: redisson File: RedissonReactiveClusterServerCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}

Example 18

Source Project: redisson File: RedissonReactiveSetCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<ByteBuffer> sPop(SPopCommand command) {
    Assert.notNull(command.getKey(), "Key must not be null!");
    
    byte[] keyBuf = toByteArray(command.getKey());
    Mono<Set<byte[]>> m = write(keyBuf, ByteArrayCodec.INSTANCE, RedisCommands.SPOP, keyBuf, command.getCount());
    return m.flatMapMany(v -> Flux.fromIterable(v).map(e -> ByteBuffer.wrap(e)));
}

Example 19

Source Project: redisson File: RedissonReactiveClusterServerCommands.java License: Apache License 2.0

5 votes

@Override
public Flux<RedisClientInfo> getClientList(RedisClusterNode node) {
    MasterSlaveEntry entry = getEntry(node);
    Mono<List<String>> m = executorService.reactive(() -> {
        return executorService.readAsync(entry, StringCodec.INSTANCE, RedisCommands.CLIENT_LIST);
    });
    return m.flatMapMany(s -> Flux.fromIterable(CONVERTER.convert(s.toArray(new String[s.size()]))));
}

Example 20

Source Project: feign-reactive File: FluxPublisherHttpClient.java License: Apache License 2.0

4 votes

@Override
public Flux<?> executeRequest(ReactiveHttpRequest request) {
	Mono<ReactiveHttpResponse> response = reactiveHttpClient.executeRequest(request);
	return response.flatMapMany(ReactiveHttpResponse::body);
}