Serialization akka在跨32位和64位JVM序列化TypedActor代理和ActorRef时静默失败

修复以下问题需要什么配置？ 64位jvm（machine1）上的Akka Actor无法在32位jvm（machine2）上使用TypedActor代理（案例1） 但反之亦然（案例2）

是否有我遗漏的序列化配置设置？ 我正在使用来自java的akka-2.2.1

我有一个小的测试代码，它总是复制这个问题

即使启用了远程生命周期事件，也没有报告“错误”的日志。 在CASE1上调用registerListener（）时，它会超时

我不知道，任何帮助/线索都将不胜感激

server.java

public class Server implements ServerActor {

    public static final String serverActorName = "server";
    public static final String serverIP = "192.168.11.112";
    public static final int serverPort = 9999;

    public static void main(String[] args) {
        new Server();
    }

    ActorSystem serverSystem;

    public Server() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = %d", Server.serverIP,
                        Server.serverPort);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        serverSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) serverSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Server Akka IP=%s PORT=%s\n", addr, port);

        final Server server = this;

        // start server service
        @SuppressWarnings("unused")
        ServerActor proxy = TypedActor.get(serverSystem).typedActorOf(
                new TypedProps<Server>(ServerActor.class,
                        new Creator<Server>() {

                            private static final long serialVersionUID = 6301999771454618282L;

                            @Override
                            public Server create() {
                                return server;
                            }
                        }), Server.serverActorName);

    }

    @Override
    public boolean registerListener(ITestListener listener) {
        listener.update(10);
        return true;
    }

}

public class Client implements ITestListener {

    public static final String clientActorName = "client";
    public static final String clientIP = "192.168.11.111";

    public static void main(String[] args) {
        new Client();
    }

    ActorSystem clientSystem;
    private ITestListener clientListener = null;

    public Client() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = 0", Client.clientIP);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        clientSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) clientSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Client Akka IP=%s PORT=%s\n", addr, port);

        final Client client = this;

        // start server service
        clientListener = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<Client>(ITestListener.class,
                        new Creator<Client>() {

                            private static final long serialVersionUID = 2034444366744329184L;

                            @Override
                            public Client create() {
                                return client;
                            }
                        }), Client.clientActorName);

        connect();

    }

    private void connect() {

        // Connect to remote actor system
        String remotePath = String.format("akka.tcp://sys@%s:%d/user/%s",
                Server.serverIP, Server.serverPort, Server.serverActorName);

        // get remote server proxy object
        // TypedActor.context().setReceiveTimeout(Duration.create("3 second"));
        ActorRef remoteRef = clientSystem.actorFor(remotePath);

        if (remoteRef == null)
            throw new RuntimeException("Cannot get remote akka actor");

        final ServerActor server = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<ServerActor>(ServerActor.class), remoteRef);

        server.registerListener(clientListener);

    }

    @Override
    public void update(int a) {
        System.out.printf("*********** Server Sent %d ************\n", a);
    }
}

公共类服务器实现ServerActor{
公共静态最终字符串serverActorName=“server”；
公共静态最终字符串serverIP=“192.168.11.112”；
公共静态最终int服务器端口=9999；
公共静态void main（字符串[]args）{
新服务器（）；
}
ActorSystem服务器系统；
公共服务器（）{
字符串网络=字符串
.format（“akka.actor.provider=\”akka.remote.RemoteActorRefProvider\“\n”
+“akka.remote.enabled-transports=[\“akka.remote.netty.tcp\”]\n”
+“akka.remote.netty.tcp.hostname=\%s\\n”
+“akka.remote.netty.tcp.port=%d”，Server.serverIP，
服务器端口）；
Config=ConfigFactory.parseString（“akka.loglevel=DEBUG\n”
+“akka.actor.debug.lifecycle=on\n”+网络）；
serverSystem=ActorSystem.create（“sys”，config）；
RemoteActorRefProvider ref=（RemoteActorRefProvider）服务器系统
.provider（）；
地址addr=ref.transport（）.defaultAddress（）；
字符串端口=addr.port（）.get（）.toString（）；
System.out.printf（“服务器Akka IP=%s端口=%s\n”，地址，端口）；
最终服务器=此服务器；
//启动服务器服务
@抑制警告（“未使用”）
ServerActor proxy=TypedActor.get（serverSystem.typedActorOf）(
新类型的DProps（ServerActor.class，
新创建者（）{
私有静态最终长serialVersionUID=6301999771454618282L；
@凌驾
公共服务器创建（）{
返回服务器；
}
})，Server.serverActorName）；
}
@凌驾
公共布尔寄存器侦听器（ITestListener侦听器）{
更新（10）；
返回true；
}
}

和client.java

public class Server implements ServerActor {

    public static final String serverActorName = "server";
    public static final String serverIP = "192.168.11.112";
    public static final int serverPort = 9999;

    public static void main(String[] args) {
        new Server();
    }

    ActorSystem serverSystem;

    public Server() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = %d", Server.serverIP,
                        Server.serverPort);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        serverSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) serverSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Server Akka IP=%s PORT=%s\n", addr, port);

        final Server server = this;

        // start server service
        @SuppressWarnings("unused")
        ServerActor proxy = TypedActor.get(serverSystem).typedActorOf(
                new TypedProps<Server>(ServerActor.class,
                        new Creator<Server>() {

                            private static final long serialVersionUID = 6301999771454618282L;

                            @Override
                            public Server create() {
                                return server;
                            }
                        }), Server.serverActorName);

    }

    @Override
    public boolean registerListener(ITestListener listener) {
        listener.update(10);
        return true;
    }

}

public class Client implements ITestListener {

    public static final String clientActorName = "client";
    public static final String clientIP = "192.168.11.111";

    public static void main(String[] args) {
        new Client();
    }

    ActorSystem clientSystem;
    private ITestListener clientListener = null;

    public Client() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = 0", Client.clientIP);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        clientSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) clientSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Client Akka IP=%s PORT=%s\n", addr, port);

        final Client client = this;

        // start server service
        clientListener = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<Client>(ITestListener.class,
                        new Creator<Client>() {

                            private static final long serialVersionUID = 2034444366744329184L;

                            @Override
                            public Client create() {
                                return client;
                            }
                        }), Client.clientActorName);

        connect();

    }

    private void connect() {

        // Connect to remote actor system
        String remotePath = String.format("akka.tcp://sys@%s:%d/user/%s",
                Server.serverIP, Server.serverPort, Server.serverActorName);

        // get remote server proxy object
        // TypedActor.context().setReceiveTimeout(Duration.create("3 second"));
        ActorRef remoteRef = clientSystem.actorFor(remotePath);

        if (remoteRef == null)
            throw new RuntimeException("Cannot get remote akka actor");

        final ServerActor server = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<ServerActor>(ServerActor.class), remoteRef);

        server.registerListener(clientListener);

    }

    @Override
    public void update(int a) {
        System.out.printf("*********** Server Sent %d ************\n", a);
    }
}

公共类客户端实现ITestListener{
公共静态最终字符串clientActorName=“client”；
公共静态最终字符串clientIP=“192.168.11.111”；
公共静态void main（字符串[]args）{
新客户机（）；
}
ActorSystem客户端系统；
私有ITestListener clientListener=null；
公共客户机（）{
字符串网络=字符串
.format（“akka.actor.provider=\”akka.remote.RemoteActorRefProvider\“\n”
+“akka.remote.enabled-transports=[\“akka.remote.netty.tcp\”]\n”
+“akka.remote.netty.tcp.hostname=\%s\\n”
+“akka.remote.netty.tcp.port=0”，Client.clientIP）；
Config=ConfigFactory.parseString（“akka.loglevel=DEBUG\n”
+“akka.actor.debug.lifecycle=on\n”+网络）；
clientSystem=ActorSystem.create（“sys”，config）；
RemoteActorRefProvider ref=（RemoteActorRefProvider）客户端系统
.provider（）；
地址addr=ref.transport（）.defaultAddress（）；
字符串端口=addr.port（）.get（）.toString（）；
System.out.printf（“客户端Akka IP=%s端口=%s\n”，地址，端口）；
最终客户=此；
//启动服务器服务
clientListener=TypedActor.get（clientSystem.typedActorOf）(
新类型DProps（ITestListener.class，
新创建者（）{
私有静态最终长serialVersionUID=2034444366744329184L；
@凌驾
公共客户端创建（）{
返回客户；
}
})，clientActorName）；
connect（）；
}
专用void connect（）{
//连接到远程参与者系统
String remotePath=String.format（“akka。tcp://sys@%s:%d/用户/%s“，
Server.serverIP、Server.serverPort、Server.serverActorName）；
//获取远程服务器代理对象
//TypedActor.context（）.setReceiveTimeout（Duration.create（“3秒”）；
ActorRef remoteRef=clientSystem.actorFor（remotePath）；
if（remoteRef==null）
抛出新的RuntimeException（“无法获取远程akka actor”）；
final ServerActor server=TypedActor.get（clientSystem.typedActorOf）(
新的类型dprops（ServerActor.class），remoteRef；
registerListener（clientListener）；
}
@凌驾
公共无效更新（INTA）{
System.out.printf（“**********服务器发送了%d***************\n”，a）；
}
}