import com.sun.corba.se.spi.oa.OADestroyed; //导入依赖的package包/类
public ServantObject servant_preinvoke( org.omg.CORBA.Object self,
    String operation, Class expectedType )
{
    OAInvocationInfo cachedInfo = getCachedInfo() ;
    if (!checkForCompatibleServant( cachedInfo, expectedType ))
        return null ;

    // Note that info is shared across multiple threads
    // using the same subcontract, each of which may
    // have its own operation.  Therefore we need to clone it.
    OAInvocationInfo info = new OAInvocationInfo( cachedInfo, operation ) ;
    orb.pushInvocationInfo( info ) ;

    try {
        info.oa().enter() ;
    } catch (OADestroyed pdes) {
        throw wrapper.preinvokePoaDestroyed( pdes ) ;
    }

    return info ;
}
 

import com.sun.corba.se.spi.oa.OADestroyed; //导入依赖的package包/类
private java.lang.Object getServant(ObjectAdapter objectAdapter, byte[] objectId,
    String operation)
    throws OADestroyed
{
    try {
        if (orb.subcontractDebugFlag) {
            dprint(".getServant->");
        }

        OAInvocationInfo info = objectAdapter.makeInvocationInfo(objectId);
        info.setOperation(operation);
        orb.pushInvocationInfo(info);
        objectAdapter.getInvocationServant(info);
        return info.getServantContainer() ;
    } finally {
        if (orb.subcontractDebugFlag) {
            dprint(".getServant<-");
        }
    }
}
 

import com.sun.corba.se.spi.oa.OADestroyed; //导入依赖的package包/类
protected synchronized OAInvocationInfo getCachedInfo()
{
    if (!servantIsLocal)
        throw wrapper.servantMustBeLocal() ;

    if (cachedInfo == null) {
        ObjectAdapter oa = oaf.find( oaid ) ;
        cachedInfo = oa.makeInvocationInfo( objectId ) ;

        // InvocationInfo must be pushed before calling getInvocationServant
        orb.pushInvocationInfo( cachedInfo ) ;

        try {
            oa.enter( );
            oa.getInvocationServant( cachedInfo ) ;
        } catch (ForwardException freq) {
            throw wrapper.illegalForwardRequest( freq ) ;
        } catch( OADestroyed oades ) {
            // This is an error since no user of this implementation
            // should ever throw this exception
            throw wrapper.adapterDestroyed( oades ) ;
        } finally {
            oa.returnServant( );
            oa.exit( );
            orb.popInvocationInfo() ;
        }
    }

    return cachedInfo ;
}
 

import com.sun.corba.se.spi.oa.OADestroyed; //导入依赖的package包/类
private OAInvocationInfo servantEnter( ObjectAdapter oa ) throws OADestroyed
{
    oa.enter() ;

    OAInvocationInfo info = oa.makeInvocationInfo( objectId ) ;
    orb.pushInvocationInfo( info ) ;

    return info ;
}
 

import com.sun.corba.se.spi.oa.OADestroyed; //导入依赖的package包/类
public void enter() throws OADestroyed
{
    try {
        lock() ;

        if (debug) {
            ORBUtility.dprint( this, "Calling enter on poa " + this ) ;
        }

        // Avoid deadlock if this is the thread that is processing the
        // POA.destroy because this is the only thread that can notify
        // waiters on beingDestroyedCV.  This can happen if an
        // etherealize upcall invokes a method on a colocated object
        // served by this POA.
        while ((state == STATE_DESTROYING) &&
            (isDestroying.get() == Boolean.FALSE)) {
            try {
                beingDestroyedCV.await();
            } catch (InterruptedException ex) {
                // NO-OP
            }
        }

        if (!waitUntilRunning())
            throw new OADestroyed() ;

        invocationCount++;
    } finally {
        if (debug) {
            ORBUtility.dprint( this, "Exiting enter on poa " + this ) ;
        }

        unlock() ;
    }

    manager.enter();
}