import reactor.core.spec.Reactors; //导入依赖的package包/类
private void initializeReactor() {
    reactor = Reactors.reactor()
            .env(env)
            .dispatcher(Environment.RING_BUFFER)
            .get();

    decoderReactor = Reactors.reactor()
            .env(env)
            .dispatcher(Environment.RING_BUFFER)
            .get();

    decoderReactor.on(Selectors.$(DECODE_TOPIC), (Event<byte[]> m) -> {
        try {
            Envelope message = EnvelopeCodec.decode(m.getData());
            message.setDecoded(false);
            send(message);
        } catch (IOException | MessageTypeException ex) {
            LOG.error("Error decoding message.", ex);
        }
    });
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
	Environment env = new Environment();
	Reactor reactor = Reactors.reactor().env(env).dispatcher(Environment.THREAD_POOL).get();

	// topic: parse
	reactor.on($("parse"), App::handleEvent1);
	reactor.on($("parse"), App::handleEvent2);

	// Notify consumers of the 'parse' topic that data is ready
	// by passing a Supplier<Event<T>> in the form of a lambda

	for (long l = 0; true; l++) {
		String obj = "Test-" + l;
		reactor.notify("parse", Event.wrap(new ObjectEvent().setObject(obj)));
		Thread.sleep(1000);
	}

}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
    Environment env = new Environment();
    final TradeServer server = new TradeServer();

    // Use a Reactor to dispatch events using the default Dispatcher
    Reactor reactor = Reactors.reactor()
            .env(env)
            .dispatcher("ringBuffer")
            .get();

    String topic = "trade.execute";

    // For each Trade event, execute that on the server
    reactor.on($(topic), new Consumer<Event<Trade>>() {
        @Override
        public void accept(Event<Trade> tradeEvent) {
            server.execute(tradeEvent.getData());

            // Since we're async, for this test, use a latch to tell when we're done
            latch.countDown();
        }
    });

    // Start a throughput timer
    startTimer();

    // Publish one event per trade
    for (int i = 0; i < totalTrades; i++) {
        // Pull next randomly-generated Trade from server
        Trade t = server.nextTrade();

        // Notify the Reactor the event is ready to be handled
        reactor.notify(topic, Event.wrap(t));
    }

    // Stop throughput timer and output metrics
    endTimer();

    server.stop();
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
@Bean
public Reactor reactor(Environment env, MailServer mailServer) {
    Logger log = LoggerFactory.getLogger("mail.server");
    Reactor r = Reactors.reactor(env);

    // Wire an event handler to execute messages
    r.on($("mail.execute"), (Event<MessageDescriptor> ev) -> {
        mailServer.execute(ev.getData());
        log.info("Executed message: {}", ev.getData());
    });

    return r;
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
/**
 * Constructor.
 */
public ListenerRegistry() {
    reactor = Reactors.reactor()
            .env(environment)
            .dispatcher(Environment.RING_BUFFER)
            .get();
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
public VisactorResourceConfig() {
	this.reactor = Reactors.reactor(new Environment(), Environment.RING_BUFFER);
	this.store = new ListEventStore();

	register(SseFeature.class);
	registerInstances(new VisactorResource(reactor, store));
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
private SingletonEnvironment() {
	env = new Environment();
	defaultReactor = Reactors.reactor(env);
}
 

import reactor.core.spec.Reactors; //导入依赖的package包/类
@Bean
public Reactor rootReactor(final Environment env) {
	return Reactors.reactor().env(env).get();
}