1
public class RemoteObjImpl extends UnicastRemoteObject implements RemoteObj{
2
    public RemoteObjImpl() throws RemoteException {
3
        super();
4
    }
5
        @Override
6
    public String sayHello(String keywords){
7
        String upKeywords = keywords.toUpperCase();
8
        System.out.println(upKeywords);
9
        return upKeywords;
10
    }
11
}

1
public class RMIServer {
2
    public static  void main(String[] args) throws RemoteException, AlreadyBoundException {
3
        RemoteObj remoteObj = new RemoteObjImpl(); // 下断点
4
        Registry registry = LocateRegistry.createRegistry(10777);
5
        registry.bind("remoteObj",remoteObj);
6
    }
7
}

1
/*
2
调试进入 `exportObject` 方法，（下文有跟进 exportObject 的发布逻辑）该方法指定发布的 IP 与 port， 其中 TCPEndpoint 拿到一个 TCPTransport 对象，并在里面启动一个监听线程监听该地址，并建立远程对象的唯一  ObjID(rmi协议通信会携带 objid 一个端口会绑定很多远程对象)，和 ObjID → Target（impl）的映射表 ObjectTable。
3
*/
4
/*
5
当客户端拿到 stub 之后，调用某个远程方法，是通过 stub 中记录的 该远程方法所处的地址去连接，此时远程服务端读出其中的RMI序列化数据，ObjId，找到target，继而找到相应的实现类impl，最后执行方法。
6
*/

1
public static Remote exportObject(Remote obj, int port)
2
    throws RemoteException
3
{
4
    return exportObject(obj, new UnicastServerRef(port));
5
}

1
if (var2 || !ignoreStubClasses && stubClassExists(var3)) {
2
    return createStub(var3, var1);
3
// 进入了下面的 else 分支

1
public Target(Remote var1, Dispatcher var2, Remote var3, ObjID var4, boolean var5) {
2
    this.weakImpl = new WeakRef(var1, ObjectTable.reapQueue);
3
    this.disp = var2;
4
    this.stub = var3;
5
    this.id = var4;
6
    this.acc = AccessController.getContext();
7
    ClassLoader var6 = Thread.currentThread().getContextClassLoader();
8
    ClassLoader var7 = var1.getClass().getClassLoader();
9
    if (checkLoaderAncestry(var6, var7)) {
10
        this.ccl = var6;
11
    } else {
12
        this.ccl = var7;
13
    }
14

15
    this.permanent = var5;
16
    if (var5) {
17
        this.pinImpl();
18
    }
19

20
}

1
this.weakImpl = new WeakRef(var1, ObjectTable.reapQueue);

1
public void exportObject(Target var1) throws RemoteException {
2
    synchronized(this) {
3
        this.listen(); //下断点跟进
4
        ++this.exportCount;
5
    }
6

7
    boolean var2 = false;
8
    boolean var12 = false;
9

10
    try {
11
        var12 = true;
12
        super.exportObject(var1);
13
        var2 = true;
14
        var12 = false;
15
    } finally {
16
        if (var12) {
17
            if (!var2) {
18
                synchronized(this) {
19
                    this.decrementExportCount();
20
                }
21
            }
22

23
        }
24
    }
25

26
    if (!var2) {
27
        synchronized(this) {
28
            this.decrementExportCount();
29
        }
30
    }
31

32
}

1
LocateRegistry.createRegistry(port) --> RegistryImpl(port)
2
-->

1
remoteObj.sayHello("Hello world");

1
public interface InvocationHandler {
2
    public Object invoke(Object proxy, Method method, Object[] args)
3
        throws Throwable;
4
}

1
for(int var12 = 0; var12 < ((Object[])var11).length; ++var12) {
2
    marshalValue((Class)((Object[])var11)[var12], var3[var12], var10);
3
}

1
@Deprecated
2
public interface Skeleton {
3
    @Deprecated
4
    void dispatch(Remote obj, RemoteCall theCall, int opnum, long hash)
5
        throws Exception;
6

7
    @Deprecated
8
    Operation[] getOperations();
9
}