/* | |
* 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.i18n.Messages; | |
import org.apache.axis2.jaxws.ExceptionFactory; | |
import org.apache.axis2.jaxws.core.MessageContext; | |
import org.apache.axis2.transport.http.HTTPConstants; | |
import org.apache.commons.logging.Log; | |
import org.apache.commons.logging.LogFactory; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.Collection; | |
import java.util.HashMap; | |
import java.util.List; | |
import java.util.Map; | |
import java.util.Set; | |
/** | |
* The JAX-WS exposes transport properties whose value is Map<String, List<String>>. The | |
* String is the content-id and DataHandler is the data handler representing the TransportHeaders. | |
* | |
* The JAX-WS MessageContext stores transport properties in an Map object located on the AXIS2 | |
* MessageContext. | |
* | |
* This class, TransportHeadersAdapter, is an adapter between the Map<String, List<String>> | |
* interface needed by the properties and the actual implementation. | |
* All useful function is delegated through the MessageContext, | |
* so that we only have one copy of the information. | |
* | |
* To use this class, invoke the install method. This will create an TransportHeadersAdapter | |
* (if necessary) and install it on the property JAX-WS standard TransportHeaders properties. | |
* (See BaseMessageContext.) | |
*/ | |
public class TransportHeadersAdapter implements Map { | |
private static final Log log = LogFactory.getLog(TransportHeadersAdapter.class); | |
MessageContext mc; // MessageContext which provides the backing implementation | |
String propertyName; // The name of the JAX-WS property | |
/** | |
* @param mc | |
* @param propertyName | |
*/ | |
private TransportHeadersAdapter(MessageContext mc, String propertyName) { | |
this.mc = mc; | |
this.propertyName = propertyName; | |
} | |
/** | |
* Add the TransportHeadersAdapter as the property for TransportHeaders | |
* @param mc MessageContext | |
*/ | |
public static void install(MessageContext mc) { | |
boolean isRequest = (mc.getMEPContext().getRequestMessageContext() == mc); | |
// The property is either a request or response | |
String propertyName = | |
(isRequest) ? javax.xml.ws.handler.MessageContext.HTTP_REQUEST_HEADERS | |
: javax.xml.ws.handler.MessageContext.HTTP_RESPONSE_HEADERS; | |
if (log.isDebugEnabled()) { | |
log.debug("Installing TransportHeadersAdapter for " + propertyName); | |
} | |
// See if there is an existing map | |
Object map = mc.getProperty(propertyName); | |
// Reuse existing TransportHeadersAdapter | |
if (map instanceof TransportHeadersAdapter) { | |
if (log.isDebugEnabled()) { | |
log.debug("An TransportHeadersAdapter is already installed. " + | |
"Reusing the existing one."); | |
} | |
return; | |
} | |
// Create a new TransportHeadersAdapter and set it on the property | |
TransportHeadersAdapter tha = new TransportHeadersAdapter(mc, propertyName); | |
if (map != null) { | |
if (log.isDebugEnabled()) { | |
log.debug("The TransportHeaders in the existing map (" + propertyName | |
+ ") are copied to the TransportHeadersAdapter."); | |
} | |
// Copy the existing Map contents to this new adapter | |
tha.putAll((Map) map); | |
} | |
mc.setPropertyNoReturn(propertyName, tha); | |
// If this is a response, then also set the property for the response code | |
if (!isRequest) { | |
Object value = mc.getProperty(HTTPConstants.MC_HTTP_STATUS_CODE); | |
mc.setProperty(javax.xml.ws.handler.MessageContext.HTTP_RESPONSE_CODE, value); | |
} | |
} | |
/** | |
* Get/Create the implementation map from the Axis2 properties | |
* @param mc | |
* @return Map | |
*/ | |
private static Map getDelegateMap(MessageContext mc) { | |
// Get the axis2 Map | |
Map map = (Map) mc.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS); | |
if (map == null) { | |
map = new HashMap(); | |
mc.setProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS, map); | |
} | |
return map; | |
} | |
/** | |
* Convert intput into a List | |
* @param o | |
* @return List | |
*/ | |
private static List<String> convertToList(Object o) { | |
if (o == null) { | |
return null; | |
} else if (o instanceof List) { | |
return (List) o; | |
} else if (o instanceof String) { | |
String s = (String)o; | |
String[] values = s.split(", "); | |
List<String> l = new ArrayList<String>(); | |
l.addAll(Arrays.asList(values)); | |
return l; | |
} else { | |
throw ExceptionFactory.makeWebServiceException( | |
Messages.getMessage("inputConvertionErr",o.getClass().toString())); | |
} | |
} | |
private static String convertToString(Object o) { | |
if (o == null) { | |
return null; | |
} else if (o instanceof String) { | |
return (String) o; | |
} else if (o instanceof List) { | |
List l = (List) o; | |
if (l.size() == 0) { | |
return null; | |
} else { | |
String s = ""; | |
for (int i = 0 ; i < l.size() ; i++) { | |
s += l.get(i); | |
if (i != l.size() - 1) { | |
s += ", "; | |
} | |
} | |
return s; | |
} | |
} | |
throw ExceptionFactory.makeWebServiceException( | |
Messages.getMessage("inputConvertionErr1",o.getClass().toString())); | |
} | |
public int size() { | |
return getDelegateMap(mc).size(); | |
} | |
public boolean isEmpty() { | |
return getDelegateMap(mc).isEmpty(); | |
} | |
public boolean containsKey(Object key) { | |
return getDelegateMap(mc).containsKey(key); | |
} | |
public boolean containsValue(Object value) { | |
String valueString = convertToString(value); | |
return getDelegateMap(mc).containsValue(valueString); | |
} | |
public Object get(Object key) { | |
Object value = convertToList(getDelegateMap(mc).get(key)); | |
if (log.isDebugEnabled()) { | |
log.debug("get(" + key + ") returns value=" + value); | |
} | |
return value; | |
} | |
public Object put(Object key, Object value) { | |
if (log.isDebugEnabled()) { | |
log.debug("put(" + key + " , " + value + ")"); | |
} | |
String valueString = convertToString(value); | |
return convertToList(getDelegateMap(mc).put(key, valueString)); | |
} | |
public Object remove(Object key) { | |
return convertToList(getDelegateMap(mc).remove(key)); | |
} | |
public void putAll(Map t) { | |
for (Object key : t.keySet()) { | |
Object value = t.get(key); | |
if (log.isDebugEnabled()) { | |
log.debug("put via putAll (" + key + " , " + value + ")"); | |
} | |
put(key, value); | |
} | |
} | |
public void clear() { | |
getDelegateMap(mc).clear(); | |
} | |
public Set keySet() { | |
return getDelegateMap(mc).keySet(); | |
} | |
public Collection values() { | |
return copy().values(); | |
} | |
public Set entrySet() { | |
return copy().entrySet(); | |
} | |
private Map copy() { | |
Map tempMap = new HashMap<String, List<String>>(); | |
for (Object key : keySet()) { | |
List<String> value = (List<String>)get(key); | |
tempMap.put(key, value); | |
} | |
return tempMap; | |
} | |
public String toString() { | |
return "TransportHeadersAdapter: " + getDelegateMap(mc).toString(); | |
} | |
} |