import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Override
public void registerListeners() {
    super.registerListeners();
    String defaultTenant = FpcProvider.getInstance().getConfig().getDefaultTenantId();
    FpcIdentity defaultIdentity = (defaultTenant == null) ?  new FpcIdentity(0L) :  new FpcIdentity(defaultTenant);

    groupsDataTreeChangeListenerRegistration = this.db
               .registerDataTreeChangeListener(
                       new DataTreeIdentifier<DpnGroups>(LogicalDatastoreType.CONFIGURATION,
                               InstanceIdentifier.builder(Tenants.class)
                                 .child(Tenant.class, new TenantKey( defaultIdentity ))
                                 .child(FpcTopology.class)
                                 .child(DpnGroups.class).build() ),
                           new DpnGroupChangeManager() );
    LOG.info("DpnManager Registered");
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
private void retrieveInitialAppConfig(final DataBroker dataBroker) {
    LOG.debug("{}: Got DataBroker instance - reading app config {}", logName(), bindingContext.appConfigPath);

    setDependencyDesc("Initial app config " + bindingContext.appConfigBindingClass.getSimpleName());

    // We register a DTCL to get updates and also read the app config data from the data store. If
    // the app config data is present then both the read and initial DTCN update will return it. If the
    // the data isn't present, we won't get an initial DTCN update so the read will indicate the data
    // isn't present.

    DataTreeIdentifier<DataObject> dataTreeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
            bindingContext.appConfigPath);
    appConfigChangeListenerReg = dataBroker.registerDataTreeChangeListener(dataTreeId,
            (ClusteredDataTreeChangeListener<DataObject>) this::onAppConfigChanged);

    readInitialAppConfig(dataBroker);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void onDataTreeChangedTest() {
    InstanceIdentifier<Node> instanceIdentifierMock = mock(InstanceIdentifier.class);
    DataTreeModification<Node> mockDataTreeModification = mock(DataTreeModification.class);
    DataObjectModification<Node> mockModification = mock(DataObjectModification.class);
    doReturn(mockModification).when(mockDataTreeModification).getRootNode();
    doReturn(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, instanceIdentifierMock))
            .when(mockDataTreeModification).getRootPath();
    doReturn(DataObjectModification.ModificationType.WRITE).when(mockModification).getModificationType();

    Node dataObjectNodeMock = mock(Node.class);
    doReturn(getNodeKey("testNodeId01")).when(dataObjectNodeMock).getKey();
    NodeId nodeIdMock = mock(NodeId.class);
    doReturn(nodeIdMock).when(dataObjectNodeMock).getNodeId();
    doReturn("nodeIdPattern1").when(nodeIdMock).getValue();

    doReturn(dataObjectNodeMock).when(mockModification).getDataAfter();

    eventSourceTopic.onDataTreeChanged(Collections.singletonList(mockDataTreeModification));
    verify(dataObjectNodeMock).getNodeId();
    verify(nodeIdMock).getValue();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Override
public <T extends DataObject, L extends DataTreeChangeListener<T>> ListenerRegistration<L> registerDataTreeChangeListener(
        final DataTreeIdentifier<T> treeId, final L listener) {
    final DOMDataTreeIdentifier domIdentifier = toDomTreeIdentifier(treeId);

    @SuppressWarnings({ "rawtypes", "unchecked" })
    final BindingDOMDataTreeChangeListenerAdapter<T> domListener =
            listener instanceof ClusteredDataTreeChangeListener ?
                    new BindingClusteredDOMDataTreeChangeListenerAdapter<>(
                            codec, (ClusteredDataTreeChangeListener) listener, treeId.getDatastoreType()) :
                    new BindingDOMDataTreeChangeListenerAdapter<>(codec, listener, treeId.getDatastoreType());

    final ListenerRegistration<BindingDOMDataTreeChangeListenerAdapter<T>> domReg =
            dataTreeChangeService.registerDataTreeChangeListener(domIdentifier, domListener);
    return new BindingDataTreeChangeListenerRegistration<>(listener,domReg);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Test
public void testRegisterDataTreeChangeListener() {
    final BindingToNormalizedNodeCodec codec = new BindingToNormalizedNodeCodec(this.classLoadingStrategy, this.codecRegistry);

    final DataTreeChangeService service = BindingDOMDataTreeChangeServiceAdapter.create(codec, this.mockDOMService);

    doReturn(this.mockDOMReg).when(this.mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
            any(DOMDataTreeChangeListener.class));
    final DataTreeIdentifier<Top> treeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, TOP_PATH);
    final TestClusteredDataTreeChangeListener mockClusteredListener = new TestClusteredDataTreeChangeListener();
    service.registerDataTreeChangeListener(treeId , mockClusteredListener);

    verify(this.mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
            isA(ClusteredDOMDataTreeChangeListener.class));

    reset(this.mockDOMService);
    doReturn(this.mockDOMReg).when(this.mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
            any(DOMDataTreeChangeListener.class));
    final TestDataTreeChangeListener mockNonClusteredListener = new TestDataTreeChangeListener();
    service.registerDataTreeChangeListener(treeId , mockNonClusteredListener);

    verify(this.mockDOMService).registerDataTreeChangeListener(domDataTreeIdentifier(this.mockYangID),
            not(isA(ClusteredDOMDataTreeChangeListener.class)));
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Test
public void testWildcardedListListener() throws Exception {
    final EventCapturingListener<TopLevelList> listener = new EventCapturingListener<>();
    final DataTreeIdentifier<TopLevelList> wildcard = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, TOP_PATH.child(TopLevelList.class));
    dataBrokerImpl.registerDataTreeChangeListener(wildcard, listener);

    putTx(TOP_PATH, TOP_INITIAL_DATA).submit().checkedGet();

    final DataTreeModification<TopLevelList> fooWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
    assertEquals(FOO_PATH, fooWriteEvent.getRootPath().getRootIdentifier());
    verifyModification(fooWriteEvent.getRootNode(), FOO_ARGUMENT, ModificationType.WRITE);

    putTx(BAR_PATH, BAR_DATA).submit().checkedGet();
    final DataTreeModification<TopLevelList> barWriteEvent = Iterables.getOnlyElement(listener.nextEvent());
    assertEquals(BAR_PATH, barWriteEvent.getRootPath().getRootIdentifier());
    verifyModification(barWriteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.WRITE);

    deleteTx(BAR_PATH).submit().checkedGet();
    final DataTreeModification<TopLevelList> barDeleteEvent = Iterables.getOnlyElement(listener.nextEvent());
    assertEquals(BAR_PATH, barDeleteEvent.getRootPath().getRootIdentifier());
    verifyModification(barDeleteEvent.getRootNode(), BAR_ARGUMENT, ModificationType.DELETE);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testDataTreeChangeListener() throws Exception {
    DataBroker dataBroker = getDataBroker();

    DataTreeChangeListener<ListItem> listener = mock(DataTreeChangeListener.class);
    InstanceIdentifier<ListItem> wildCard = InstanceIdentifier.builder(ListenerTest.class)
            .child(ListItem.class).build();
    ListenerRegistration<DataTreeChangeListener<ListItem>> reg = dataBroker.registerDataTreeChangeListener(
            new DataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, wildCard), listener);

    final ListItem item = writeListItem();

    ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class);

    verify(listener, timeout(100)).onDataTreeChanged(captor.capture());

    Collection<DataTreeModification<ListItem>> mods = captor.getValue();
    assertEquals("ListItem", item, mods.iterator().next().getRootNode().getDataAfter());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    aclStatsService = new AclLiveStatisticsRpcServiceImpl(config, dataBroker, odlDirectStatsService);
    singleTransactionDataBroker = new SingleTransactionDataBroker(dataBroker);

    LOG.info("Acl mode: {}", config.getSecurityGroupMode());

    newElan(ELAN, ELAN_TAG);
    newElanInterface(ELAN, PORT_1, true);

    Pair<DataTreeIdentifier<Interface>, Interface> port1 = new IdentifiedInterfaceWithAclBuilder()
            .interfaceName(PORT_1)
            .portSecurity(true).build();
    dataBrokerUtil.put(port1);
    testInterfaceManager.addInterface(port1.getValue());
    putNewStateInterface(dataBroker, "port1", PORT_MAC_1);
    asyncEventsWaiter.awaitEventsConsumption();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
public final void start() {

		bgpUpdatesExecutor.execute(new Runnable() {
			@Override
			public void run() {
				doUpdatesThread();
			}
		});

		// Starting host listener
		hostService.start();

		hostService.addListener(new InternalHostListener());

		final InstanceIdentifier<Tables> tablesId = this.localRibRef.getInstanceIdentifier().child(LocRib.class)
				.child(Tables.class, new TablesKey(AFI, SAFI));
		final DataTreeIdentifier<T> id = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
				getRouteWildcard(tablesId));
		dataTreeChangeService.registerDataTreeChangeListener(id, this);

		LOG.info("Rib Manager Started");
	}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
synchronized void init() {
    final WriteTransaction tx = this.dataBroker.newWriteOnlyTransaction();
    tx.put(LogicalDatastoreType.OPERATIONAL, getTopologyReference().getInstanceIdentifier(),
            new TopologyBuilder().setTopologyId(this.tunneltopologyId)
                    .setTopologyTypes(new TopologyTypesBuilder()
                            .addAugmentation(TopologyTypes1.class, new TopologyTypes1Builder()
                                    .setTopologyTunnelPcep(
                                            new TopologyTunnelPcepBuilder().build()).build()).build())
                    .setNode(new ArrayList<>()).build(), true);
    try {
        tx.submit().get();
    } catch (final InterruptedException | ExecutionException e) {
        LOG.error("Failed to create Tunnel Topology root", e);
    }
    this.reg = this.ncl.getDataProvider()
            .registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, this.src),
                    this.ncl);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
public void init() {
    logger.info("logging levels: error={}, warn={}, info={}, debug={}, trace={}",
                logger.isErrorEnabled(), logger.isWarnEnabled(),
                logger.isInfoEnabled(), logger.isDebugEnabled(), logger.isTraceEnabled());

    final DataTreeIdentifier<Ccap> ccapsDataTreeIid =
            new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, ccapsIID.child(Ccap.class));

    final DataTreeIdentifier<Gate> appDataTreeIid =
            new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
                    qosIID.child(Apps.class).child(App.class).child(Subscribers.class).child(Subscriber.class).child(Gates.class).child(Gate.class));

    ccapsDataTreeChangeListenerRegistration =
            dataBroker.registerDataTreeChangeListener(ccapsDataTreeIid, new CcapsDataTreeChangeListener());

    qosDataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(appDataTreeIid, new QosDataTreeChangeListener());

    rpcRegistration = rpcProviderRegistry.addRpcImplementation(PacketcableService.class, this);
    routedRpcRegistration = rpcProviderRegistry.addRoutedRpcImplementation(PacketcableService.class, this);

    logger.info("Packetcable Session Initiated");
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
/**
 * Registers Change Listener for Descriptors under the Tenant.
 */
public void registerListeners() {
    dataTreeChangeListenerRegistration = this.db
               .registerDataTreeChangeListener(
                       new DataTreeIdentifier<Contexts>(LogicalDatastoreType.OPERATIONAL,
                              InstanceIdentifier.builder(Tenants.class)
                                .child(Tenant.class, new TenantKey( tenantId ))
                                .child(FpcMobility.class)
                                .child(Contexts.class).build() ),
                           new ContextChangeManager() );
    LOG.info("ContextChangeManager Registered for Tenant {}", tenantId);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
/**
 * Registers Change Listener for Dpns under the Tenant.
 */
public void registerListeners() {
    dataTreeChangeListenerRegistration = this.db
               .registerDataTreeChangeListener(
                       new DataTreeIdentifier<Dpns>(LogicalDatastoreType.CONFIGURATION,
                              InstanceIdentifier.builder(Tenants.class)
                                .child(Tenant.class, new TenantKey( tenantId ))
                                .child(FpcTopology.class)
                                .child(Dpns.class).build() ),
                           new DpnChangeManager() );
    LOG.info("DpnChangeManager Registered for Tenant {}", tenantId);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
public void createAndRegisterListeners(final int numListeners) {
    for (int i = 0; i < numListeners; i++) {
        DsbenchmarkListener listener = new DsbenchmarkListener();
        listeners.add(dataBroker.registerDataTreeChangeListener(
                new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, TEST_EXEC_IID), listener));
        listeners.add(dataBroker.registerDataTreeChangeListener(
                new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, TEST_EXEC_IID), listener));

    }
    LOG.debug("DsbenchmarkListenerProvider created {} listeneres", numListeners);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
private void registerListner(final EventSourceTopology eventSourceTopology) {
    this.listenerRegistration =
            eventSourceTopology.getDataBroker().registerDataTreeChangeListener(new DataTreeIdentifier<>(
                    LogicalDatastoreType.OPERATIONAL,
                    EventSourceTopology.EVENT_SOURCE_TOPOLOGY_PATH.child(Node.class)),
                    this);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
private void topicTestHelper() throws Exception{
    constructorTestHelper();
    createTopicInputMock = mock(CreateTopicInput.class);
    eventSourceTopology = new EventSourceTopology(dataBrokerMock, rpcProviderRegistryMock);

    NotificationPattern notificationPattern = new NotificationPattern("value1");
    doReturn(notificationPattern).when(createTopicInputMock).getNotificationPattern();
    Pattern pattern = new Pattern("valuePattern1");
    doReturn(pattern).when(createTopicInputMock).getNodeIdPattern();

    listenerRegistrationMock = mock(ListenerRegistration.class);
    doReturn(listenerRegistrationMock).when(dataBrokerMock).registerDataTreeChangeListener(
            any(DataTreeIdentifier.class), any(EventSourceTopic.class));

    ReadOnlyTransaction readOnlyTransactionMock = mock(ReadOnlyTransaction.class);
    doReturn(readOnlyTransactionMock).when(dataBrokerMock).newReadOnlyTransaction();

    CheckedFuture checkedFutureMock = mock(CheckedFuture.class);
    doReturn(checkedFutureMock).when(readOnlyTransactionMock).read(eq(LogicalDatastoreType.OPERATIONAL),
            any(InstanceIdentifier.class));
    Optional optionalMock = mock(Optional.class);
    doReturn(optionalMock).when(checkedFutureMock).checkedGet();
    doReturn(true).when(optionalMock).isPresent();

    Topology topologyMock = mock(Topology.class);
    doReturn(topologyMock).when(optionalMock).get();
    Node nodeMock = mock(Node.class);
    List<Node> nodeList = new ArrayList<>();
    nodeList.add(nodeMock);
    doReturn(nodeList).when(topologyMock).getNode();

    NodeId nodeId = new NodeId("nodeIdValue1");
    doReturn(nodeId).when(nodeMock).getNodeId();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Override
public <T extends DataObject, L extends DataTreeChangeListener<T>> ListenerRegistration<L> registerDataTreeChangeListener(
        final DataTreeIdentifier<T> treeId, final L listener) {
    if(treeChangeService == null) {
        throw new UnsupportedOperationException("Underlying data broker does not expose DOMDataTreeChangeService.");
    }
    return treeChangeService.registerDataTreeChangeListener(treeId, listener);
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
public void init() {
    LOG.info("Initializing...");

    Preconditions.checkNotNull(dataBroker, "dataBroker must be set");
    dataTreeChangeListenerRegistration = dataBroker.registerDataTreeChangeListener(
            new DataTreeIdentifier<>(CONFIGURATION, TOASTER_IID), this);
    setToasterStatusUp(null);

    // Register our MXBean.
    register();
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
protected void newAllowedAddressPair(String portName, List<String> sgUuidList, List<AllowedAddressPairs> aapList)
        throws TransactionCommitFailedException {
    List<Uuid> sgList = sgUuidList.stream().map(Uuid::new).collect(Collectors.toList());
    Pair<DataTreeIdentifier<Interface>, Interface> port = new IdentifiedInterfaceWithAclBuilder()
            .interfaceName(portName)
            .portSecurity(true)
            .addAllNewSecurityGroups(sgList)
            .addAllIfAllowedAddressPairs(aapList).build();
    dataBrokerUtil.put(port);
    testInterfaceManager.addInterface(port.getValue());
}
 

import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; //导入依赖的package包/类
@Inject
public SnatNodeEventListener(final DataBroker dataBroker,
        final CentralizedSwitchScheduler centralizedSwitchScheduler) {

    super(dataBroker,new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
            .create(Nodes.class).child(Node.class)),
            Executors.newSingleThreadExecutor());
    this.centralizedSwitchScheduler = centralizedSwitchScheduler;
}