import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
protected StreamingContainer(String containerId, StreamingContainerUmbilicalProtocol umbilical)
{
  this.jvmName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
  this.components = new HashSet<>();
  this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  this.singletons = new HashMap<>();
  this.nodeRequests = new ArrayList<>();

  logger.debug("instantiated StramChild {}", containerId);
  this.umbilical = umbilical;
  this.containerId = containerId;
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
public StreamingContainerManager(LogicalPlan dag, boolean enableEventRecording, Clock clock)
{
  this.clock = clock;
  this.vars = new FinalVars(dag, clock.getTime());
  poolExecutor = Executors.newFixedThreadPool(4);
  // setup prior to plan creation for event recording
  if (enableEventRecording) {
    this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  }
  this.plan = new PhysicalPlan(dag, this);
  this.journal = new Journal(this);
  init(enableEventRecording);
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
@Inject
public DefaultEventController(final Logger logger) {
    this.mBassador = new MBassador<Event>(new BusConfiguration()
            .addFeature(Feature.SyncPubSub.Default())
            .addFeature(Feature.AsynchronousHandlerInvocation.Default())
            .addFeature(Feature.AsynchronousMessageDispatch.Default())
            .setProperty(Properties.Common.Id, "global bus")
            .setProperty(Properties.Handler.PublicationError, new IPublicationErrorHandler() {
                @Override
                public void handleError(PublicationError publicationError) {
                    logger.catching(publicationError.getCause());
                }
            }));
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
private static BusConfiguration createBusConfiguration() {
	BusConfiguration config = new BusConfiguration();
	// synchronous dispatching of events
	config.addFeature(Feature.SyncPubSub.Default());
	// asynchronous dispatching of events
	config.addFeature(Feature.AsynchronousHandlerInvocation.Default());
	config.addFeature(Feature.AsynchronousMessageDispatch.Default());
	return config;
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
/**
 * Creates a new {@link TaskModel} backed by the specified
 * {@link TaskManager}.
 */
public TaskModel(TaskManager taskManager) {
    this.taskManager = Objects.requireNonNull(taskManager, "taskManager");
    this.bus = new MBassador<Object>(new BusConfiguration()
            .addFeature(Feature.SyncPubSub.Default())
            .addFeature(Feature.AsynchronousHandlerInvocation.Default())
            .addFeature(Feature.AsynchronousMessageDispatch.Default()));
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
/**
 * Creates a new {@link ClientModel} backed by the specified
 * {@link ClientManager}.
 */
public ClientModel(ClientManager clientManager) {
    this.clientManager = Objects.requireNonNull(clientManager, "clientManager");
    this.bus = new MBassador<Object>(new BusConfiguration()
            .addFeature(Feature.SyncPubSub.Default())
            .addFeature(Feature.AsynchronousHandlerInvocation.Default())
            .addFeature(Feature.AsynchronousMessageDispatch.Default()));
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
public MBassador(BusConfiguration configuration) {
    super(configuration);
}
 

import net.engio.mbassy.bus.config.BusConfiguration; //导入依赖的package包/类
@Override
public void link(Lookup.Provider lkpProviderOurs, Lookup.Provider lkpProviderTheirs) {
            
    MBassador busOurs = lkpProviderOurs.getLookup().lookup(MBassador.class);
    MBassador busTheirs = lkpProviderTheirs.getLookup().lookup(MBassador.class);
    if (busOurs != null && busTheirs != null) {
        // already linked
        if (!busOurs.equals(busTheirs)) {
            String msg = "Linking between two separately linked groups is not allowed.";
            //Exceptions.printStackTrace(new ViewerLinkingException(msg));
            NotifyDescriptor d = new NotifyDescriptor.Message(msg, NotifyDescriptor.ERROR_MESSAGE);
            DialogDisplayer.getDefault().notify(d);
        }
        return;
    }
    MBassador<Object> bus = busOurs != null ? busOurs : busTheirs;
    if (bus == null) {
        // there was no bus set up yet, so we'll create one
        IBusConfiguration busConf = new BusConfiguration()
                .addFeature(Feature.SyncPubSub.Default())
                .addFeature(Feature.AsynchronousHandlerInvocation.Default())
                .addFeature(Feature.AsynchronousMessageDispatch.Default())
                .setProperty(Properties.Handler.PublicationError, new IPublicationErrorHandler() {
                    @Override
                    public void handleError(final PublicationError error) {
                        LOG.log(Level.SEVERE,
                                "Mbassador pub/sub error: " + error.getMessage(),
                                error.getCause());
                    }
                });
        bus = new MBassador<>(busConf);
    }
    InstanceContent icOurs = lkpProviderOurs.getLookup().lookup(InstanceContent.class);
    if (icOurs == null) {
        Exceptions.printStackTrace(new ViewerLinkingException("Our lookup did not contain"
                + " an InstanceContent in it"));
        return;
    }
    InstanceContent icTheirs = lkpProviderTheirs.getLookup().lookup(InstanceContent.class);
    if (icTheirs == null) {
        Exceptions.printStackTrace(new ViewerLinkingException("Their lookup did not contain"
                + " an InstanceContent in it"));
        return;
    }

    // now we have both InstanceContents
    icOurs.add(bus);
    icTheirs.add(bus);

    int a = 1;
}