Java CoreSubscriber.onSubscribe方法代码示例

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public final void subscribe(final CoreSubscriber<? super Void> s) {
	if(future.isDone()){
		if(future.isSuccess()){
			Operators.complete(s);
		}
		else{
			Operators.error(s, future.cause());
		}
		return;
	}

	FutureSubscription<F> fs = new FutureSubscription<>(future, s);
	s.onSubscribe(fs);
	future.addListener(fs);
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super R> actual) {

	JoinSubscription<TLeft, TRight, TLeftEnd, TRightEnd, R> parent =
			new JoinSubscription<>(actual,
					leftEnd,
					rightEnd,
					resultSelector,
					queueSupplier.get());

	actual.onSubscribe(parent);

	LeftRightSubscriber left = new LeftRightSubscriber(parent, true);
	parent.cancellations.add(left);
	LeftRightSubscriber right = new LeftRightSubscriber(parent, false);
	parent.cancellations.add(right);

	source.subscribe(left);
	other.subscribe(right);
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super C> actual) {
	C buffer;

	try {
		buffer = Objects.requireNonNull(bufferSupplier.get(),
				"The bufferSupplier returned a null buffer");
	}
	catch (Throwable e) {
		Operators.error(actual, Operators.onOperatorError(e, actual.currentContext()));
		return;
	}

	BufferBoundaryMain<T, U, C> parent =
			new BufferBoundaryMain<>(
					source instanceof FluxInterval ?
							actual : Operators.serialize(actual),
					buffer, bufferSupplier);

	actual.onSubscribe(parent);

	other.subscribe(parent.other);

	source.subscribe(parent);
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	Operators.MonoSubscriber<T, T>
			sds = new Operators.MonoSubscriber<>(actual);

	actual.onSubscribe(sds);

	if (sds.isCancelled()) {
		return;
	}

	try {
		T t = supplier.get();
		if (t == null) {
			sds.onComplete();
		}
		else {
			sds.complete(t);
		}
	}
	catch (Throwable e) {
		actual.onError(Operators.onOperatorError(e, actual.currentContext()));
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super Flux<T>> actual) {
	WindowWhenMainSubscriber<T, U, V> main = new WindowWhenMainSubscriber<>(actual,
			start, end, processorQueueSupplier);
	actual.onSubscribe(main);

	if (main.cancelled) {
		return;
	}
	WindowWhenOpenSubscriber<T, U> os = new WindowWhenOpenSubscriber<>(main);

	if (WindowWhenMainSubscriber.BOUNDARY.compareAndSet(main,null, os)) {
		WindowWhenMainSubscriber.OPEN_WINDOW_COUNT.incrementAndGet(main);
		start.subscribe(os);
		source.subscribe(main);
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super Long> actual) {
	Worker w = timedScheduler.createWorker();

	IntervalRunnable r = new IntervalRunnable(actual, w);

	actual.onSubscribe(r);

	try {
		w.schedulePeriodically(r, initialDelay, period, unit);
	}
	catch (RejectedExecutionException ree) {
		if (!r.cancelled) {
			actual.onError(Operators.onRejectedExecution(ree, r, null, null,
					actual.currentContext()));
		}
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Test
public void scanDelayRunnable() {
	CoreSubscriber<Long> actual = new LambdaMonoSubscriber<>(null, e -> {
	}, null, null);
	MonoDelay.MonoDelayRunnable test = new MonoDelay.MonoDelayRunnable(actual);

	actual.onSubscribe(test);

	assertThat(test.scan(Scannable.Attr.PARENT)).isNull();
	assertThat(test.scan(Scannable.Attr.ACTUAL)).isSameAs(actual);

	assertThat(test.scan(Scannable.Attr.TERMINATED)).isFalse();
	test.request(1);
	test.run();
	assertThat(test.scan(Scannable.Attr.TERMINATED)).isTrue();
	assertThat(test.scan(Scannable.Attr.CANCELLED)).isFalse();
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	Objects.requireNonNull(actual, "subscribe");
	if (once == 0 && ONCE.compareAndSet(this, 0, 1)) {

		actual.onSubscribe(this);
		this.actual = actual;
		if (cancelled) {
			this.actual = null;
		} else {
			drain();
		}
	} else {
		Operators.error(actual, new IllegalStateException("UnicastProcessor " +
				"allows only a single Subscriber"));
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	T v = value;
	if (v == null) {
		ScheduledEmpty parent = new ScheduledEmpty(actual);
		actual.onSubscribe(parent);
		try {
			parent.setFuture(scheduler.schedule(parent));
		}
		catch (RejectedExecutionException ree) {
			if (parent.future != OperatorDisposables.DISPOSED) {
				actual.onError(Operators.onRejectedExecution(ree,
						actual.currentContext()));
			}
		}
	}
	else {
		actual.onSubscribe(new ScheduledScalar<>(actual, v, scheduler));
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	Objects.requireNonNull(actual, "subscribe");
	EmitterInner<T> inner = new EmitterInner<>(actual, this);
	actual.onSubscribe(inner);

	if (inner.isCancelled()) {
		return;
	}

	if (add(inner)) {
		if (inner.isCancelled()) {
			remove(inner);
		}
		drain();
	}
	else {
		Throwable e = error;
		if (e != null) {
			inner.actual.onError(e);
		}
		else {
			inner.actual.onComplete();
		}
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public CoreSubscriber<? super T> apply(Scannable scannable, CoreSubscriber<? super T> coreSubscriber) {
    return new CoreSubscriber<T>() {
        @Override
        public void onSubscribe(Subscription subscription) {
            if (subscribedOnce.getAndSet(true)) {
                throw new NullPointerException("You cannot directly subscribe to a gRPC service multiple times " +
                        "concurrently. Use Flux.share() instead.");
            } else {
                coreSubscriber.onSubscribe(subscription);
            }
        }

        @Override
        public void onNext(T t) {
            coreSubscriber.onNext(t);
        }

        @Override
        public void onError(Throwable throwable) {
            coreSubscriber.onError(throwable);
        }

        @Override
        public void onComplete() {
            coreSubscriber.onComplete();
        }
    };
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Test
public void subscribeOnlyOnceLifterErrorsWhenMultipleSubscribe() throws Exception {
    SubscribeOnlyOnceLifter<Object> op = new SubscribeOnlyOnceLifter<>();
    CoreSubscriber<Object> innerSub = mock(CoreSubscriber.class);
    Subscription subscription = mock(Subscription.class);

    CoreSubscriber<Object> outerSub = op.apply(null, innerSub);

    outerSub.onSubscribe(subscription);
    assertThatThrownBy(() -> outerSub.onSubscribe(subscription))
            .isInstanceOf(NullPointerException.class)
            .hasMessageContaining("cannot directly subscribe to a gRPC service multiple times");

    verify(innerSub, times(1)).onSubscribe(subscription);
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
final void startReceiver(CoreSubscriber<? super Object> s) {
	if (receiver == null) {
		if (log.isDebugEnabled()) {
			log.debug("{} Subscribing inbound receiver [pending: {}, cancelled:{}, " +
							"inboundDone: {}]", channel.toString(), getPending(),
					isCancelled(),
					inboundDone);
		}
		if (inboundDone && getPending() == 0) {
			if (inboundError != null) {
				Operators.error(s, inboundError);
				return;
			}

			Operators.complete(s);
			return;
		}

		receiver = s;

		s.onSubscribe(this);
	}
	else {
		Operators.error(s,
				new IllegalStateException(
						"Only one connection receive subscriber allowed."));
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	PublishInner<T> inner = new PublishInner<>(actual);
	actual.onSubscribe(inner);
	for (; ; ) {
		if (inner.isCancelled()) {
			break;
		}

		PublishSubscriber<T> c = connection;
		if (c == null || c.isTerminated()) {
			PublishSubscriber<T> u = new PublishSubscriber<>(prefetch, this);
			if (!CONNECTION.compareAndSet(this, c, u)) {
				continue;
			}

			c = u;
		}

		if (c.add(inner)) {
			if (inner.isCancelled()) {
				c.remove(inner);
			}
			else {
				inner.parent = c;
			}
			c.drain();
			break;
		}
	}
}
 

import reactor.core.CoreSubscriber; //导入方法依赖的package包/类
@Override
public void subscribe(CoreSubscriber<? super T> actual) {
	SampleFirstMain<T, U> main = new SampleFirstMain<>(actual, throttler);

	actual.onSubscribe(main);

	source.subscribe(main);
}