Java RemoteRef类代码示例

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * Returns the port number the RMI {@link Registry} is running on.
 *
 * @param registry the registry to find the port of.
 * @return the port number the registry is using.
 * @throws RuntimeException if there was a problem getting the port number.
 */
public static int getRegistryPort(Registry registry) {
    int port = -1;

    try {
        RemoteRef remoteRef = ((RegistryImpl)registry).getRef();
        LiveRef liveRef = ((UnicastServerRef)remoteRef).getLiveRef();
        Endpoint endpoint = liveRef.getChannel().getEndpoint();
        TCPEndpoint tcpEndpoint = (TCPEndpoint) endpoint;
        port = tcpEndpoint.getPort();
    } catch (Exception ex) {
        throw new RuntimeException("Error getting registry port.", ex);
    }

    return port;
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
private void writeObject(ObjectOutputStream out) throws IOException, ClassNotFoundException {
    // rmi.log.0C=ActivationID.writeObject:
    rlog.log(RMILog.VERBOSE, Messages.getString("rmi.log.0C")); //$NON-NLS-1$
    try {
        out.writeObject(uid);
        // rmi.log.0D=activator = {0}
        rlog.log(RMILog.VERBOSE, Messages.getString("rmi.log.0D", activator)); //$NON-NLS-1$
        RemoteRef ref = ((RemoteObject) activator).getRef();
        // rmi.log.09=ref = {0}
        rlog.log(RMILog.VERBOSE, Messages.getString("rmi.log.09", ref)); //$NON-NLS-1$
        String refType = ref.getRefClass(out);
        // rmi.log.08=refType={0}
        rlog.log(RMILog.VERBOSE, Messages.getString("rmi.log.08", refType)); //$NON-NLS-1$
        out.writeUTF(refType);
        ref.writeExternal(out);
        // rmi.log.04=ActivationID.writeObject COMPLETED.
        rlog.log(RMILog.VERBOSE, Messages.getString("rmi.log.04")); //$NON-NLS-1$
    } catch (Throwable t) {
        // rmi.0A=Unable to serialize ActivationID: {0}
        throw new IOException(Messages.getString("rmi.0A", t.getMessage()));//$NON-NLS-1$
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * Returns the Remote Stub for the given activatable class.
 */
public static RemoteStub getStub(ActivationDesc desc, ActivationID aid)
        throws StubNotFoundException {

    String cn = desc.getClassName();
    String stubName = ""; //$NON-NLS-1$

    try {
        Class cl = RMIClassLoader.loadClass(desc.getLocation(), cn);
        Class rcl = RMIUtil.getRemoteClass(cl);
        stubName = rcl.getName() + "_Stub"; //$NON-NLS-1$
        Class stubClass = RMIClassLoader.loadClass((String) null, stubName);
        Constructor constructor = stubClass.getConstructor(new Class[] { RemoteRef.class });
        RemoteStub stub = (RemoteStub) constructor.newInstance(new Object[] {
                new ActivatableRef(aid, null)
        });
        return stub;

    } catch (Exception ex) {
        // rmi.68=Stub {0} not found.
        throw new StubNotFoundException(Messages.getString("rmi.68", stubName), //$NON-NLS-1$ //$NON-NLS-2$
                ex);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * To obtain the description of the Serialization of this class see the Serialized form of
 * java.rmi.server.RemoteObject.
 */
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    id = (ActivationID) in.readObject();

    String s = in.readUTF();

    if (s.equals("")) { //$NON-NLS-1$
        return;
    }
    Class extRefTypeClass = Class.forName(RemoteRef.packagePrefix +"."+ s); //$NON-NLS-1$

    try {
        ref = (RemoteRef)extRefTypeClass.newInstance();
    }
    catch(Throwable  t) {
        // rmi.73=Instantiation failed.
        throw new ClassNotFoundException(Messages.getString("rmi.73"), t); //$NON-NLS-1$
    }
    ref.readExternal(in);
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * Sends the first dirty for a received reference in order to get the
 * appropiate lease time from the server, and then schedules the dirty call
 * for lease renewal. If the first dirty message fails, a clean "strong"
 * message is sent for that remote object. If the first dirty call
 * succeeded, the reference becomes a "live" reference for the client DGC.
 * 
 * @param ref
 *            The reference received inside the stub
 * @return The <code>Endpoint / ObjID</code> pair contained inside the
 *         reference
 * @throws UnmarshalException
 *             If the first dirty call fails
 */
private final Pair<Endpoint, ObjID> activateReference(RemoteRef ref)
        throws UnmarshalException {
    // Get necessary data previously stored during RemoteRef
    // deserialization.
    Pair<Endpoint, ObjID> data = deserializedRemoteRefTable.get(ref);
    if (data == null) {
        throw new UnmarshalException(
                "Impossible to get a stub for this object.");
    }
    Lease lease = sendDirty(data.getFirst(),
            new ObjID[] { data.getSecond() });

    if (lease != null) {
        enqueueDirtyCall(data, lease.getValue());
        liveReferences.put(data, new Long(lease.getValue()));
        return data;
    } else {
        sendClean(data.getFirst(), new ObjID[] { data.getSecond() }, true);
        throw new UnmarshalException(
                "Impossible to get a stub for this object.");
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public final void testInvoke004() throws RemoteException {
    EchoUnicast_Imp eui = new EchoUnicast_Imp() {
        public String echo(String msg) throws RemoteException {
            return msg;
        }
    };
    RemoteRef ref = eui.getRef();
    Echo proxy = (Echo) RemoteObject.toStub(eui);
    String toSend = "hola invoquer";
    try {
        r = new RemoteObjectInvocationHandler(ref);
        assertEquals("The result is what we expect", toSend, r.invoke(
                proxy, Echo.class.getMethods()[0], new Object[] { toSend }));
    } catch (Throwable e) {
        fail("Failed with:" + e);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public final void testInvoke008() throws RemoteException {
    EchoUnicast_Imp eui = new EchoUnicast_Imp() {
        public String echo(String msg) throws RemoteException {
            return msg;
        }
    };
    RemoteRef ref = eui.getRef();
    Echo proxy = (Echo) RemoteObject.toStub(eui);
    String toSend = "hola invoquer";
    try {
        r = new RemoteObjectInvocationHandler(ref);
        assertEquals("The result is what we expected", toSend, r.invoke(
                proxy, Echo.class.getMethods()[0], new Object[] { toSend,
                        toSend }));
    } catch (Throwable e) {
        fail("Failed with:" + e);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public final void testInvoke011() throws RemoteException {
    BigEcho_imp bei = new BigEcho_imp() {
        public void echo() throws RemoteException {
            throw new RemoteException("Always pass throw here");
        }

        public void echo(Object... objs) throws RemoteException {
            if (objs == null) {
                throw new RemoteException("Objs Null");
            }
        }
    };
    RemoteRef ref = bei.getRef();
    BigEcho proxy = (BigEcho) RemoteObject.toStub(bei);
    try {
        r = new RemoteObjectInvocationHandler(ref);
        assertNull(r.invoke(proxy, BigEcho.class.getMethods()[1],
                new Object[] { new Object[] { 1, 2, 3, 4 } }));
    } catch (Throwable e) {
        fail("Failed with:" + e);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public final void testInvoke012() throws RemoteException {
    BigEcho_imp bei = new BigEcho_imp() {
        public void echo() throws RemoteException {
            throw new RemoteException("Always pass throw here");
        }

        public void echo(Object... objs) throws RemoteException {
            if (objs == null) {
                throw new RemoteException("Objs Null");
            }
        }
    };
    RemoteRef ref = bei.getRef();
    BigEcho proxy = (BigEcho) RemoteObject.toStub(bei);
    try {
        r = new RemoteObjectInvocationHandler(ref);
        assertNull(r.invoke(proxy, BigEcho.class.getMethods()[1],
                new Object[] { new Object[] {} }));
    } catch (Throwable e) {
        fail("Failed with:" + e);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public UnicastRemoteObject getObject ( final String command ) throws Exception {
    int jrmpPort = Integer.parseInt(command);
    UnicastRemoteObject uro = Reflections.createWithConstructor(ActivationGroupImpl.class, RemoteObject.class, new Class[] {
        RemoteRef.class
    }, new Object[] {
        new UnicastServerRef(jrmpPort)
    });

    Reflections.getField(UnicastRemoteObject.class, "port").set(uro, jrmpPort);
    return uro;
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * private method to obtain the ref for a call.
 */
private synchronized RemoteRef getRef()
    throws RemoteException
{
    if (ref == null) {
        ref = activate(false);
    }

    return ref;
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * Write out external representation for remote ref.
 */
public void writeExternal(ObjectOutput out) throws IOException
{
    RemoteRef localRef = ref;

    out.writeObject(id);
    if (localRef == null) {
        out.writeUTF("");
    } else {
        out.writeUTF(localRef.getRefClass(out));
        localRef.writeExternal(out);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
/**
 * Returns a proxy for the specified implClass.
 *
 * If both of the following criteria is satisfied, a dynamic proxy for
 * the specified implClass is returned (otherwise a RemoteStub instance
 * for the specified implClass is returned):
 *
 *    a) either the property java.rmi.server.ignoreStubClasses is true or
 *       a pregenerated stub class does not exist for the impl class, and
 *    b) forceStubUse is false.
 *
 * If the above criteria are satisfied, this method constructs a
 * dynamic proxy instance (that implements the remote interfaces of
 * implClass) constructed with a RemoteObjectInvocationHandler instance
 * constructed with the clientRef.
 *
 * Otherwise, this method loads the pregenerated stub class (which
 * extends RemoteStub and implements the remote interfaces of
 * implClass) and constructs an instance of the pregenerated stub
 * class with the clientRef.
 *
 * @param implClass the class to obtain remote interfaces from
 * @param clientRef the remote ref to use in the invocation handler
 * @param forceStubUse if true, forces creation of a RemoteStub
 * @throws IllegalArgumentException if implClass implements illegal
 * remote interfaces
 * @throws StubNotFoundException if problem locating/creating stub or
 * creating the dynamic proxy instance
 **/
public static Remote createProxy(Class<?> implClass,
                                 RemoteRef clientRef,
                                 boolean forceStubUse)
    throws StubNotFoundException
{
    Class<?> remoteClass;

    try {
        remoteClass = getRemoteClass(implClass);
    } catch (ClassNotFoundException ex ) {
        throw new StubNotFoundException(
            "object does not implement a remote interface: " +
            implClass.getName());
    }

    if (forceStubUse ||
        !(ignoreStubClasses || !stubClassExists(remoteClass)))
    {
        return createStub(remoteClass, clientRef);
    }

    final ClassLoader loader = implClass.getClassLoader();
    final Class<?>[] interfaces = getRemoteInterfaces(implClass);
    final InvocationHandler handler =
        new RemoteObjectInvocationHandler(clientRef);

    /* REMIND: private remote interfaces? */

    try {
        return AccessController.doPrivileged(new PrivilegedAction<Remote>() {
            public Remote run() {
                return (Remote) Proxy.newProxyInstance(loader,
                                                       interfaces,
                                                       handler);
            }});
    } catch (IllegalArgumentException e) {
        throw new StubNotFoundException("unable to create proxy", e);
    }
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
public Constructor<?> run() throws Exception {
    Class thisClass = RMIConnector.class;
    ClassLoader thisLoader = thisClass.getClassLoader();
    ProtectionDomain thisProtectionDomain =
            thisClass.getProtectionDomain();
    String[] otherClassNames = {ProxyRef.class.getName()};
    ClassLoader cl =
            new NoCallStackClassLoader(pRefClassName,
            pRefByteCode,
            otherClassNames,
            thisLoader,
            thisProtectionDomain);
    Class<?> c = cl.loadClass(pRefClassName);
    return c.getConstructor(RemoteRef.class);
}
 

import java.rmi.server.RemoteRef; //导入依赖的package包/类
private static RMIConnection shadowJrmpStub(RemoteObject stub)
throws InstantiationException, IllegalAccessException,
        InvocationTargetException, ClassNotFoundException,
        NoSuchMethodException {
    RemoteRef ref = stub.getRef();
    RemoteRef proxyRef = (RemoteRef)
        proxyRefConstructor.newInstance(new Object[] {ref});
    final Constructor<?> rmiConnectionImplStubConstructor =
        rmiConnectionImplStubClass.getConstructor(RemoteRef.class);
    Object[] args = {proxyRef};
    RMIConnection proxyStub = (RMIConnection)
    rmiConnectionImplStubConstructor.newInstance(args);
    return proxyStub;
}