import java.rmi.Remote;
import java.rmi.RemoteException;

public interface IRemoteObj extends Remote {
    // 远程方法要抛RemoteException
    public String sayHello() throws RemoteException;
}

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class IRemoteObjImpl extends UnicastRemoteObject implements IRemoteObj{
    protected IRemoteObjImpl() throws RemoteException {
    }

    @Override
    public String sayHello() throws RemoteException {
        String name = this.getClass().getName();
        System.out.println(name);
        return name;
    }
}

public class RMIServer {
    public static void main(String[] args) throws RemoteException, AlreadyBoundException {
        //创建远程对象
        IRemoteObjImpl iRemoteObj = new IRemoteObjImpl();
        //创建注册中心
        Registry registry = LocateRegistry.createRegistry(1099);
        //把远程对象发布到注册中心上，这里还提供了查询（lookup）、重新绑定（rebind）、接触绑定（unbind）、list（列表）的方式
        registry.bind("iRemoteObj",iRemoteObj);
    }
}

import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIClient {
    public static void main(String[] args) throws  RemoteException, NotBoundException {
        Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099);
        IRemoteObj remoteObj = (IRemoteObj) registry.lookup("iRemoteObj");
        String s = remoteObj.sayHello();
        System.out.println(s);
    }
}

  public static TCPEndpoint getLocalEndpoint(int port) {
        return getLocalEndpoint(port, null, null);
    }

public static TCPEndpoint getLocalEndpoint(int port,
        RMIClientSocketFactory csf, RMIServerSocketFactory ssf) {
    /*
     * 查找将一个端点键映射到此客户端/服务器套接字工厂对的本地唯一端点列表（可能为null）的特定端口。
     */
    TCPEndpoint ep = null;

    // 使用localEndpoints对象对方法进行同步
    synchronized (localEndpoints) {
        // 创建一个 TCPEndpoint 实例作为端点键
        TCPEndpoint endpointKey = new TCPEndpoint(null, port, csf, ssf);
        // 获取本地唯一端点列表
        LinkedList<TCPEndpoint> epList = localEndpoints.get(endpointKey);
        // 获取本地主机名称
        String localHost = resampleLocalHost();

        // 如果本地唯一端点列表不存在
        if (epList == null) {
            /*
             * 创建新的端点列表
             */
            // 创建一个 TCPEndpoint 实例，作为新的唯一端点
            ep = new TCPEndpoint(localHost, port, csf, ssf);
            // 创建一个 LinkedList 实例，将新唯一端点添加到其中
            epList = new LinkedList<TCPEndpoint>();
            epList.add(ep);
            // 设置唯一端点的监听端口和传输协议
            ep.listenPort = port;
            ep.transport = new TCPTransport(epList);
            // 将端点键与新的唯一端点列表加入到 localEndpoints 对象中
            localEndpoints.put(endpointKey, epList);

            // 如果 tcpLog 的记录级别为 BRIEF，则记录端口创建成功的日志信息
            if (TCPTransport.tcpLog.isLoggable(Log.BRIEF)) {
                TCPTransport.tcpLog.log(Log.BRIEF,
                        "created local endpoint for socket factory " + ssf +
                        " on port " + port);
            }
        } else {
            synchronized (epList) {
                // 获取本地唯一端点列表的最后一个唯一端点
                ep = epList.getLast();
                // 获取最后一个唯一端点的主机名称、端口号和传输协议
                String lastHost = ep.host;
                int lastPort =  ep.port;
                TCPTransport lastTransport = ep.transport;

                // 如果本地主机名称不为 null 且不等于最后一个唯一端点的主机名称
                if (localHost != null && !localHost.equals(lastHost)) {
                    /*
                     * 主机名称已更新；将更新的端点添加到列表中
                     */
                    // 如果最后一个唯一端点的端口号已设置，则移除旧唯一端点
                    if (lastPort != 0) {
                        epList.clear();
                    }

                    // 创建一个 TCPEndpoint 实例，作为新的唯一端点
                    ep = new TCPEndpoint(localHost, lastPort, csf, ssf);
                    // 设置唯一端点的监听端口和传输协议
                    ep.listenPort = port;
                    ep.transport = lastTransport;
                    // 将新唯一端点添加到列表中
					epList.add(ep);
                   }
                }
            }
        }
        return ep;
    }

public UnicastServerRef(int port) {
    super(new LiveRef(port));
}

public Remote exportObject(Remote impl, Object data,
                           boolean permanent)
    throws RemoteException
{
    Class<?> implClass = impl.getClass();
    Remote stub;

    try {
        stub = Util.createProxy(implClass, getClientRef(), forceStubUse);
    } catch (IllegalArgumentException e) {
        throw new ExportException(
            "remote object implements illegal remote interface", e);
    }
    if (stub instanceof RemoteStub) {
        setSkeleton(impl);
    }

    Target target =
        new Target(impl, this, stub, ref.getObjID(), permanent);
    ref.exportObject(target);
    hashToMethod_Map = hashToMethod_Maps.get(implClass);
    return stub;
}

public Target(Remote impl, Dispatcher disp, Remote stub, ObjID id, boolean permanent)
{
    // 初始化 weakImpl 为一个 WeakRef 对象，它持有传入的 impl 对象，并将其添加到 ObjectTable 的 reapQueue 队列中。
    this.weakImpl = new WeakRef(impl, ObjectTable.reapQueue);
    
    // 将传入的 disp 赋值给实例变量 disp。
    this.disp = disp;
    
    // 将传入的 stub 赋值给实例变量 stub。
    this.stub = stub;
    
    // 将传入的 id 赋值给实例变量 id。
    this.id = id;
    
    // 使用 AccessController 获取当前线程的上下文。
    this.acc = AccessController.getContext();

    // 获取当前线程的上下文类加载器。
    ClassLoader threadContextLoader = Thread.currentThread().getContextClassLoader();
    
    // 获取传入的 impl 对象的类加载器。
    ClassLoader serverLoader = impl.getClass().getClassLoader();
    
    // 检查当前线程的上下文类加载器是否是传入的 impl 对象的类加载器的子级。
    if (checkLoaderAncestry(threadContextLoader, serverLoader)) {
        // 如果是，则使用当前线程的上下文类加载器作为上下文类加载器。
        this.ccl = threadContextLoader;
    } else {
        // 如果不是，则使用传入的 impl 对象的类加载器作为上下文类加载器。
        this.ccl = serverLoader;
    }
    
    // 将传入的 permanent 赋值给实例变量 permanent。
    this.permanent = permanent;
    
    // 如果 permanent 为 true，则调用 pinImpl 方法将 impl 对象钉住（防止被 GC 回收）。
    if (permanent) {
        pinImpl();
    }
}

public void exportObject(Target target) throws RemoteException {
    
        synchronized (this) {
            listen();
            exportCount++;
        }
        boolean ok = false;
        try {
            super.exportObject(target);
            ok = true;
        } finally {
            if (!ok) {
                synchronized (this) {
                    decrementExportCount();
                }
            }
        }
    }

private void listen() throws RemoteException {
    assert Thread.holdsLock(this); // 断言当前线程已经拥有锁，如果不满足会抛出 AssertionError

    TCPEndpoint ep = getEndpoint(); // 获取 TCPEndpoint 对象
    int port = ep.getPort(); // 获取 TCPEndpoint 对象的端口号

    if (server == null) { // 如果 Server 对象为 null
        if (tcpLog.isLoggable(Log.BRIEF)) { // 如果 TCP 日志记录器支持 brief 日志级别
            tcpLog.log(Log.BRIEF,
                "(port " + port + ") create server socket"); // 记录 brief 日志
        }

        try {
            server = ep.newServerSocket(); // 创建 ServerSocket 对象
            Thread t = AccessController.doPrivileged(
                new NewThreadAction(new AcceptLoop(server),
                                    "TCP Accept-" + port, true)); // 创建新线程，启动 AcceptLoop
            t.start(); // 启动新线程
        } catch (java.net.BindException e) { // 如果端口已被占用，抛出 ExportException 异常
            throw new ExportException("Port already in use: " + port, e);
        } catch (IOException e) { // 如果监听失败，抛出 ExportException 异常
            throw new ExportException("Listen failed on port: " + port, e);
        }

    } else { // 如果 Server 对象不为 null
        // otherwise verify security access to existing server socket
        SecurityManager sm = System.getSecurityManager(); // 获取安全管理器
        if (sm != null) { // 如果安全管理器不为 null
            sm.checkListen(port); // 验证监听端口是否被授权访问
        }
    }
}

public void exportObject(Target target) throws RemoteException {
    target.setExportedTransport(this);
    ObjectTable.putTarget(target);
}

void setExportedTransport(Transport exportedTransport) {
    if (this.exportedTransport == null) {
        this.exportedTransport = exportedTransport;
    }
}

static void putTarget(Target target) throws ExportException {
    ObjectEndpoint oe = target.getObjectEndpoint();
    WeakRef weakImpl = target.getWeakImpl();

    if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
        DGCImpl.dgcLog.log(Log.VERBOSE, "add object " + oe);
    }

    synchronized (tableLock) {
        if (target.getImpl() != null) {
            if (objTable.containsKey(oe)) {
                throw new ExportException(
                    "internal error: ObjID already in use");
            } else if (implTable.containsKey(weakImpl)) {
                throw new ExportException("object already exported");
            }

            objTable.put(oe, target);
            implTable.put(weakImpl, target);

            if (!target.isPermanent()) {
                incrementKeepAliveCount();
            }
        }
    }
}

if (DGCImpl.dgcLog.isLoggable(Log.VERBOSE)) {
    DGCImpl.dgcLog.log(Log.VERBOSE, "add object " + oe);
}

static {
     /*
      * 在与任意当前线程上下文隔离的上下文中“导出”单例的DGCImpl。
      */
     AccessController.doPrivileged(new PrivilegedAction<Void>() {
         public Void run() {
             ClassLoader savedCcl = Thread.currentThread().getContextClassLoader();
             try {
                 // 设置上下文类加载器为系统类加载器
                 Thread.currentThread().setContextClassLoader(ClassLoader.getSystemClassLoader());

                 /*
                  * 将远程收集器对象手动放入表格中，以防止在端口上侦听。 
                  * （UnicastServerRef.exportObject将导致传输侦听。）
                  */
                 try {
                     // 创建并导出 DGCImpl
                     dgc = new DGCImpl();
                     ObjID dgcID = new ObjID(ObjID.DGC_ID);
                     LiveRef ref = new LiveRef(dgcID, 0);
                     UnicastServerRef disp = new UnicastServerRef(ref);
                     Remote stub = Util.createProxy(DGCImpl.class, new UnicastRef(ref), true);
                     disp.setSkeleton(dgc);

                     // 创建一个Target对象，并将其放入ObjectTable中
                     Permissions perms = new Permissions();
                     perms.add(new SocketPermission("*", "accept,resolve"));
                     ProtectionDomain[] pd = { new ProtectionDomain(null, perms) };
                     AccessControlContext acceptAcc = new AccessControlContext(pd);

                     Target target = AccessController.doPrivileged(new PrivilegedAction<Target>() {
                         public Target run() {
                             return new Target(dgc, disp, stub, dgcID, true);
                         }
                     }, acceptAcc);
                     ObjectTable.putTarget(target);
                 } catch (RemoteException e) {
                     throw new Error("exception initializing server-side DGC", e);
                 }
             } finally {
                 // 恢复上下文类加载器
                 Thread.currentThread().setContextClassLoader(savedCcl);
             }
             return null;
         }
     });
 }