Java EventManager类代码示例

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
default ServiceBundle createServiceBundle(String address,
                                          final QueueBuilder requestQueueBuilder,
                                          final QueueBuilder responseQueueBuilder,
                                          final QueueBuilder webResponseQueueBuilder,
                                          final Factory factory, final boolean asyncCalls,
                                          final BeforeMethodCall beforeMethodCall,
                                          final BeforeMethodCall beforeMethodCallAfterTransform,
                                          final Transformer<Request, Object> argTransformer,
                                          boolean invokeDynamic,
                                          final QBitSystemManager systemManager,
                                          final HealthServiceAsync healthService,
                                          final StatsCollector statsCollector,
                                          final Timer timer,
                                          final int statsFlushRateSeconds,
                                          final int checkTimingEveryXCalls,
                                          final CallbackManager callbackManager,
                                          final EventManager eventManager,
                                          final BeforeMethodSent beforeMethodSent,
                                          final BeforeMethodCall beforeMethodCallOnServiceQueue, AfterMethodCall afterMethodCallOnServiceQueue) {
    throw new UnsupportedOperationException();
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
public ServiceQueueImpl(final String rootAddress,
                        final String serviceAddress,
                        final Object service,
                        final QueueBuilder requestQueueBuilder,
                        final QueueBuilder responseQueueBuilder,
                        final ServiceMethodHandler serviceMethodHandler,
                        final Queue<Response<Object>> responseQueue,
                        final boolean async,
                        final boolean handleCallbacks,
                        final QBitSystemManager systemManager,
                        final BeforeMethodCall beforeMethodCall,
                        final BeforeMethodCall beforeMethodCallAfterTransform,
                        final AfterMethodCall afterMethodCall,
                        final AfterMethodCall afterMethodCallAfterTransform,
                        final QueueCallBackHandler handler,
                        final CallbackManager callbackManager,
                        final BeforeMethodSent beforeMethodSent,
                        final EventManager eventManager,
                        final boolean joinEventManager) {
    super(rootAddress, serviceAddress, service, requestQueueBuilder, responseQueueBuilder,
            serviceMethodHandler, responseQueue,
            async, handleCallbacks, systemManager, beforeMethodCall, beforeMethodCallAfterTransform,
            afterMethodCall, afterMethodCallAfterTransform, handler, callbackManager, beforeMethodSent, eventManager,
            joinEventManager);
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Override
public EventManager systemEventManager() {

    final EventManager eventManager = eventManagerThreadLocal.get();
    if (eventManager != null) {
        return eventManager;
    }

    EventManager proxy;
    if (systemEventManager.get() == null) {
        final ServiceQueue serviceQueue = serviceBuilder().setInvokeDynamic(false)
                .setServiceObject(
                        EventManagerBuilder.eventManagerBuilder().setName("QBIT_SYSTEM").build()).build().startServiceQueue();

        systemEventManager.set(serviceQueue);
        proxy = serviceQueue.createProxyWithAutoFlush(EventManager.class, 100, TimeUnit.MILLISECONDS);
    } else {
        proxy = systemEventManager.get().createProxyWithAutoFlush(EventManager.class, 100, TimeUnit.MILLISECONDS);
    }

    eventManagerThreadLocal.set(proxy);
    return proxy;
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Override
public <T> T createProxyWithChannelPrefix(final EventManager eventManager, final Class<T> eventBusProxyInterface,
                                          final String channelPrefix) {

    if (!eventBusProxyInterface.isInterface()) {
        throw new IllegalArgumentException("Must be an interface for eventBusProxyInterface argument");
    }
    final Map<String, String> methodToChannelMap = createMethodToChannelMap(channelPrefix, eventBusProxyInterface);

    final InvocationHandler invocationHandler = (proxy, method, args) -> {

        if (flushMethodNameSet.contains(method.getName())) {
            flushServiceProxy(eventManager);
            return null;
        }
        final String channelName = methodToChannelMap.get(method.toString());
        eventManager.sendArguments(channelName, args);

        return null;
    };
    final Object o = Proxy.newProxyInstance(eventBusProxyInterface.getClassLoader(), new Class[]{eventBusProxyInterface, ClientProxy.class}, invocationHandler);
    //noinspection unchecked
    return (T) o;

}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
public EventExampleService(final EventManager eventManager,
                           final String statKeyPrefix,
                           final Reactor reactor,
                           final Timer timer,
                           final StatsCollector statsCollector) {
    super(statKeyPrefix, reactor, timer, statsCollector);
    this.eventManager = eventManager;
    reactor.addServiceToFlush(eventManager);
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Bean
public EventBusCluster eventBusCluster(final @Qualifier("clusteredEventManagerImpl") EventManager eventManager,
                                       final EventConnectorHub eventConnectorHub,
                                       final ServiceDiscovery serviceDiscovery,
                                       final EventBusProperties props) {

    logger.info("Binding event bus to " + props.getPort());
    final EventBusClusterBuilder clusterBuilder = EventBusClusterBuilder.eventBusClusterBuilder();
    clusterBuilder.setServiceDiscovery(serviceDiscovery);
    clusterBuilder.setReplicationPortLocal(props.getPort());
    clusterBuilder.setEventBusName(props.getName());
    clusterBuilder.setEventManager(eventManager);
    clusterBuilder.setEventConnectorHub(eventConnectorHub);
    clusterBuilder.setPeerCheckTimeUnit(TimeUnit.SECONDS);
    clusterBuilder.setPeerCheckTimeInterval(props.getPeriodicCheckInSeconds());
    clusterBuilder.setReplicationServerCheckInInterval(props.getTtl());
    clusterBuilder.setReplicationServerCheckInTimeUnit(TimeUnit.SECONDS);
    final EventBusCluster cluster = clusterBuilder.build();
    try {
        cluster.start();
    } catch (final Exception e) {
        logger.error("Failed to start cluster for event bus.  Make sure you can connect to consul.");
        logger.error("Consul is down.  The event bus predates ServiceDiscovery");
        logger.error("ServiceDiscovery will default to using JSON files for peer endpoint config.");
        logger.error("The stats count is using service discovery, event bus is not yet.");
    }
    return cluster;
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Bean
@Clustered
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public EventManager clusteredEventManager(final @Qualifier("clusteredEventManagerServiceQueue")
                                          ServiceQueue eventManagerServiceQueue) {

    return eventManagerServiceQueue.createProxy(EventManager.class);
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
/**
 * Wraps factory method call so we can provide another implementation of interface if needed.
 *
 * @param eventConnectorHub the cluster of event connectors
 * @return the event manager
 */
@Bean
public EventManager clusteredEventManagerImpl(final EventConnectorHub eventConnectorHub) {
    return EventManagerBuilder.eventManagerBuilder()
            .setEventConnector(eventConnectorHub)
            .setName("CLUSTERED_EVENT_MANAGER").build();
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
public EventBusCluster(final EventManager eventManager,
                       final String eventBusName,
                       final EventConnectorHub eventConnectorHub,
                       final PeriodicScheduler periodicScheduler,
                       final int peerCheckTimeInterval,
                       final TimeUnit peerCheckTimeTimeUnit,
                       final int replicationServerCheckInInterval,
                       final TimeUnit replicationServerCheckInTimeUnit,
                       final ServiceDiscovery serviceDiscovery,
                       final int replicationPortLocal,
                       final String replicationHostLocal) {

    this.eventBusName = eventBusName;
    this.eventConnectorHub = eventConnectorHub == null ? new EventConnectorHub() : eventConnectorHub;
    this.periodicScheduler = periodicScheduler == null ?
            QBit.factory().periodicScheduler() : periodicScheduler;
    this.peerCheckTimeInterval = peerCheckTimeInterval;
    this.peerCheckTimeUnit = peerCheckTimeTimeUnit;
    this.eventManager = eventManager == null ? createEventManager() : wrapEventManager(eventManager);
    this.replicationServerCheckInIntervalInSeconds = (int) replicationServerCheckInTimeUnit.toSeconds(replicationServerCheckInInterval);
    this.serviceDiscovery = serviceDiscovery;

    this.replicationPortLocal = replicationPortLocal;

    this.replicationHostLocal = getHost(replicationHostLocal);

    this.servicePool = new ServicePool(eventBusName, null);

    endpointDefinition = serviceDiscovery.registerWithTTL(eventBusName, replicationHostLocal, replicationPortLocal,
            (int) replicationServerCheckInTimeUnit.toSeconds(replicationServerCheckInInterval));

    serviceDiscovery.checkInOk(endpointDefinition.getId());
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
private EventManager wrapEventManager(final EventManager eventManager) {
    if (eventManager instanceof ClientProxy) {
        return eventManager;
    } else {
        eventManagerImpl = eventManager;
        eventServiceQueue = serviceBuilder().setServiceObject(eventManager).build();
        return eventServiceQueue.createProxyWithAutoFlush(EventManager.class, periodicScheduler,
                100, TimeUnit.MILLISECONDS);
    }
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
private EventManager createEventManager() {
    eventManagerImpl = eventManagerBuilder().setEventConnector(eventConnectorHub).build(eventBusName);
    eventServiceQueue = serviceBuilder().setServiceObject(eventManagerImpl).build();

    return eventServiceQueue.createProxyWithAutoFlush(
            EventManager.class, periodicScheduler, 100, TimeUnit.MILLISECONDS);
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Before
public void setup() throws IOException {

    setupLatch();

    RegisterVertxWithQBit.registerVertxWithQBit();
    RegisterBoonWithQBit.registerBoonWithQBit();
    eventManager = mock(EventManager.class);
    service = new EventRemoteReplicatorService(eventManager);


    Sys.sleep(1000);
    int port = PortUtils.useOneOfThesePorts(3000, 6000, 4000, 3000);

    puts("findOpenPort(", port, ")");

    serviceEndpointServer = endpointServerBuilder().setPort(port).build();
    serviceEndpointServer.initServices(service);
    client = clientBuilder().setPort(port).build();

    Sys.sleep(1000);
    serviceEndpointServer.start();
    Sys.sleep(1000);
    client.start();

    clientEventConnector = client.createProxy(EventConnector.class, "eventRemoteReplicatorService");
    Sys.sleep(100);
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
@Before
public void setup() {
    setupLatch();
    eventManager = mock(EventManager.class);
    service = new EventRemoteReplicatorService(eventManager);

    try {
        serviceBundle = serviceBundleBuilder().build();
        serviceBundle.addServiceObject("remote", service);
        client = serviceBundle.createLocalProxy(EventConnector.class, "remote");
        serviceBundle.startUpCallQueue();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
/**
 * Get event manager
 *
 * @return event manager
 */
public EventManager getEventManager() {
    if (eventManager == null) {
        eventManager = getFactory().systemEventManager();
    }
    return eventManager;
}
 

import io.advantageous.qbit.events.EventManager; //导入依赖的package包/类
private void flushEventManagerCalls() {
    final EventManager eventManager = factory.eventManagerProxy();
    if (eventManager != null) {
        ServiceProxyUtils.flushServiceProxy(eventManager);
        factory.clearEventManagerProxy();
    }
}