import reactor.core.Reactor; //导入依赖的package包/类
/**
 * Accept an image upload via POST and notify a Reactor that the image needs to be thumbnailed. Asynchronously respond
 * to the client when the thumbnailing has completed.
 *
 * @param channel
 *     the channel on which to send an HTTP response
 * @param thumbnail
 *     a reference to the shared thumbnail path
 * @param reactor
 *     the Reactor on which to publish events
 *
 * @return a consumer to handle HTTP requests
 */
public static Consumer<FullHttpRequest> thumbnailImage(NetChannel<FullHttpRequest, FullHttpResponse> channel,
                                                       AtomicReference<Path> thumbnail,
                                                       Reactor reactor) {
  return req -> {
    if (req.getMethod() != HttpMethod.POST) {
      channel.send(badRequest(req.getMethod() + " not supported for this URI"));
      return;
    }

    // write to a temp file
    Path imgIn = null;
    try {
      imgIn = readUpload(req.content());
    } catch (IOException e) {
      throw new IllegalStateException(e.getMessage(), e);
    }

    // Asynchronously thumbnail the image to 250px on the long side
    reactor.sendAndReceive("thumbnail", Event.wrap(imgIn), ev -> {
      thumbnail.set(ev.getData());
      channel.send(redirect());
    });
  };
}
 

import reactor.core.Reactor; //导入依赖的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.Reactor; //导入依赖的package包/类
/**
 * Ctor.
 * 
 * @param reactor
 *            the instance of reactor to use
 * @param store
 *            the instance of event store to use
 */
public EventResource(Reactor reactor, EventStore store) {
	this.broadcaster = new SseBroadcaster();
	this.store = store;
	this.reactors = reactor;
	this.lastEventId = new AtomicLong(-1);

	this.reactors.on(Selectors.object("out"), (reactor.event.Event<Long> lastEventId) -> {
		broadcast(lastEventId.getData().longValue());
	});
	this.reactors.on(Selectors.object("in"), (reactor.event.Event<Event> e) -> {
		store.use(e.getData());
		broadcast(this.lastEventId.longValue());
	});

	if (Boolean.getBoolean("visactor.demo")) {
		logger.warn("visactor demo mode is enabled.");
		startDemoEvents();
	}
}
 

import reactor.core.Reactor; //导入依赖的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.Reactor; //导入依赖的package包/类
@Autowired
public GroupMessageListener(final List<CommandPlugin> commandPlugins, final GroupService groupService, final Reactor reactor,
		final CounterService counterService) {
	this.commandPlugins = commandPlugins;
	this.groupService = groupService;
	this.reactor = reactor;
	this.counterService = counterService;
}
 

import reactor.core.Reactor; //导入依赖的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.Reactor; //导入依赖的package包/类
public Reactor getDefaultReactor() {
	return defaultReactor;
}
 

import reactor.core.Reactor; //导入依赖的package包/类
@Autowired
public WhatsAppClientToReactorBridge(final WhatsAppClient whatsAppClient, final Reactor rootReactor, final CounterService counterService) {
	this.whatsAppClient = whatsAppClient;
	this.rootReactor = rootReactor;
	this.counterService = counterService;
}
 

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

import reactor.core.Reactor; //导入依赖的package包/类
@Autowired
public MailController(UserRepository users,
                      Reactor reactor) {
    this.users = users;
    this.reactor = reactor;
}
 

import reactor.core.Reactor; //导入依赖的package包/类
/**
 * Creates a new Subscription
 * @param reactor The reactor for event listening and async dispatch
 * @param pattern The subscription pattern
 * @param expectedInsertions The number of expected insertions
 * @param types The TSDBEvent types to subscribe to
 */
public Subscription(final Reactor reactor, final ObjectName pattern, final int expectedInsertions, final TSDBEventType...types) {
	this(reactor, pattern.toString(), expectedInsertions);
}
 

import reactor.core.Reactor; //导入依赖的package包/类
/**
 * Ctor.
 * 
 * @param reactor
 *            the instance of {@link Reactor} to use.
 * @param store
 *            the event store instance.
 */
public VisactorResource(Reactor reactor, EventStore store) {
	this.eventResource = new EventResource(reactor, store);
}
 

import reactor.core.Reactor; //导入依赖的package包/类
public abstract void invoke(final Group group, final Reactor reactor, final GroupMessage message);