jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/xml/internal/ws/client/RequestContext.java

-:8c0b6bccfe47
+:0989ad8c0860
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * questions.
 */
 package com.sun.xml.internal.ws.client;
+import com.oracle.webservices.internal.api.message.BaseDistributedPropertySet;
 import com.sun.istack.internal.NotNull;
-import com.sun.xml.internal.ws.api.DistributedPropertySet;
 import com.sun.xml.internal.ws.api.EndpointAddress;
-import com.sun.xml.internal.ws.api.PropertySet;
 import com.sun.xml.internal.ws.api.message.Packet;
 import com.sun.xml.internal.ws.transport.Headers;
 import javax.xml.ws.BindingProvider;
-import javax.xml.ws.handler.MessageContext;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.logging.Logger;
+import static javax.xml.ws.BindingProvider.*;
+import static javax.xml.ws.handler.MessageContext.HTTP_REQUEST_HEADERS;
 /**
 * Request context implementation.
 *
 * <h2>Why a custom map?</h2>
 * <p>
 * setting to make a bunch of invocations. So we'd like to take some hit
 * when the user actually sets a property to do some computation,
 * then use that computed value during a method invocation again and again.
 *
 * <p>
-* For this goal, we use {@link PropertySet} and implement some properties
+* For this goal, we use {@link com.sun.xml.internal.ws.api.PropertySet} and implement some properties
 * as virtual properties backed by methods. This allows us to do the computation
 * in the setter, and store it in a field.
 *
 * <p>
 * These fields are used by {@link Stub#process} to populate a {@link Packet}.
 *
-*
-*
 * <h2>How it works?</h2>
 * <p>
-* We make an assumption that a request context is mostly used to just
+* For better performance, we wan't use strongly typed field as much as possible
-* get and put values, not really for things like enumerating or size.
+* to avoid reflection and unnecessary collection iterations;
 *
-* <p>
+* Using {@link com.oracle.webservices.internal.api.message.BasePropertySet.MapView} implementation allows client to use {@link Map} interface
-* So we start by maintaining state as a combination of {@link #others}
+* in a way that all the strongly typed properties are reflected to the fields
-* bag and strongly-typed fields. As long as the application uses
+* right away. Any additional (extending) properties can be added by client as well;
-* just {@link Map#put}, {@link Map#get}, and {@link Map#putAll}, we can
+* those would be processed using iterating the {@link MapView} and their processing,
-* do things in this way. In this mode a {@link Map} we return works as
+* of course, would be slower.
-* a view into {@link RequestContext}, and by itself it maintains no state.
+* <p>
-*
+* The previous implementation with fallback mode has been removed to simplify
-* <p>
+* the code and remove the bugs.
-* If {@link RequestContext} is in this mode, its state can be copied
-* efficiently into {@link Packet}.
-*
-* <p>
-* Once the application uses any other {@link Map} method, we move to
-* the "fallback" mode, where the data is actually stored in a {@link HashMap},
-* this is necessary for implementing the map interface contract correctly.
-*
-* <p>
-* To be safe, once we fallback, we'll never come back to the efficient state.
-*
-*
-*
-* <h2>Caution</h2>
-* <p>
-* Once we are in the fallback mode, none of the strongly typed field will
-* be used, and they may contain stale values. So the only method
-* the code outside this class can safely use is {@link #copy()},
-* {@link #fill(Packet)}, and constructors. Do not access the strongly
-* typed fields nor {@link #others} directly.
 *
 * @author Kohsuke Kawaguchi
 */
 @SuppressWarnings({"SuspiciousMethodCalls"})
-public final class RequestContext extends DistributedPropertySet {
+public final class RequestContext extends BaseDistributedPropertySet {
 private static final Logger LOGGER = Logger.getLogger(RequestContext.class.getName());
 /**
 * The default value to be use for {@link #contentNegotiation} obtained
 * from a system property.
 */
 private static ContentNegotiation defaultContentNegotiation =
 ContentNegotiation.obtainFromSystemProperty();
 /**
-* Stores properties that don't fit the strongly-typed fields.
+* @deprecated
 */
-private final Map<String,Object> others;
+public void addSatellite(@NotNull com.sun.xml.internal.ws.api.PropertySet satellite) {
+super.addSatellite(satellite);
+}
 /**
 * The endpoint address to which this message is sent to.
 *
 * <p>
 * on top of {@link #endpointAddress}.
 *
 * @deprecated
 *      always access {@link #endpointAddress}.
 */
-@Property(BindingProvider.ENDPOINT_ADDRESS_PROPERTY)
+@Property(ENDPOINT_ADDRESS_PROPERTY)
 public String getEndPointAddressString() {
 return endpointAddress != null ? endpointAddress.toString() : null;
 }
 public void setEndPointAddressString(String s) {
-if(s==null)
+if (s == null) {
 throw new IllegalArgumentException();
-else
+} else {
 this.endpointAddress = EndpointAddress.create(s);
+}
 }
 public void setEndpointAddress(@NotNull EndpointAddress epa) {
 this.endpointAddress = epa;
 }
 public String getContentNegotiationString() {
 return contentNegotiation.toString();
 }
 public void setContentNegotiationString(String s) {
-if(s==null)
+if (s == null) {
 contentNegotiation = ContentNegotiation.none;
-else {
+} else {
 try {
 contentNegotiation = ContentNegotiation.valueOf(s);
 } catch (IllegalArgumentException e) {
 // If the value is not recognized default to none
 contentNegotiation = ContentNegotiation.none;
 }
 }
 }
 /**
 * The value of the SOAPAction header associated with the message.
 *
 * <p>
 * For outgoing messages, the transport may sends out this value.
 * this is moved to the parameter of the "application/soap+xml".
 */
 private String soapAction;
-@Property(BindingProvider.SOAPACTION_URI_PROPERTY)
+@Property(SOAPACTION_URI_PROPERTY)
-public String getSoapAction(){
+public String getSoapAction() {
 return soapAction;
 }
-public void setSoapAction(String sAction){
-if(sAction == null) {
+public void setSoapAction(String sAction) {
-throw new IllegalArgumentException("SOAPAction value cannot be null");
-}
 soapAction = sAction;
 }
 /**
 * This controls whether BindingProvider.SOAPACTION_URI_PROPERTY is used.
 *
 * This only control whether value of BindingProvider.SOAPACTION_URI_PROPERTY is used or not and not
 * if it can be sent if it can be obtained by other means such as WSDL binding
 */
 private Boolean soapActionUse;
-@Property(BindingProvider.SOAPACTION_USE_PROPERTY)
-public Boolean getSoapActionUse(){
+@Property(SOAPACTION_USE_PROPERTY)
+public Boolean getSoapActionUse() {
 return soapActionUse;
 }
-public void setSoapActionUse(Boolean sActionUse){
+public void setSoapActionUse(Boolean sActionUse) {
 soapActionUse = sActionUse;
 }
 /**
-* {@link Map} exposed to the user application.
-*/
-private final MapView mapView = new MapView();
-/**
 * Creates an empty {@link RequestContext}.
 */
-/*package*/ RequestContext() {
+RequestContext() {
-others = new HashMap<String, Object>();
 }
 /**
 * Copy constructor.
 */
 private RequestContext(RequestContext that) {
-others = new HashMap<String,Object>(that.others);
+for (Map.Entry<String, Object> entry : that.asMapLocal().entrySet()) {
-mapView.fallbackMap = that.mapView.fallbackMap != null ?
+if (!propMap.containsKey(entry.getKey())) {
-new HashMap<String, Object>(that.mapView.fallback()) : null;
+asMap().put(entry.getKey(), entry.getValue());
+}
+}
 endpointAddress = that.endpointAddress;
 soapAction = that.soapAction;
+soapActionUse = that.soapActionUse;
 contentNegotiation = that.contentNegotiation;
 that.copySatelliteInto(this);
 }
 /**
 * The efficient get method that reads from {@link RequestContext}.
 */
+@Override
 public Object get(Object key) {
-if(super.supports(key))
+if(supports(key)) {
 return super.get(key);
-else
+} else {
-return others.get(key);
+// use mapView to get extending property
+return asMap().get(key);
+}
 }
 /**
 * The efficient put method that updates {@link RequestContext}.
 */
+@Override
 public Object put(String key, Object value) {
-if(super.supports(key))
+if(supports(key)) {
 return super.put(key,value);
-else
+} else {
-return others.put(key,value);
+// use mapView to put extending property (if the map allows that)
-}
+return asMap().put(key, value);
+}
-/**
-* Gets the {@link Map} view of this request context.
-*
-* @return
-*      Always same object. Returned map is live.
-*/
-public Map<String,Object> getMapView() {
-return mapView;
 }
 /**
 * Fill a {@link Packet} with values of this {@link RequestContext}.
-*/
+*
+* @param packet              to be filled with context values
+* @param isAddressingEnabled flag if addressing enabled (to provide warning if necessary)
+*/
+@SuppressWarnings("unchecked")
 public void fill(Packet packet, boolean isAddressingEnabled) {
-if(mapView.fallbackMap==null) {
-if (endpointAddress != null)
+// handling as many properties as possible (all in propMap.keySet())
-packet.endpointAddress = endpointAddress;
+// to avoid slow Packet.put()
-packet.contentNegotiation = contentNegotiation;
+if (endpointAddress != null) {
+packet.endpointAddress = endpointAddress;
-//JAX-WS-596: Check the semantics of SOAPACTION_USE_PROPERTY before using the SOAPACTION_URI_PROPERTY for
+}
-// SoapAction as specified in the javadoc of BindingProvider. The spec seems to be little contradicting with
+packet.contentNegotiation = contentNegotiation;
-//  javadoc and says that the use property effects the sending of SOAPAction property.
+fillSOAPAction(packet, isAddressingEnabled);
-// Since the user has the capability to set the value as "" if needed, implement the javadoc behavior.
+mergeRequestHeaders(packet);
-if ((soapActionUse != null && soapActionUse) || (soapActionUse == null && isAddressingEnabled)) {
+Set<String> handlerScopeNames = new HashSet<String>();
-if (soapAction != null) {
-packet.soapAction = soapAction;
+copySatelliteInto(packet);
+// extending properties ...
+for (String key : asMapLocal().keySet()) {
+//if it is not standard property it defaults to Scope.HANDLER
+if (!supportsLocal(key)) {
+handlerScopeNames.add(key);
+}
+// to avoid slow Packet.put(), handle as small number of props as possible
+// => only properties not from RequestContext object
+if (!propMap.containsKey(key)) {
+Object value = asMapLocal().get(key);
+if (packet.supports(key)) {
+// very slow operation - try to avoid it!
+packet.put(key, value);
+} else {
+packet.invocationProperties.put(key, value);
 }
 }
+}
-if((!isAddressingEnabled && (soapActionUse == null || !soapActionUse)) && soapAction != null) {
-LOGGER.warning("BindingProvider.SOAPACTION_URI_PROPERTY is set in the RequestContext but is ineffective," +
+if (!handlerScopeNames.isEmpty()) {
-" Either set BindingProvider.SOAPACTION_USE_PROPERTY to true or enable AddressingFeature");
+packet.getHandlerScopePropertyNames(false).addAll(handlerScopeNames);
 }
+}
-copySatelliteInto((DistributedPropertySet)packet);
+@SuppressWarnings("unchecked")
-if(!others.isEmpty()) {
+private void mergeRequestHeaders(Packet packet) {
 //for bug 12883765
 //retrieve headers which is set in soap message
-Headers headerFromPacketProperty = (Headers)packet.invocationProperties.get(MessageContext.HTTP_REQUEST_HEADERS);
+Headers packetHeaders = (Headers) packet.invocationProperties.get(HTTP_REQUEST_HEADERS);
 //retrieve headers from request context
-Map<String,List<String>>  headerFromOthers =(Map<String,List<String>>) others.get(MessageContext.HTTP_REQUEST_HEADERS);
+Map<String, List<String>> myHeaders = (Map<String, List<String>>) asMap().get(HTTP_REQUEST_HEADERS);
-if((headerFromPacketProperty != null) && (headerFromOthers != null) ) {
+if ((packetHeaders != null) && (myHeaders != null)) {
 //update the headers set in soap message with those in request context
-for(String key: headerFromOthers.keySet()) {
+for (Entry<String, List<String>> entry : myHeaders.entrySet()) {
-if(key!=null && key.trim().length()!=0) {
+String key = entry.getKey();
-List<String> valueFromPacketProperty = headerFromPacketProperty.get(key);
+if (key != null && key.trim().length() != 0) {
-//if the two headers contain the same key, combine the value
+List<String> listFromPacket = packetHeaders.get(key);
-if(valueFromPacketProperty!=null) {
+//if the two headers contain the same key, combine the value
-valueFromPacketProperty.addAll(headerFromOthers.get(key));
+if (listFromPacket != null) {
-}else{
+listFromPacket.addAll(entry.getValue());
-//add the headers  in request context to those set in soap message
+} else {
-headerFromPacketProperty.put(key, headerFromOthers.get(key));
+//add the headers  in request context to those set in soap message
-}
+packetHeaders.put(key, myHeaders.get(key));
-}
 }
-// update headers in request context with those set in soap message since 'others' may contain other properties..
-others.put(MessageContext.HTTP_REQUEST_HEADERS, headerFromPacketProperty);
 }
-packet.invocationProperties.putAll(others);
+}
-//if it is not standard property it deafults to Scope.HANDLER
+// update headers in request context with those set in soap message since it may contain other properties..
-packet.getHandlerScopePropertyNames(false).addAll(others.keySet());
+asMap().put(HTTP_REQUEST_HEADERS, packetHeaders);
 }
-} else {
+}
-Set<String> handlerScopePropertyNames = new HashSet<String>();
-// fallback mode, simply copy map in a slow way
+private void fillSOAPAction(Packet packet, boolean isAddressingEnabled) {
-for (Entry<String,Object> entry : mapView.fallbackMap.entrySet()) {
+final boolean p = packet.packetTakesPriorityOverRequestContext;
-String key = entry.getKey();
+final String  localSoapAction    = p ? packet.soapAction : soapAction;
-if(packet.supports(key))
+final Boolean localSoapActionUse = p ? (Boolean) packet.invocationProperties.get(BindingProvider.SOAPACTION_USE_PROPERTY)
-packet.put(key,entry.getValue());
+: soapActionUse;
-else
-packet.invocationProperties.put(key,entry.getValue());
+//JAX-WS-596: Check the semantics of SOAPACTION_USE_PROPERTY before using the SOAPACTION_URI_PROPERTY for
+// SoapAction as specified in the javadoc of BindingProvider. The spec seems to be little contradicting with
-//if it is not standard property it deafults to Scope.HANDLER
+//  javadoc and says that the use property effects the sending of SOAPAction property.
-if(!super.supports(key)) {
+// Since the user has the capability to set the value as "" if needed, implement the javadoc behavior.
-handlerScopePropertyNames.add(key);
+if ((localSoapActionUse != null && localSoapActionUse) || (localSoapActionUse == null && isAddressingEnabled)) {
-}
+if (localSoapAction != null) {
-}
+packet.soapAction = localSoapAction;
+}
-if(!handlerScopePropertyNames.isEmpty())
+}
-packet.getHandlerScopePropertyNames(false).addAll(handlerScopePropertyNames);
+if ((!isAddressingEnabled && (localSoapActionUse == null || !localSoapActionUse)) && localSoapAction != null) {
+LOGGER.warning("BindingProvider.SOAPACTION_URI_PROPERTY is set in the RequestContext but is ineffective," +
+" Either set BindingProvider.SOAPACTION_USE_PROPERTY to true or enable AddressingFeature");
 }
 }
 public RequestContext copy() {
 return new RequestContext(this);
 }
-private final class MapView implements Map<String,Object> {
+@Override
-private Map<String,Object> fallbackMap;
-private Map<String,Object> fallback() {
-if(fallbackMap==null) {
-// has to fall back. fill in fallbackMap
-fallbackMap = new HashMap<String,Object>(others);
-// then put all known properties
-fallbackMap.putAll(createMapView());
-}
-return fallbackMap;
-}
-public int size() {
-return fallback().size();
-}
-public boolean isEmpty() {
-return fallback().isEmpty();
-}
-public boolean containsKey(Object key) {
-return fallback().containsKey(key);
-}
-public boolean containsValue(Object value) {
-return fallback().containsValue(value);
-}
-public Object get(Object key) {
-if (fallbackMap ==null) {
-return RequestContext.this.get(key);
-} else {
-return fallback().get(key);
-}
-}
-public Object put(String key, Object value) {
-if(fallbackMap ==null)
-return RequestContext.this.put(key,value);
-else
-return fallback().put(key, value);
-}
-public Object remove(Object key) {
-if (fallbackMap ==null) {
-return RequestContext.this.remove(key);
-} else {
-return fallback().remove(key);
-}
-}
-public void putAll(Map<? extends String, ? extends Object> t) {
-for (Entry<? extends String, ? extends Object> e : t.entrySet()) {
-put(e.getKey(),e.getValue());
-}
-}
-public void clear() {
-fallback().clear();
-}
-public Set<String> keySet() {
-return fallback().keySet();
-}
-public Collection<Object> values() {
-return fallback().values();
-}
-public Set<Entry<String, Object>> entrySet() {
-return fallback().entrySet();
-}
-}
 protected PropertyMap getPropertyMap() {
 return propMap;
 }
 private static final PropertyMap propMap = parse(RequestContext.class);
+@Override
+protected boolean mapAllowsAdditionalProperties() {
+return true;
+}
 }

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/xml/internal/ws/client/RequestContext.java

src/share/jaxws_classes/com/sun/xml/internal/ws/client/RequestContext.java