Java Serializer.using方法代码示例

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
public void activate() {
    Serializer serializer = Serializer.using(KryoNamespaces.API,
                    ObjectNode.class, ArrayNode.class,
                    JsonNodeFactory.class, LinkedHashMap.class,
                    TextNode.class, BooleanNode.class,
                    LongNode.class, DoubleNode.class, ShortNode.class,
                    IntNode.class, NullNode.class);

    prefsConsistentMap = storageService.<String, ObjectNode>consistentMapBuilder()
            .withName(ONOS_USER_PREFERENCES)
            .withSerializer(serializer)
            .withRelaxedReadConsistency()
            .build();
    prefsConsistentMap.addListener(prefsListener);
    prefs = prefsConsistentMap.asJavaMap();
    register(core);
    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setup() {
    // Init step
    meterStore = new DistributedMeterStore();
    // Let's initialize some internal services
    TestUtils.setField(meterStore, "storageService", new TestStorageService());
    TestUtils.setField(meterStore, "clusterService", new TestClusterService());
    TestUtils.setField(meterStore, "mastershipService", new TestMastershipService());
    TestUtils.setField(meterStore, "driverService", new TestDriverService());

    // Inject TestApplicationId into the DistributedMeterStore serializer
    KryoNamespace.Builder testKryoBuilder = TestUtils.getField(meterStore, "APP_KRYO_BUILDER");
    testKryoBuilder.register(TestApplicationId.class);
    Serializer testSerializer = Serializer.using(Lists.newArrayList(testKryoBuilder.build()));
    TestUtils.setField(meterStore, "serializer", testSerializer);

    // Activate the store
    meterStore.activate();
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
private Serializer createSerializer(KryoNamespace ns) {
    return Serializer.using(KryoNamespace.newBuilder()
            .register(ns)
            // not so robust way to avoid collision with other
            // user supplied registrations
            .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID + 100)
            .register(KryoNamespaces.BASIC)
            .register(LogicalTimestamp.class)
            .register(WallClockTimestamp.class)
            .register(AntiEntropyAdvertisement.class)
            .register(AntiEntropyResponse.class)
            .register(UpdateEntry.class)
            .register(MapValue.class)
            .register(MapValue.Digest.class)
            .register(UpdateRequest.class)
            .build(name() + "-ecmap"));
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
protected void activate() {
    Serializer serializer =
            Serializer.using(Arrays.asList(KryoNamespaces.API),
                    Identifier.class);

    regionsRepo = storageService.<RegionId, Region>consistentMapBuilder()
            .withSerializer(serializer)
            .withName("onos-regions")
            .withRelaxedReadConsistency()
            .build();
    regionsRepo.addListener(listener);
    regionsById = regionsRepo.asJavaMap();

    membershipRepo = storageService.<RegionId, Set<DeviceId>>consistentMapBuilder()
            .withSerializer(serializer)
            .withName("onos-region-devices")
            .withRelaxedReadConsistency()
            .build();
    membershipRepo.addListener(membershipListener);
    regionDevices = membershipRepo.asJavaMap();
    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
protected void activate() {
    Serializer serializer =
            Serializer.using(Arrays.asList(KryoNamespaces.API),
                             Identifier.class,
                             RegionId.class,
                             Region.class,
                             DefaultRegion.class,
                             Region.Type.class);

    regionsRepo = storageService.<RegionId, Region>consistentMapBuilder()
            .withSerializer(serializer)
            .withName("onos-regions")
            .withRelaxedReadConsistency()
            .build();
    regionsRepo.addListener(listener);
    regionsById = regionsRepo.asJavaMap();

    membershipRepo = storageService.<RegionId, Set<DeviceId>>consistentMapBuilder()
            .withSerializer(serializer)
            .withName("onos-region-devices")
            .withRelaxedReadConsistency()
            .build();
    membershipRepo.addListener(membershipListener);
    regionDevices = membershipRepo.asJavaMap();
    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
public void activate() {
    Serializer serializer = Serializer.using(KryoNamespaces.API,
                 ObjectNode.class, ArrayNode.class,
                 JsonNodeFactory.class, LinkedHashMap.class,
                 TextNode.class, BooleanNode.class,
                 LongNode.class, DoubleNode.class, ShortNode.class,
                 IntNode.class, NullNode.class, UiSessionToken.class);

    prefsConsistentMap = storageService.<String, ObjectNode>consistentMapBuilder()
            .withName(ONOS_USER_PREFERENCES)
            .withSerializer(serializer)
            .withRelaxedReadConsistency()
            .build();
    prefsConsistentMap.addListener(prefsListener);
    prefs = prefsConsistentMap.asJavaMap();

    tokensConsistentMap = storageService.<UiSessionToken, String>consistentMapBuilder()
            .withName(ONOS_SESSION_TOKENS)
            .withSerializer(serializer)
            .withRelaxedReadConsistency()
            .build();
    tokens = tokensConsistentMap.asJavaMap();

    register(core);

    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
public void activate() {

    Serializer serializer = Serializer.using(KryoNamespaces.API,
                                                Mapping.class,
                                                DefaultMapping.class,
                                                MappingId.class,
                                                MappingEvent.Type.class,
                                                MappingKey.class,
                                                MappingValue.class,
                                                MappingAddress.class,
                                                MappingAddress.Type.class,
                                                MappingAction.class,
                                                MappingAction.Type.class,
                                                MappingTreatment.class,
                                                MappingInstruction.class,
                                                MappingInstruction.Type.class);

    database = storageService.<MappingId, Mapping>consistentMapBuilder()
                    .withName("onos-mapping-database")
                    .withSerializer(serializer)
                    .build();

    cache = storageService.<MappingId, Mapping>consistentMapBuilder()
                    .withName("onos-mapping-cache")
                    .withSerializer(serializer)
                    .build();

    database.addListener(listener);
    cache.addListener(listener);
    databaseMap = database.asJavaMap();
    cacheMap = cache.asJavaMap();
    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
private CompletableFuture<StoragePartitionClient> openClient() {
    client = new StoragePartitionClient(this,
            MemberId.from(localNodeId.id()),
            new RaftClientCommunicator(
                    String.format("partition-%s-%s", partition.getId(), partition.getVersion()),
                    Serializer.using(StorageNamespaces.RAFT_PROTOCOL),
                    clusterCommunicator));
    return client.open().thenApply(v -> client);
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    serializer = Serializer.using(KryoNamespaces.API);
    map = new HashMap<>();
    baseMap = new AsyncConsistentMapMock<>();

    transcodingMap =  DistributedPrimitives.newTranscodingMap(
            baseMap,
            Function.identity(),
            Function.identity(),
            serializer::encode,
            serializer::decode);
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    baseMap = new HashMap<>();
    asyncMap1 = new AsyncConsistentMapMock<>(baseMap);
    asyncMap2 = new AsyncConsistentMapMock<>(baseMap);

    pid1 = PartitionId.from(1);
    pid2 = PartitionId.from(2);
    partitions = new HashMap<>();
    serializer = Serializer.using(KryoNamespaces.BASIC);

    asyncMap1.put(KEY1, VALUE1);
    asyncMap2.put(KEY2, VALUE2);
    partitions.put(pid1, asyncMap1);
    partitions.put(pid2, asyncMap2);

    sortedMemberPartitionIds = Lists.newArrayList(partitions.keySet());

    hasher = key -> {
        int hashCode = Hashing.sha256().hashBytes(serializer.encode(key)).asInt();
        return sortedMemberPartitionIds.get(Math.abs(hashCode) % partitions.size());
    };

    partitionedAsyncConsistentMap = new PartitionedAsyncConsistentMap(partitionName,
            partitions, hasher);

}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    serializer = Serializer.using(KryoNamespaces.API);
    asyncConsistentMap = new AsyncConsistentMapMock<>();
    name = "Default Name";
    map = new HashMap<>();
    collection = new ArrayList<>();
    set = new HashSet<>();

    defaultAsyncDistributedSet = new DefaultAsyncDistributedSet<>(asyncConsistentMap,
            name, MAGENT);
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setUp() throws Exception {
    asyncMap = new AsyncConsistentMapMock<>();
    serializer = Serializer.using(KryoNamespaces.BASIC);
    meteringAgent = new MeteringAgent(NAME, "*", false);
    defaultAsyncAtomicValue = new DefaultAsyncAtomicValue(MAPNAME, serializer,
            asyncMap, meteringAgent);
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Activate
public void activate() {
    cfgService.registerProperties(getClass());
    KryoNamespace.Builder kryoBuilder = new KryoNamespace.Builder()
            .register(KryoNamespaces.API)
            .nextId(KryoNamespaces.BEGIN_USER_CUSTOM_ID)
            .register(DefaultGroup.class,
                      DefaultGroupBucket.class,
                      DefaultGroupDescription.class,
                      DefaultGroupKey.class,
                      GroupDescription.Type.class,
                      Group.GroupState.class,
                      GroupBuckets.class,
                      GroupStoreMessage.class,
                      GroupStoreMessage.Type.class,
                      UpdateType.class,
                      GroupStoreMessageSubjects.class,
                      MultiValuedTimestamp.class,
                      GroupStoreKeyMapKey.class,
                      GroupStoreIdMapKey.class,
                      GroupStoreMapKey.class
            );

    clusterMsgSerializer = kryoBuilder.build("GroupStore");
    Serializer serializer = Serializer.using(clusterMsgSerializer);

    messageHandlingExecutor = Executors.
            newFixedThreadPool(MESSAGE_HANDLER_THREAD_POOL_SIZE,
                               groupedThreads("onos/store/group",
                                              "message-handlers",
                                              log));

    clusterCommunicator.addSubscriber(GroupStoreMessageSubjects.REMOTE_GROUP_OP_REQUEST,
                                      clusterMsgSerializer::deserialize,
                                      this::process,
                                      messageHandlingExecutor);

    log.debug("Creating Consistent map onos-group-store-keymap");

    groupStoreEntriesByKey = storageService.<GroupStoreKeyMapKey, StoredGroupEntry>consistentMapBuilder()
            .withName("onos-group-store-keymap")
            .withSerializer(serializer)
            .build();
    groupStoreEntriesByKey.addListener(new GroupStoreKeyMapListener());
    log.debug("Current size of groupstorekeymap:{}",
              groupStoreEntriesByKey.size());

    log.debug("Creating Consistent map pendinggroupkeymap");

    auditPendingReqQueue = storageService.<GroupStoreKeyMapKey, StoredGroupEntry>consistentMapBuilder()
            .withName("onos-pending-group-keymap")
            .withSerializer(serializer)
            .build();
    log.debug("Current size of pendinggroupkeymap:{}",
              auditPendingReqQueue.size());

    log.info("Started");
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Before
public void setup() {
    //Init step for the deviceService
    deviceService = new TestDeviceService();
    //Init step for the driver registry and driver service.
    DriverRegistryManager driverRegistry = new DriverRegistryManager();
    driverService = new TestDriverManager(driverRegistry, deviceService);
    driverRegistry.addDriver(new DefaultDriver("foo", ImmutableList.of(), "",
            "", "",
            ImmutableMap.of(MeterProgrammable.class,
                    TestMeterProgrammable.class, MeterQuery.class, TestMeterQuery.class),
            ImmutableMap.of()));

    // Init step for the store
    meterStore = new DistributedMeterStore();
    // Let's initialize some internal services of the store
    TestUtils.setField(meterStore, "storageService", new TestStorageService());
    TestUtils.setField(meterStore, "clusterService", new TestClusterService());
    TestUtils.setField(meterStore, "mastershipService", new TestMastershipService());
    TestUtils.setField(meterStore, "driverService", driverService);

    // Inject TestApplicationId into the DistributedMeterStore serializer
    KryoNamespace.Builder testKryoBuilder = TestUtils.getField(meterStore, "APP_KRYO_BUILDER");
    testKryoBuilder.register(TestApplicationId.class);
    Serializer testSerializer = Serializer.using(Lists.newArrayList(testKryoBuilder.build()));
    TestUtils.setField(meterStore, "serializer", testSerializer);

    // Activate the store
    meterStore.activate();
    // Init step for the manager
    manager = new MeterManager();
    // Let's initialize some internal services of the manager
    TestUtils.setField(manager, "store", meterStore);
    injectEventDispatcher(manager, new TestEventDispatcher());
    manager.deviceService = deviceService;
    manager.mastershipService = new TestMastershipService();
    manager.cfgService = new ComponentConfigAdapter();
    TestUtils.setField(manager, "storageService", new TestStorageService());
    // Init the reference of the registry
    registry = manager;

    manager.driverService = driverService;

    // Activate the manager
    manager.activate(null);
    // Initialize the test provider

    provider = new TestProvider(PID);
    // Register the provider against the manager
    providerService = registry.register(provider);
    // Verify register
    assertTrue("provider should be registered",
               registry.getProviders().contains(provider.id()));
}
 

import org.onosproject.store.service.Serializer; //导入方法依赖的package包/类
@Test
public void testTransactionMapCaching() throws Exception {
    AsyncConsistentMap asyncMap = mock(AsyncConsistentMap.class);
    expect(asyncMap.name()).andReturn("foo");
    expect(asyncMap.addListener(anyObject(MapEventListener.class), anyObject(Executor.class)))
            .andReturn(CompletableFuture.completedFuture(null)).anyTimes();
    asyncMap.addStatusChangeListener(anyObject(Consumer.class));
    expectLastCall().anyTimes();
    expect(asyncMap.entrySet()).andReturn(CompletableFuture.completedFuture(new HashMap<>().entrySet())).anyTimes();

    ConsistentMapBuilder mapBuilder = mock(ConsistentMapBuilder.class);
    expect(mapBuilder.withName(anyString())).andReturn(mapBuilder).anyTimes();
    expect(mapBuilder.withSerializer(anyObject(Serializer.class))).andReturn(mapBuilder).anyTimes();
    expect(mapBuilder.buildAsyncMap()).andReturn(asyncMap).anyTimes();

    DistributedPrimitiveCreator primitiveCreator = mock(DistributedPrimitiveCreator.class);
    expect(primitiveCreator.newAsyncConsistentMap(anyString(), anyObject(Serializer.class)))
            .andReturn(asyncMap).anyTimes();

    StorageService storageService = mock(StorageService.class);
    expect(storageService.consistentMapBuilder()).andReturn(mapBuilder);

    PartitionService partitionService = mock(PartitionService.class);
    Set<PartitionId> partitionIds = Sets.newHashSet(PartitionId.from(1), PartitionId.from(2), PartitionId.from(3));
    expect(partitionService.getAllPartitionIds())
            .andReturn(partitionIds).anyTimes();
    expect(partitionService.getNumberOfPartitions())
            .andReturn(partitionIds.size()).anyTimes();
    expect(partitionService.getDistributedPrimitiveCreator(anyObject(PartitionId.class)))
            .andReturn(primitiveCreator).anyTimes();

    replay(storageService, partitionService, asyncMap, primitiveCreator, mapBuilder);

    TransactionManager transactionManager = new TransactionManager(storageService, partitionService, 128);
    TransactionId transactionId = TransactionId.from(UUID.randomUUID().toString());
    TransactionCoordinator transactionCoordinator = new TransactionCoordinator(transactionId, transactionManager);
    Serializer serializer = Serializer.using(KryoNamespaces.API);

    PartitionedTransactionalMap<String, String> transactionalMap1 = (PartitionedTransactionalMap)
            transactionManager.getTransactionalMap("foo", serializer, transactionCoordinator);
    PartitionedTransactionalMap<String, String> transactionalMap2 = (PartitionedTransactionalMap)
            transactionManager.getTransactionalMap("foo", serializer, transactionCoordinator);

    assertSame(transactionalMap1.partitions.get(PartitionId.from(1)).transaction.transactionalObject,
            transactionalMap2.partitions.get(PartitionId.from(1)).transaction.transactionalObject);
    assertSame(transactionalMap1.partitions.get(PartitionId.from(2)).transaction.transactionalObject,
            transactionalMap2.partitions.get(PartitionId.from(2)).transaction.transactionalObject);
    assertSame(transactionalMap1.partitions.get(PartitionId.from(3)).transaction.transactionalObject,
            transactionalMap2.partitions.get(PartitionId.from(3)).transaction.transactionalObject);
}