Java WSBinding类代码示例

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * The same as
 * {@link #create(Class, boolean, Invoker, QName, QName, Container, WSBinding, SDDocumentSource, Collection, EntityResolver)}
 * except that this version takes an url of the {@code jax-ws-catalog.xml}.
 *
 * @param catalogUrl
 *      if not null, an {@link EntityResolver} is created from it and used.
 *      otherwise no resolution will be performed.
 */
public static <T> WSEndpoint<T> create(
    @NotNull Class<T> implType,
    boolean processHandlerAnnotation,
    @Nullable Invoker invoker,
    @Nullable QName serviceName,
    @Nullable QName portName,
    @Nullable Container container,
    @Nullable WSBinding binding,
    @Nullable SDDocumentSource primaryWsdl,
    @Nullable Collection<? extends SDDocumentSource> metadata,
    @Nullable URL catalogUrl) {
    return create(
        implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata,
        XmlUtil.createEntityResolver(catalogUrl),false);
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * Creates a new pipeline for the given port name.
 */
private Tube createPipeline(WSPortInfo portInfo, WSBinding binding) {
    //Check all required WSDL extensions are understood
    checkAllWSDLExtensionsUnderstood(portInfo, binding);
    SEIModel seiModel = null;
    Class sei = null;
    if (portInfo instanceof SEIPortInfo) {
            SEIPortInfo sp = (SEIPortInfo) portInfo;
        seiModel = sp.model;
        sei = sp.sei;
    }
    BindingID bindingId = portInfo.getBindingId();

    TubelineAssembler assembler = TubelineAssemblerFactory.create(
            Thread.currentThread().getContextClassLoader(), bindingId, owner.getContainer());
    if (assembler == null) {
        throw new WebServiceException("Unable to process bindingID=" + bindingId); // TODO: i18n
    }
    return assembler.createClient(
            new ClientTubeAssemblerContext(
                    portInfo.getEndpointAddress(),
                    portInfo.getPort(),
                    this, binding, owner.getContainer(), ((BindingImpl) binding).createCodec(), seiModel, sei));
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
private void populateAddressingHeaders(WSBinding binding, Packet responsePacket, WSDLPort wsdlPort, SEIModel seiModel) {
    AddressingVersion addressingVersion = binding.getAddressingVersion();

    if (addressingVersion == null) {
        return;
    }

    WsaTubeHelper wsaHelper = addressingVersion.getWsaHelper(wsdlPort, seiModel, binding);
    String action = responsePacket.getMessage().isFault() ?
            wsaHelper.getFaultAction(this, responsePacket) :
            wsaHelper.getOutputAction(this);
    if (action == null) {
        LOGGER.info("WSA headers are not added as value for wsa:Action cannot be resolved for this message");
        return;
    }
    populateAddressingHeaders(responsePacket, addressingVersion, binding.getSOAPVersion(), action, AddressingVersion.isRequired(binding));
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * Creates a new {@link Dispatch} stub that connects to the given pipe.
 *
 * @param portInfo
 *      see <a href="#param">common parameters</a>
 * @param owner
 *      see <a href="#param">common parameters</a>
 * @param binding
 *      see <a href="#param">common parameters</a>
 * @param clazz
 *      Type of the {@link Dispatch} to be created.
 *      See {@link Service#createDispatch(QName, Class, Service.Mode)}.
 * @param mode
 *      The mode of the dispatch.
 *      See {@link Service#createDispatch(QName, Class, Service.Mode)}.
 * @param epr
 *      see <a href="#param">common parameters</a>
 * TODO: are these parameters making sense?
 */
public static <T> Dispatch<T> createDispatch(WSPortInfo portInfo,
                                             WSService owner,
                                             WSBinding binding,
                                             Class<T> clazz, Service.Mode mode,
                                             @Nullable WSEndpointReference epr) {
    if (clazz == SOAPMessage.class) {
        return (Dispatch<T>) createSAAJDispatch(portInfo, binding, mode, epr);
    } else if (clazz == Source.class) {
        return (Dispatch<T>) createSourceDispatch(portInfo, binding, mode, epr);
    } else if (clazz == DataSource.class) {
        return (Dispatch<T>) createDataSourceDispatch(portInfo, binding, mode, epr);
    } else if (clazz == Message.class) {
        if(mode==Mode.MESSAGE)
            return (Dispatch<T>) createMessageDispatch(portInfo, binding, epr);
        else
            throw new WebServiceException(mode+" not supported with Dispatch<Message>");
    } else if (clazz == Packet.class) {
        if(mode==Mode.MESSAGE)
            return (Dispatch<T>) createPacketDispatch(portInfo, binding, epr);
        else
            throw new WebServiceException(mode+" not supported with Dispatch<Packet>");
    } else
        throw new WebServiceException("Unknown class type " + clazz.getName());
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
private static AbstractSEIModelImpl createSEIModel(WSDLPort wsdlPort,
                                                   Class<?> implType, @NotNull QName serviceName, @NotNull QName portName, WSBinding binding,
                                                   SDDocumentSource primaryWsdl) {
            DatabindingFactory fac = DatabindingFactory.newInstance();
            DatabindingConfig config = new DatabindingConfig();
            config.setEndpointClass(implType);
            config.getMappingInfo().setServiceName(serviceName);
            config.setWsdlPort(wsdlPort);
            config.setWSBinding(binding);
            config.setClassLoader(implType.getClassLoader());
            config.getMappingInfo().setPortName(portName);
            if (primaryWsdl != null) config.setWsdlURL(primaryWsdl.getSystemId());
    config.setMetadataReader(getExternalMetadatReader(implType, binding));

            com.sun.xml.internal.ws.db.DatabindingImpl rt = (com.sun.xml.internal.ws.db.DatabindingImpl)fac.createRuntime(config);
            return (AbstractSEIModelImpl) rt.getModel();
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * The same as
 * {@link #create(Class, boolean, Invoker, QName, QName, Container, WSBinding, SDDocumentSource, Collection, EntityResolver)}
 * except that this version takes an url of the <tt>jax-ws-catalog.xml</tt>.
 *
 * @param catalogUrl
 *      if not null, an {@link EntityResolver} is created from it and used.
 *      otherwise no resolution will be performed.
 */
public static <T> WSEndpoint<T> create(
    @NotNull Class<T> implType,
    boolean processHandlerAnnotation,
    @Nullable Invoker invoker,
    @Nullable QName serviceName,
    @Nullable QName portName,
    @Nullable Container container,
    @Nullable WSBinding binding,
    @Nullable SDDocumentSource primaryWsdl,
    @Nullable Collection<? extends SDDocumentSource> metadata,
    @Nullable URL catalogUrl) {
    return create(
        implType,processHandlerAnnotation,invoker,serviceName,portName,container,binding,primaryWsdl,metadata,
        XmlUtil.createEntityResolver(catalogUrl),false);
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
void setUpProcessor() {
    if (handlers == null) {
            // Take a snapshot, User may change chain after invocation, Same chain
            // should be used for the entire MEP
            handlers = new ArrayList<Handler>();
            WSBinding binding = getBinding();
            List<LogicalHandler> logicalSnapShot= ((BindingImpl) binding).getHandlerConfig().getLogicalHandlers();
            if (!logicalSnapShot.isEmpty()) {
                handlers.addAll(logicalSnapShot);
                if (binding.getSOAPVersion() == null) {
                    processor = new XMLHandlerProcessor(this, binding,
                            handlers);
                } else {
                    processor = new SOAPHandlerProcessor(true, this, binding,
                            handlers);
                }
            }
    }
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * Generates an MTOM policy if MTOM is enabled.
 *
 * <ol>
 * <li>If MTOM is enabled
 * <ol>
 * <li>If MTOM policy does not already exist, generate
 * <li>Otherwise do nothing
 * </ol>
 * <li>Otherwise, do nothing (that implies that we do not remove any MTOM policies if MTOM is disabled)
 * </ol>
 *
 */
public Collection<PolicySubject> update(PolicyMap policyMap, SEIModel model, WSBinding wsBinding) throws PolicyException {
    LOGGER.entering(policyMap, model, wsBinding);

    Collection<PolicySubject> subjects = new ArrayList<PolicySubject>();
    if (policyMap != null) {
        final MTOMFeature mtomFeature = wsBinding.getFeature(MTOMFeature.class);
        if (LOGGER.isLoggable(Level.FINEST)) {
            LOGGER.finest("mtomFeature = " + mtomFeature);
        }
        if ((mtomFeature != null) && mtomFeature.isEnabled()) {
            final QName bindingName = model.getBoundPortTypeName();
            final WsdlBindingSubject wsdlSubject = WsdlBindingSubject.createBindingSubject(bindingName);
            final Policy mtomPolicy = createMtomPolicy(bindingName);
            final PolicySubject mtomPolicySubject = new PolicySubject(wsdlSubject, mtomPolicy);
            subjects.add(mtomPolicySubject);
            if (LOGGER.isLoggable(Level.FINEST)) {
                LOGGER.fine("Added MTOM policy with ID \"" + mtomPolicy.getIdOrName() + "\" to binding element \"" + bindingName + "\"");
            }
        }
    } // endif policy map not null

    LOGGER.exiting(subjects);
    return subjects;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * Parses the handler and role information and sets it
 * on the {@link WSBinding}.
 *
 * @return true if <handler-chains> element present in DD
 *         false otherwise.
 */
protected boolean setHandlersAndRoles(WSBinding binding, XMLStreamReader reader, QName serviceName, QName portName) {

    if (reader.getEventType() == XMLStreamConstants.END_ELEMENT ||
            !reader.getName().equals(HandlerChainsModel.QNAME_HANDLER_CHAINS)) {
        return false;
    }

    HandlerAnnotationInfo handlerInfo = HandlerChainsModel.parseHandlerFile(
            reader, classLoader, serviceName, portName, binding);

    binding.setHandlerChain(handlerInfo.getHandlers());
    if (binding instanceof SOAPBinding) {
        ((SOAPBinding) binding).setRoles(handlerInfo.getRoles());
    }

    // move past </handler-chains>
    XMLStreamReaderUtil.nextContent(reader);
    return true;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
protected MUTube(WSBinding binding, Tube next) {
    super(next);
    // MUPipe should n't be used for bindings other than SOAP.
    if (!(binding instanceof SOAPBinding)) {
        throw new WebServiceException(
                "MUPipe should n't be used for bindings other than SOAP.");
    }
    this.binding = (SOAPBindingImpl) binding;
    this.soapVersion = binding.getSOAPVersion();
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
public Packet relateServerResponse(@Nullable Packet r, @Nullable WSDLPort wsdlPort, @Nullable SEIModel seiModel, @NotNull WSBinding binding) {
    relatePackets(r, false);
    r.setState(State.ServerResponse);
    AddressingVersion av = binding.getAddressingVersion();
    // populate WS-A headers only if WS-A is enabled
    if (av == null) {
        return r;
    }

    if (getMessage() == null) {
        return r;
    }

    //populate WS-A headers only if the request has addressing headers
    String inputAction = AddressingUtils.getAction(getMessage().getHeaders(), av, binding.getSOAPVersion());
    if (inputAction == null) {
        return r;
    }
    // if one-way, then dont populate any WS-A headers
    if (r.getMessage() == null || (wsdlPort != null && getMessage().isOneWay(wsdlPort))) {
        return r;
    }

    // otherwise populate WS-Addressing headers
    populateAddressingHeaders(binding, r, wsdlPort, seiModel);
    return r;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
public WSBinding getBinding() {
    if (endpoint != null) {
        return endpoint.getBinding();
    }
    if (proxy != null) {
        return (WSBinding) proxy.getBinding();
    }
    return null;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
/**
 * Creates {@link Packet} from method invocation's return value
 */
protected Packet getResponse(Packet request, @Nullable T returnValue, WSDLPort port, WSBinding binding) {
    Message message = null;
    if (returnValue != null) {
        message = getResponseMessage(returnValue);
    }
    Packet response = request.createServerResponse(message,port,null,binding);
    return response;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
@Override
public Set<QName> getNotUnderstoodHeaders(Set<String> roles, Set<QName> knownHeaders, WSBinding binding) {
    Set<QName> notUnderstoodHeaders = null;
    if (roles == null) {
        roles = new HashSet<String>();
    }
    SOAPVersion effectiveSoapVersion = getEffectiveSOAPVersion(binding);
    roles.add(effectiveSoapVersion.implicitRole);
    for (int i = 0; i < size(); i++) {
        if (!isUnderstood(i)) {
            Header header = get(i);
            if (!header.isIgnorable(effectiveSoapVersion, roles)) {
                QName qName = new QName(header.getNamespaceURI(), header.getLocalPart());
                if (binding == null) {
                    //if binding is null, no further checks needed...we already
                    //know this header is not understood from the isUnderstood
                    //check above
                    if (notUnderstoodHeaders == null) {
                        notUnderstoodHeaders = new HashSet<QName>();
                    }
                    notUnderstoodHeaders.add(qName);
                } else {
                    // if the binding is not null, see if the binding can understand it
                    if (binding instanceof SOAPBindingImpl && !((SOAPBindingImpl) binding).understandsHeader(qName)) {
                        if (!knownHeaders.contains(qName)) {
                            //logger.info("Element not understood=" + qName);
                            if (notUnderstoodHeaders == null) {
                                notUnderstoodHeaders = new HashSet<QName>();
                            }
                            notUnderstoodHeaders.add(qName);
                        }
                    }
                }
            }
        }
    }
    return notUnderstoodHeaders;
}
 

import com.sun.xml.internal.ws.api.WSBinding; //导入依赖的package包/类
private SOAPVersion getEffectiveSOAPVersion(WSBinding binding) {
    SOAPVersion mySOAPVersion = (soapVersion != null) ? soapVersion : binding.getSOAPVersion();
    if (mySOAPVersion == null) {
        mySOAPVersion = SOAPVersion.SOAP_11;
    }
    return mySOAPVersion;
}