import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testAutoregistrationOnHibernate5Available()
        throws Exception {

    HazelcastInstance hz = Hazelcast.newHazelcastInstance();
    HazelcastInstanceImpl impl = (HazelcastInstanceImpl) ORIGINAL.get(hz);
    SerializationService ss = impl.getSerializationService();
    @SuppressWarnings("unchecked")
    ConcurrentMap<Class, ?> typeMap = (ConcurrentMap) TYPE_MAP.get(ss);

    boolean cacheEntrySerializerFound = false;
    for (Class clazz : typeMap.keySet()) {
        if (StandardCacheEntryImpl.class.equals(clazz)
                || "com.hazelcast.hibernate.serialization.CacheEntryImpl".equals(clazz.getName())) {
            cacheEntrySerializerFound = true;
        }
    }

    assertTrue("CacheEntry serializer not found", cacheEntrySerializerFound);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test(timeout = 60000)
public void testAttributeReloadSession() throws Exception {
    IMap<String, Object> map = hz.getMap(DEFAULT_MAP_NAME);
    CookieStore cookieStore = new BasicCookieStore();
    assertEquals("true", executeRequest("write", serverPort1, cookieStore));
    assertEquals(1, map.size());
    String oldSessionId = findHazelcastSessionId(map);
    assertNotNull(oldSessionId);
    assertEquals("value", executeRequest("read", serverPort2, cookieStore));
    assertEquals("true", executeRequest("reload", serverPort2, cookieStore));
    String newSessionId = findHazelcastSessionId(map);
    assertEquals(1, map.size());
    assertNotNull(map.get(newSessionId));
    SessionState sessionState = (SessionState) map.get(newSessionId);
    SerializationService ss = getNode(hz).getSerializationService();
    assertEquals("first-value", ss.toObject(sessionState.getAttributes().get("first-key")));
    assertEquals("second-value", ss.toObject(sessionState.getAttributes().get("second-key")));
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testAutoregistrationOnHibernate4Available()
        throws Exception {

    HazelcastInstance hz = Hazelcast.newHazelcastInstance();
    HazelcastInstanceImpl impl = (HazelcastInstanceImpl) ORIGINAL.get(hz);
    SerializationService ss = impl.getSerializationService();
    ConcurrentMap<Class, ?> typeMap = (ConcurrentMap<Class, ?>) TYPE_MAP.get(ss);

    boolean cacheKeySerializerFound = false;
    boolean cacheEntrySerializerFound = false;
    for (Class clazz : typeMap.keySet()) {
        if (clazz == CacheKey.class) {
            cacheKeySerializerFound = true;
        } else if (clazz == CacheEntry.class) {
            cacheEntrySerializerFound = true;
        }
    }

    assertTrue("CacheKey serializer not found", cacheKeySerializerFound);
    assertTrue("CacheEntry serializer not found", cacheEntrySerializerFound);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testAutoregistrationOnHibernate3Available()
        throws Exception {

    HazelcastInstance hz = Hazelcast.newHazelcastInstance();
    HazelcastInstanceImpl impl = (HazelcastInstanceImpl) ORIGINAL.get(hz);
    SerializationService ss = impl.getSerializationService();
    ConcurrentMap<Class, ?> typeMap = (ConcurrentMap<Class, ?>) TYPE_MAP.get(ss);

    boolean cacheKeySerializerFound = false;
    boolean cacheEntrySerializerFound = false;
    for (Class clazz : typeMap.keySet()) {
        if (clazz == CacheKey.class) {
            cacheKeySerializerFound = true;
        } else if (clazz == CacheEntry.class) {
            cacheEntrySerializerFound = true;
        }
    }

    assertTrue("CacheKey serializer not found", cacheKeySerializerFound);
    assertTrue("CacheEntry serializer not found", cacheEntrySerializerFound);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
protected void setupSerialization() {
    // set up the serializer for the storage record if not already configured
    SerializationService serializationService;
    if (this.hazelcastInstance instanceof HazelcastInstanceImpl) {
        serializationService = ((HazelcastInstanceImpl) this.hazelcastInstance).getSerializationService();
    } else if (this.hazelcastInstance instanceof SerializationServiceSupport) {
        serializationService = ((SerializationServiceSupport) this.hazelcastInstance).getSerializationService();
    } else {
        serializationService = null;
    }
    if (serializationService != null) {
        try {
            ((AbstractSerializationService) serializationService).register(MutableStorageRecord.class, new MutableStorageRecordSerializer());
        } catch (IllegalStateException e) {
            logger.warn("Problem registering storage record serializer", e);
        }
    }
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
/**
 * Update attributes.
 *
 * @param id      the id
 * @param updates the updates
 * @throws Exception the exception
 */
public void updateAttributes(String id, Map<String, Object> updates) throws Exception {
    SerializationService ss = sss.getSerializationService();
    SessionUpdateEntryProcessor sessionUpdate = new SessionUpdateEntryProcessor(updates.size());
    for (Map.Entry<String, Object> entry : updates.entrySet()) {
        String name = entry.getKey();
        Object value = entry.getValue();
        sessionUpdate.getAttributes().put(name, ss.toData(value));
    }
    executeOnKey(id, sessionUpdate);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test(timeout = 20000)
public void test_updateAttribute() throws Exception {
    IMap<String, Object> map = hz.getMap(DEFAULT_MAP_NAME);
    CookieStore cookieStore = new BasicCookieStore();
    executeRequest("write", serverPort1, cookieStore);
    executeRequest("update", serverPort2, cookieStore);
    assertEquals("value-updated", executeRequest("read", serverPort1, cookieStore));
    String newSessionId = map.keySet().iterator().next();
    SessionState sessionState = (SessionState) map.get(newSessionId);
    SerializationService ss = getNode(hz).getSerializationService();
    assertSizeEventually(1, map);
    assertSizeEventually(1, sessionState.getAttributes());
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
public ProcCtx(JetInstance instance, SerializationService serService, ILogger logger, String vertexName,
               int index, ProcessingGuarantee processingGuarantee) {
    this.instance = instance;
    this.serService = serService;
    this.logger = logger;
    this.vertexName = vertexName;
    this.index = index;
    this.processingGuarantee = processingGuarantee;
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
public static <T> T deserializeWithCustomClassLoader(
        SerializationService serializationService, ClassLoader cl, Data data
) {
    ClassLoader previous = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(cl);
    try {
        return serializationService.toObject(data);
    } finally {
        Thread.currentThread().setContextClassLoader(previous);
    }
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
/**
 * @param outstreams The output queues
 * @param hasSnapshot If the last queue in {@code outstreams} is the snapshot queue
 * @param progTracker Tracker to track progress. Only madeProgress will be called,
 *                    done status won't be ever changed
 * @param batchSize Maximum number of items that will be allowed to offer until
 *                  {@link #resetBatch()} is called.
 */
@SuppressFBWarnings("EI_EXPOSE_REP")
public OutboxImpl(OutboundCollector[] outstreams, boolean hasSnapshot, ProgressTracker progTracker,
                  SerializationService serializationService, int batchSize) {
    this.outstreams = outstreams;
    this.progTracker = progTracker;
    this.serializationService = serializationService;
    this.batchSize = batchSize;
    checkPositive(batchSize, "batchSize must be positive");

    allEdges = IntStream.range(0, outstreams.length - (hasSnapshot ? 1 : 0)).toArray();
    allEdgesAndSnapshot = IntStream.range(0, outstreams.length).toArray();
    snapshotEdge = hasSnapshot ? new int[] {outstreams.length - 1} : null;
    broadcastTracker = new BitSet(outstreams.length);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testSerializerHook() throws Exception {
    assertFalse("Type implements java.io.Serializable", instance instanceof Serializable);
    SerializationService serializationService = new DefaultSerializationServiceBuilder().build();
    Data serialized = serializationService.toData(instance);
    Object deserialized = serializationService.toObject(serialized);
    assertNotSame("serialization/deserialization didn't take place", instance, deserialized);
    assertEquals("objects are not equal after serialize/deserialize", instance, deserialized);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testSerializerHook() throws Exception {
    if (!(instance instanceof Map.Entry || instance instanceof Tag)) {
        assertFalse(instance.getClass() + " implements java.io.Serializable", instance instanceof Serializable);
    }
    SerializationService serializationService = new DefaultSerializationServiceBuilder().build();
    Data serialized = serializationService.toData(instance);
    Object deserialized = serializationService.toObject(serialized);
    if (!(instance instanceof Tag)) {
        assertNotSame("serialization/deserialization didn't take place", instance, deserialized);
    }
    assertEquals("objects are not equal after serialize/deserialize", instance, deserialized);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testSerializerHooks() throws Exception {
    SerializationService serializationService = new DefaultSerializationServiceBuilder().build();

    Data serialized = serializationService.toData(instance);
    Object deserialized = serializationService.toObject(serialized);

    assertNotSame("serialization/deserialization didn't take place", instance, deserialized);
    if (instance instanceof Object[]) {
        assertArrayEquals("objects are not equal after serialize/deserialize",
                (Object[]) instance, (Object[]) deserialized);
    } else {
        assertEquals("objects are not equal after serialize/deserialize", instance, deserialized);
    }
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testSerializerHooks() throws Exception {
    if (!(instance instanceof Map.Entry)) {
        assertFalse("Type implements java.io.Serializable", instance instanceof Serializable);
    }
    SerializationService serializationService = new DefaultSerializationServiceBuilder().build();
    Data serialized = serializationService.toData(instance);
    Object deserialized = serializationService.toObject(serialized);
    assertNotSame("serialization/deserialization didn't take place", instance, deserialized);
    assertEquals("objects are not equal after serialize/deserialize", instance, deserialized);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Test
public void testSerializerHook() throws Exception {
    SerializationService serializationService = new DefaultSerializationServiceBuilder().build();

    Data serialized = serializationService.toData(instance);
    Object deserialized = serializationService.toObject(serialized);

    assertEquals("objects are not equal after serialize/deserialize", instance, deserialized);
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Override
public void handle(Data item, long publishTime, String uuid) {
    TRACER.trace("New event message retrieved");
    ClientContext context = clientSequencer.getContext();
    SerializationService serializationService = context.getSerializationService();

    Object message = serializationService.toObject(item);
    if (message instanceof ClientDestroySequencerNotification) {
        TRACER.trace("ClientDestroySequencerNotification received");
        clientSequencer.stateTransition(SnowcastSequenceState.Destroyed);
        sequencerContext.unregisterClientChannel(clientSequencer);
    }
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
public SerializationService getSerializationService() {
    return serService;
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Override
protected SerializationService serializationService() {
    return container().getSerializationService();
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
@Override
public void onResponse(Object response) {
    SerializationService serializationService = nodeEngine.getSerializationService();
    sendResponse(serializationService.toData(response));
}
 

import com.hazelcast.spi.serialization.SerializationService; //导入依赖的package包/类
ClientChannelHandler(@Nonnull MessageChannel messageChannel, @Nonnull SerializationService serializationService) {
    this.messageChannel = messageChannel;
    this.serializationService = serializationService;
}