import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
public void register(final EventSource eventSource){

        final NodeKey nodeKey = eventSource.getSourceNodeKey();
        final KeyedInstanceIdentifier<Node, NodeKey> sourcePath = EVENT_SOURCE_TOPOLOGY_PATH.child(Node.class, nodeKey);
        final RoutedRpcRegistration<EventSourceService> reg = rpcRegistry.addRoutedRpcImplementation(EventSourceService.class, eventSource);
        reg.registerPath(NodeContext.class, sourcePath);
        routedRpcRegistrations.put(nodeKey,reg);
        insert(sourcePath);

    }
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
public void unRegister(final EventSource eventSource){
    final NodeKey nodeKey = eventSource.getSourceNodeKey();
    final KeyedInstanceIdentifier<Node, NodeKey> sourcePath = EVENT_SOURCE_TOPOLOGY_PATH.child(Node.class, nodeKey);
    final RoutedRpcRegistration<EventSourceService> removeRegistration = routedRpcRegistrations.remove(nodeKey);
    if(removeRegistration != null){
        removeRegistration.close();
    remove(sourcePath);
    }
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public Future<RpcResult<StartTestOutput>> startTest(final StartTestInput input) {
    LOG.debug("startTest {}", input);

    final RTCClient client;
    final List<RoutedRpcRegistration<?>> rpcRegs = new ArrayList<>();

    switch (input.getOperation()) {
    case ROUTEDRTC:
        List<InstanceIdentifier<?>> routeIid = new ArrayList<>();
        for (int i = 0; i < input.getNumServers().intValue(); i++) {
            GlobalBindingRTCServer server = new GlobalBindingRTCServer();
            RoutedRpcRegistration<RpcbenchPayloadService> routedReg =
                    providerRegistry.addRoutedRpcImplementation(RpcbenchPayloadService.class, server);

            KeyedInstanceIdentifier<RpcRoute, RpcRouteKey> iid =
                    InstanceIdentifier
                        .create(RpcbenchRpcRoutes.class)
                        .child(RpcRoute.class, new RpcRouteKey(Integer.toString(i)));
            routeIid.add(iid);
            routedReg.registerPath(NodeContext.class, iid);
            rpcRegs.add(routedReg);
        }

        client = new RoutedBindingRTClient(providerRegistry, input.getPayloadSize().intValue(), routeIid);
        break;

    case GLOBALRTC:
        client = new GlobalBindingRTCClient(providerRegistry, input.getPayloadSize().intValue());
        break;

    default:
        LOG.error("Unsupported server/client type {}", input.getOperation());
        throw new IllegalArgumentException("Unsupported server/client type" + input.getOperation());
    }

    try {
        ExecutorService executor = Executors.newFixedThreadPool(input.getNumClients().intValue());

        final Runnable testRun = () -> client.runTest(input.getIterations().intValue());

        LOG.info("Test Started");
        long startTime = System.nanoTime();

        for (int i = 0; i < input.getNumClients().intValue(); i++ ) {
            executor.submit(testRun);
        }

        executor.shutdown();
        try {
            executor.awaitTermination(testTimeout, TimeUnit.MINUTES);
        } catch (final InterruptedException e) {
            LOG.error("Out of time: test did not finish within the {} min deadline ", testTimeout);
        }

        long endTime = System.nanoTime();
        LOG.info("Test Done");

        long elapsedTime = endTime - startTime;

        StartTestOutput output = new StartTestOutputBuilder()
                                        .setRate((long)0)
                                        .setGlobalRtcClientError(client.getRpcError())
                                        .setGlobalRtcClientOk(client.getRpcOk())
                                        .setExecTime(TimeUnit.NANOSECONDS.toMillis(elapsedTime))
                                        .setRate((client.getRpcOk() + client.getRpcError()) * 1000000000 / elapsedTime)
                                        .build();
        return RpcResultBuilder.success(output).buildFuture();
    } finally {
        for (RoutedRpcRegistration<?> routedRpcRegistration : rpcRegs) {
            routedRpcRegistration.close();
        }
    }
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public boolean canConvert(final Object sourceObject, final ReifiedType targetType) {
    return sourceObject instanceof RoutedRpcRegistration
            && RoutedRpcRegistration.class.isAssignableFrom(targetType.getRawClass());
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public void destroy(final Object instance) {
    LOG.debug("{}: In destroy: instance: {}", logName(), instance);

    ((RoutedRpcRegistration<?>)instance).close();
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public <T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(final Class<T> type,
        final T implementation) throws IllegalStateException {
    return getRpcRegistryChecked().addRoutedRpcImplementation(type, implementation);
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public <T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(Class<T> type,
        T implementation) throws IllegalStateException {
    return getSALService(RpcProviderRegistry.class).addRoutedRpcImplementation(type, implementation);
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
@Override
public <T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(final Class<T> type, final T impl)
        throws IllegalStateException {
    return new CompositeRoutedRpcRegistration<>(type,impl,providerAdapter);
}
 

import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration; //导入依赖的package包/类
/**
 * Registers an implementation of the given routed RPC service interface.
 * <p>
 * See the {@link RpcProviderRegistry class} documentation for information and example on
 * how to use routed RPCs.
 *
 * @param serviceInterface the YANG-generated interface of the RPC Service for which to register.
 * @param implementation the implementation instance to register.
 * @return a RoutedRpcRegistration instance which can be used to register paths for the RPC
 *         implementation via invoking RoutedRpcRegistration#registerPath(Class, InstanceIdentifer).
 *         {@link RoutedRpcRegistration#close()} should be called to unregister the implementation
 *         and all previously registered paths when no longer needed.
 *
 * @throws IllegalStateException
 *            if the supplied RPC interface is not a routed RPC type.
 */
<T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(Class<T> serviceInterface,
                                                                           T implementation)
        throws IllegalStateException;