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
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
@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
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 vote down vote up
@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
/**
 * 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 vote down vote up
@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
/**
 * 参考了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
@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 vote down vote up
@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
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
@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
@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
@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
@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
@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
@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
@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
@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
@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
@Override
public Flux<?> executeRequest(ReactiveHttpRequest request) {
	Mono<ReactiveHttpResponse> response = reactiveHttpClient.executeRequest(request);
	return response.flatMapMany(ReactiveHttpResponse::body);
}