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.core; import org.apache.axiom.om.util.DetachableInputStream; import org.apache.axis2.AxisFault; import org.apache.axis2.Constants; import org.apache.axis2.description.AxisService; import org.apache.axis2.jaxws.api.MessageAccessor; import org.apache.axis2.jaxws.api.MessageAccessorFactory; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.OperationDescription; import org.apache.axis2.jaxws.handler.MEPContext; import org.apache.axis2.jaxws.message.Message; import org.apache.axis2.jaxws.message.util.MessageUtils; import org.apache.axis2.jaxws.registry.FactoryRegistry; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.xml.namespace.QName; import javax.xml.ws.BindingProvider; import javax.xml.ws.Service.Mode; import javax.xml.ws.WebServiceException; import java.io.IOException; import java.util.HashMap; import java.util.Iterator; import java.util.Map; /** * The <code>org.apache.axis2.jaxws.core.MessageContext</code> is an interface that extends the * JAX-WS 2.0 <code>javax.xml.ws.handler.MessageContext</code> defined in the spec. This * encapsulates all of the functionality needed of the MessageContext for the other JAX-WS spec * pieces (the handlers for example) and also provides the needed bits of contextual information for * the rest of the JAX-WS implementation. * <p/> * Specifically, this is responsible for providing APIs so that the client and server implementation * portions can get to the Message, defined by the Message Model format and also any metadata that * is available. */ public class MessageContext { private static Log log = LogFactory.getLog(MessageContext.class); private InvocationContext invocationCtx; private org.apache.axis2.context.MessageContext axisMsgCtx; private EndpointDescription endpointDesc; private OperationDescription operationDesc; private QName operationName; //FIXME: This should become the OperationDescription private Message message; private Mode mode; private boolean isOutbound; // Outbound or inbound message context private boolean isServer = false; // Indicate if server role, default is false /* * JAXWS runtime uses a request and response mc, but we need to know the pair. * We will use this mepCtx as a wrapper to the request and response message contexts * where the requestMC and responseMC have the same parent MEPContext to * preserve the relationship. */ private MEPContext mepCtx; // If a local exception is thrown, the exception is placed on the message context. // It is not converted into a Message. private Throwable localException = null; private AxisFault causedByException = null; /** * Construct a MessageContext without a prior Axis2 MessageContext * (usage outbound dispatch/proxy) */ public MessageContext() { axisMsgCtx = new org.apache.axis2.context.MessageContext(); isOutbound = true; // Set the MessageAccessor object on the MessageContext so that it can be accessed MessageAccessorFactory factory = (MessageAccessorFactory) FactoryRegistry .getFactory(MessageAccessorFactory.class); if (factory != null) { this.setProperty(org.apache.axis2.jaxws.Constants.JAXWS_MESSAGE_ACCESSOR, factory.createMessageAccessor(this)); } } /** * Construct a MessageContext with a prior MessageContext * (usage inbound client/server or outbound server) * @param mc * @throws WebServiceException */ public MessageContext(org.apache.axis2.context.MessageContext mc) throws WebServiceException { // Assume inbound (caller must setOutbound) isOutbound = false; /* * Instead of creating a member MEPContext object every time, we will * rely on users of this MessageContext class to create a new * MEPContext and call setMEPContext(MEPContext) */ if (mc != null) { axisMsgCtx = mc; message = MessageUtils.getMessageFromMessageContext(mc); if (message != null) { message.setMessageContext(this); } } else { axisMsgCtx = new org.apache.axis2.context.MessageContext(); } // Set the MessageAccessor object on the MessageContext so that it can be accessed MessageAccessorFactory factory = (MessageAccessorFactory) FactoryRegistry .getFactory(MessageAccessorFactory.class); if (factory != null) { this.setProperty(org.apache.axis2.jaxws.Constants.JAXWS_MESSAGE_ACCESSOR, factory.createMessageAccessor(this)); } } public InvocationContext getInvocationContext() { return invocationCtx; } public void setInvocationContext(InvocationContext ic) { invocationCtx = ic; } public Map<String, Object> getProperties() { // only use properties that are local to the axis2 MC, // not the options bag. See org.apache.axis2.context.AbstractContext Iterator names = axisMsgCtx.getPropertyNames(); HashMap tempProps = new HashMap<String, Object>(); for (; names.hasNext();) { String name = (String) names.next(); tempProps.put(name, axisMsgCtx.getProperty(name)); } //return new ReadOnlyProperties(tempProps); return tempProps; } public void setProperties(Map<String, Object> _properties) { // make sure copy is made, not just reference: _properties.put(org.apache.axis2.context.MessageContext.COPY_PROPERTIES, true); axisMsgCtx.setProperties(_properties); } public Object getProperty(String key) { // only use properties that are local to the axis2 MC. return axisMsgCtx.getLocalProperty(key, false); } public boolean containsKey(Object key) { // Only use properties that are local to the axis2 MC. // @see getProperty(String key) return (key instanceof String && getProperty((String) key) != null); } // acts like Map.put(key, value) public Object setProperty(String key, Object value) { // only use properties that are local to the axis2 MC Object retval = axisMsgCtx.getLocalProperty(key, false); axisMsgCtx.setProperty(key, value); return retval; } /** * Like getProperty, but does not return prior value. * This method should be used in scenarios where * the prior value is not needed. * @param key String * @param value Object */ public void setPropertyNoReturn(String key, Object value) { axisMsgCtx.setProperty(key, value); } public EndpointDescription getEndpointDescription() { return endpointDesc; } public void setEndpointDescription(EndpointDescription ed) { endpointDesc = ed; } public OperationDescription getOperationDescription() { return operationDesc; } public void setOperationDescription(OperationDescription od) { operationDesc = od; } public Mode getMode() { return mode; } public void setMode(Mode m) { mode = m; } //FIXME: This should become the OperationDescription public QName getOperationName() { return operationName; } //FIXME: This should become the OperationDescription public void setOperationName(QName op) { operationName = op; } public void setMessage(Message msg) { message = msg; msg.setMessageContext(this); } public Message getMessage() { return message; } public org.apache.axis2.context.MessageContext getAxisMessageContext() { return axisMsgCtx; } public ClassLoader getClassLoader() { AxisService svc = axisMsgCtx.getAxisService(); if (svc != null) return svc.getClassLoader(); else return null; } /** * Used to determine whether or not session state has been enabled. * * @return */ public boolean isMaintainSession() { boolean maintainSession = false; Boolean value = (Boolean) getProperty(BindingProvider.SESSION_MAINTAIN_PROPERTY); if (value != null && value.booleanValue()) { maintainSession = true; } return maintainSession; } /** * The local exception is the Throwable object held on the Message from a problem that occurred * due to something other than the server. In other words, no message ever travelled across * the wire. * * @return the Throwable object or null */ public Throwable getLocalException() { return localException; } /** * The local exception is the Throwable object held on the Message from a problem that occurred * due to something other than the server. In other words, no message ever travelled across the * wire. * * @param t * @see Throwable */ public void setLocalException(Throwable t) { localException = t; } /** * @param t */ public void setCausedByException(AxisFault t) { this.causedByException = t; } /** * @return */ public AxisFault getCausedByException() { return this.causedByException; } /** * Set the wrapper MEPContext. Internally, this method also sets * the MEPContext's children so the pointer is bi-directional; you can * get the MEPContext from the MessageContext and vice-versa. * * @param mepCtx */ public void setMEPContext(MEPContext mepCtx) { if (this.mepCtx == null) { this.mepCtx = mepCtx; // and set parent's child pointer this.mepCtx.setResponseMessageContext(this); } } public MEPContext getMEPContext() { if (mepCtx == null) { setMEPContext(new MEPContext(this)); } return mepCtx; } /** * @return if outbound MessageContext */ public boolean isOutbound() { return isOutbound; } /** * @param isOutbound true if outbound MessageContext */ public void setOutbound(boolean isOutbound) { this.isOutbound = isOutbound; } /** * @return true if server role */ public boolean isServer() { return isServer; } /** * Indicate if server role * @param isServer */ public void setServer(boolean isServer) { this.isServer = isServer; } /** * Free the resources associated with the incoming input stream. (i.e. HTTPInputStream) * This allows the transport layer to free resources and pool connections */ public void freeInputStream() throws IOException { // During builder processing, the original input stream was wrapped with // a detachable input stream. The detachable input stream's detach method // causes the original stream to be consumed and closed. DetachableInputStream is = (DetachableInputStream) getProperty(Constants.DETACHABLE_INPUT_STREAM); if (is != null) { if (log.isDebugEnabled()) { log.debug("Detaching inbound input stream " + is); } is.detach(); } } }