死磕rmi之 RegistryImpl

Registry初始化

可以把注册中心理解为特殊的远程对象，这个对象就像一个容器一样，存储其他远程对象。

可以本地直接调用四大方法，也可通过调用远程对象的方式调用。

查看一下类继承关系

可参照https://android.googlesource.com/toolchain/gcc.git/+/eclair/gcc-4.2.1/libjava/classpath/gnu/java/rmi

public class RegistryImpl extends RemoteServer implements Registry
public abstract class RemoteServer extends RemoteObject
public abstract class RemoteObject implements Remote, java.io.Serializable {

java.rmi.registry.LocateRegistry#createRegistry(int)

创建并暴露一个Registry在localhost上，接受特定的请求

/**
 * Creates and exports a <code>Registry</code> instance on the local
 * host that accepts requests on the specified <code>port</code>.
 *
 * <p>The <code>Registry</code> instance is exported as if the static
 * {@link UnicastRemoteObject#exportObject(Remote,int)
 * UnicastRemoteObject.exportObject} method is invoked, passing the
 * <code>Registry</code> instance and the specified <code>port</code> as
 * arguments, except that the <code>Registry</code> instance is
 * exported with a well-known object identifier, an {@link ObjID}
 * instance constructed with the value {@link ObjID#REGISTRY_ID}.
 *
 * @param port the port on which the registry accepts requests
 * @return the registry
 * @exception RemoteException if the registry could not be exported
 * @since JDK1.1
 **/
public static Registry createRegistry(int port) throws RemoteException {
    return new RegistryImpl(port);
}

sun.rmi.registry.RegistryImpl#RegistryImpl(int)

public RegistryImpl(final int var1) throws RemoteException {
    this.bindings = new Hashtable(101);
    if (var1 == 1099 && System.getSecurityManager() != null) {
        try {
            AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
                public Void run() throws RemoteException {
                    LiveRef var1x = new LiveRef(RegistryImpl.id, var1);
                    //这种写法跟后面的lambda方法不一致啊
                    RegistryImpl.this.setup(new UnicastServerRef(var1x, (var0) -> {
                        return RegistryImpl.registryFilter(var0);
                    }));
                    return null;
                }
            }, (AccessControlContext)null, new SocketPermission("localhost:" + var1, "listen,accept"));
        } catch (PrivilegedActionException var3) {
            throw (RemoteException)var3.getException();
        }
    } else {
    //var1为port
    //liveRef，实时引用，包含，endpoint，id，channel。
    //endpoint的构造在远程对象里已经讲过了。就是通过host+ip,确定一个。在这期间会采集一些host的变化。如果已经存在了，就看host变没变。
    //id为new ObjID(0)，RegistryImpl的ID是固定的
        LiveRef var2 = new LiveRef(id, var1);
        //这里为lambda方法
        //下面查看setup方法,也是ref=serverref，然后发布一个对象。把这个对象作为注册中心
        this.setup(new UnicastServerRef(var2, RegistryImpl::registryFilter));
    }

}

sun.rmi.server.UnicastServerRef#UnicastServerRef(sun.rmi.transport.LiveRef, sun.misc.ObjectInputFilter)

public UnicastServerRef(LiveRef var1, ObjectInputFilter var2) {
    super(var1);
    //这里为forceStubUse=false
    this.forceStubUse = false;
    this.hashToMethod_Map = null;
    this.methodCallIDCount = new AtomicInteger(0);
    //远程对象的ServerRef为null，这里有过滤拦截
    this.filter = var2;
}

sun.rmi.registry.RegistryImpl#registryFilter

filter配置参考：https://docs.oracle.com/en/java/javase/11/core/serialization-filtering1.html#GUID-0A1D23AB-2F18-4979-9288-9CFEC04F207E

private static ObjectInputFilter.Status registryFilter(ObjectInputFilter.FilterInfo var0) {
//registryFilter被初始化为sun.rmi.registry.registryFilter
//配置参考
    if (registryFilter != null) {
        ObjectInputFilter.Status var1 = registryFilter.checkInput(var0);
        if (var1 != Status.UNDECIDED) {
            return var1;
        }
    }

    if (var0.depth() > 20L) {
        return Status.REJECTED;
    } else {
        Class var2 = var0.serialClass();
        if (var2 != null) {
            if (!var2.isArray()) {
                return String.class != var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
            } else {
                return var0.arrayLength() >= 0L && var0.arrayLength() > 1000000L ? Status.REJECTED : Status.UNDECIDED;
            }
        } else {
            return Status.UNDECIDED;
        }
    }
}

sun.rmi.registry.RegistryImpl#setup

private void setup(UnicastServerRef var1) throws RemoteException {
    this.ref = var1;
    //true 要这个类为永久类
    //之后的逻辑跟暴露远程对象一样了
    var1.exportObject(this, (Object)null, true);
}

sun.rmi.server.UnicastServerRef#exportObject(java.rmi.Remote, java.lang.Object, boolean)

public Remote exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
    Class var4 = var1.getClass();

    Remote var5;
    try {
        var5 = Util.createProxy(var4, this.getClientRef(), this.forceStubUse);
    } catch (IllegalArgumentException var7) {
        throw new ExportException("remote object implements illegal remote interface", var7);
    }
//会进入这里，跟普通远程对象不一样
    if (var5 instanceof RemoteStub) {
    //设置注册中心为var1，就是它自己。
        this.setSkeleton(var1);
    }

    Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);
    //这里处理逻辑
    this.ref.exportObject(var6);
    this.hashToMethod_Map = (Map)hashToMethod_Maps.get(var4);
    return var5;
}

sun.rmi.server.Util#createProxy

public static Remote createProxy(Class<?> var0, RemoteRef var1, boolean var2) throws StubNotFoundException {
    Class var3;
    try {
        var3 = getRemoteClass(var0);
    } catch (ClassNotFoundException var9) {
        throw new StubNotFoundException("object does not implement a remote interface: " + var0.getName());
    }
//这里为true
//sun.rmi.registry.RegistryImpl_Stub 应该是用RegistryImpl的类加载器加载的，跟普通远程对象不是一个类加载器，所以，普通远程对象这里返回false。
//验证一下这个猜测
//RegistryImpl的类加载器为null，也是BootstrapClassloader。这个是用c++写的，用来加载系统类。通过包名可得，RegistryImpl_Stub为系统类。
//普通远程对象的类加载器为AppClassLoaer
    if (var2 || !ignoreStubClasses && stubClassExists(var3)) {
        return createStub(var3, var1);
    } else {
        final ClassLoader var4 = var0.getClassLoader();
        final Class[] var5 = getRemoteInterfaces(var0);
        final RemoteObjectInvocationHandler var6 = new RemoteObjectInvocationHandler(var1);

        try {
            return (Remote)AccessController.doPrivileged(new PrivilegedAction<Remote>() {
                public Remote run() {
                    return (Remote)Proxy.newProxyInstance(var4, var5, var6);
                }
            });
        } catch (IllegalArgumentException var8) {
            throw new StubNotFoundException("unable to create proxy", var8);
        }
    }
}

处理逻辑

sun.rmi.transport.LiveRef#exportObject

sun.rmi.transport.tcp.TCPEndpoint#exportObject

sun.rmi.transport.tcp.TCPTransport#exportObject

sun.rmi.transport.tcp.TCPTransport#listen

sun.rmi.transport.Transport#exportObject

sun.rmi.server.UnicastServerRef#dispatch

这里有一个分支跟普通远程对象不一样。

public void dispatch(Remote var1, RemoteCall var2) throws IOException {
    try {
        int var3;
        ObjectInput var41;
        try {
            var41 = var2.getInputStream();
            //读4个字节
            var3 = var41.readInt();
        } catch (Exception var38) {
            throw new UnmarshalException("error unmarshalling call header", var38);
        }
//这里registryImpl可以进入，普通对象不行。
        if (this.skel != null) {
            this.oldDispatch(var1, var2, var3);
            return;
        }

        if (var3 >= 0) {
            throw new UnmarshalException("skeleton class not found but required for client version");
        }

        long var4;
        try {
            var4 = var41.readLong();
        } catch (Exception var37) {
            throw new UnmarshalException("error unmarshalling call header", var37);
        }

        MarshalInputStream var7 = (MarshalInputStream)var41;
        var7.skipDefaultResolveClass();
        Method var42 = (Method)this.hashToMethod_Map.get(var4);
        if (var42 == null) {
            throw new UnmarshalException("unrecognized method hash: method not supported by remote object");
        }

        this.logCall(var1, var42);
        Object[] var9 = null;

        try {
            this.unmarshalCustomCallData(var41);
            var9 = this.unmarshalParameters(var1, var42, var7);
        } catch (AccessException var34) {
            ((StreamRemoteCall)var2).discardPendingRefs();
            throw var34;
        } catch (ClassNotFoundException | IOException var35) {
            ((StreamRemoteCall)var2).discardPendingRefs();
            throw new UnmarshalException("error unmarshalling arguments", var35);
        } finally {
            var2.releaseInputStream();
        }

        Object var10;
        try {
            var10 = var42.invoke(var1, var9);
        } catch (InvocationTargetException var33) {
            throw var33.getTargetException();
        }

        try {
            ObjectOutput var11 = var2.getResultStream(true);
            Class var12 = var42.getReturnType();
            if (var12 != Void.TYPE) {
                marshalValue(var12, var10, var11);
            }
        } catch (IOException var32) {
            throw new MarshalException("error marshalling return", var32);
        }
    } catch (Throwable var39) {
        Object var6 = var39;
        this.logCallException(var39);
        ObjectOutput var8 = var2.getResultStream(false);
        if (var39 instanceof Error) {
            var6 = new ServerError("Error occurred in server thread", (Error)var39);
        } else if (var39 instanceof RemoteException) {
            var6 = new ServerException("RemoteException occurred in server thread", (Exception)var39);
        }

        if (suppressStackTraces) {
            clearStackTraces((Throwable)var6);
        }

        var8.writeObject(var6);
        if (var39 instanceof AccessException) {
            throw new IOException("Connection is not reusable", var39);
        }
    } finally {
        var2.releaseInputStream();
        var2.releaseOutputStream();
    }

}

sun.rmi.server.UnicastServerRef#oldDispatch

private void oldDispatch(Remote var1, RemoteCall var2, int var3) throws Exception {
    ObjectInput var6 = var2.getInputStream();

    try {
        Class var7 = Class.forName("sun.rmi.transport.DGCImpl_Skel");
        if (var7.isAssignableFrom(this.skel.getClass())) {
            ((MarshalInputStream)var6).useCodebaseOnly();
        }
    } catch (ClassNotFoundException var9) {
    }

    long var4;
    try {
    //读8个字节
        var4 = var6.readLong();
    } catch (Exception var8) {
        throw new UnmarshalException("error unmarshalling call header", var8);
    }
//允许的方法，四种，写死。
    Operation[] var10 = this.skel.getOperations();
    this.logCall(var1, var3 >= 0 && var3 < var10.length ? var10[var3] : "op: " + var3);
    //这里会设置UnicastServerRef.this.filter，就是上文的RegistryImpl::registryFilter 到输入流var6上。
    this.unmarshalCustomCallData(var6);
    //这里是逻辑
    //var1就是注册中心
    //var2就remotecall,持有socket的输入输出流
    //var3为输入流读入的4字节int,opnum
	//var4为输入流读入的8字节long,hash
    this.skel.dispatch(var1, var2, var3, var4);
}

sun.rmi.registry.RegistryImpl_Skel#dispatch

这个是提供给远程调用用的

public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
    if (var3 < 0) {
    //这些是hash值
        if (var4 == 7583982177005850366L) {
            var3 = 0;
        } else if (var4 == 2571371476350237748L) {
            var3 = 1;
        } else if (var4 == -7538657168040752697L) {
            var3 = 2;
        } else if (var4 == -8381844669958460146L) {
            var3 = 3;
        } else {
            if (var4 != 7305022919901907578L) {
                throw new UnmarshalException("invalid method hash");
            }

            var3 = 4;
        }
    } else if (var4 != 4905912898345647071L) {
        throw new SkeletonMismatchException("interface hash mismatch");
    }

    RegistryImpl var6 = (RegistryImpl)var1;
    StreamRemoteCall var7 = (StreamRemoteCall)var2;
    String var8;
    ObjectInputStream var9;
    ObjectInputStream var10;
    Remote var81;
    switch (var3) {
        case 0:
            RegistryImpl.checkAccess("Registry.bind");

            try {
                var10 = (ObjectInputStream)var7.getInputStream();
                //读取name
                //会调用java.io.ObjectInputStream#readObject(java.lang.Class<?>)
                var8 = SharedSecrets.getJavaObjectInputStreamReadString().readString(var10);
                //反序列化对象
                var81 = (Remote)var10.readObject();
            } catch (IOException | ClassNotFoundException | ClassCastException var78) {
                var7.discardPendingRefs();
                throw new UnmarshalException("error unmarshalling arguments", var78);
            } finally {
                var7.releaseInputStream();
            }

            var6.bind(var8, var81);

            try {
                var7.getResultStream(true);
                break;
            } catch (IOException var77) {
                throw new MarshalException("error marshalling return", var77);
            }
        case 1:
            var7.releaseInputStream();
            String[] var80 = var6.list();

            try {
                ObjectOutput var82 = var7.getResultStream(true);
                var82.writeObject(var80);
                break;
            } catch (IOException var76) {
                throw new MarshalException("error marshalling return", var76);
            }
        case 2:
            try {
                var9 = (ObjectInputStream)var7.getInputStream();
                var8 = SharedSecrets.getJavaObjectInputStreamReadString().readString(var9);
            } catch (IOException | ClassCastException var74) {
                var7.discardPendingRefs();
                throw new UnmarshalException("error unmarshalling arguments", var74);
            } finally {
                var7.releaseInputStream();
            }

            var81 = var6.lookup(var8);

            try {
                ObjectOutput var83 = var7.getResultStream(true);
                var83.writeObject(var81);
                break;
            } catch (IOException var73) {
                throw new MarshalException("error marshalling return", var73);
            }
        case 3:
            RegistryImpl.checkAccess("Registry.rebind");

            try {
                var10 = (ObjectInputStream)var7.getInputStream();
                var8 = SharedSecrets.getJavaObjectInputStreamReadString().readString(var10);
                var81 = (Remote)var10.readObject();
            } catch (IOException | ClassNotFoundException | ClassCastException var71) {
                var7.discardPendingRefs();
                throw new UnmarshalException("error unmarshalling arguments", var71);
            } finally {
                var7.releaseInputStream();
            }

            var6.rebind(var8, var81);

            try {
                var7.getResultStream(true);
                break;
            } catch (IOException var70) {
                throw new MarshalException("error marshalling return", var70);
            }
        case 4:
            RegistryImpl.checkAccess("Registry.unbind");

            try {
                var9 = (ObjectInputStream)var7.getInputStream();
                var8 = SharedSecrets.getJavaObjectInputStreamReadString().readString(var9);
            } catch (IOException | ClassCastException var68) {
                var7.discardPendingRefs();
                throw new UnmarshalException("error unmarshalling arguments", var68);
            } finally {
                var7.releaseInputStream();
            }

            var6.unbind(var8);

            try {
                var7.getResultStream(true);
                break;
            } catch (IOException var67) {
                throw new MarshalException("error marshalling return", var67);
            }
        default:
            throw new UnmarshalException("invalid method number");
    }

}

稍微看一下readString方法。感觉写的也是很杂糅，将TC_STRING与TC_LONGSTRING的逻辑混在一起了。

java.io.ObjectInputStream#readString(boolean)

/**
 * Reads in and returns new string.  Sets passHandle to new string's
 * assigned handle.
 */
private String readString(boolean unshared) throws IOException {
    String str;
    byte tc = bin.readByte();
    switch (tc) {
        case TC_STRING:
            str = bin.readUTF();
            break;

        case TC_LONGSTRING:
            str = bin.readLongUTF();
            break;

        default:
            throw new StreamCorruptedException(
                String.format("invalid type code: %02X", tc));
    }
    passHandle = handles.assign(unshared ? unsharedMarker : str);
    handles.finish(passHandle);
    return str;
}

总结

1、registryImpl有两种注册方式，本地注册，远程注册。

2、远程注册，就跟调用远程对象一样