java序列化实现RMI

RMI（Remote Method Invocation）是Java中的远程过程调用（Remote Procedure Call，RPC）实现，是一种分布式Java应用的实现方式。它的目的在于对开发人员屏蔽横跨不同JVM和网络连接等细节，使得分布在不同JVM上的对象像是存在于一个统一的JVM中一样，可以很方便的互相通讯。通讯就涉及到了数据的编码和解码，对于一般的数据类型我们不需要这么做，但是涉及到比较复杂的数据类型，例如对象，RMI利用到了序列化，使得数据的编码与解码对于开发人员透明起来，我们不需要关注数据如何传输，只需要实现相关方法就能做到远程调用。

一、序列化

对象的序列化主要是使用JAVA中的ObjectOutputStream的writeObject(Object obj)来序列化和ObjectInputStream的readObject()来反序列化。
1、在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。当然目前大多数项目存储会员状态信息都会用到Memcached。
2、当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。此处RMI就利用了这点来帮我们编排对象数据信息。

总结就有如下优点：

• 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。
• 便于在网络上传送对象的字节序列。

package rmiTest;import java.io.Serializable;public class Person implements Serializable{    private static final long serialVersionUID = -6379887343250921447L;    private int id;    private String name;    private String sex;    public Person(){}    public Person(int id, String name, String sex) {        super();        this.id = id;        this.name = name;        this.sex = sex;    }    //getXx();    //setXx();}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package serializeTest;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import rmiTest.Person;public class TestObjSerializeAndDeserialize {    public static void main(String[] args) {        Person person = new Person(1, "丁烁", "man");        try {            serialize(person, "E:/ds.txt");            deserialize("E:/ds.txt");        } catch (Exception e) {            e.printStackTrace();        }    }    //序列化    public static void serialize(Object object, String path) throws Exception{        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(path));        outputStream.writeObject(object);        outputStream.flush();        outputStream.close();        System.out.println("序列化成功!");    }    //反序列化    public static void deserialize(String path) throws Exception{        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(path));        Person person =(Person) inputStream.readObject();        inputStream.close();        System.out.println("反序列化成功!");        System.out.println("id:"+person.getId());        System.out.println("name:"+person.getName());        System.out.println("sex:"+person.getSex());    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

输出结果：

文件生成：

注意事项：实体类上必须实现序列化接口，并且设定一个serialVersionUID。如果没有添加该字段，序列化对象之后，修改实体类再进行反序列化就会报错。java编译器会自动给这个class进行一个摘要算法来生成serialVersionUID，只要这个文件多一个空格，得到的serialVersionUID就会截然不同。所以修改之后java编译器又给我们生成了一个serialVersionUID，反序列化时两个版本号不一致就会报错。

二、jar命令

jar(Java archive file)，这里为了更加真实的模拟远程接口调用，我们使用一个简单的面向接口编程，包含一个客户端和一个服务端。服务端包含了接口、实现以及实体类，客户端引入接口以及实体类的jar包，通过远程接口调用来调用接口的实现类。所以简要的梳理一下如何使用jar命令来进行打包相关类文件。当然在实际的项目中会使用maven来构建jar工程。

举例：
jar cvf d:\rmitest.jar D:\workspace\tjfae-v2300-20160410\appTest\bin\rmiTest
该命令会将rmiTest下的所有文件打包成jar并命名为rmitest.jar存放与d盘下。当然也可以指定多个目录、多个类文件。但是这样有一个弊端，我们打出的jar并不是按照我们所想的package目录打出来的。我们反编译一个jar如下图：

jar里面的类文件路径是按照我们打包时的路径所写，这样会导致我们在引用这个jar包时，报路径错误。明白了这点，我们可以将dos下的当前目录调整到与package对应位置，再执行打包命令。先将dos路径调整到D:\workspace\tjfae-v2300-20160410\appTest\bin下，然后执行如下命令：
jar cvf d:\rmitest.jar rmiTest

此时就已经打出了我们想要的jar包，为后面的远程接口调用做准备。

三、RMI远程调用实例

前面介绍了序列化和如何利用jar命令打包，下面的例子分为客户端和服务器端，服务器端包含了接口和接口的实现，并且将实现注册到一个服务地址上。然后用jar命令将服务器端的接口和实体类打包，在客户端引用，这样客户端只有接口，而不会看到具体实现。这里为了方便，将接口和实现放在同一个工程。但是更好方式是：

1. 将接口写在一个工程A；
2. 将工程A打成jar包；
3. 在工程B中引入工程A的jar包，实现这些接口并注册服务，工程B即服务端；
4. 在工程C中引入工程A的jar包，获取服务并注入给相应接口，工程C即客户端；
5. 客户端远程调用。

本例中涉及到的类文件如下：
服务端:
Person：实体类，实现Serializable进行序列化；
PersonService：服务接口，继承Remote；
PersonServiceImp：服务实现，继承UnicastRemoteObject，并且实现PersonService；
ServerTest：注册PersonService这个服务；
客户端:
引入事先打好的jar包（Person.class、PersonService.class）
ClientTest：调用远程服务。

Person上面已经贴出。
PersonService包含一个getPerson的抽象方法。

package rmiTest;import java.rmi.Remote;import java.rmi.RemoteException;public interface PersonService extends Remote {    public Person getPerson() throws RemoteException;}
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

PersonServiceImp必须要继承UnicastRemoteObject，如果不继承这个类，那么客户端每次lookup出来的都是不一样的对象，可以通过在服务端添加一个成员变量，每调用一次自增一下来进行测试，这里不做多余讲解。

package rmiTest;import java.rmi.RemoteException;import java.rmi.server.UnicastRemoteObject;public class PersonServiceImp extends UnicastRemoteObject implements PersonService {    private static final long serialVersionUID = 1L;    protected PersonServiceImp() throws RemoteException {        super();    }    @Override    public Person getPerson() throws RemoteException {        Person person = new Person();        person.setId(1);        person.setName("ds");        person.setSex("M");        return person;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ServerTest服务端注册这个服务

package rmiTest;import java.rmi.Naming;import java.rmi.registry.LocateRegistry;public class ServerTest {    public static void main(String[] arg){        try {            PersonService personService = new PersonServiceImp();            LocateRegistry.createRegistry(6600);            Naming.bind("rmi://127.0.0.1:6600/PersonService", personService);        } catch (Exception e) {            e.printStackTrace();        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ClientTest客户端进行远程调用，客户端要先引入事先打好的jar包

import java.rmi.Naming;import rmiTest.Person;import rmiTest.PersonService;public class ClientTest {    public static void main(String[] args) {        try {            PersonService personService = (PersonService) Naming.lookup("rmi://127.0.0.1:6600/PersonService");            Person person = personService.getPerson();            System.out.println("ID:"+person.getId());            System.out.println("Name:"+person.getName());            System.out.println("Sex:"+person.getSex());        } catch (Exception e) {            e.printStackTrace();        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

(function () {('pre.prettyprint code').each(function () { var lines = (this).text().split(′\n′).length;varnumbering = $('

').addClass('pre-numbering').hide(); (this).addClass(′has−numbering′).parent().append(numbering); for (i = 1; i