Java Examples for reactor.core.publisher.Flux

@Test
public void testNumbers() throws Exception {
    CamelReactiveStreamsService reactive = CamelReactiveStreams.get(context);
    // create a published that receive from the numbers stream
    Publisher<Integer> numbers = reactive.fromStream("numbers", Integer.class);
    // use stream engine to subscribe from the publisher
    // where we filter out the big numbers which is logged
    Flux.from(numbers).filter( n -> n > 5).doOnNext( c -> log.info("Streaming big number {}", c)).subscribe();
    // let it run for 10 seconds
    Thread.sleep(10000);
}

public Flux<Quote> fetchQuoteStream(Duration period) {
    return Flux.generate(() -> 0, (BiFunction<Integer, SynchronousSink<Quote>, Integer>) ( index,  sink) -> {
        Quote updatedQuote = updateQuote(prices.get(index));
        sink.next(updatedQuote);
        return ++index % prices.size();
    }).zipWith(Flux.interval(period)).map( t -> t.getT1()).map( quote -> {
        quote.setInstant(Instant.now());
        return quote;
    }).share().log();
}

static Flux<ServerSentEvent> decode(HttpClientResponse response) {
    return response.addHandler(createDecoder()).receive().asString().windowWhile( s -> !s.isEmpty(), // TODO: Remove Prefetch with reactor-core 3.0.6
    Integer.MAX_VALUE).concatMap( window -> window.reduce(ServerSentEvent.builder(), EventStreamCodec::parseLine)).map(ServerSentEvent.Builder::build).filter( sse -> sse.getData() != null || sse.getEventType() != null || sse.getId() != null || sse.getRetry() != null);
}

@Override
public Processor<Integer, Integer> createProcessor(int bufferSize) {
    Flux<String> otherStream = Flux.just("test", "test2", "test3");
    System.out.println("Providing new downstream");
    FluxProcessor<Integer, Integer> p = WorkQueueProcessor.create("fluxion-raw-fork", bufferSize);
    cumulated.set(0);
    cumulatedJoin.set(0);
    BiFunction<Integer, String, Integer> combinator = ( t1,  t2) -> t1;
    return FluxProcessor.wrap(p, p.groupBy( k -> k % 2 == 0).flatMap( stream -> stream.scan(( prev,  next) -> next).map( integer -> -integer).filter( integer -> integer <= 0).map( integer -> -integer).bufferTimeout(batch, Duration.ofMillis(50)).flatMap(Flux::fromIterable).doOnNext( array -> cumulated.getAndIncrement()).flatMap( i -> Flux.zip(Flux.just(i), otherStream, combinator)).doOnNext(this::monitorThreadUse)).doOnNext( array -> cumulatedJoin.getAndIncrement()).subscribeWith(TopicProcessor.create("fluxion-raw-join", bufferSize)).doOnError(Throwable::printStackTrace).awaitOnSubscribe());
}

@Override
public Flux<DataBuffer> encode(Publisher<? extends String> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Object... hints) {
    Charset charset;
    if (mimeType != null && mimeType.getCharset() != null) {
        charset = mimeType.getCharset();
    } else {
        charset = DEFAULT_CHARSET;
    }
    return Flux.from(inputStream).map( s -> {
        byte[] bytes = s.getBytes(charset);
        DataBuffer dataBuffer = bufferFactory.allocateBuffer(bytes.length);
        dataBuffer.write(bytes);
        return dataBuffer;
    });
}

@Override
public ObservableSender adapt(MessageChannel bindingTarget, MethodParameter parameter) {
    return new ObservableSender() {

        private FluxSender fluxSender = MessageChannelToObservableSenderParameterAdapter.this.messageChannelToFluxSenderArgumentAdapter.adapt(bindingTarget, parameter);

        @Override
        public Single<Void> send(Observable<?> observable) {
            Publisher<?> adaptedPublisher = RxReactiveStreams.toPublisher(observable);
            return RxReactiveStreams.toSingle(this.fluxSender.send(Flux.from(adaptedPublisher)));
        }
    };
}

@Test
public void decode() {
    DataBuffer fooBuffer = stringBuffer("foo");
    DataBuffer barBuffer = stringBuffer("bar");
    Flux<DataBuffer> source = Flux.just(fooBuffer, barBuffer);
    Flux<DataBuffer> output = this.decoder.decode(source, ResolvableType.forClassWithGenerics(Publisher.class, ByteBuffer.class), null, Collections.emptyMap());
    assertSame(source, output);
}

@Override
public Publisher<Event> apply(Publisher<Event> publisher) {
    Flux<Event> flux = from(publisher).map( event -> {
        try {
            return processRequest(event);
        } catch (MuleException e) {
            throw propagate(new MessagingException(event, e));
        }
    });
    flux = from(flux.transform(next));
    return flux.map( event -> {
        try {
            return processResponse(event);
        } catch (MuleException e) {
            throw propagate(new MessagingException(event, e));
        }
    });
}

/* (non-Javadoc)
	 * @see org.springframework.data.redis.connection.lettuce.LettuceReactiveStringCommands#bitOp(org.reactivestreams.Publisher)
	 */
@Override
public Flux<ReactiveRedisConnection.NumericResponse<BitOpCommand, Long>> bitOp(Publisher<BitOpCommand> commands) {
    return getConnection().execute( cmd -> Flux.from(commands).flatMap( command -> {
        List<ByteBuffer> keys = new ArrayList<>(command.getKeys());
        keys.add(command.getDestinationKey());
        if (ClusterSlotHashUtil.isSameSlotForAllKeys(keys)) {
            return super.bitOp(Mono.just(command));
        }
        return Mono.error(new InvalidDataAccessApiUsageException("All keys must map to the same slot for BITOP command."));
    }));
}

public Order getOrder(String orderId, Boolean validate) {
    // 获取订单
    Order order = orderRepositroy.findOne(orderId);
    if (validate) {
        // 验证事件对应的订单的账户号(account number)属于用户
        try {
            validateAccountNumber(order.getAccountNumber());
        } catch (Exception e) {
            return null;
        }
    }
    Flux<OrderEvent> orderEvents = Flux.fromStream(orderEventRepository.findOrderEventsByOrderId(orderId));
    // 聚合订单状态
    return orderEvents.takeWhile( orderEvent -> orderEvent.getType() != OrderEventType.DELIVERED).reduceWith(() -> order, Order::incorporate).get();
}

@Override
public void afterTestClass(TestContext testContext) {
    getServiceType(testContext).ifPresent( serviceType -> {
        Collection<Application> applications = getApplications(testContext);
        ServiceInstance serviceInstance = getServiceInstance(testContext, serviceType);
        Flux.fromIterable(applications).flatMap(( application) -> serviceInstance.unbind(application).doOnError( t -> this.logger.warn("Error while unbinding: {}", t.getMessage())).retryWhen(DelayUtils.exponentialBackOffError(Duration.ofSeconds(1), Duration.ofSeconds(10), Duration.ofMinutes(1)))).then().block(Duration.ofMinutes(1));
    });
}