Java ListenerRegistration类代码示例

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
protected AbstractDOMDataBroker(final Map<LogicalDatastoreType, DOMStore> datastores) {
    super(datastores);

    boolean treeChange = true;
    for (DOMStore ds : datastores.values()) {
        if (!(ds instanceof DOMStoreTreeChangePublisher)) {
            treeChange = false;
            break;
        }
    }

    if (treeChange) {
        extensions = ImmutableMap.<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension>of(DOMDataTreeChangeService.class, new DOMDataTreeChangeService() {
            @Nonnull
            @Override
            public <L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerDataTreeChangeListener(@Nonnull final DOMDataTreeIdentifier treeId, @Nonnull final L listener) {
                DOMStore publisher = getTxFactories().get(treeId.getDatastoreType());
                checkState(publisher != null, "Requested logical data store is not available.");

                return ((DOMStoreTreeChangePublisher)publisher).registerTreeChangeListener(treeId.getRootIdentifier(), listener);
            }
        });
    } else {
        extensions = Collections.emptyMap();
    }
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
void deliverNotification() {
    LOG.trace("Start delivery of notification {}", notification);
    for (ListenerRegistration<? extends DOMNotificationListener> r : subscribers) {
        final DOMNotificationListener listener = r.getInstance();
        if (listener != null) {
            try {
                LOG.trace("Notifying listener {}", listener);
                listener.onNotification(notification);
                LOG.trace("Listener notification completed");
            } catch (Exception e) {
                LOG.error("Delivery of notification {} caused an error in listener {}", notification, listener, e);
            }
        }
    }
    LOG.trace("Delivery completed");
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Test
public void testNotifSubscription() throws InterruptedException {
    final CountDownLatch latch = new CountDownLatch(1);
    final TwoLevelListChanged testData = createTestData();

    final TestNotifListener testNotifListener = new TestNotifListener(latch);
    final ListenerRegistration<TestNotifListener> listenerRegistration = getNotificationService()
            .registerNotificationListener(testNotifListener);
    getNotificationPublishService().putNotification(testData);

    latch.await();
    assertTrue(testNotifListener.getReceivedNotifications().size() == 1);
    assertEquals(testData, testNotifListener.getReceivedNotifications().get(0));

    listenerRegistration.close();
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
<L extends DOMDataTreeChangeListener> ListenerRegistration<L> registerTreeChangeListener(final YangInstanceIdentifier treeId, final L listener, final DataTreeSnapshot snapshot) {
    final AbstractDOMDataTreeChangeListenerRegistration<L> reg = registerTreeChangeListener(treeId, listener);

    final Optional<NormalizedNode<?, ?>> node = snapshot.readNode(YangInstanceIdentifier.EMPTY);
    if (node.isPresent()) {
        final DataTreeCandidate candidate = DataTreeCandidates.fromNormalizedNode(
                YangInstanceIdentifier.EMPTY, node.get());

        InMemoryDOMStoreTreeChangePublisher publisher =
                new InMemoryDOMStoreTreeChangePublisher(notificationManager);
        publisher.registerTreeChangeListener(treeId, listener);
        publisher.publishChange(candidate);
    }

    return reg;
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <L extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>>
                                          ListenerRegistration<L> registerChangeListener(
    final YangInstanceIdentifier path, final L listener,
    final AsyncDataBroker.DataChangeScope scope) {

    Preconditions.checkNotNull(path, "path should not be null");
    Preconditions.checkNotNull(listener, "listener should not be null");

    LOG.debug("Registering listener: {} for path: {} scope: {}", listener, path, scope);

    String shardName = actorContext.getShardStrategyFactory().getStrategy(path).findShard(path);

    final DataChangeListenerRegistrationProxy listenerRegistrationProxy =
            new DataChangeListenerRegistrationProxy(shardName, actorContext, listener);
    listenerRegistrationProxy.init(path, scope);

    return listenerRegistrationProxy;
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Test
public void testNotifSubscription2() throws InterruptedException {
    final CountDownLatch latch = new CountDownLatch(1);
    final TwoLevelListChanged testData = createTestData();

    final TestNotifListener testNotifListener = new TestNotifListener(latch);
    final ListenerRegistration<TestNotifListener> listenerRegistration = getNotificationService()
            .registerNotificationListener(testNotifListener);
    try {
        getNotificationPublishService().offerNotification(testData).get(1, TimeUnit.SECONDS);
    } catch (ExecutionException | TimeoutException e) {
        LOG.error("Notification delivery failed", e);
        Assert.fail("notification should be delivered");
    }

    latch.await();
    assertTrue(testNotifListener.getReceivedNotifications().size() == 1);
    assertEquals(testData, testNotifListener.getReceivedNotifications().get(0));

    listenerRegistration.close();
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public void registerTreeChangeListener(YangInstanceIdentifier treeId, DOMDataTreeChangeListener listener,
        Optional<DataTreeCandidate> initialState,
        Consumer<ListenerRegistration<DOMDataTreeChangeListener>> onRegistration) {
    LOG.debug("{}: registerTreeChangeListener: path: {}, listener: {}", logContext, treeId, listener);

    AbstractDOMDataTreeChangeListenerRegistration<org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener>
        registration = super.registerTreeChangeListener(treeId, new ForwardingDOMDataTreeChangeListener(listener));

    onRegistration.accept(
        new org.opendaylight.controller.md.sal.dom.spi.AbstractDOMDataTreeChangeListenerRegistration<
                DOMDataTreeChangeListener>(listener) {
            @Override
            protected void removeRegistration() {
                registration.close();
            }
        });

    if (initialState.isPresent()) {
        notifySingleListener(treeId, listener, initialState.get(), logContext);
    }
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Nonnull
@Override
public <T extends DOMDataTreeShard> ListenerRegistration<T> registerDataTreeShard(
        @Nonnull final DOMDataTreeIdentifier prefix,
        @Nonnull final T shard,
        @Nonnull final DOMDataTreeProducer producer)
        throws DOMDataTreeShardingConflictException {

    LOG.debug("Registering shard[{}] at prefix: {}", shard, prefix);

    if (producer instanceof ProxyProducer) {
        return shardedDOMDataTree.registerDataTreeShard(prefix, shard, ((ProxyProducer) producer).delegate());
    }

    return shardedDOMDataTree.registerDataTreeShard(prefix, shard, producer);
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public Future<RpcResult<UnsubscribeYnlOutput>> unsubscribeYnl(final UnsubscribeYnlInput input) {
    LOG.debug("Received unsubscribe-ynl, input: {}", input);

    if (!ynlRegistrations.containsKey(input.getId())) {
        final RpcError rpcError = RpcResultBuilder
                .newError(ErrorType.APPLICATION, "missing-registration", "No ynl listener with this id registered.");
        final RpcResult<UnsubscribeYnlOutput> result =
                RpcResultBuilder.<UnsubscribeYnlOutput>failed().withRpcError(rpcError).build();
        return Futures.immediateFuture(result);
    }

    final ListenerRegistration<YnlListener> registration = ynlRegistrations.remove(input.getId());
    final UnsubscribeYnlOutput output = registration.getInstance().getOutput();

    registration.close();

    return Futures.immediateFuture(RpcResultBuilder.<UnsubscribeYnlOutput>success().withResult(output).build());
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的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.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
public long getDataChangeCount() {
    long dataChanges = 0;

    for (ListenerRegistration<DsbenchmarkListener> listenerRegistration : listeners) {
        dataChanges += listenerRegistration.getInstance().getNumDataChanges();
    }
    LOG.debug("DsbenchmarkListenerProvider , total data changes {}", dataChanges);
    return dataChanges;
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store,
        final YangInstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {

    DOMStore potentialStore = getTxFactories().get(store);
    checkState(potentialStore != null, "Requested logical data store is not available.");
    return potentialStore.registerChangeListener(path, listener, triggeringScope);
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store,
                                                                              final YangInstanceIdentifier path,
                                                                              final DOMDataChangeListener listener,
                                                                              final DataChangeScope triggeringScope) {
    throw new UnsupportedOperationException("Registering data change listeners is not supported in " +
            "md-sal forwarding data broker");

}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public <T extends DOMDataTreeShard> ListenerRegistration<T> registerDataTreeShard(final DOMDataTreeIdentifier prefix, final T shard) throws DOMDataTreeShardingConflictException {
    final ShardRegistration<T> reg;
    final ShardRegistration<?> parentReg;

    synchronized (this) {
        /*
         * Lookup the parent shard (e.g. the one which currently matches the prefix),
         * and if it exists, check if its registration prefix does not collide with
         * this registration.
         */
        final ShardingTableEntry parent = lookupShard(prefix);
        parentReg = parent.getRegistration();
        if (parentReg != null && prefix.equals(parentReg.getPrefix())) {
            throw new DOMDataTreeShardingConflictException(String.format("Prefix %s is already occupied by shard %s", prefix, parentReg.getInstance()));
        }

        // FIXME: wrap the shard in a proper adaptor based on implemented interface

        reg = new ShardRegistration<>(this, prefix, shard);

        storeShard(prefix, reg);

        // FIXME: update any producers/registrations
    }

    // Notify the parent shard
    if (parentReg != null) {
        parentReg.getInstance().onChildAttached(prefix, shard);
    }

    return reg;
}
 

import org.opendaylight.yangtools.concepts.ListenerRegistration; //导入依赖的package包/类
@Override
public synchronized <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(
        final T listener) {
    final Registration<T> ret = new Registration<>(this, listener, routingTable.getRpcs(listener));
    final Builder<Registration<?>> b = ImmutableList.builder();
    b.addAll(listeners);
    b.add(ret);
    listeners = b.build();

    listenerNotifier.execute(ret::initialTable);
    return ret;
}