import akka.serialization.Serialization; //导入依赖的package包/类
private void createArea(int loaclGridId) {
    CacheManager cacheManager = ContextResolver.getComponent(CacheManager.class);
    if (cacheManager.containsAreaKey(loaclGridId)) {
        return;
    } else {
        String areaId = CacheManager.getAreaId(loaclGridId);
        ActorRef actorOf = getContext().actorOf(Props.create(AreaActor.class, areaId), areaId);
        AreaInfoCache info=new AreaInfoCache();
        info.setAreaId(areaId);
        info.setAreaRef(actorOf);
        cacheManager.putAreaInfoCache(areaId,info);
        getContext().watch(actorOf);

        String identifier = Serialization.serializedActorPath(actorOf);
        cacheManager.putAreaManagerPath(areaId, identifier);
    }
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
/**
 * 创建一个格子
 * @param gridId
 */
private void createGrid(String gridId) {
    CacheManager component = ContextResolver.getComponent(CacheManager.class);
    AreaInfoCache areaInfoCache = component.getAreaInfoCache(areaId);
    Map<String, String> gridPath = areaInfoCache.getGridPath();
    if (!gridPath.containsKey(gridId)) {
        ActorRef actorOf = getContext().actorOf(Props.create(GridActor.class, getSelf()), gridId);
        getContext().watch(actorOf);

        gridPath.put(gridId,Serialization.serializedActorPath(actorOf));
        component.putAreaInfoCache(areaId,areaInfoCache);
    }
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
String getSerializedLeaderActor() {
    if (isLeader()) {
        return Serialization.serializedActorPath(getActor());
    } else {
        return addressResolver.resolve(leaderId);
    }
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void writeExternal(ObjectOutput out) throws IOException {
    out.writeObject(messageSliceReply.identifier);
    out.writeInt(messageSliceReply.sliceIndex);
    out.writeObject(messageSliceReply.failure);
    out.writeObject(Serialization.serializedActorPath(messageSliceReply.sendTo));
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void writeExternal(ObjectOutput out) throws IOException {
    out.writeObject(messageSlice.identifier);
    out.writeInt(messageSlice.sliceIndex);
    out.writeInt(messageSlice.totalSlices);
    out.writeInt(messageSlice.lastSliceHashCode);
    out.writeObject(messageSlice.data);
    out.writeObject(Serialization.serializedActorPath(messageSlice.replyTo));
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
    out.writeObject(Serialization.serializedActorPath(rpcInvoker));

    final NormalizedNodeDataOutput nnout = NormalizedNodeInputOutput.newDataOutput(out);
    nnout.writeInt(rpcs.size());
    for (DOMRpcIdentifier id : rpcs) {
        nnout.writeSchemaPath(id.getType());
        nnout.writeYangInstanceIdentifier(id.getContextReference());
    }
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
    super.writeExternal(out);

    out.writeObject(Serialization.serializedActorPath(backend));
    out.writeInt(maxMessages);

    out.writeInt(alternates.size());
    for (ActorSelection b : alternates) {
        out.writeObject(b.toSerializationFormat());
    }
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
public void setAreaRef(ActorRef areaRef) {
    AreaRef = Serialization.serializedActorPath(areaRef);
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
private void handleRequestAssemblerMessage(final Object message) {
    dispatchers.getDispatcher(DispatcherType.Serialization).execute(() -> {
        JavaSerializer.currentSystem().value_$eq((ExtendedActorSystem) context().system());
        requestMessageAssembler.handleMessage(message, self());
    });
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void preStart() throws Exception {
    super.preStart();
    LOG.info("RoleChangeNotifier:{} created and ready for shard:{}",
        Serialization.serializedActorPath(getSelf()), memberId);
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
@Override
public void writeExternal(final ObjectOutput out) throws IOException {
    super.writeExternal(out);
    out.writeObject(Serialization.serializedActorPath(replyTo));
}
 

import akka.serialization.Serialization; //导入依赖的package包/类
public static void main(String[] args) {

		ActorSystem system = ActorSystem.create("MySerializableSys",
				ConfigFactory.load().getConfig("MySerializableSys"));
		
		Serialization serialization = SerializationExtension.get(system);

		MyMessage originalMessage = new MyMessage("Munish", 36, "Bangalore");

		System.out.println("The original message is as " + originalMessage);

		// Get the Binded Serializer for it
		Serializer serializer = serialization
				.findSerializerFor(originalMessage);

		// Turn the object into bytes
		byte[] bytes = serializer.toBinary(originalMessage);

		// Turn the byte[] back into an object,
		MyMessage deSerializedMessage = (MyMessage) serializer.fromBinary(
				bytes, MyMessage.class);

		System.out.println("The de-serialized message is as " + deSerializedMessage);

		system.shutdown();
	}
 

import akka.serialization.Serialization; //导入依赖的package包/类
/**
 * 放置唯一的
 * @param IDENTIFY
 * @param actorRef
 */
public void putActorGlobalPath(String IDENTIFY, ActorRef actorRef) {
    String identifier = Serialization.serializedActorPath(actorRef);
    putActorRefPath(IDENTIFY, identifier);
}