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.axis2.AxisFault; import org.apache.axis2.jaxws.Constants; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.context.factory.MessageContextFactory; import org.apache.axis2.jaxws.core.MessageContext; import org.apache.axis2.jaxws.handler.factory.HandlerPostInvokerFactory; import org.apache.axis2.jaxws.handler.factory.HandlerPreInvokerFactory; import org.apache.axis2.jaxws.i18n.Messages; import org.apache.axis2.jaxws.marshaller.impl.alt.MethodMarshallerUtils; import org.apache.axis2.jaxws.message.Message; import org.apache.axis2.jaxws.message.Protocol; import org.apache.axis2.jaxws.message.XMLFault; import org.apache.axis2.jaxws.message.factory.MessageFactory; import org.apache.axis2.jaxws.message.util.MessageUtils; import org.apache.axis2.jaxws.message.util.XMLFaultUtils; import org.apache.axis2.jaxws.registry.FactoryRegistry; import org.apache.axis2.jaxws.utility.SAAJFactory; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.xml.soap.SOAPBody; import javax.xml.soap.SOAPConstants; import javax.xml.soap.SOAPFault; import javax.xml.soap.SOAPMessage; import javax.xml.ws.ProtocolException; import javax.xml.ws.WebServiceException; import javax.xml.ws.handler.Handler; import javax.xml.ws.handler.LogicalHandler; import javax.xml.ws.handler.soap.SOAPHandler; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; public class HandlerChainProcessor { private static final Log log = LogFactory.getLog(HandlerChainProcessor.class); private HandlerPreInvoker handlerPreInvoker = null; private HandlerPostInvoker handlerPostInvoker = null; public enum Direction { IN, OUT }; // the type of message, not indicative of one-way vs. request-response public enum MEP { REQUEST, RESPONSE }; private javax.xml.ws.handler.MessageContext currentMC; // just a pointer private LogicalMessageContext logicalMC = null; private SoapMessageContext soapMC = null; private MEPContext mepCtx; // Copy of the handler chain used by HandlerChainProcessor private List<Handler> handlers = null; private static final List<Handler> EMPTY_CHAIN = new ArrayList<Handler>(0); // for tracking purposes -- see trackInternalCall private static Handler currentHandler = null; private static String currentMethod = null; // track start/end of logical and protocol handlers in the list // The two scenarios are: 1) run logical handlers only, 2) run all handlers // logical start is always 0 // protocol start is always logicalLength + 1 // list end is always handlers.size()-1 private int logicalLength = 0; private final static int SUCCESSFUL = 0; private final static int FAILED = 1; private final static int PROTOCOL_EXCEPTION = 2; private final static int OTHER_EXCEPTION = 3; // save it if Handler.handleMessage throws one in // HandlerChainProcessor.handleMessage private RuntimeException savedException; private Protocol proto; // need to save it incase we have to make a fault message // we track whether the SOAPHeadersAdapter and SAAJ are both used in a given handler // method. If the tracker property is set, and both are called in a handler method, // we throw an exception. This behavior can easily be turned off by a handler method // by removing or setting to true the Constants.JAXWS_HANDLER_TRACKER property public enum TRACKER { SOAP_HEADERS_ADAPTER_CALLED, SAAJ_CALLED }; private static boolean soap_headers_adapter_called = false; private static boolean saaj_called = false; /* * The HandlerChainProcessor is constructed with the handler chain. * The handler chain may be null, empty or already sorted. * It also may be shared. For this reason a copy of chain is made * so that the sort and other manipulation does not affect the original * chain. * @param chain Handler chain * @param proto Protocol */ public HandlerChainProcessor(List<Handler> chain, Protocol proto) { if (chain != null) { synchronized (chain) { if (chain.size() == 0) { // Use empty chain to avoid excessive garbage collection this.handlers = EMPTY_CHAIN; } else { this.handlers = new CopyOnWriteArrayList<Handler>(chain); } } } else { handlers = EMPTY_CHAIN; } this.proto = proto; } /* * sortChain sorts the local copy of the handlers chain. * The logical handlers are first followed by the protocol handlers. * sortChain also keeps track of the start/end of each type of handler. */ private void sortChain() throws WebServiceException { if (handlers.size() == 0) { logicalLength = 0; return; } ArrayList<Handler> logicalHandlers = new ArrayList<Handler>(); ArrayList<Handler> protocolHandlers = new ArrayList<Handler>(); Iterator handlerIterator = handlers.iterator(); while (handlerIterator.hasNext()) { // this is a safe cast since the handlerResolver and binding.setHandlerChain // and InvocationContext.setHandlerChain verifies it before we get here Handler handler = (Handler) handlerIterator.next(); // JAXWS 9.2.1.2 sort them by Logical, then SOAP if (LogicalHandler.class.isAssignableFrom(handler.getClass())) logicalHandlers.add((LogicalHandler) handler); else if (SOAPHandler.class.isAssignableFrom(handler.getClass())) // instanceof ProtocolHandler protocolHandlers.add((SOAPHandler) handler); else if (Handler.class.isAssignableFrom(handler.getClass())) { throw ExceptionFactory.makeWebServiceException( Messages.getMessage("handlerChainErr1", handler.getClass().getName())); } else { throw ExceptionFactory.makeWebServiceException( Messages.getMessage("handlerChainErr2", handler.getClass().getName())); } } logicalLength = logicalHandlers.size(); // JAXWS 9.2.1.2 sort them by Logical, then SOAP handlers.clear(); handlers.addAll(logicalHandlers); handlers.addAll(protocolHandlers); } /** * @param mc * By the time processChain method is called, we already have the sorted chain, * and now we have the direction, MEP, MessageContext, and if a response is expected. We should * be able to handle everything from here, no pun intended. * * Two things a user of processChain should check when the method completes: * 1. Has the MessageContext.MESSAGE_OUTBOUND_PROPERTY changed, indicating reversal of message direction * 2. Has the message been converted to a fault message? (indicated by a flag in the message) */ public boolean processChain(MEPContext mepCtx, Direction direction, MEP mep, boolean expectResponse) { if (handlers.size() == 0) return true; this.mepCtx = mepCtx; sortChain(); initContext(direction); boolean result = true; if (direction == Direction.OUT) { // 9.3.2 outbound currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction == Direction.OUT)); result = callGenericHandlers(mep, expectResponse, 0, handlers.size() - 1, direction); } else { // IN case - 9.3.2 inbound currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction == Direction.OUT)); result = callGenericHandlers(mep, expectResponse, handlers.size() - 1, 0, direction); } // message context may have been changed to be response, and message // converted // according to the JAXWS spec 9.3.2.1 footnote 2 if ((Boolean) (currentMC.get( javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY)) != (direction == Direction.OUT)) return false; return result; } public boolean processChainForClose(MEPContext mepCtx, Direction direction) { boolean result = true; if (handlers.size() == 0) return true; this.mepCtx = mepCtx; sortChain(); initContext(direction); callCloseHandlers(handlers.size() - 1, 0, direction); return result; } /* * This is the implementation of JAX-WS 2.0 section 9.3.2.1 */ private boolean callGenericHandlers(MEP mep, boolean expectResponse, int start, int end, Direction direction) throws RuntimeException { // if this is a response message, expectResponse should always be false if (mep == MEP.RESPONSE) expectResponse = false; int i = start; int result = SUCCESSFUL; // declared and initialized just in case we need them // in a reverse flow situation int newStart = 0, newStart_inclusive = 0, newEnd = 0; Direction newDirection = direction; if (direction == Direction.OUT) { while ((i <= end) && (result == SUCCESSFUL)) { result = handleMessage(((Handler) handlers.get(i)), direction, expectResponse); newStart = i - 1; newStart_inclusive = i; newEnd = 0; newDirection = Direction.IN; i++; if (result == SUCCESSFUL) // don't switch if failed, since we'll be reversing directions switchContext(direction, i); } } else { // IN case while ((i >= end) && (result == SUCCESSFUL)) { result = handleMessage(((Handler) handlers.get(i)), direction, expectResponse); newStart = i + 1; newStart_inclusive = i; newEnd = handlers.size() - 1; newDirection = Direction.OUT; i--; if (result == SUCCESSFUL) // don't switch if failed, since we'll be reversing directions switchContext(direction, i); } } if (newDirection == direction) // we didn't actually process anything, probably due to empty list return true; // no need to continue // 9.3.2.3 in all situations, we want to close as many handlers as // were invoked prior to completion or exception throwing if (expectResponse) { if (result == FAILED) { if (log.isDebugEnabled()) { log.debug("Handler returned false...Start running the handlers in reverse"); } // One of that handlers returned false, therefore the handler processing // is stoped and the transport outbound will be avoided. // This may be due to an exception or it may be due the customer intentionally // preventing a message from flowing outbound. // we should only use callGenericHandlers_avoidRecursion in this case // the message context is now an outbound message context, // and should be marked as such so the SOAPHeadersAdapter will // "install" with the correct property key. // Get the MessageContext and switch its direction MessageContext jaxwsMC = mepCtx.getMessageContext(); jaxwsMC.setOutbound(newDirection == Direction.OUT); SOAPHeadersAdapter.install(jaxwsMC); callGenericHandlers_avoidRecursion(newStart, newEnd, newDirection); // Now we need to place the Message (which is the one edited by the handler) // onto the Axis2 MC. This is necessary because the Axis2 response MC // will be created from this MC and must have the correct message. this.placeMessageOnAxis2MessageContext(jaxwsMC); // Now close the handlers callCloseHandlers(newStart_inclusive, newEnd, newDirection); if (log.isDebugEnabled()) { log.debug("Handler returned false...End running the handlers in reverse"); } } else if (result == PROTOCOL_EXCEPTION) { try { if (log.isDebugEnabled()) { log.debug("Handler threw ProtocolException...Start running the handlers in reverse"); } // the message context is now an outbound message context, // and should be marked as such so the SOAPHeadersAdapter will // "install" with the correct property key. // Get the MessageContext and switch its direction MessageContext jaxwsMC = mepCtx.getMessageContext(); jaxwsMC.setOutbound(newDirection == Direction.OUT); SOAPHeadersAdapter.install(jaxwsMC); // Call the handlerFault methods on the handlers and also close the handlers callGenericHandleFault(newStart, newEnd, newDirection); // Now we need to place the Message (which is the one edited by the handler) // onto the Axis2 MC. This is necessary because the Axis2 response MC // will be created from this MC and must have the correct message. this.placeMessageOnAxis2MessageContext(jaxwsMC); // Now close the handlers callCloseHandlers(newStart_inclusive, newEnd, newDirection); if (log.isDebugEnabled()) { log.debug("Handler threw ProtocolException...End running the handlers in reverse"); } } catch (RuntimeException re) { callCloseHandlers(newStart_inclusive, newEnd, newDirection); throw re; } } else if (result == OTHER_EXCEPTION) { if (log.isDebugEnabled()) { log.debug("Handler threw unanticipated Exception...Start handler closure"); } callCloseHandlers(newStart_inclusive, newEnd, newDirection); // savedException initialized in HandlerChainProcessor.handleMessage if (log.isDebugEnabled()) { log.debug("Handler threw unanticipated Exception...End handler closure"); } throw savedException; } } else { // everything was successful OR finished processing handlers /* * This is a little confusing. There are several cases we should be * aware of. An incoming request with false expectResponse is * equivalent to server inbound one-way, for example. * * An outgoing response is server outbound, and is always marked * with a false expectResponse. The problem, however, is that the * direction for the call to closehandlers will be incorrect. In * this case, the handlers should be closed in the opposite order of * the ORIGINAL invocation. */ if (mep.equals(MEP.REQUEST)) { // a request that requires no response is a one-way message // and we should only close whomever got invoked callCloseHandlers(newStart_inclusive, newEnd, newDirection); // As according to the Sun "experts", exceptions raised by // handlers in one way invocation are discarded. They // are NOT propagated to the user code. if (savedException != null) { log.warn("Exception thrown by a handler in one way invocation", savedException); //But do return failure so that we know not to send to server return false; } } else { // it's a response, so we can safely assume that // ALL the handlers were invoked on the request, // so we need to close ALL of them if (direction.equals(Direction.IN)) { callCloseHandlers(handlers.size() - 1, 0, direction); } else { callCloseHandlers(0, handlers.size() - 1, direction); } if (savedException != null) { // we have a saved exception, throw it (JAX-WS 9.3.2.1 "Throw // ProtocolException or any other runtime exception --> No // response" case. throw savedException; } } } // If we've failed before this, we would have already thrown exception // or returned false, so just return true here ... don't need to check result again. return true; } /** * Called during reversal and exception processing to place the * current Message (edited by the Handlers) onto the MessageContext * @param jaxwsMC */ private void placeMessageOnAxis2MessageContext(MessageContext jaxwsMC) { if (log.isDebugEnabled()) { log.debug("start placeMessageOnAxis2MessageContext"); } try { org.apache.axis2.context.MessageContext mc = jaxwsMC.getAxisMessageContext(); if (mc != null) { Message message = jaxwsMC.getMessage(); if (message != null) { if (log.isDebugEnabled()) { log.debug("Place the (perhaps new or edited) Message on the MessageContext"); } MessageUtils.putMessageOnMessageContext(message, mc); } else { if (log.isDebugEnabled()) { log.debug("There is no Message. Message is not copied to the Axis2 MessageContext."); } } } else { if (log.isDebugEnabled()) { log.debug("Axis2 MessageContext is not available. Message is not copied"); } } } catch (AxisFault e) { throw ExceptionFactory.makeWebServiceException(e); } if (log.isDebugEnabled()) { log.debug("end placeMessageOnAxis2MessageContext"); } } /* * callGenericHandlers_avoidRecursion should ONLY be called from one place. * TODO: We cannot necessarily assume no false returns and no exceptions will be * thrown from here even though the handlers we will be calling have all already * succeeded in callGenericHandlers. */ private void callGenericHandlers_avoidRecursion(int start, int end, Direction direction) { int i = start; if (direction == Direction.OUT) { for (; i <= end; i++) { switchContext(direction, i); Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking handleMessage on: " + handler.getClass().getName()); } callHandleMessageWithTracker(handler); } } else { // IN case for (; i >= end; i--) { switchContext(direction, i); Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking handleMessage on: " + handler.getClass().getName()); } callHandleMessageWithTracker(handler); } } } /** * Calls handleMessage on the Handler. If an exception is thrown and a response is expected, the * MessageContext is updated with the handler information * * @returns SUCCESSFUL if successfully, UNSUCCESSFUL if false, EXCEPTION if exception thrown */ private int handleMessage(Handler handler, Direction direction, boolean expectResponse) throws RuntimeException { try { if (log.isDebugEnabled()) { log.debug("Invoking handleMessage on: " + handler.getClass().getName()); } // The pre and post invokers will likely need more than just the handler message context. // They may need access to the axis service object or description objects. currentMC.put(Constants.MEP_CONTEXT, mepCtx); getPreInvoker().preInvoke(currentMC); boolean success = callHandleMessageWithTracker(handler); getPostInvoker().postInvoke(currentMC); if (success) { if (log.isDebugEnabled()) { log.debug("handleMessage() returned true"); } return SUCCESSFUL; } else { if (log.isDebugEnabled()) { log.debug("handleMessage() returned false"); } if (expectResponse) currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction != Direction.OUT)); return FAILED; } } catch (RuntimeException re) { // RuntimeException and ProtocolException if (log.isDebugEnabled()) { log.debug("An exception was thrown during the handleMessage() invocation"); log.debug("Exception: ", re); } savedException = re; if (expectResponse) // mark it as reverse direction currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction != Direction.OUT)); if (ProtocolException.class.isAssignableFrom(re.getClass())) { convertToFaultMessage(mepCtx, re, proto, true); // just re-initialize the current handler message context since // that will pick up the now-changed message return PROTOCOL_EXCEPTION; } return OTHER_EXCEPTION; } } /* * start and end should be INclusive of the handlers that have already been * invoked on Handler.handleMessage or Handler.handleFault */ private void callCloseHandlers(int start, int end, Direction direction) { int i = start; if (direction == Direction.OUT) { for (; i <= end; i++) { try { switchContext(direction, i); Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking close on: " + handler.getClass().getName()); } callCloseWithTracker(handler); // TODO when we close, are we done with the handler instance, and thus // may call the PreDestroy annotated method? I don't think so, especially // if we've cached the handler list somewhere. } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("An Exception occurred while calling handler.close()"); log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage()); } } } } else { // IN case for (; i >= end; i--) { try { switchContext(direction, i); Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking close on: " + handler.getClass().getName()); } callCloseWithTracker(handler); // TODO when we close, are we done with the handler instance, and thus // may call the PreDestroy annotated method? I don't think so, especially // if we've cached the handler list somewhere. } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("An Exception occurred while calling handler.close()"); log.debug("Exception: " + e.getClass().getName() + ":" + e.getMessage()); } } } } } /* * processFault is available for a server to use when the endpoint * throws an exception or a client when it gets a fault response message * * In both cases, all of the handlers have run successfully in the * opposite direction as this call to callHandleFault, and thus * should be closed. */ public void processFault(MEPContext mepCtx, Direction direction) { // direction.IN = client // direction.OUT = server if (handlers.size() == 0) return; this.mepCtx = mepCtx; sortChain(); initContext(direction); currentMC.put(javax.xml.ws.handler.MessageContext.MESSAGE_OUTBOUND_PROPERTY, (direction == Direction.OUT)); try { if (direction == Direction.OUT) { callGenericHandleFault(0, handlers.size() - 1, direction); } else { // IN case callGenericHandleFault(handlers.size() - 1, 0, direction); } } catch (RuntimeException re) { if (log.isDebugEnabled()) { log.debug("An exception occurred during handleFault chain processing", re); } throw re; } finally { // we can close all the Handlers in reverse order if (direction == Direction.OUT) { initContext(Direction.IN); callCloseHandlers(0, handlers.size() - 1, Direction.OUT); } else { // IN case initContext(Direction.IN); callCloseHandlers(handlers.size() - 1, 0, Direction.IN); } } } /* * The callGenericHandleFault caller is responsible for closing any invoked * Handlers. We don't know how far the Handler.handleMessage calls got * before a failure may have occurred. * * Regardless of the Handler.handleFault result, the flow is the same (9.3.2.2) */ private void callGenericHandleFault(int start, int end, Direction direction) throws RuntimeException { int i = start; // we may be starting in the middle of the list, and therefore may need to switch contexts switchContext(direction, i); if (direction == Direction.OUT) { for (; i <= end; i++) { Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking handleFault on: " + handler.getClass().getName()); } boolean success = callHandleFaultWithTracker(handler); if (!success) break; switchContext(direction, i + 1); } } else { // IN case for (; i >= end; i--) { Handler handler = (Handler) handlers.get(i); if (log.isDebugEnabled()) { log.debug("Invoking handleFault on: " + handler.getClass().getName()); } boolean success = callHandleFaultWithTracker(handler); if (!success) break; switchContext(direction, i - 1); } } } public static void convertToFaultMessage(MEPContext mepCtx, Exception e, Protocol protocol) { convertToFaultMessage(mepCtx, e, protocol, false); } /** * Converts the Exception into an XML Fault Message that is stored on the MEPContext. * Note that if the forceConversion flag is true, this conversion will always occur. * If the checkMsg flag is true, this conversion only occurs if the Message is not already * a Fault (per 9,3,2.1 of the JAX-WS specification) * * @param mepCtx MEPContext * @param e Exception * @param protocol Protocol * @param forceConversion If true, the Exception is always converted to a Message */ public static void convertToFaultMessage(MEPContext mepCtx, Exception e, Protocol protocol, boolean checkMsg) { // need to check if message is already a fault message or not, // probably by way of a flag (isFault) in the MessageContext or Message if (log.isDebugEnabled()) { log.debug("start convertToFaultMessge with exception: " + e.getClass().getName()); log.debug(" checkMsg is : " + checkMsg); } try { // According to the 9.3.2.1, The message is converted into a fault only if it is not already a Fault Message messageFromHandler = null; if (checkMsg) { messageFromHandler = mepCtx.getMessageContext().getMessage(); } if (messageFromHandler != null && messageFromHandler.isFault()) { if (log.isDebugEnabled()) { log.debug("The Message is already a SOAPFault. The exception is not converted into a Message"); } } else if (protocol == Protocol.soap11 || protocol == Protocol.soap12) { if (log.isDebugEnabled()) { log.debug("Converting Exception into a Message"); } String protocolNS = (protocol == Protocol.soap11) ? SOAPConstants.URI_NS_SOAP_1_1_ENVELOPE : SOAPConstants.URI_NS_SOAP_1_2_ENVELOPE; // The following set of instructions is used to avoid // some unimplemented methods in the Axis2 SAAJ implementation XMLFault xmlFault = MethodMarshallerUtils.createXMLFaultFromSystemException(e); javax.xml.soap.MessageFactory mf = SAAJFactory.createMessageFactory(protocolNS); SOAPMessage message = mf.createMessage(); SOAPBody body = message.getSOAPBody(); SOAPFault soapFault = XMLFaultUtils.createSAAJFault(xmlFault, body); MessageFactory msgFactory = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); Message msg = msgFactory.createFrom(message); mepCtx.setMessage(msg); } else { WebServiceException wse = ExceptionFactory .makeWebServiceException(Messages.getMessage("cFaultMsgErr")); if (log.isDebugEnabled()) { log.debug("end convertToFaultMessge due to error ", wse); } throw wse; } } catch (Exception ex) { WebServiceException wse = ExceptionFactory.makeWebServiceException(ex); if (log.isDebugEnabled()) { log.debug("end convertToFaultMessge due to error ", wse); } throw wse; } } private void initContext(Direction direction) { soapMC = MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext()); logicalMC = MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext()); if (direction == Direction.OUT) { // logical context, then SOAP if ((logicalLength == 0) && (handlers.size() > 0)) // we only have soap handlers currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext()); else currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext()); } else { // SOAP context, then logical if ((logicalLength == handlers.size()) && (handlers.size() > 0)) // we only have logical handlers currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext()); else currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext()); } } private void switchContext(Direction direction, int index) { if ((logicalLength == handlers.size()) || (logicalLength == 0)) return; // all handlers must be the same type, so no context switch if (((direction == Direction.OUT) && (index == logicalLength)) || ((direction == Direction.IN) && (index == (logicalLength - 1)))) { //if (currentMC.getClass().isAssignableFrom(LogicalMessageContext.class)) if (currentMC == logicalMC) // object check, not .equals() currentMC = soapMC; //MessageContextFactory.createSoapMessageContext(mepCtx.getMessageContext()); else currentMC = logicalMC; //MessageContextFactory.createLogicalMessageContext(mepCtx.getMessageContext()); } } private HandlerPreInvoker getPreInvoker() { if (handlerPreInvoker == null) { HandlerPreInvokerFactory preInvokerFactory = (HandlerPreInvokerFactory) FactoryRegistry .getFactory(HandlerPreInvokerFactory.class); handlerPreInvoker = (HandlerPreInvoker) preInvokerFactory.createHandlerPreInvoker(); } return handlerPreInvoker; } private HandlerPostInvoker getPostInvoker() { if (handlerPostInvoker == null) { HandlerPostInvokerFactory postInvokerFactory = (HandlerPostInvokerFactory) FactoryRegistry .getFactory(HandlerPostInvokerFactory.class); handlerPostInvoker = (HandlerPostInvoker) postInvokerFactory.createHandlerPostInvoker(); } return handlerPostInvoker; } public static void trackInternalCall(org.apache.axis2.jaxws.core.MessageContext mc, TRACKER tracker) { switch (tracker) { case SAAJ_CALLED: saaj_called = true; break; case SOAP_HEADERS_ADAPTER_CALLED: soap_headers_adapter_called = true; break; } Object trackerProp = (mc == null ? null : mc.getProperty(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER)); if ((trackerProp != null) && ((Boolean) trackerProp).booleanValue()) { if (saaj_called && soap_headers_adapter_called) { // this means both the SAAJ model and SOAPHeadersAdapter code has been called in such a // way as to cause data transformation. We want customers to avoid doing this (calling both) // in a given handler method, so we throw an exception: if (log.isDebugEnabled()) { String logString = "JAX-WS Handler implementations should not use the " + org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER + " property to retrieve SOAP headers and manipulate the SOAP message using the SAAJ API in the same method " + "implementation. The Handler implementation and method doing this is: " + currentHandler.getClass().getName() + currentMethod; log.debug(logString); } } } } private boolean callHandleMessageWithTracker(Handler handler) throws RuntimeException { currentHandler = handler; currentMethod = "handleMessage"; // turn on the tracker property currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true); boolean success = false; RuntimeException savedEx = null; try { success = handler.handleMessage(currentMC); } catch (RuntimeException t) { savedEx = t; } // turn off the tracker property and reset the static tracker booleans currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false); saaj_called = false; soap_headers_adapter_called = false; // If the handler changed the SOAPPart or Attachments, then we need // that the Message gets updated if (currentMC instanceof SoapMessageContext) { ((SoapMessageContext) currentMC).checkAndUpdate(); } if (savedEx != null) { throw savedEx; } return success; } private boolean callHandleFaultWithTracker(Handler handler) { currentHandler = handler; currentMethod = "handleFault"; // turn on the tracker property currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true); boolean success = false; RuntimeException savedEx = null; try { success = handler.handleFault(currentMC); } catch (RuntimeException t) { savedEx = t; } // turn off the tracker property and reset the static tracker booleans currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false); saaj_called = false; soap_headers_adapter_called = false; // If the handler changed the SOAPPart or Attachments, then we need // that the Message gets updated if (currentMC instanceof SoapMessageContext) { ((SoapMessageContext) currentMC).checkAndUpdate(); } if (savedEx != null) { throw savedEx; } return success; } private void callCloseWithTracker(Handler handler) { currentHandler = handler; currentMethod = "close"; // turn on the tracker property currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, true); RuntimeException savedEx = null; try { handler.close(currentMC); } catch (RuntimeException t) { savedEx = t; } // turn off the tracker property and reset the static tracker booleans currentMC.put(org.apache.axis2.jaxws.handler.Constants.JAXWS_HANDLER_TRACKER, false); saaj_called = false; soap_headers_adapter_called = false; if (savedEx != null) { throw savedEx; } } }