jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/api/streaming/XMLStreamReaderFactory.java@d950f4a0753b (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/streaming/XMLStreamReaderFactory.java@d950f4a0753b (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/streaming/XMLStreamReaderFactory.java

Fri, 14 Feb 2014 11:13:45 +0100

author: mkos
date: Fri, 14 Feb 2014 11:13:45 +0100
changeset 558: d950f4a0753b
parent 515: 6cd506508147
child 637: 9c07ef4934dd
permissions: -rw-r--r--

8026188: Enhance envelope factory
Summary: Avoiding caching data initialized via TCCL in static context; fix also reviewed by Alexander Fomin
Reviewed-by: ahgross, mgrebac, skoivu

 /*
  * Copyright (c) 1997, 2014, 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
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.xml.internal.ws.api.streaming;
 import com.sun.istack.internal.NotNull;
 import com.sun.istack.internal.Nullable;
 import com.sun.xml.internal.ws.streaming.XMLReaderException;
 import com.sun.xml.internal.ws.util.xml.XmlUtil;
 import org.xml.sax.InputSource;
 import javax.xml.stream.XMLInputFactory;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
 import java.io.UnsupportedEncodingException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.security.AccessController;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import com.sun.xml.internal.ws.resources.StreamingMessages;
 /**
  * Factory for {@link XMLStreamReader}.
  *
  * <p>
  * This wraps {@link XMLInputFactory} and allows us to reuse {@link XMLStreamReader} instances
  * when appropriate.
  *
  * @author Kohsuke Kawaguchi
  */
 @SuppressWarnings("StaticNonFinalUsedInInitialization")
 public abstract class XMLStreamReaderFactory {
     private static final Logger LOGGER = Logger.getLogger(XMLStreamReaderFactory.class.getName());
     private static final String CLASS_NAME_OF_WSTXINPUTFACTORY = "com.ctc.wstx.stax.WstxInputFactory";
     /**
      * Singleton instance.
      */
     private static volatile ContextClassloaderLocal<XMLStreamReaderFactory> streamReader =
             new ContextClassloaderLocal<XMLStreamReaderFactory>() {
                 @Override
                 protected XMLStreamReaderFactory initialValue() {
                     XMLInputFactory xif = getXMLInputFactory();
                     XMLStreamReaderFactory f=null;
                     // this system property can be used to disable the pooling altogether,
                     // in case someone hits an issue with pooling in the production system.
                     if(!getProperty(XMLStreamReaderFactory.class.getName()+".noPool")) {
                         f = Zephyr.newInstance(xif);
                     }
                     if(f==null) {
                         // is this Woodstox?
                         if (xif.getClass().getName().equals(CLASS_NAME_OF_WSTXINPUTFACTORY)) {
                             f = new Woodstox(xif);
                         }
                     }
                     if (f==null) {
                         f = new Default();
                     }
                     if (LOGGER.isLoggable(Level.FINE)) {
                         LOGGER.log(Level.FINE, "XMLStreamReaderFactory instance is = {0}", f);
                     }
                     return f;
                 }
             };
     private static XMLInputFactory getXMLInputFactory() {
         XMLInputFactory xif = null;
         if (getProperty(XMLStreamReaderFactory.class.getName()+".woodstox")) {
             try {
                 xif = (XMLInputFactory)Class.forName("com.ctc.wstx.stax.WstxInputFactory").newInstance();
             } catch (Exception e) {
                 if (LOGGER.isLoggable(Level.WARNING)) {
                     LOGGER.log(Level.WARNING, StreamingMessages.WOODSTOX_CANT_LOAD(CLASS_NAME_OF_WSTXINPUTFACTORY), e);
                 }
             }
         }
         if (xif == null) {
              xif = XmlUtil.newXMLInputFactory(true);
         }
         xif.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, true);
         xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);
         xif.setProperty(XMLInputFactory.IS_COALESCING, true);
         return xif;
     }
     /**
      * Overrides the singleton {@link XMLStreamReaderFactory} instance that
      * the JAX-WS RI uses.
      */
     public static void set(XMLStreamReaderFactory f) {
         if(f==null) {
             throw new IllegalArgumentException();
         }
         streamReader.set(f);
     }
     public static XMLStreamReaderFactory get() {
         return streamReader.get();
     }
     public static XMLStreamReader create(InputSource source, boolean rejectDTDs) {
         try {
             // Char stream available?
             if (source.getCharacterStream() != null) {
                 return get().doCreate(source.getSystemId(), source.getCharacterStream(), rejectDTDs);
             }
             // Byte stream available?
             if (source.getByteStream() != null) {
                 return get().doCreate(source.getSystemId(), source.getByteStream(), rejectDTDs);
             }
             // Otherwise, open URI
             return get().doCreate(source.getSystemId(), new URL(source.getSystemId()).openStream(),rejectDTDs);
         } catch (IOException e) {
             throw new XMLReaderException("stax.cantCreate",e);
         }
     }
     public static XMLStreamReader create(@Nullable String systemId, InputStream in, boolean rejectDTDs) {
         return get().doCreate(systemId,in,rejectDTDs);
     }
     public static XMLStreamReader create(@Nullable String systemId, InputStream in, @Nullable String encoding, boolean rejectDTDs) {
         return (encoding == null)
                 ? create(systemId, in, rejectDTDs)
                 : get().doCreate(systemId,in,encoding,rejectDTDs);
     }
     public static XMLStreamReader create(@Nullable String systemId, Reader reader, boolean rejectDTDs) {
         return get().doCreate(systemId,reader,rejectDTDs);
     }
     /**
      * Should be invoked when the code finished using an {@link XMLStreamReader}.
      *
      * <p>
      * If the recycled instance implements {@link RecycleAware},
      * {@link RecycleAware#onRecycled()} will be invoked to let the instance
      * know that it's being recycled.
      *
      * <p>
      * It is not a hard requirement to call this method on every {@link XMLStreamReader}
      * instance. Not doing so just reduces the performance by throwing away
      * possibly reusable instances. So the caller should always consider the effort
      * it takes to recycle vs the possible performance gain by doing so.
      *
      * <p>
      * This method may be invoked by multiple threads concurrently.
      *
      * @param r
      *      The {@link XMLStreamReader} instance that the caller finished using.
      *      This could be any {@link XMLStreamReader} implementation, not just
      *      the ones that were created from this factory. So the implementation
      *      of this class needs to be aware of that.
      */
     public static void recycle(XMLStreamReader r) {
         get().doRecycle(r);
         if (r instanceof RecycleAware) {
             ((RecycleAware)r).onRecycled();
         }
     }
     // implementations
     public abstract XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs);
     private XMLStreamReader doCreate(String systemId, InputStream in, @NotNull String encoding, boolean rejectDTDs) {
         Reader reader;
         try {
             reader = new InputStreamReader(in, encoding);
         } catch(UnsupportedEncodingException ue) {
             throw new XMLReaderException("stax.cantCreate", ue);
         }
         return doCreate(systemId, reader, rejectDTDs);
     }
     public abstract XMLStreamReader doCreate(String systemId, Reader reader, boolean rejectDTDs);
     public abstract void doRecycle(XMLStreamReader r);
     /**
      * Interface that can be implemented by {@link XMLStreamReader} to
      * be notified when it's recycled.
      *
      * <p>
      * This provides a filtering {@link XMLStreamReader} an opportunity to
      * recycle its inner {@link XMLStreamReader}.
      */
     public interface RecycleAware {
         void onRecycled();
     }
     /**
      * {@link XMLStreamReaderFactory} implementation for SJSXP/JAXP RI.
      */
     private static final class Zephyr extends XMLStreamReaderFactory {
         private final XMLInputFactory xif;
         private final ThreadLocal<XMLStreamReader> pool = new ThreadLocal<XMLStreamReader>();
         /**
          * Sun StAX impl <code>XMLReaderImpl.setInputSource()</code> method via reflection.
          */
         private final Method setInputSourceMethod;
         /**
          * Sun StAX impl <code>XMLReaderImpl.reset()</code> method via reflection.
          */
         private final Method resetMethod;
         /**
          * The Sun StAX impl's {@link XMLStreamReader} implementation clas.
          */
         private final Class zephyrClass;
         /**
          * Creates {@link Zephyr} instance if the given {@link XMLInputFactory} is the one
          * from Zephyr.
          */
         public static @Nullable
         XMLStreamReaderFactory newInstance(XMLInputFactory xif) {
             // check if this is from Zephyr
             try {
                 Class<?> clazz = xif.createXMLStreamReader(new StringReader("<foo/>")).getClass();
                 // JDK has different XMLStreamReader impl class. Even if we check for that,
                 // it doesn't have setInputSource(InputSource). Let it use Default
                 if(!(clazz.getName().startsWith("com.sun.xml.internal.stream.")) )
                     return null;    // nope
                 return new Zephyr(xif,clazz);
             } catch (NoSuchMethodException e) {
                 return null;    // this factory is not for zephyr
             } catch (XMLStreamException e) {
                 return null;    // impossible to fail to parse <foo/>, but anyway
             }
         }
         public Zephyr(XMLInputFactory xif, Class clazz) throws NoSuchMethodException {
             zephyrClass = clazz;
             setInputSourceMethod = clazz.getMethod("setInputSource", InputSource.class);
             resetMethod = clazz.getMethod("reset");
             try {
                 // Turn OFF internal factory caching in Zephyr.
                 // Santiago told me that this makes it thread-safe.
                 xif.setProperty("reuse-instance", false);
             } catch (IllegalArgumentException e) {
                 // falls through
             }
             this.xif = xif;
         }
         /**
          * Fetchs an instance from the pool if available, otherwise null.
          */
         private @Nullable XMLStreamReader fetch() {
             XMLStreamReader sr = pool.get();
             if(sr==null)    return null;
             pool.set(null);
             return sr;
         }
         @Override
         public void doRecycle(XMLStreamReader r) {
             if(zephyrClass.isInstance(r))
                 pool.set(r);
         }
         @Override
         public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
             try {
                 XMLStreamReader xsr = fetch();
                 if(xsr==null)
                     return xif.createXMLStreamReader(systemId,in);
                 // try re-using this instance.
                 InputSource is = new InputSource(systemId);
                 is.setByteStream(in);
                 reuse(xsr,is);
                 return xsr;
             } catch (IllegalAccessException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             } catch (InvocationTargetException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         @Override
         public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
             try {
                 XMLStreamReader xsr = fetch();
                 if(xsr==null)
                     return xif.createXMLStreamReader(systemId,in);
                 // try re-using this instance.
                 InputSource is = new InputSource(systemId);
                 is.setCharacterStream(in);
                 reuse(xsr,is);
                 return xsr;
             } catch (IllegalAccessException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             } catch (InvocationTargetException e) {
                 Throwable cause = e.getCause();
                 if (cause == null) {
                     cause = e;
                 }
                 throw new XMLReaderException("stax.cantCreate", cause);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         private void reuse(XMLStreamReader xsr, InputSource in) throws IllegalAccessException, InvocationTargetException {
             resetMethod.invoke(xsr);
             setInputSourceMethod.invoke(xsr,in);
         }
     }
     /**
      * Default {@link XMLStreamReaderFactory} implementation
      * that can work with any {@link XMLInputFactory}.
      *
      * <p>
      * {@link XMLInputFactory} is not required to be thread-safe, but
      * if the create method on this implementation is synchronized,
      * it may run into (see <a href="https://jax-ws.dev.java.net/issues/show_bug.cgi?id=555">
      * race condition</a>). Hence, using a XMLInputFactory per thread.
      */
     public static final class Default extends XMLStreamReaderFactory {
         private final ThreadLocal<XMLInputFactory> xif = new ThreadLocal<XMLInputFactory>() {
             @Override
             public XMLInputFactory initialValue() {
                 return getXMLInputFactory();
             }
         };
         @Override
         public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
             try {
                 return xif.get().createXMLStreamReader(systemId,in);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         @Override
         public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
             try {
                 return xif.get().createXMLStreamReader(systemId,in);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         @Override
         public void doRecycle(XMLStreamReader r) {
             // there's no way to recycle with the default StAX API.
         }
     }
     /**
      * Similar to {@link Default} but doesn't do any synchronization.
      *
      * <p>
      * This is useful when you know your {@link XMLInputFactory} is thread-safe by itself.
      */
     public static class NoLock extends XMLStreamReaderFactory {
         private final XMLInputFactory xif;
         public NoLock(XMLInputFactory xif) {
             this.xif = xif;
         }
         @Override
         public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
             try {
                 return xif.createXMLStreamReader(systemId,in);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         @Override
         public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
             try {
                 return xif.createXMLStreamReader(systemId,in);
             } catch (XMLStreamException e) {
                 throw new XMLReaderException("stax.cantCreate",e);
             }
         }
         @Override
         public void doRecycle(XMLStreamReader r) {
             // there's no way to recycle with the default StAX API.
         }
     }
     /**
      * Handles Woodstox's XIF, but sets properties to do the string interning, sets various limits, ...
      * Woodstox {@link XMLInputFactory} is thread safe.
      */
     public static final class Woodstox extends NoLock {
         public final static String PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT = "xml.ws.maximum.AttributesPerElement";
         public final static String PROPERTY_MAX_ATTRIBUTE_SIZE = "xml.ws.maximum.AttributeSize";
         public final static String PROPERTY_MAX_CHILDREN_PER_ELEMENT = "xml.ws.maximum.ChildrenPerElement";
         public final static String PROPERTY_MAX_ELEMENT_COUNT = "xml.ws.maximum.ElementCount";
         public final static String PROPERTY_MAX_ELEMENT_DEPTH = "xml.ws.maximum.ElementDepth";
         public final static String PROPERTY_MAX_CHARACTERS = "xml.ws.maximum.Characters";
         private static final int DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT = 500;
         private static final int DEFAULT_MAX_ATTRIBUTE_SIZE = 65536 * 8;
         private static final int DEFAULT_MAX_CHILDREN_PER_ELEMENT = Integer.MAX_VALUE;
         private static final int DEFAULT_MAX_ELEMENT_DEPTH = 500;
         private static final long DEFAULT_MAX_ELEMENT_COUNT = Integer.MAX_VALUE;
         private static final long DEFAULT_MAX_CHARACTERS = Long.MAX_VALUE;
         /* Woodstox default setting:
          int mMaxAttributesPerElement = 1000;
          int mMaxAttributeSize = 65536 * 8;
          int mMaxChildrenPerElement = Integer.MAX_VALUE;
          int mMaxElementDepth = 1000;
          long mMaxElementCount = Long.MAX_VALUE;
          long mMaxCharacters = Long.MAX_VALUE;
          */
         private int maxAttributesPerElement = DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT;
         private int maxAttributeSize = DEFAULT_MAX_ATTRIBUTE_SIZE;
         private int maxChildrenPerElement = DEFAULT_MAX_CHILDREN_PER_ELEMENT;
         private int maxElementDepth = DEFAULT_MAX_ELEMENT_DEPTH;
         private long maxElementCount = DEFAULT_MAX_ELEMENT_COUNT;
         private long maxCharacters = DEFAULT_MAX_CHARACTERS;
         // Note: this is a copy from com.ctc.wstx.api.WstxInputProperties, to be removed in the future
         private static final java.lang.String P_MAX_ATTRIBUTES_PER_ELEMENT = "com.ctc.wstx.maxAttributesPerElement";
         private static final java.lang.String P_MAX_ATTRIBUTE_SIZE = "com.ctc.wstx.maxAttributeSize";
         private static final java.lang.String P_MAX_CHILDREN_PER_ELEMENT = "com.ctc.wstx.maxChildrenPerElement";
         private static final java.lang.String P_MAX_ELEMENT_COUNT = "com.ctc.wstx.maxElementCount";
         private static final java.lang.String P_MAX_ELEMENT_DEPTH = "com.ctc.wstx.maxElementDepth";
         private static final java.lang.String P_MAX_CHARACTERS = "com.ctc.wstx.maxCharacters";
         private static final java.lang.String P_INTERN_NSURIS = "org.codehaus.stax2.internNsUris";
         public Woodstox(XMLInputFactory xif) {
             super(xif);
             if (xif.isPropertySupported(P_INTERN_NSURIS)) {
                 xif.setProperty(P_INTERN_NSURIS, true);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_INTERN_NSURIS + " is {0}", true);
                 }
             }
             if (xif.isPropertySupported(P_MAX_ATTRIBUTES_PER_ELEMENT)) {
                 maxAttributesPerElement = Integer.valueOf(buildIntegerValue(
                     PROPERTY_MAX_ATTRIBUTES_PER_ELEMENT, DEFAULT_MAX_ATTRIBUTES_PER_ELEMENT)
                 );
                 xif.setProperty(P_MAX_ATTRIBUTES_PER_ELEMENT, maxAttributesPerElement);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_ATTRIBUTES_PER_ELEMENT + " is {0}", maxAttributesPerElement);
                 }
             }
             if (xif.isPropertySupported(P_MAX_ATTRIBUTE_SIZE)) {
                 maxAttributeSize = Integer.valueOf(buildIntegerValue(
                     PROPERTY_MAX_ATTRIBUTE_SIZE, DEFAULT_MAX_ATTRIBUTE_SIZE)
                 );
                 xif.setProperty(P_MAX_ATTRIBUTE_SIZE, maxAttributeSize);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_ATTRIBUTE_SIZE + " is {0}", maxAttributeSize);
                 }
             }
             if (xif.isPropertySupported(P_MAX_CHILDREN_PER_ELEMENT)) {
                 maxChildrenPerElement = Integer.valueOf(buildIntegerValue(
                     PROPERTY_MAX_CHILDREN_PER_ELEMENT, DEFAULT_MAX_CHILDREN_PER_ELEMENT)
                 );
                 xif.setProperty(P_MAX_CHILDREN_PER_ELEMENT, maxChildrenPerElement);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_CHILDREN_PER_ELEMENT + " is {0}", maxChildrenPerElement);
                 }
             }
             if (xif.isPropertySupported(P_MAX_ELEMENT_DEPTH)) {
                 maxElementDepth = Integer.valueOf(buildIntegerValue(
                     PROPERTY_MAX_ELEMENT_DEPTH, DEFAULT_MAX_ELEMENT_DEPTH)
                 );
                 xif.setProperty(P_MAX_ELEMENT_DEPTH, maxElementDepth);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_ELEMENT_DEPTH + " is {0}", maxElementDepth);
                 }
             }
             if (xif.isPropertySupported(P_MAX_ELEMENT_COUNT)) {
                 maxElementCount = Long.valueOf(buildLongValue(
                     PROPERTY_MAX_ELEMENT_COUNT, DEFAULT_MAX_ELEMENT_COUNT)
                 );
                 xif.setProperty(P_MAX_ELEMENT_COUNT, maxElementCount);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_ELEMENT_COUNT + " is {0}", maxElementCount);
                 }
             }
             if (xif.isPropertySupported(P_MAX_CHARACTERS)) {
                 maxCharacters = Long.valueOf(buildLongValue(
                     PROPERTY_MAX_CHARACTERS, DEFAULT_MAX_CHARACTERS)
                 );
                 xif.setProperty(P_MAX_CHARACTERS, maxCharacters);
                 if (LOGGER.isLoggable(Level.FINE)) {
                     LOGGER.log(Level.FINE, P_MAX_CHARACTERS + " is {0}", maxCharacters);
                 }
             }
         }
         @Override
         public XMLStreamReader doCreate(String systemId, InputStream in, boolean rejectDTDs) {
             return super.doCreate(systemId, in, rejectDTDs);
         }
         @Override
         public XMLStreamReader doCreate(String systemId, Reader in, boolean rejectDTDs) {
             return super.doCreate(systemId, in, rejectDTDs);
         }
     }
     private static int buildIntegerValue(String propertyName, int defaultValue) {
         String propVal = System.getProperty(propertyName);
         if (propVal != null && propVal.length() > 0) {
             try {
                 Integer value = Integer.parseInt(propVal);
                 if (value > 0) {
                     // return with the value in System property
                     return value;
                 }
             } catch (NumberFormatException nfe) {
                 if (LOGGER.isLoggable(Level.WARNING)) {
                     LOGGER.log(Level.WARNING, StreamingMessages.INVALID_PROPERTY_VALUE_INTEGER(propertyName, propVal, Integer.toString(defaultValue)), nfe);
                 }
             }
         }
         // return with the default value
         return defaultValue;
     }
     private static long buildLongValue(String propertyName, long defaultValue) {
         String propVal = System.getProperty(propertyName);
         if (propVal != null && propVal.length() > 0) {
             try {
                 long value = Long.parseLong(propVal);
                 if (value > 0L) {
                     // return with the value in System property
                     return value;
                 }
             } catch (NumberFormatException nfe) {
                 // defult will be returned
                 if (LOGGER.isLoggable(Level.WARNING)) {
                     LOGGER.log(Level.WARNING, StreamingMessages.INVALID_PROPERTY_VALUE_LONG(propertyName, propVal, Long.toString(defaultValue)), nfe);
                 }
             }
         }
         // return with the default value
         return defaultValue;
     }
     private static Boolean getProperty(final String prop) {
         return AccessController.doPrivileged(
             new java.security.PrivilegedAction<Boolean>() {
                 @Override
                 public Boolean run() {
                     String value = System.getProperty(prop);
                     return value != null ? Boolean.valueOf(value) : Boolean.FALSE;
                 }
             }
         );
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/api/streaming/XMLStreamReaderFactory.java@d950f4a0753b (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/api/streaming/XMLStreamReaderFactory.java