util.java

java1.6众多例子参考

            // by not fully implementing interop issue resolution 3857,
            // and returning a null TypeCode with a tk_value TCKind.
            // If we're not talking to Kestrel or Ladybird, fall through
            // to the abstract interface case (also used for foreign ORBs).
            if (!ORBVersionFactory.getFOREIGN().equals(ourORB.getORBVersion()) &&
                ORBVersionFactory.getNEWER().compareTo(ourORB.getORBVersion()) > 0) {

                return orb.get_primitive_tc(TCKind.tk_value);
            }
        }

        // Use tk_abstract_interface as detailed in the resolution

        // REVISIT: Define this in IDL and get the ID in generated code
        String abstractBaseID = "IDL:omg.org/CORBA/AbstractBase:1.0";

        return orb.create_abstract_interface_tc(abstractBaseID, "");
    }

    /**
     * Reads a java.lang.Object as a CORBA any.
     * @param in the stream from which to read the any.
     * @return the object read from the stream.
     */
    public Object readAny(InputStream in) 
    {
	Any any = in.read_any();
        if ( any.type().kind().value() == TCKind._tk_objref )
	    return any.extract_Object ();
        else
	    return any.extract_Value();
    }

    /**
     * Writes a java.lang.Object as a CORBA Object. If <code>obj</code> is
     * an exported RMI-IIOP server object, the tie is found
     * and wired to <code>obj</code>, then written to <code>out.write_Object(org.omg.CORBA.Object)</code>. 
     * If <code>obj</code> is a CORBA Object, it is written to 
     * <code>out.write_Object(org.omg.CORBA.Object)</code>.
     * @param out the stream in which to write the object.
     * @param obj the object to write.
     */
    public void writeRemoteObject(OutputStream out, java.lang.Object obj) 
    {
        // Make sure we have a connected object, then
        // write it out...
    
        Object newObj = Utility.autoConnect(obj,out.orb(),false);
	out.write_Object((org.omg.CORBA.Object)newObj);
    }
    
    /**
     * Writes a java.lang.Object as either a value or a CORBA Object. 
     * If <code>obj</code> is a value object or a stub object, it is written to 
     * <code>out.write_abstract_interface(java.lang.Object)</code>. If <code>obj</code> is an exported 
     * RMI-IIOP server object, the tie is found and wired to <code>obj</code>,
     * then written to <code>out.write_abstract_interface(java.lang.Object)</code>. 
     * @param out the stream in which to write the object.
     * @param obj the object to write.
     */
    public void writeAbstractObject( OutputStream out, java.lang.Object obj ) 
    {
        // Make sure we have a connected object, then
        // write it out...
    
        Object newObj = Utility.autoConnect(obj,out.orb(),false);
        ((org.omg.CORBA_2_3.portable.OutputStream)out).write_abstract_interface(newObj);
    }
    
    /**
     * Registers a target for a tie. Adds the tie to an internal table and calls
     * {@link Tie#setTarget} on the tie object.
     * @param tie the tie to register.
     * @param target the target for the tie.
     */
    public void registerTarget(javax.rmi.CORBA.Tie tie, java.rmi.Remote target) 
    {
        synchronized (exportedServants) {
            // Do we already have this target registered?
            if (lookupTie(target) == null) {
                // No, so register it and set the target...
                exportedServants.put(target,tie);
                tie.setTarget(target);
            
                // Do we need to instantiate our keep-alive thread?
                if (keepAlive == null) {
                    // Yes. Instantiate our keep-alive thread and start
                    // it up...
                    keepAlive = (KeepAlive)AccessController.doPrivileged(new PrivilegedAction() {
                        public java.lang.Object run() {
                            return new KeepAlive();
                        }
                    });
                    keepAlive.start();
                }
            }
        }
    }
    
    /**
     * Removes the associated tie from an internal table and calls {@link Tie#deactivate} 
     * to deactivate the object.
     * @param target the object to unexport.
     */
    public void unexportObject(java.rmi.Remote target) 
        throws java.rmi.NoSuchObjectException 
    {
        synchronized (exportedServants) {
            Tie cachedTie = lookupTie(target);
            if (cachedTie != null) {
                exportedServants.remove(target);
                Utility.purgeStubForTie(cachedTie);
		Utility.purgeTieAndServant(cachedTie);
                try {
                    cleanUpTie(cachedTie);
                } catch (BAD_OPERATION e) {
		    // ignore
                } catch (org.omg.CORBA.OBJ_ADAPTER e) {
                    // This can happen when the target was never associated with a POA.
                    // We can safely ignore this case.
                }
                
                // Is it time to shut down our keep alive thread?
                if (exportedServants.isEmpty()) {
                    keepAlive.quit();
                    keepAlive = null;
                }
            } else {
                throw new java.rmi.NoSuchObjectException("Tie not found" );
            }
        }
    }

    protected void cleanUpTie(Tie cachedTie) 
        throws java.rmi.NoSuchObjectException 
    {
        cachedTie.setTarget(null);
        cachedTie.deactivate();
    }
    
    /**
     * Returns the tie (if any) for a given target object.
     * @return the tie or null if no tie is registered for the given target.
     */
    public Tie getTie (Remote target) 
    {
        synchronized (exportedServants) {
            return lookupTie(target);
        }
    }

    /**
     * An unsynchronized version of getTie() for internal use.
     */
    private static Tie lookupTie (Remote target) 
    {
        Tie result = (Tie)exportedServants.get(target);
        if (result == null && target instanceof Tie) {
            if (exportedServants.contains(target)) {
                result = (Tie)target;
            }
        }
        return result;
    }

    /**
     * Returns a singleton instance of a class that implements the
     * {@link ValueHandler} interface. 
     * @return a class which implements the ValueHandler interface.
     */
    public ValueHandler createValueHandler() 
    {
        return valueHandlerSingleton;
    }

    /**
     * Returns the codebase, if any, for the given class. 
     * @param clz the class to get a codebase for.
     * @return a space-separated list of URLs, or null.
     */
    public String getCodebase(java.lang.Class clz) {
        return RMIClassLoader.getClassAnnotation(clz);
    }

    /**
     * Returns a class instance for the specified class. 
     * @param className the name of the class.
     * @param remoteCodebase a space-separated list of URLs at which
     * the class might be found. May be null.
     * @param loadingContext a class whose ClassLoader may be used to
     * load the class if all other methods fail.
     * @return the <code>Class</code> object representing the loaded class.
     * @exception ClassNotFoundException if class cannot be loaded.
     */
    public Class loadClass( String className, String remoteCodebase,	
	ClassLoader loader) throws ClassNotFoundException 
    {
        return JDKBridge.loadClass(className,remoteCodebase,loader);                                
    }

    /**
     * The <tt>isLocal</tt> method has the same semantics as the 
     * ObjectImpl._is_local method, except that it can throw a RemoteException.
     * (no it doesn't but the spec says it should.)
     *   
     * The <tt>_is_local()</tt> method is provided so that stubs may determine 
     * if a particular object is implemented by a local servant and hence local
     * invocation APIs may be used.
     * 
     * @param stub the stub to test.
     *
     * @return The <tt>_is_local()</tt> method returns true if
     * the servant incarnating the object is located in the same process as
     * the stub and they both share the same ORB instance.  The <tt>_is_local()</tt>
     * method returns false otherwise. The default behavior of <tt>_is_local()</tt> is
     * to return false.
     *
     * @throws RemoteException The Java to IDL specification does to
     * specify the conditions that cause a RemoteException to be thrown.
     */
    public boolean isLocal(javax.rmi.CORBA.Stub stub) throws RemoteException 
    {
	boolean result = false ;

        try {
	    org.omg.CORBA.portable.Delegate delegate = stub._get_delegate() ;
	    if (delegate instanceof CorbaClientDelegate) {
		// For the Sun ORB
		CorbaClientDelegate cdel = (CorbaClientDelegate)delegate ;
		ContactInfoList cil = cdel.getContactInfoList() ;
		if (cil instanceof CorbaContactInfoList) {
		    CorbaContactInfoList ccil = (CorbaContactInfoList)cil ;
		    LocalClientRequestDispatcher lcs = ccil.getLocalClientRequestDispatcher() ;
		    result = lcs.useLocalInvocation( null ) ;
		}
	    } else {
		// For a non-Sun ORB
		result = delegate.is_local( stub ) ;
	    }
        } catch (SystemException e) {
            throw javax.rmi.CORBA.Util.mapSystemException(e);
        }

	return result ;
    }
    
    /**
     * Wraps an exception thrown by an implementation
     * method.  It returns the corresponding client-side exception. 
     * @param orig the exception to wrap.
     * @return the wrapped exception.
     */
    public RemoteException wrapException(Throwable orig) 
    {
        if (orig instanceof SystemException) {
            return mapSystemException((SystemException)orig);
        }
    	
    	if (orig instanceof Error) {
    	    return new ServerError("Error occurred in server thread",(Error)orig);   
    	} else if (orig instanceof RemoteException) {
	    return new ServerException("RemoteException occurred in server thread",
				       (Exception)orig);   
    	} else if (orig instanceof RuntimeException) {
            throw (RuntimeException) orig;
    	}    	
        
	if (orig instanceof Exception)
	    return new UnexpectedException( orig.toString(), (Exception)orig );
	else
	    return new UnexpectedException( orig.toString());
    }

    /**
     * Copies or connects an array of objects. Used by local stubs
     * to copy any number of actual parameters, preserving sharing
     * across parameters as necessary to support RMI semantics.
     * @param obj the objects to copy or connect.
     * @param orb the ORB.
     * @return the copied or connected objects.
     * @exception RemoteException if any object could not be copied or connected.
     */
    public Object[] copyObjects (Object[] obj, org.omg.CORBA.ORB orb)
	throws RemoteException 
    {
	if (obj == null)
	    // Bug fix for 5018613: JCK test expects copyObjects to throw
	    // NPE when obj==null.  This is actually not in the spec, since
	    // obj is not really an RMI-IDL data type, but we follow our
	    // test here, and force this error to be thrown.
	    throw new NullPointerException() ;

	Class compType = obj.getClass().getComponentType() ;
	if (Remote.class.isAssignableFrom( compType ) && !compType.isInterface()) {
	    // obj is an array of remote impl types.  This
	    // causes problems with stream copier, so we copy
	    // it over to an array of Remotes instead.
	    Remote[] result = new Remote[obj.length] ;
	    System.arraycopy( (Object)obj, 0, (Object)result, 0, obj.length ) ;
	    return (Object[])copyObject( result, orb ) ;
	} else
	    return (Object[])copyObject( obj, orb ) ;
    }

    /**
     * Copies or connects an object. Used by local stubs to copy 
     * an actual parameter, result object, or exception.
     * @param obj the object to copy.
     * @param orb the ORB.
     * @return the copy or connected object.
     * @exception RemoteException if the object could not be copied or connected.
     */
    public Object copyObject (Object obj, org.omg.CORBA.ORB orb)
	throws RemoteException 
    {
	if (orb instanceof ORB) {
	    ORB lorb = (ORB)orb ;

	    try {
		try {
		    // This gets the copier for the current invocation, which was
		    // previously set by preinvoke.
		    return lorb.peekInvocationInfo().getCopierFactory().make().copy( obj ) ;
		} catch (java.util.EmptyStackException exc) {
		    // copyObject was invoked outside of an invocation, probably by
		    // a test.  Get the default copier from the ORB.
		    // XXX should we just make the default copier available directly
		    // and avoid constructing one on each call?
		    CopierManager cm = lorb.getCopierManager() ;
		    ObjectCopier copier = cm.getDefaultObjectCopierFactory().make() ;
		    return copier.copy( obj ) ;
		}
	    } catch (ReflectiveCopyException exc) {
		RemoteException rexc = new RemoteException() ;
		rexc.initCause( exc ) ;
		throw rexc ;
	    }
	} else {
	    org.omg.CORBA_2_3.portable.OutputStream out = 
		(org.omg.CORBA_2_3.portable.OutputStream)orb.create_output_stream();
	    out.write_value((Serializable)obj);
	    org.omg.CORBA_2_3.portable.InputStream in = 
		(org.omg.CORBA_2_3.portable.InputStream)out.create_input_stream();
	    return in.read_value();
	}
    }
}

class KeepAlive extends Thread 
{
    boolean quit = false;
    
    public KeepAlive () 
    {
        setDaemon(false);
    }
    
    public synchronized void run () 
    {
        while (!quit) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
    }
    
    public synchronized void quit () 
    {
        quit = true;
        notifyAll();
    }  
}