import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null)
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n

    Fiber fiber = engine.createFiber();
    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null)
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n

    Fiber fiber = engine.createFiber();
    // then send it away!
    final Tube tube = pool.take();
    fiber.start(tube, request, new Fiber.CompletionCallback() {
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    });
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * The pool instance needs to be recreated to prevent reuse of old Toolkit instances.
 */
public void reconfigure() {
    this.pool = new Pool<TK>() {
        protected TK create() {
            return createToolkit();
        }
    };
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * Passes a message to a pipe for processing.
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param packet         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param receiver       Receives the {@link ResponseContext}. Since the spec requires
 *                       that the asynchronous invocations must not update response context,
 *                       depending on the mode of invocation they have to go to different places.
 *                       So we take a setter that abstracts that away.
 */
protected final Packet process(Packet packet, RequestContext requestContext, ResponseContextReceiver receiver) {
    packet.isSynchronousMEP = true;
    packet.component = this;
    configureRequestPacket(packet, requestContext);
    Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    // then send it away!
    Tube tube = pool.take();

    try {
        return fiber.runSync(tube, packet);
    } finally {
        // this allows us to capture the packet even when the call failed with an exception.
        // when the call fails with an exception it's no longer a 'reply' but it may provide some information
        // about what went wrong.

        // note that Packet can still be updated after
        // ResponseContext is created.
        Packet reply = (fiber.getPacket() == null) ? packet : fiber.getPacket();
        receiver.setResponseContext(new ResponseContext(reply));

        pool.recycle(tube);
    }
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
private JAXBRIContext createJAXBContext() {
    final List<TypeReference> types = getAllTypeReferences();
    final List<Class> cls = new ArrayList<Class>(types.size() + additionalClasses.size());

    cls.addAll(additionalClasses);
    for (TypeReference type : types)
        cls.add((Class) type.type);

    try {
        //jaxbContext = JAXBRIContext.newInstance(cls, types, targetNamespace, false);
        // Need to avoid doPriv block once JAXB is fixed. Afterwards, use the above
        jaxbContext = AccessController.doPrivileged(new PrivilegedExceptionAction<JAXBRIContext>() {
            public JAXBRIContext run() throws Exception {
                if(LOGGER.isLoggable(Level.FINE)) {
                    LOGGER.log(Level.FINE,"Creating JAXBContext with classes="+cls+" and types="+types);
                }
                UsesJAXBContextFeature f = WebServiceFeatureList.getFeature(features, UsesJAXBContextFeature.class);
                JAXBContextFactory factory = f!=null ? f.getFactory() : null;
                if(factory==null)   factory=JAXBContextFactory.DEFAULT;
                return factory.createJAXBContext(AbstractSEIModelImpl.this,cls,types);
            }
        });
        createBridgeMap(types);
    } catch (PrivilegedActionException e) {
        throw new WebServiceException(ModelerMessages.UNABLE_TO_CREATE_JAXB_CONTEXT(), e);
    }
    knownNamespaceURIs = new ArrayList<String>();
    for (String namespace : jaxbContext.getKnownNamespaceURIs()) {
        if (namespace.length() > 0) {
            if (!namespace.equals(SOAPNamespaceConstants.XSD) && !namespace.equals(SOAPNamespaceConstants.XMLNS))
                knownNamespaceURIs.add(namespace);
        }
    }

    marshallers = new Pool.Marshaller(jaxbContext);

    return jaxbContext;
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
@Override
public Pool.Marshaller getMarshallerPool() {
    return marshallers;
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
private void /*JAXBRIContext*/ createJAXBContext() {
        final List<TypeInfo> types = getAllTypeInfos();
        final List<Class> cls = new ArrayList<Class>(types.size() + additionalClasses.size());

        cls.addAll(additionalClasses);
        for (TypeInfo type : types) {
            cls.add((Class) type.type);
        }

        try {
            //jaxbContext = JAXBRIContext.newInstance(cls, types, targetNamespace, false);
            // Need to avoid doPriv block once JAXB is fixed. Afterwards, use the above
            bindingContext = AccessController.doPrivileged(new PrivilegedExceptionAction<BindingContext>() {
                public BindingContext run() throws Exception {
                    if(LOGGER.isLoggable(Level.FINEST)) {
                        LOGGER.log(Level.FINEST, "Creating JAXBContext with classes={0} and types={1}", new Object[]{cls, types});
                    }
                    UsesJAXBContextFeature f = features.get(UsesJAXBContextFeature.class);
                    com.oracle.webservices.internal.api.databinding.DatabindingModeFeature dmf =
                            features.get(com.oracle.webservices.internal.api.databinding.DatabindingModeFeature.class);
                    JAXBContextFactory factory = f!=null ? f.getFactory() : null;
                    if(factory==null)   factory=JAXBContextFactory.DEFAULT;

//                    return factory.createJAXBContext(AbstractSEIModelImpl.this,cls,types);

                    databindingInfo.properties().put(JAXBContextFactory.class.getName(), factory);
                    if (dmf != null) {
                        if (LOGGER.isLoggable(Level.FINE))
                            LOGGER.log(Level.FINE, "DatabindingModeFeature in SEI specifies mode: {0}", dmf.getMode());
                        databindingInfo.setDatabindingMode(dmf
                                .getMode());
                    }

                        if (f!=null) databindingInfo.setDatabindingMode(BindingContextFactory.DefaultDatabindingMode);
                        databindingInfo.setClassLoader(classLoader);
                        databindingInfo.contentClasses().addAll(cls);
                        databindingInfo.typeInfos().addAll(types);
                        databindingInfo.properties().put("c14nSupport", Boolean.FALSE);
                        databindingInfo.setDefaultNamespace(AbstractSEIModelImpl.this.getDefaultSchemaNamespace());
                        BindingContext bc =  BindingContextFactory.create(databindingInfo);
                            if (LOGGER.isLoggable(Level.FINE))
                                LOGGER.log(Level.FINE,
                                        "Created binding context: "
                                                + bc.getClass().getName());
//                      System.out.println("---------------------- databinding " + bc);
                        return bc;
                }
            });
//          createBridgeMap(types);
            createBondMap(types);
        } catch (PrivilegedActionException e) {
            throw new WebServiceException(ModelerMessages.UNABLE_TO_CREATE_JAXB_CONTEXT(), e);
        }
        knownNamespaceURIs = new ArrayList<String>();
        for (String namespace : bindingContext.getKnownNamespaceURIs()) {
            if (namespace.length() > 0) {
                if (!namespace.equals(SOAPNamespaceConstants.XSD) && !namespace.equals(SOAPNamespaceConstants.XMLNS))
                    knownNamespaceURIs.add(namespace);
            }
        }

        marshallers = new Pool.Marshaller(jaxbContext);

        //return getJAXBContext();
    }
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
public Pool<Tube> getTubes() {
    return tubes;
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * Passes a message through a {@link Tube}line for processing. The processing happens
 * asynchronously and when the response is available, Fiber.CompletionCallback is
 * called. The processing could happen on multiple threads.
 *
 * <p>
 * Unlike {@link Tube} instances,
 * this method is thread-safe and can be invoked from
 * multiple threads concurrently.
 *
 * @param receiver       The {@link Response} implementation
 * @param request         The message to be sent to the server
 * @param requestContext The {@link RequestContext} when this invocation is originally scheduled.
 *                       This must be the same object as {@link #requestContext} for synchronous
 *                       invocations, but for asynchronous invocations, it needs to be a snapshot
 *                       captured at the point of invocation, to correctly satisfy the spec requirement.
 * @param completionCallback Once the processing is done, the callback is invoked.
 */
protected final void processAsync(AsyncResponseImpl<?> receiver, Packet request, RequestContext requestContext, final Fiber.CompletionCallback completionCallback) {
    // fill in Packet
    request.component = this;
    configureRequestPacket(request, requestContext);

    final Pool<Tube> pool = tubes;
    if (pool == null) {
        throw new WebServiceException("close method has already been invoked"); // TODO: i18n
    }

    final Fiber fiber = engine.createFiber();
    configureFiber(fiber);

    receiver.setCancelable(fiber);

    // check race condition on cancel
    if (receiver.isCancelled()) {
        return;
    }

    FiberContextSwitchInterceptorFactory fcsif = owner.getSPI(FiberContextSwitchInterceptorFactory.class);
    if (fcsif != null) {
        fiber.addInterceptor(fcsif.create());
    }

    // then send it away!
    final Tube tube = pool.take();

    Fiber.CompletionCallback fiberCallback = new Fiber.CompletionCallback() {
        @Override
        public void onCompletion(@NotNull Packet response) {
            pool.recycle(tube);
            completionCallback.onCompletion(response);
        }

        @Override
        public void onCompletion(@NotNull Throwable error) {
            // let's not reuse tubes as they might be in a wrong state, so not
            // calling pool.recycle()
            completionCallback.onCompletion(error);
        }
    };

    // Check for SyncStartForAsyncInvokeFeature

    fiber.start(tube, request, fiberCallback,
                    getBinding().isFeatureEnabled(SyncStartForAsyncFeature.class) &&
                    !requestContext.containsKey(PREVENT_SYNC_START_FOR_ASYNC_INVOKE));
}
 

import com.sun.xml.internal.ws.util.Pool; //导入依赖的package包/类
/**
 * Receives the incoming HTTP connection and dispatches
 * it to JAX-WS. This method returns when JAX-WS completes
 * processing the request and the whole reply is written
 * to {@link WSHTTPConnection}.
 *
 * <p>
 * This method is invoked by the lower-level HTTP stack,
 * and "connection" here is an HTTP connection.
 *
 * <p>
 * To populate a request {@link com.sun.xml.internal.ws.api.message.Packet} with more info,
 * define {@link com.oracle.webservices.internal.api.message.PropertySet.Property properties} on
 * {@link WSHTTPConnection}.
 *
 * @param connection to receive/send HTTP messages for web service endpoints
 * @throws java.io.IOException when I/O errors happen
 */
public void handle(@NotNull WSHTTPConnection connection) throws IOException {
    if (handleGet(connection)) {
        return;
    }

    // Make sure the Toolkit is recycled by the same pool instance from which it was taken
    final Pool<HttpToolkit> currentPool = getPool();
    // normal request handling
    final HttpToolkit tk = currentPool.take();
    try {
        tk.handle(connection);
    } finally {
        currentPool.recycle(tk);
    }
}