Java FluxSink类代码示例

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Test
public void test4() {
    SomeFeed<PriceTick> feed = new SomeFeed<>();
    Flux<Object> priceFlux = Flux.create(emitter ->
    {
        SomeListener l = new SomeListener() {
            @Override
            public void priceTick(PriceTick event) {
                emitter.next(event);
            }

            @Override
            public void error(Throwable throwable) {
                emitter.error(throwable);
            }

        };
        feed.register(l);
    }, FluxSink.OverflowStrategy.LATEST);
    ConnectableFlux<Object> connectableFlux = priceFlux.publish();
    connectableFlux.connect();
    connectableFlux.subscribe(System.out::println);
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
public CommentController(MeterRegistry meterRegistry) {
	this.meterRegistry = meterRegistry;
	this.flux = Flux.<Message<Comment>>create(
		emitter -> this.commentSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
		.publish()
		.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Test
public void test() throws InterruptedException {
    SomeFeed<PriceTick> feed = new SomeFeed<>();
    Flux<PriceTick> flux =
            Flux.create(emitter ->
            {
                SomeListener listener = new SomeListener() {
                    @Override
                    public void priceTick(PriceTick event) {
                        emitter.next(event);
                        if (event.isLast()) {
                            emitter.complete();
                        }
                    }

                    @Override
                    public void error(Throwable e) {
                        emitter.error(e);
                    }
                };
                        feed.register(listener);
    }, FluxSink.OverflowStrategy.LATEST);
    ConnectableFlux connectable = flux.publish();
    connectable.subscribe(x -> System.out.println("1st " + x));
    Thread.sleep(1000);
    connectable.subscribe(x -> System.out.println("2nd " + x));
    connectable.connect();

}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Override public void accept(FluxSink<Response<T>> sink) {
  // Since Call is a one-shot type, clone it for each new subscriber.
  Call<T> call = originalCall.clone();

  sink.onDispose(call::cancel);

  Response<T> response;
  try {
    response = call.execute();
  } catch (IOException e) {
    sink.error(e);
    return;
  }
  sink.next(response);
  sink.complete();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Override public Object adapt(Call<R> call) {
  Consumer<FluxSink<Response<R>>> consumer = isAsync
      ? new EnqueueSinkConsumer<>(call)
      : new ExecuteSinkConsumer<>(call);
  Flux<Response<R>> responseFlux = Flux.create(consumer, LATEST);

  Flux<?> flux;
  if (isResult) {
    flux = new ResultFlux<>(responseFlux);
  } else if (isBody) {
    flux = new BodyFlux<>(responseFlux);
  } else {
    flux = responseFlux;
  }

  if (scheduler != null) {
    flux = flux.subscribeOn(scheduler);
  }

  if (isMono) {
    return flux.single();
  }
  return flux;
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
public Runnable burstyProducerRunnable(final FluxSink<Object> emitter, int count, int
		burstSize) {
	return () -> {

		// Let's start with some messages to keep the ringbuffer from going total empty
		for (int i = 0; i < INITAL_MESSAGES_COUNT; ++i) {
			emitter.next("initial" + i);
		}

		for (int outer=0; outer<count/burstSize; ++outer) {
			for (int inner=0; inner<burstSize; ++inner) {
				emitter.next(outer*burstSize+inner);
			}
			sleep(PRODUCER_LATENCY * burstSize);
		}
	};
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
/**
 * Return a Publisher of type T out of the the hystrix command.
 *
 * @param clazz the wanted stream type.
 * @param mapper the object mapper used to parse objects.
 * @param command the hystrix command to deal with.
 * @param <T> the type of objects to stream.
 * @return a Publisher<T></T> out of the hystrix command response body.
 */
public static <T> Publisher<T> toPublisher(final Class<T> clazz, final ObjectMapper mapper,
        final HystrixCommand<InputStream> command) {
    AtomicInteger count = new AtomicInteger(0);
    return Flux.create(sink -> {
        final Observable<InputStream> observable = command.toObservable();
        observable.map(i -> {
            try {
                return mapper.readerFor(clazz).<T> readValues(i);
            } catch (IOException e) {
                throw new TDPException(CommonErrorCodes.UNEXPECTED_EXCEPTION, e);
            }
        }) //
        .doOnCompleted(() -> LOGGER.debug("Completed command '{}' (emits '{}') with '{}' records.", command.getClass().getName(), clazz.getName(), count.get())) //
        .toBlocking() //
        .forEach(s -> {
            while (s.hasNext()) {
                sink.next(s.next());
                count.incrementAndGet();
            }
            sink.complete();
        });
    }, FluxSink.OverflowStrategy.BUFFER);
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
public CommentController(MeterRegistry meterRegistry) {
	this.meterRegistry = meterRegistry;
	this.flux = Flux.<Message<Comment>>create(
		emitter -> this.commentSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
			.publish()
			.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
CommentService(ObjectMapper mapper) {
	this.mapper = mapper;
	this.flux = Flux.<Comment>create(
		emitter -> this.webSocketCommentSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
		.publish()
		.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
public OutboundChatService() {
	this.flux = Flux.<Message<String>>create(
		emitter -> this.chatMessageSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
		.publish()
		.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
public OutboundChatService() {
	this.flux = Flux.<String>create(
		emitter -> this.chatMessageSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
		.publish()
		.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
CommentService(ObjectMapper mapper) {
	this.mapper = mapper;
	this.flux = Flux.<Comment>create(
		emitter -> this.webSocketCommentSink = emitter,
		FluxSink.OverflowStrategy.IGNORE)
			.publish()
			.autoConnect();
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
private void emmit(FluxSink<Message> emitter, String roomId) {
    HttpClient
            .create()
            .get("https://stream.gitter.im/v1/rooms/" + roomId + "/chatMessages",
                    (r) -> r.addHeader("Authorization", "Bearer 3cd4820adf59b6a7116f99d92f68a1b786895ce7"))
            .flatMapMany(HttpClientResponse::receiveContent)
            .map(ByteBufHolder::content)
            .filter(bb -> bb.capacity() > 2)
            .map(MessageEncoder::mapToMessage)
            .doOnNext(m -> System.out.println("Log Emit: " + m))
            .subscribe(emitter::next, emitter::error, emitter::complete);
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Override public void accept(FluxSink<Response<T>> sink) {
  // Since Call is a one-shot type, clone it for each new subscriber.
  Call<T> call = originalCall.clone();

  DisposableCallback<T> callback = new DisposableCallback<>(call, sink);
  sink.onDispose(callback);
  call.enqueue(callback);
}
 

import reactor.core.publisher.FluxSink; //导入依赖的package包/类
@Before
public void setUp() {
    crazedFlux = Flux.create(new Consumer<FluxSink<Integer>>() {
        @Override
        public void accept(FluxSink<Integer> sink) {
            int i = 0;
            //noinspection InfiniteLoopStatement
            while (true) {
                sink.next(i);
                i++;
            }
        }
    }, FluxSink.OverflowStrategy.DROP);
}