import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
	BindingAwareBroker bindingAwareBroker = getBindingAwareBrokerDependency();
    DataBroker dataBrokerService = getDataBrokerDependency();
    RpcProviderRegistry rpcProviderRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();

    Preconditions.checkNotNull(bindingAwareBroker);
    Preconditions.checkNotNull(dataBrokerService);
    Preconditions.checkNotNull(rpcProviderRegistry);
    Preconditions.checkNotNull(notificationService);

    MyRouterOrchestrator orchestrator = new MyRouterOrchestrator(bindingAwareBroker, dataBrokerService, notificationService, rpcProviderRegistry);
    LOG.info("Tutorial NetconfExercise (instance {}) initialized.", orchestrator);
    return orchestrator;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public void start() {
    checkState(controllerRoot == null, "Binding Aware Broker was already started.");
    LOG.info("Starting Binding Aware Broker: {}", identifier);

    controllerRoot = new RootSalInstance(getRpcProviderRegistry(), getNotificationBroker());

    final ImmutableClassToInstanceMap.Builder<BindingAwareService> consBuilder = ImmutableClassToInstanceMap
            .builder();

    consBuilder.put(NotificationService.class, getRoot());
    consBuilder.put(RpcConsumerRegistry.class, getRoot());
    if (dataBroker != null) {
        consBuilder.put(DataBroker.class, dataBroker);
    }
    consBuilder.put(MountPointService.class, mountService);

    supportedConsumerServices = consBuilder.build();
    final ImmutableClassToInstanceMap.Builder<BindingAwareService> provBuilder = ImmutableClassToInstanceMap
            .builder();
    provBuilder.putAll(supportedConsumerServices).put(NotificationProviderService.class, getRoot())
            .put(RpcProviderRegistry.class, getRoot());
    if (notificationPublishService != null) {
        provBuilder.put(NotificationPublishService.class, notificationPublishService);
    }

    supportedProviderServices = provBuilder.build();
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
    DataBroker dataBrokerService = getDataBrokerDependency();
    RpcProviderRegistry rpcProviderRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();
    NegotiatorProvider provider = new NegotiatorProvider(dataBrokerService, rpcProviderRegistry, notificationService);
    notificationService.registerNotificationListener(new TopologyChangeListenerImpl());
    return provider;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public NegotiatorProvider(DataBroker dataBroker, RpcProviderRegistry rpcProviderRegistry,
                          NotificationProviderService notificationService) {
    this.dataBroker = dataBroker;
    this.salFlowService = rpcProviderRegistry.getRpcService(SalFlowService.class);
    this.notificationService = notificationService;
    this.negotiatorService = rpcProviderRegistry.addRpcImplementation(NegotiatorService.class,
            new QoSNegotiatorImpl(salFlowService, dataBroker));

}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
    DataBroker dataBrokerService = getDataBrokerDependency();
    RpcProviderRegistry rpcProviderRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();
    MonitoringProvider provider = new MonitoringProvider(dataBrokerService, rpcProviderRegistry, notificationService);

    InstanceIdentifier<Link> linkInstance = InstanceIdentifier.builder(NetworkTopology.class)
            .child(Topology.class, new TopologyKey(new TopologyId("flow:1"))).child(Link.class).build();
    dataBrokerService.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, linkInstance,
            new TopologyListener(dataBrokerService, notificationService),
            AsyncDataBroker.DataChangeScope.BASE);

    return provider;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public void setServices(DataBroker dataService, RoutingConfigService configService,
		PacketProcessingService packetService, NotificationProviderService notificationService) {
	this.dataService = dataService;
	this.configService = configService;
	this.packetService = packetService;
	this.notificationService = notificationService;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
    //Get all MD-SAL provider objects
    DataBroker dataBroker = getDataBrokerDependency();
    RpcProviderRegistry rpcRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();

    TutorialACL tutorialACL = new TutorialACL(dataBroker, notificationService, rpcRegistry);
    LOG.info("Tutorial Access Control List (instance {}) initialized.", tutorialACL);
    return tutorialACL;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public TutorialACL(DataBroker dataBroker, NotificationProviderService notificationService, RpcProviderRegistry rpcProviderRegistry) {
    //Store the data broker for reading/writing from inventory store
    this.dataBroker = dataBroker;

    //Get access to the packet processing service for making RPC calls later
    this.packetProcessingService = rpcProviderRegistry.getRpcService(PacketProcessingService.class);

    //List used to track notification (both data change and YANG-defined) listener registrations
    this.registrations = registerDataChangeListeners();

    //Register this object for receiving notifications when there are PACKET_INs
    registrations.add(notificationService.registerNotificationListener(this));
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
	//Get all MD-SAL provider objects
    DataBroker dataBroker = getDataBrokerDependency();
    RpcProviderRegistry rpcRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();
    
    TutorialL2Forwarding tutorialL2Forwarding = new TutorialL2Forwarding(dataBroker, notificationService, rpcRegistry);
    LOG.info("Tutorial Learning Switch (instance {}) initialized.", tutorialL2Forwarding);
    return tutorialL2Forwarding;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public TutorialL2Forwarding(DataBroker dataBroker, NotificationProviderService notificationService, RpcProviderRegistry rpcProviderRegistry) {
 	//Store the data broker for reading/writing from inventory store
     this.dataBroker = dataBroker;

     //Get access to the packet processing service for making RPC calls later
     this.packetProcessingService = rpcProviderRegistry.getRpcService(PacketProcessingService.class);        

 	//List used to track notification (both data change and YANG-defined) listener registrations
 	this.registrations = Lists.newArrayList(); 

     //Register this object for receiving notifications when there are PACKET_INs
     registrations.add(notificationService.registerNotificationListener(this));
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public TutorialTapProvider(DataBroker dataBroker, NotificationProviderService notificationService, RpcProviderRegistry rpcProviderRegistry) {
    //Store the data broker for reading/writing from inventory store
    this.dataBroker = dataBroker;

    //Object used for flow programming through RPC calls
    this.salFlowService = rpcProviderRegistry.getRpcService(SalFlowService.class);

    //List used to track notification (both data change and YANG-defined) listener registrations
    this.registrations = registerDataChangeListeners();

    //Register this object for receiving notifications when there are New switches
    registrations.add(notificationService.registerNotificationListener(this));
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public java.lang.AutoCloseable createInstance() {
    DataBroker dataBrokerService = getDataBrokerDependency();
    RpcProviderRegistry rpcProviderRegistry = getRpcRegistryDependency();
    NotificationProviderService notificationService = getNotificationServiceDependency();

    Preconditions.checkNotNull(dataBrokerService);
    Preconditions.checkNotNull(rpcProviderRegistry);
    Preconditions.checkNotNull(notificationService);

    TutorialTapProvider tapProvider = new TutorialTapProvider(dataBrokerService, notificationService, rpcProviderRegistry);
    LOG.info("Tutorial TapApp (instance {}) initialized.", tapProvider);
    return tapProvider;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public MyRouterOrchestrator(BindingAwareBroker bindingAwareBroker, DataBroker dataBroker, NotificationProviderService notificationService, RpcProviderRegistry rpcProviderRegistry) {
    //Register this object as a provider for receiving session context
    bindingAwareBroker.registerProvider(this);
    
    //Register this object as listener for changes in netconf topology
    InstanceIdentifier<Topology> netconfTopoIID = InstanceIdentifier.builder(NetworkTopology.class)
            .child(Topology.class, new TopologyKey(new TopologyId(TopologyNetconf.QNAME.getLocalName())))
            .build();
    registrations.add(dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, netconfTopoIID.child(Node.class), this, DataChangeScope.SUBTREE));
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public Set<Class<? extends BindingAwareService>> getProvidedServices() {

    Set<Class<? extends BindingAwareService>> ret = new HashSet<Class<? extends BindingAwareService>>();
    ret.add(NotificationService.class);
    ret.add(NotificationProviderService.class);
    return ret;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public void onBISessionAvailable(ProviderSession session) {
    biSession = session;
    if (biSession != null) {
        biNotifyService = session
                .getService(org.opendaylight.controller.sal.core.api.notify.NotificationProviderService.class);
    }
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
@Override
public void onSessionInitiated(ProviderContext providerContext) {
    try {
        this.providerContext = providerContext;
        service.setNotificationProvider(this.providerContext
                .getSALService(NotificationProviderService.class));
        registration = providerContext.addRpcImplementation(
                HelloService.class, service);
        log.info(
                "Registered 'HelloService' implementation '{}' with registration '{}'",
                service, registration);
    } catch (IllegalStateException e) {
        log.error("Unable to register 'HelloService' implementation", e);
    }
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public NotificationProviderService getNotificationBroker() {
    return this.notificationBroker;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public void setNotificationBroker(final NotificationProviderService notificationBroker) {
    this.notificationBroker = notificationBroker;
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public RootSalInstance(final RpcProviderRegistry rpcRegistry,
        final NotificationProviderService notificationBroker) {
    super(rpcRegistry, notificationBroker);
}
 

import org.opendaylight.controller.sal.binding.api.NotificationProviderService; //导入依赖的package包/类
public void setNotificationProvider(final NotificationProviderService salService) {
  this.notificationProvider = salService;
}