Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.axis2.jaxws.handler; import org.apache.axiom.soap.RolePlayer; import org.apache.axiom.soap.SOAP11Constants; import org.apache.axiom.soap.SOAP12Constants; import org.apache.axiom.soap.SOAPConstants; import org.apache.axiom.soap.SOAPEnvelope; import org.apache.axiom.soap.SOAPHeaderBlock; import org.apache.axis2.AxisFault; import org.apache.axis2.Constants; import org.apache.axis2.context.MessageContext; import org.apache.axis2.context.OperationContext; import org.apache.axis2.description.AxisService; import org.apache.axis2.description.Parameter; import org.apache.axis2.i18n.Messages; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.util.JavaUtils; import org.apache.axis2.util.LoggingControl; import org.apache.axis2.wsdl.WSDLConstants; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.xml.namespace.QName; import javax.xml.ws.handler.Handler; import javax.xml.ws.handler.soap.SOAPHandler; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Set; /* * Utility class to perform static utility type of operations on Handlers. */ public class HandlerUtils { private static Log log = LogFactory.getLog(HandlerUtils.class); /** * registerHandlerHeaders will invoke getHeaders on SOAPHandlers and return a List of headers * that are Understood by the handlers. * @param msgContext * @param handlers */ public static List<QName> registerSOAPHandlerHeaders(MessageContext msgContext, List<Handler> handlers) { List<QName> understood = new ArrayList<QName>(); if (msgContext == null) { return understood; } for (Handler handler : handlers) { if (handler instanceof SOAPHandler) { SOAPHandler soapHandler = (SOAPHandler) handler; //Invoking getHeaders. if (log.isDebugEnabled()) { log.debug("Invoking getHeader() on SOAPHandler"); } Set<QName> headers = soapHandler.getHeaders(); if (headers != null) { for (QName header : headers) { if (!understood.contains(header)) { if (log.isDebugEnabled()) { log.debug("Adding Header QName" + header + " to uderstoodHeaderQName List"); } //Adding this to understood header list. understood.add(header); } } } } } return understood; } /** * checkMustUnderstand will validate headers that where delegated by Axis Engine * to MessageReceiver for mustUnderstand check. * * Note that there is other JAX-WS related mustUnderstand checking occuring elsewhere: * @see org.apache.axis2.jaxws.dispatchers.MustUnderstandValidationDispatcher * @see org.apache.axis2.jaxws.dispatchers.MustUnderstandChecker * * @param msgContext Contains the SOAPEnvelope and optionally a list of headers not * understood by the AxisEngine * @param understood A list of header QNames understood by JAX-WS, for example those understood * by associated application handlers. Can be null. * @param additionalRoles An instance of RolePlayer for any addtional roles played by JAX-WS * for example, roles configured for associated handlers. Can be null. * * @throws AxisFault if any headers marked mustUndersand are not understood. */ public static void checkMustUnderstand(MessageContext msgContext, List<QName> understood, List<String> additionalRoles) throws AxisFault { if (msgContext == null || !msgContext.isHeaderPresent()) { return; } SOAPEnvelope envelope = msgContext.getEnvelope(); if (envelope.getHeader() == null) { return; } if (log.isDebugEnabled()) { log.debug("Reading UnprocessedHeaderNames from Message Context properties"); } List<QName> unprocessed = (List) msgContext.getProperty(Constants.UNPROCESSED_HEADER_QNAMES); // Add to the unprocessed header list any headers that are unprocssed and mustUnderstand // for addtional roles, for example those played by associated JAXWS handlers if (additionalRoles != null) { if (log.isDebugEnabled()) { log.debug("Adding any mustUnderstand headers based on additonal SOAP roles: " + additionalRoles); } HandlerRolePlayer handlerRolePlayer = new HandlerRolePlayer(additionalRoles); Iterator headerBlocks = envelope.getHeader().getHeadersToProcess(handlerRolePlayer); while (headerBlocks.hasNext()) { SOAPHeaderBlock shb = (SOAPHeaderBlock) headerBlocks.next(); if (unprocessed == null) { unprocessed = new ArrayList<QName>(); } if (!shb.isProcessed() && shb.getMustUnderstand()) { unprocessed.add(shb.getQName()); if (log.isDebugEnabled()) { log.debug("Added header to unprocessed list: " + shb.getQName()); } } } } if (unprocessed == null || unprocessed.size() == 0) { if (log.isDebugEnabled()) { log.debug("UNPROCESSED_HEADER_QNAMES not found."); } return; } //lets go thru each header only if @HandlerChain is present if (!canUnderstand(msgContext)) { QName[] qNames = unprocessed.toArray(new QName[0]); String[] headerNames = new String[qNames.length]; for (int i = 0; i < qNames.length; i++) { headerNames[i] = "{" + qNames[i].getNamespaceURI() + "}" + qNames[i].getLocalPart(); } QName faultQName = envelope.getVersion().getMustUnderstandFaultCode(); throw new AxisFault(Messages.getMessage("mustunderstandfailed2", headerNames), faultQName); } checkUnprocessed(envelope, unprocessed, understood, msgContext); //resetting the FAULTY_HEADER_QNAME to null. msgContext.setProperty(Constants.UNPROCESSED_HEADER_QNAMES, null); } private static void checkUnprocessed(SOAPEnvelope envelope, List<QName> unprocessed, List<QName> understood, MessageContext msgContext) throws AxisFault { for (QName headerQName : unprocessed) { if (understood != null && !understood.isEmpty()) { if (understood.contains(headerQName)) { if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) { log.debug( "MustUnderstand header registered as understood on AxisOperation: " + headerQName); } continue; } } if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) { log.debug("MustUnderstand header not processed or registered as understood " + headerQName); } // Throw a MustUnderstand fault for the current SOAP version String prefix = envelope.getNamespace().getPrefix(); if (!msgContext.isSOAP11()) { if (prefix == null || "".equals(prefix)) { prefix = SOAPConstants.SOAP_DEFAULT_NAMESPACE_PREFIX; } // TODO: should we be using a prefix on the faultcode? What about // the QName object Constants.FAULT_SOAP12_MUSTUNDERSTAND? throw new AxisFault(Messages.getMessage("mustunderstandfailed", prefix, headerQName.toString()), SOAP12Constants.FAULT_CODE_MUST_UNDERSTAND); } else { // TODO: should we be using a prefix on the faultcode? What about // the QName object Constants.FAULT_MUSTUNDERSTAND? throw new AxisFault(Messages.getMessage("mustunderstandfailed", prefix, headerQName.toString()), SOAP11Constants.FAULT_CODE_MUST_UNDERSTAND); } } } private static boolean canUnderstand(MessageContext msgContext) { //JAXWSMessageReceiver will only commit to handling must understand if @HandlerChain annotation is present on the //Endpoint. This will indicate to AxisEngine that Faulty Header names are understood however the mustUnderstand //Check will be performed in HandlerUtils class after Handlers are injected in application. AxisService axisSvc = msgContext.getAxisService(); if (axisSvc.getParameter(EndpointDescription.AXIS_SERVICE_PARAMETER) != null) { Parameter param = axisSvc.getParameter(EndpointDescription.AXIS_SERVICE_PARAMETER); EndpointDescription ed = (EndpointDescription) param.getValue(); //Lets check if there is a Handler implementation present using Metadata layer. //HandlerChain annotation can be present in Service Endpoint or ServiceEndpointInterface. // ed.getHandlerChain() looks for HandlerAnnotation at both Endpoint and at SEI. if (log.isDebugEnabled()) { log.debug("Check to see if a jaxws handler is configured."); } if (ed.getHandlerChain() != null) { return true; } return false; } else { //If we cannot get to ServiceDescription to check for HandlerChain annotation we will return true; return true; } } /** * isHighFidelity * * The JAX-WS engine attempts to stream data as fast as possible. * For example, the message payload may be transformed into a JAXB object early in the processing. * Unfortunately such transformations are lossy, some information is lost. * An installed SOAP handler will see different namespaces (etc) then the original message. * * If the a customer enables the "jaxws.payload.highFidelity" flag, then lossy transformations are * avoided until necessary. * * @see Constants.JAXWS_HIGH_FIDELITY * * @param mc * @return true if high fidelity is requested */ public static boolean isHighFidelity(MessageContext mc) { boolean rc = _isHighFidelity(mc); // If not true, check the OUT MessageContext. // On the client, we need this setting when we receive (inbound) // the message; however the customer set it on the outbound context. if (!rc) { rc = _isHighFidelity(getRelatedMessageContext(mc)); } return rc; } /** * @param mc * @return */ private static MessageContext getRelatedMessageContext(MessageContext mc) { if (log.isDebugEnabled()) { log.debug("Enter getRelatedMessageContext for:" + mc); } MessageContext relatedMC = null; if (mc != null) { OperationContext oc = mc.getOperationContext(); if (oc != null) { try { relatedMC = oc.getMessageContext(WSDLConstants.MESSAGE_LABEL_IN_VALUE); if (relatedMC == mc) { relatedMC = oc.getMessageContext(WSDLConstants.MESSAGE_LABEL_OUT_VALUE); } } catch (AxisFault e) { // TODO This should never occur in this scenario, swallow and continue } } } if (log.isDebugEnabled()) { log.debug("Exit getRelatedMessageContext related messageContext is" + relatedMC); } return relatedMC; } /** * isHighFidelity * * The JAX-WS engine attempts to stream data as fast as possible. * For example, the message payload may be transformed into a JAXB object early in the processing. * Unfortunately such transformations are lossy, some information is lost. * An installed SOAP handler will see different namespaces (etc) then the original message. * * If the a customer enables the "jaxws.payload.highFidelity" flag, then lossy transformations are * avoided until necessary. * * @see Constants.JAXWS_HIGH_FIDELITY * * @param mc * @return true if high fidelity is requested */ private static boolean _isHighFidelity(MessageContext mc) { boolean value = false; if (mc == null) { if (log.isDebugEnabled()) { log.debug("_isHighFidelity returns false due to missing MessageContext"); } return false; } // First examine the high fidelity flag on the context hierarchy Boolean highFidelity = (Boolean) mc .getProperty(org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY); if (highFidelity != null) { value = highFidelity.booleanValue(); if (log.isDebugEnabled()) { log.debug("_isHighFidelity returns " + value + " per Context property " + org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY); } return value; } // Second examine the deprecated jaxb streaming flag Boolean jaxbStreaming = (Boolean) mc .getProperty(org.apache.axis2.jaxws.Constants.JAXWS_ENABLE_JAXB_PAYLOAD_STREAMING); if (jaxbStreaming != null) { value = !jaxbStreaming.booleanValue(); if (log.isDebugEnabled()) { log.debug("_isHighFidelity returns " + value + " per inspection of Context property " + org.apache.axis2.jaxws.Constants.JAXWS_ENABLE_JAXB_PAYLOAD_STREAMING); } return value; } // Now look at the high fidelity parameter Parameter p = mc.getParameter(org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY); if (p != null) { value = JavaUtils.isTrue(p.getValue()); if (log.isDebugEnabled()) { log.debug("_isHighFidelity returns " + value + " per inspection of Configuration property " + org.apache.axis2.jaxws.Constants.JAXWS_PAYLOAD_HIGH_FIDELITY); } return value; } if (log.isDebugEnabled()) { log.debug("_isHighFidelity returns the default: false"); } return false; } } class HandlerRolePlayer implements RolePlayer { List<String> roles = new ArrayList<String>(); HandlerRolePlayer(List<String> additionalRoles) { roles.addAll(additionalRoles); } public List getRoles() { return roles; } public boolean isUltimateDestination() { return false; } }