import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
private void logListeners() {
    for (Map.Entry<OFType,
                   ListenerDispatcher<OFType,
                                      IOFMessageListener>> entry
         : listeners.entrySet()) {

        OFType type = entry.getKey();
        ListenerDispatcher<OFType, IOFMessageListener> ldd =
                entry.getValue();

        StringBuffer sb = new StringBuffer();
        sb.append("OFListeners for ");
        sb.append(type);
        sb.append(": ");
        for (IOFMessageListener l : ldd.getOrderedListeners()) {
            sb.append(l.getName());
            sb.append(",");
        }
        log.debug(sb.toString());
    }
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
@Override
public void init(FloodlightModuleContext context)
		throws FloodlightModuleException {
	floodlightProviderService = context.getServiceImpl(IFloodlightProviderService.class);
	threadPoolService = context.getServiceImpl(IThreadPoolService.class);
	debugCounterService = context.getServiceImpl(IDebugCounterService.class);
	flowQueue = new PriorityPendingQueue<OFMatchReconcile>();
	flowReconcileListeners = new ListenerDispatcher<OFType, IFlowReconcileListener>();

	Map<String, String> configParam = context.getConfigParams(this);
	String enableValue = configParam.get(EnableConfigKey);
	registerFlowReconcileManagerDebugCounters();
	// Set flowReconcile default to true
	flowReconcileEnabled = true;
	if (enableValue != null &&
			enableValue.equalsIgnoreCase("false")) {
		flowReconcileEnabled = false;
	}
	flowReconcileThreadRunCount = new AtomicInteger(0);
	lastReconcileTime = new Date(0);
	logger.debug("FlowReconcile is {}", flowReconcileEnabled);
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
/**
 * Initialize internal data structures
 */
public void init(Map<String, String> configParams) throws FloodlightModuleException {

    this.moduleLoaderState = ModuleLoaderState.INIT;

    // These data structures are initialized here because other
    // module's startUp() might be called before ours        
    this.messageListeners = new ConcurrentHashMap<OFType, ListenerDispatcher<OFType, IOFMessageListener>>();
    this.haListeners = new ListenerDispatcher<HAListenerTypeMarker, IHAListener>();
    this.controllerNodeIPsCache = new HashMap<String, String>();
    this.updates = new LinkedBlockingQueue<IUpdate>();
    this.providerMap = new HashMap<String, List<IInfoProvider>>();
   
    setConfigParams(configParams);

    HARole initialRole = getInitialRole(configParams);
    this.notifiedRole = initialRole;
    this.shutdownService = new ShutdownServiceImpl();

    this.roleManager = new RoleManager(this, this.shutdownService,
                                       this.notifiedRole,
                                       INITIAL_ROLE_CHANGE_DESCRIPTION);
    this.timer = new HashedWheelTimer();

    // Switch Service Startup
    this.switchService.registerLogicalOFMessageCategory(LogicalOFMessageCategory.MAIN);
    this.switchService.addOFSwitchListener(new NotificationSwitchListener());

    this.counters = new ControllerCounters(debugCounterService);
 }
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
@Override
public void init(FloodlightModuleContext context)
        throws FloodlightModuleException {
    threadPool = context.getServiceImpl(IThreadPoolService.class);
    counterStore = context.getServiceImpl(ICounterStoreService.class);
    debugCounters = context.getServiceImpl(IDebugCounterService.class);
    flowQueue = new PriorityPendingQueue<OFMatchReconcile>();
    flowReconcileListeners =
            new ListenerDispatcher<OFType, IFlowReconcileListener>();

    Map<String, String> configParam = context.getConfigParams(this);
    String enableValue = configParam.get(EnableConfigKey);
    registerFlowReconcileManagerDebugCounters();
    // Set flowReconcile default to true
    flowReconcileEnabled = true;
    if (enableValue != null &&
        enableValue.equalsIgnoreCase("false")) {
        flowReconcileEnabled = false;
    }
    flowReconcileThreadRunCount = new AtomicInteger(0);
    lastReconcileTime = new Date(0);
    logger.debug("FlowReconcile is {}", flowReconcileEnabled);
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
@Override
public void init(FloodlightModuleContext context)
        throws FloodlightModuleException {
    threadPool = context.getServiceImpl(IThreadPoolService.class);
    counterStore = context.getServiceImpl(ICounterStoreService.class);

    flowQueue = new ConcurrentLinkedQueue<OFMatchReconcile>();
    flowReconcileListeners = 
            new ListenerDispatcher<OFType, IFlowReconcileListener>();
    
    Map<String, String> configParam = context.getConfigParams(this);
    String enableValue = configParam.get(EnableConfigKey);
    // Set flowReconcile default to true
    flowReconcileEnabled = true;
    if (enableValue != null &&
        enableValue.equalsIgnoreCase("false")) {
        flowReconcileEnabled = false;
    }
    
    flowReconcileThreadRunCount = 0;
    lastReconcileTime = new Date(0);
    logger.debug("FlowReconcile is {}", flowReconcileEnabled);
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
private void logListeners() {
    for (Map.Entry<OFType,
                   ListenerDispatcher<OFType, 
                                      IOFMessageListener>> entry
         : messageListeners.entrySet()) {
        
        OFType type = entry.getKey();
        ListenerDispatcher<OFType, IOFMessageListener> ldd = 
                entry.getValue();
        
        StringBuffer sb = new StringBuffer();
        sb.append("OFListeners for ");
        sb.append(type);
        sb.append(": ");
        for (IOFMessageListener l : ldd.getOrderedListeners()) {
            sb.append(l.getName());
            sb.append(",");
        }
        log.debug(sb.toString());            
    }
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
/**
 * Initialize internal data structures
 */
public void init(Map<String, String> configParams) {
    // These data structures are initialized here because other
    // module's startUp() might be called before ours
    this.messageListeners =
            new ConcurrentHashMap<OFType, 
                                  ListenerDispatcher<OFType, 
                                                     IOFMessageListener>>();
    this.switchListeners = new CopyOnWriteArraySet<IOFSwitchListener>();
    this.haListeners = new CopyOnWriteArraySet<IHAListener>();
    this.activeSwitches = new ConcurrentHashMap<Long, IOFSwitch>();
    this.connectedSwitches = new HashSet<OFSwitchImpl>();
    this.controllerNodeIPsCache = new HashMap<String, String>();
    this.updates = new LinkedBlockingQueue<IUpdate>();
    this.factory = new BasicFactory();
    this.providerMap = new HashMap<String, List<IInfoProvider>>();
    setConfigParams(configParams);
    this.role = getInitialRole(configParams);
    this.roleChanger = new RoleChanger();
    initVendorMessages();
    this.systemStartTime = System.currentTimeMillis();
}
 

import net.floodlightcontroller.core.util.ListenerDispatcher; //导入依赖的package包/类
private void logListeners() {
    for (Map.Entry<OFType,
                   ListenerDispatcher<OFType, 
                                      IOFMessageListener>> entry
         : listeners.entrySet()) {
        
        OFType type = entry.getKey();
        ListenerDispatcher<OFType, IOFMessageListener> ldd = 
                entry.getValue();
        
        StringBuffer sb = new StringBuffer();
        sb.append("OFListeners for ");
        sb.append(type);
        sb.append(": ");
        for (IOFMessageListener l : ldd.getOrderedListeners()) {
            sb.append(l.getName());
            sb.append(",");
        }
        log.debug(sb.toString());            
    }
}