import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
@Override
public RootBindingAwareBroker createInstance() {
    final Broker domBroker = getDomAsyncBrokerDependency();
    final BindingToNormalizedNodeCodec codec = getBindingMappingServiceDependency();
    final ProviderSession session = domBroker.registerProvider(new DummyDOMProvider());

    final MountPointService mount = createMountPointAdapter(codec,session);
    final BindingDOMRpcServiceAdapter rpcConsumer = createRpcConsumer(codec,session);
    final BindingDOMRpcProviderServiceAdapter rpcProvider = createRpcProvider(codec,session);
    final RootBindingAwareBroker broker = new RootBindingAwareBroker(getIdentifier().getInstanceName());
    final RpcProviderRegistry heliumRpcBroker = new HeliumRpcProviderRegistry(rpcConsumer, rpcProvider);

    broker.setNotificationBroker(getNotificationServiceDependency());
    if (getNotificationPublishServiceDependency() != null) {
        broker.setNotificationPublishService(getNotificationPublishServiceDependency());
    }
    broker.setRpcBroker(heliumRpcBroker);
    broker.setDataBroker(getRootDataBrokerDependency());
    broker.setMountService(mount);
    broker.start();
    return broker;
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public void instantiateServiceInstance() throws ExecutionException, InterruptedException {
    final RpcProviderRegistry rpcRegistry = this.dependenciesProvider.getRpcProviderRegistry();

    this.element = requireNonNull(rpcRegistry
            .addRoutedRpcImplementation(NetworkTopologyPcepService.class, new TopologyRPCs(this.manager)));
    this.element.registerPath(NetworkTopologyContext.class, this.configDependencies.getTopology());

    this.network = requireNonNull(rpcRegistry
            .addRoutedRpcImplementation(NetworkTopologyPcepProgrammingService.class,
                    new TopologyProgramming(this.scheduler, this.manager)));
    this.network.registerPath(NetworkTopologyContext.class, this.configDependencies.getTopology());

    this.manager.instantiateServiceInstance();
    final ChannelFuture channelFuture = this.dependenciesProvider.getPCEPDispatcher()
            .createServer(this.manager.getPCEPDispatcherDependencies());
    channelFuture.get();
    this.channel = channelFuture.channel();
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public PCEPTopologyProviderBean(
        final ClusterSingletonServiceProvider cssp,
        final BundleContext bundleContext,
        final DataBroker dataBroker,
        final PCEPDispatcher pcepDispatcher,
        final RpcProviderRegistry rpcProviderRegistry,
        final TopologySessionListenerFactory sessionListenerFactory,
        final TopologySessionStatsRegistry stateRegistry) {
    this.cssp = requireNonNull(cssp);
    this.bundleContext = requireNonNull(bundleContext);
    this.pcepDispatcher = requireNonNull(pcepDispatcher);
    this.dataBroker = requireNonNull(dataBroker);
    this.sessionListenerFactory = requireNonNull(sessionListenerFactory);
    this.rpcProviderRegistry = requireNonNull(rpcProviderRegistry);
    this.stateRegistry = requireNonNull(stateRegistry);
    final List<PCEPCapability> capabilities = this.pcepDispatcher.getPCEPSessionNegotiatorFactory()
            .getPCEPSessionProposalFactory().getCapabilities();
    final boolean statefulCapability = capabilities.stream().anyMatch(PCEPCapability::isStateful);
    if (!statefulCapability) {
        throw new IllegalStateException(STATEFUL_NOT_DEFINED);
    }
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的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.RpcProviderRegistry; //导入依赖的package包/类
private void onRpcRegistry(final Object service) {
    log.debug("{}: Retrieved RpcProviderRegistry {}", logName(), service);
    rpcRegistry = (RpcProviderRegistry)service;

    // Now acquire SchemaService...
    retrieveService("SchemaService", DOMSchemaService.class, this::onSchemaService);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public EventSourceTopology(final DataBroker dataBroker, final RpcProviderRegistry rpcRegistry) {

        this.dataBroker = dataBroker;
        this.rpcRegistry = rpcRegistry;
        aggregatorRpcReg = rpcRegistry.addRpcImplementation(EventAggregatorService.class, this);
        eventSourceService = rpcRegistry.getRpcService(EventSourceService.class);

        final TopologyEventSource topologySource = new TopologyEventSourceBuilder().build();
        final TopologyTypes1 topologyTypeAugment = new TopologyTypes1Builder().setTopologyEventSource(topologySource).build();
        putData(OPERATIONAL, TOPOLOGY_TYPE_PATH, topologyTypeAugment);
        LOG.info("EventSourceRegistry has been initialized");
    }
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的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.RpcProviderRegistry; //导入依赖的package包/类
public MdsalLowLevelTestProvider(final RpcProviderRegistry rpcRegistry,
                                 final DOMRpcProviderService domRpcService,
                                 final ClusterSingletonServiceProvider singletonService,
                                 final SchemaService schemaService,
                                 final BindingNormalizedNodeSerializer bindingNormalizedNodeSerializer,
                                 final NotificationPublishService notificationPublishService,
                                 final NotificationService notificationService,
                                 final DOMDataBroker domDataBroker,
                                 final DOMDataTreeService domDataTreeService,
                                 final DistributedShardFactory distributedShardFactory,
                                 final DistributedDataStoreInterface configDataStore,
                                 final ActorSystemProvider actorSystemProvider) {
    this.rpcRegistry = rpcRegistry;
    this.domRpcService = domRpcService;
    this.singletonService = singletonService;
    this.schemaService = schemaService;
    this.bindingNormalizedNodeSerializer = bindingNormalizedNodeSerializer;
    this.notificationPublishService = notificationPublishService;
    this.notificationService = notificationService;
    this.domDataBroker = domDataBroker;
    this.domDataTreeService = domDataTreeService;
    this.distributedShardFactory = distributedShardFactory;
    this.configDataStore = configDataStore;
    this.actorSystem = actorSystemProvider.getActorSystem();

    this.prefixLeaderHandler = new PrefixLeaderHandler(domDataTreeService, bindingNormalizedNodeSerializer);

    domDataTreeChangeService =
            (DOMDataTreeChangeService) domDataBroker.getSupportedExtensions().get(DOMDataTreeChangeService.class);

    registration = rpcRegistry.addRpcImplementation(OdlMdsalLowlevelControlService.class, this);

    prefixShardHandler = new PrefixShardHandler(distributedShardFactory, domDataTreeService,
            bindingNormalizedNodeSerializer);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public BasicRpcTestProvider(final RpcProviderRegistry rpcProviderRegistry,
                            final ClusterSingletonServiceProvider singletonService) {
    this.rpcProviderRegistry = rpcProviderRegistry;
    this.singletonService = singletonService;

    singletonService.registerClusterSingletonService(this);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
@Inject
public GeniusProvider(final DataBroker dataBroker, final RpcProviderRegistry rpcProviderRegistry,
        final IInterfaceManager interfaceMgr) {
    this.dataBroker = dataBroker;
    this.interfaceMgr = interfaceMgr;
    this.interfaceManagerRpcService = rpcProviderRegistry.getRpcService(OdlInterfaceRpcService.class);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
@Inject
public StatisticsProvider(final DataBroker dataBroker, final RpcProviderRegistry rpcProviderRegistry,
        CounterRetriever counterRetriever, IInterfaceManager interfaceManager, IMdsalApiManager mdsalApiManager,
        IdManagerService idManagerService) {
    this.dataBroker = dataBroker;
    this.interfaceManager = interfaceManager;
    this.rpcProviderRegistry = rpcProviderRegistry;
    this.mdsalApiManager = mdsalApiManager;
    this.counterRetriever = counterRetriever;
    this.idManagerService = idManagerService;
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的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.RpcProviderRegistry; //导入依赖的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.RpcProviderRegistry; //导入依赖的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.RpcProviderRegistry; //导入依赖的package包/类
public ReferenceProvider(DataBroker dataBroker, RpcProviderRegistry rpcProviderRegistry) {
    this.dataBroker = dataBroker;
    this.salFlowService = rpcProviderRegistry.getRpcService(SalFlowService.class);
    this.referenceService = rpcProviderRegistry.addRpcImplementation(ReferenceService.class,
            new ReferenceMonitorImpl(dataBroker));

    ApplicationRegistryUtils.getInstance().setDb(dataBroker);
    ApplicationRegistryUtils.getInstance().initializeDataTree();
}
 

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

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


    // PacketProcessingService initialization for sending packet_outs
    PacketProcessingService packetProcessingService = rpcService
            .<PacketProcessingService> getRpcService(PacketProcessingService.class);


    // FlowObjective Service
    AtriumFlowObjectiveService flowObjectivesService = rpcService
            .<AtriumFlowObjectiveService> getRpcService(AtriumFlowObjectiveService.class);

    // RoutingConfigService initialization
    RoutingConfigService routingConfigService = this.getRoutingconfigDependency();
    RoutingService routingService = getRoutingserviceDependency();

    TunnellingConnectivityManager connectivityManager = new TunnellingConnectivityManager(dataService,
            routingConfigService, packetProcessingService, flowObjectivesService);

    // BGPRouter instantiation
    Bgprouter bgpRouter = new Bgprouter(connectivityManager, dataService, routingConfigService, routingService,
            packetProcessingService, flowObjectivesService);

    getNotificationServiceDependency().registerNotificationListener(connectivityManager);
    getBrokerDependency().registerConsumer(bgpRouter);

    // Start BGPRouter
    bgpRouter.start();

    return bgpRouter;
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public EndPointManager(DataBroker databroker, RpcProviderRegistry rpcRegistry, FabricContext fabricCtx) {
    this.databroker = databroker;
    this.rpcRegistry = rpcRegistry;
    this.fabricCtx = fabricCtx;

    DataTreeIdentifier<Endpoint> dtid = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
            Constants.DOM_ENDPOINTS_PATH.child(Endpoint.class));

    epListener = databroker.registerDataTreeChangeListener(dtid, this);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public DistributedFabricListener(InstanceIdentifier<FabricNode> fabricIId,
                        final DataBroker dataProvider,
                         final RpcProviderRegistry rpcRegistry,
                         final FabricContext fabricCtx) {
    this.fabricIId = fabricIId;
    this.fabricid = new FabricId(fabricIId.firstKeyOf(Node.class).getNodeId());
    this.dataBroker = dataProvider;
    this.rpcRegistry = rpcRegistry;

    executor = fabricCtx.executor;

    this.fabricCtx = fabricCtx;
    epMgr = new EndPointManager(dataProvider, rpcRegistry, fabricCtx);
}
 

import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; //导入依赖的package包/类
public VxlanFabricProvider(final DataBroker dataProvider,
                         final RpcProviderRegistry rpcRegistry,
                         final FabricRendererRegistry rendererRegistry,
                         final List<GatewayMac> availableMacs) {
    this.dataBroker = dataProvider;
    this.rpcRegistry = rpcRegistry;
    this.rendererRegistry = rendererRegistry;
    this.availableMacs = availableMacs;
}