jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/model/ExternalMetadataReader.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/ExternalMetadataReader.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/ExternalMetadataReader.java

Tue, 09 Apr 2013 14:51:13 +0100

author: alanb
date: Tue, 09 Apr 2013 14:51:13 +0100
changeset 368: 0989ad8c0860
child 408: b0610cd08440
permissions: -rw-r--r--

8010393: Update JAX-WS RI to 2.2.9-b12941
Reviewed-by: alanb, erikj
Contributed-by: miroslav.kos@oracle.com, martin.grebac@oracle.com

 /*
  * Copyright (c) 1997, 2013, 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.model;
 import com.oracle.xmlns.internal.webservices.jaxws_databinding.JavaMethod;
 import com.oracle.xmlns.internal.webservices.jaxws_databinding.JavaParam;
 import com.oracle.xmlns.internal.webservices.jaxws_databinding.JavaWsdlMappingType;
 import com.oracle.xmlns.internal.webservices.jaxws_databinding.ObjectFactory;
 import com.sun.xml.internal.bind.api.JAXBRIContext;
 import com.sun.xml.internal.ws.streaming.XMLStreamReaderUtil;
 import com.sun.xml.internal.ws.util.xml.XmlUtil;
 import org.w3c.dom.Element;
 import org.xml.sax.SAXException;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Unmarshaller;
 import javax.xml.bind.util.JAXBResult;
 import javax.xml.stream.XMLInputFactory;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import javax.xml.transform.Source;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.stream.StreamSource;
 import javax.xml.validation.Schema;
 import javax.xml.validation.SchemaFactory;
 import java.io.*;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.util.*;
 import static com.oracle.xmlns.internal.webservices.jaxws_databinding.ExistingAnnotationsType.MERGE;
 /**
  * Metadata Reader able to read from either class annotations or external metadata files or combine both,
  * depending on configuration provided in xml file itself.
  *
  * @author shih-chang.chen@oracle.com, miroslav.kos@oracle.com
  */
 public class ExternalMetadataReader extends ReflectAnnotationReader {
     private static final String NAMESPACE_WEBLOGIC_WSEE_DATABINDING = "http://xmlns.oracle.com/weblogic/weblogic-wsee-databinding";
     private static final String NAMESPACE_JAXWS_RI_EXTERNAL_METADATA = "http://xmlns.oracle.com/webservices/jaxws-databinding";
     /**
      * map of readers for defined java types
      */
     private Map<String, JavaWsdlMappingType> readers = new HashMap<String, JavaWsdlMappingType>();
     public ExternalMetadataReader(Collection<File> files, Collection<String> resourcePaths, ClassLoader classLoader,
                                   boolean xsdValidation, boolean disableSecureXmlProcessing) {
         if (files != null) {
             for (File file : files) {
                 try {
                     String namespace = Util.documentRootNamespace(newSource(file), disableSecureXmlProcessing);
                     JavaWsdlMappingType externalMapping = parseMetadata(xsdValidation, newSource(file), namespace, disableSecureXmlProcessing);
                     readers.put(externalMapping.getJavaTypeName(), externalMapping);
                 } catch (Exception e) {
                     throw new RuntimeModelerException("runtime.modeler.external.metadata.unable.to.read", file.getAbsolutePath());
                 }
             }
         }
         if (resourcePaths != null) {
             for (String resourcePath : resourcePaths) {
                 try {
                     String namespace = Util.documentRootNamespace(newSource(resourcePath, classLoader), disableSecureXmlProcessing);
                     JavaWsdlMappingType externalMapping = parseMetadata(xsdValidation, newSource(resourcePath, classLoader), namespace, disableSecureXmlProcessing);
                     readers.put(externalMapping.getJavaTypeName(), externalMapping);
                 } catch (Exception e) {
                     throw new RuntimeModelerException("runtime.modeler.external.metadata.unable.to.read", resourcePath);
                 }
             }
         }
     }
     private StreamSource newSource(String resourcePath, ClassLoader classLoader) {
         InputStream is = classLoader.getResourceAsStream(resourcePath);
         return new StreamSource(is);
     }
     private JavaWsdlMappingType parseMetadata(boolean xsdValidation, StreamSource source, String namespace, boolean disableSecureXmlProcessing) throws JAXBException, IOException, TransformerException {
         if (NAMESPACE_WEBLOGIC_WSEE_DATABINDING.equals(namespace)) {
             return Util.transformAndRead(source, disableSecureXmlProcessing);
         } if (NAMESPACE_JAXWS_RI_EXTERNAL_METADATA.equals(namespace)) {
             return Util.read(source, xsdValidation, disableSecureXmlProcessing);
         } else {
             throw new RuntimeModelerException("runtime.modeler.external.metadata.unsupported.schema", namespace, Arrays.asList(NAMESPACE_WEBLOGIC_WSEE_DATABINDING, NAMESPACE_JAXWS_RI_EXTERNAL_METADATA).toString());
         }
     }
     private StreamSource newSource(File file) {
         try {
             return new StreamSource(new FileInputStream(file));
         } catch (FileNotFoundException e) {
             throw new RuntimeModelerException("runtime.modeler.external.metadata.unable.to.read", file.getAbsolutePath());
         }
     }
     public <A extends Annotation> A getAnnotation(Class<A> annType, Class<?> cls) {
         JavaWsdlMappingType r = reader(cls);
         return r == null ? super.getAnnotation(annType, cls) : Util.annotation(r, annType);
     }
     private JavaWsdlMappingType reader(Class<?> cls) {
         return readers.get(cls.getName());
     }
     Annotation[] getAnnotations(List<Object> objects) {
         ArrayList<Annotation> list = new ArrayList<Annotation>();
         for (Object a : objects) {
             if (Annotation.class.isInstance(a)) {
                 list.add(Annotation.class.cast(a));
             }
         }
         return list.toArray(new Annotation[list.size()]);
     }
     public Annotation[] getAnnotations(final Class<?> c) {
         Merger<Annotation[]> merger = new Merger<Annotation[]>(reader(c)) {
             Annotation[] reflection() {
                 return ExternalMetadataReader.super.getAnnotations(c);
             }
             Annotation[] external() {
                 return getAnnotations(reader.getClassAnnotation());
             }
         };
         return merger.merge();
     }
     public Annotation[] getAnnotations(final Method m) {
         Merger<Annotation[]> merger = new Merger<Annotation[]>(reader(m.getDeclaringClass())) {
             Annotation[] reflection() {
                 return ExternalMetadataReader.super.getAnnotations(m);
             }
             Annotation[] external() {
                 JavaMethod jm = getJavaMethod(m, reader);
                 return (jm == null) ? new Annotation[0] : getAnnotations(jm.getMethodAnnotation());
             }
         };
         return merger.merge();
     }
     @SuppressWarnings("unchecked")
     public <A extends Annotation> A getAnnotation(final Class<A> annType, final Method m) {
         Merger<Annotation> merger = new Merger<Annotation>(reader(m.getDeclaringClass())) {
             Annotation reflection() {
                 return ExternalMetadataReader.super.getAnnotation(annType, m);
             }
             Annotation external() {
                 JavaMethod jm = getJavaMethod(m, reader);
                 return Util.annotation(jm, annType);
             }
         };
         return (A) merger.merge();
     }
     public Annotation[][] getParameterAnnotations(final Method m) {
         Merger<Annotation[][]> merger = new Merger<Annotation[][]>(reader(m.getDeclaringClass())) {
             Annotation[][] reflection() {
                 return ExternalMetadataReader.super.getParameterAnnotations(m);
             }
             Annotation[][] external() {
                 JavaMethod jm = getJavaMethod(m, reader);
                 Annotation[][] a = m.getParameterAnnotations();
                 for (int i = 0; i < m.getParameterTypes().length; i++) {
                     if (jm == null) continue;
                     JavaParam jp = jm.getJavaParams().getJavaParam().get(i);
                     a[i] = getAnnotations(jp.getParamAnnotation());
                 }
                 return a;
             }
         };
         return merger.merge();
     }
     public void getProperties(final Map<String, Object> prop, final Class<?> cls) {
         JavaWsdlMappingType r = reader(cls);
         // no external reader or it requires annotations merging ...
         if (r == null || MERGE.equals(r.getExistingAnnotations())) {
             super.getProperties(prop, cls);
         }
     }
     public void getProperties(final Map<String, Object> prop, final Method m) {
         JavaWsdlMappingType r = reader(m.getDeclaringClass());
         // no external reader or it requires annotations merging ...
         if (r == null || MERGE.equals(r.getExistingAnnotations())) {
             super.getProperties(prop, m);
         }
         if (r != null) {
             JavaMethod jm = getJavaMethod(m, r);
             Element[] e = Util.annotation(jm);
             prop.put("eclipselink-oxm-xml.xml-element", findXmlElement(e));
         }
     }
     public void getProperties(final Map<String, Object> prop, final Method m, int pos) {
         JavaWsdlMappingType r = reader(m.getDeclaringClass());
         // no external reader or it requires annotations merging ...
         if (r == null || MERGE.equals(r.getExistingAnnotations())) {
             super.getProperties(prop, m, pos);
         }
         if (r != null) {
             JavaMethod jm = getJavaMethod(m, r);
             if (jm == null) return;
             JavaParam jp = jm.getJavaParams().getJavaParam().get(pos);
             Element[] e = Util.annotation(jp);
             prop.put("eclipselink-oxm-xml.xml-element", findXmlElement(e));
         }
     }
     JavaMethod getJavaMethod(Method method, JavaWsdlMappingType r) {
         JavaWsdlMappingType.JavaMethods javaMethods = r.getJavaMethods();
         if (javaMethods == null) {
             return null;
         }
         List<JavaMethod> sameName = new ArrayList<JavaMethod>();
         for (JavaMethod jm : javaMethods.getJavaMethod()) {
             if (method.getName().equals(jm.getName())) {
                 sameName.add(jm);
             }
         }
         if (sameName.isEmpty()) {
             return null;
         } else {
             if (sameName.size() == 1) {
                 return sameName.get(0);
             } else {
                 Class<?>[] argCls = method.getParameterTypes();
                 for (JavaMethod jm : sameName) {
                     JavaMethod.JavaParams params = jm.getJavaParams();
                     if (params != null && params.getJavaParam() != null && params.getJavaParam().size() == argCls.length) {
                         int count = 0;
                         for (int i = 0; i < argCls.length; i++) {
                             JavaParam jp = params.getJavaParam().get(i);
                             if (argCls[i].getName().equals(jp.getJavaType())) {
                                 count++;
                             }
                         }
                         if (count == argCls.length) {
                             return jm;
                         }
                     }
                 }
             }
         }
         return null;
     }
     Element findXmlElement(Element[] xa) {
         if (xa == null) return null;
         for (Element e : xa) {
             if (e.getLocalName().equals("java-type")) return e;
             if (e.getLocalName().equals("xml-element")) return e;
         }
         return null;
     }
     /**
      * Helper class to merge two different arrays of annotation objects. It merges annotations based on attribute
      * <code>existing-annotations</code> in external customization file.
      * <p/>
      * We suppose that in the result array there wouldn't be two annotations of same type:
      * annotation.annotationType().getName(); if there are found such annotations the one from reflection is
      * considered overriden and is thrown away.
      * <p/>
      * The helper can work either with one and two dimensional array, but it can be used for two single Annotation
      * objects;
      */
     static abstract class Merger<T> {
         JavaWsdlMappingType reader;
         Merger(JavaWsdlMappingType r) {
             this.reader = r;
         }
         abstract T reflection();
         abstract T external();
         @SuppressWarnings("unchecked")
         T merge() {
             T reflection = reflection();
             if (reader == null) {
                 return reflection;
             }
             T external = external();
             if (!MERGE.equals(reader.getExistingAnnotations())) {
                 return external;
             }
             if (reflection instanceof Annotation) {
                 return (T) doMerge((Annotation) reflection, (Annotation) external);
             } else if (reflection instanceof Annotation[][]) {
                 return (T) doMerge((Annotation[][]) reflection, (Annotation[][]) external);
             } else {
                 return (T) doMerge((Annotation[]) reflection, (Annotation[]) external);
             }
         }
         private Annotation doMerge(Annotation reflection, Annotation external) {
             return external != null ? external : reflection;
         }
         private Annotation[][] doMerge(Annotation[][] reflection, Annotation[][] external) {
             for (int i = 0; i < reflection.length; i++) {
                 reflection[i] = doMerge(reflection[i], external.length > i ? external[i] : null);
             }
             return reflection;
         }
         private Annotation[] doMerge(Annotation[] annotations, Annotation[] externalAnnotations) {
             HashMap<String, Annotation> mergeMap = new HashMap<String, Annotation>();
             if (annotations != null) {
                 for (Annotation reflectionAnnotation : annotations) {
                     mergeMap.put(reflectionAnnotation.annotationType().getName(), reflectionAnnotation);
                 }
             }
             // overriding happens here, based on annotationType().getName() ...
             if (externalAnnotations != null) {
                 for (Annotation externalAnnotation : externalAnnotations) {
                     mergeMap.put(externalAnnotation.annotationType().getName(), externalAnnotation);
                 }
             }
             Collection<Annotation> values = mergeMap.values();
             int size = values.size();
             return size == 0 ? null : values.toArray(new Annotation[size]);
         }
     }
     static class Util {
         //private static final String DATABINDING_XSD = "com/sun/xml/internal/ws/model/jaxws-databinding.xsd";
         private static final String DATABINDING_XSD = "jaxws-databinding.xsd";
         //private static final String TRANSLATE_NAMESPACES_XSL = "/com/sun/xml/internal/ws/model/jaxws-databinding-translate-namespaces.xml";
         private static final String TRANSLATE_NAMESPACES_XSL = "jaxws-databinding-translate-namespaces.xml";
         static Schema schema;
         static JAXBContext jaxbContext;
         static {
             SchemaFactory sf = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
             try {
                 URL xsdUrl = getResource();
                 if (xsdUrl != null) {
                     schema = sf.newSchema(xsdUrl);
                 }
             } catch (SAXException e1) {
                 //      e1.printStackTrace();
             }
             jaxbContext = createJaxbContext(false);
         }
         private static URL getResource() {
             ClassLoader classLoader = Util.class.getClassLoader();
             return classLoader != null ? classLoader.getResource(DATABINDING_XSD) : ClassLoader.getSystemResource(DATABINDING_XSD);
         }
         private static JAXBContext createJaxbContext(boolean disableXmlSecurity) {
             Class[] cls = {ObjectFactory.class};
             try {
                 if (disableXmlSecurity) {
                     Map<String, Object> properties = new HashMap<String, Object>();
                     properties.put(JAXBRIContext.DISABLE_XML_SECURITY, disableXmlSecurity);
                     return JAXBContext.newInstance(cls, properties);
                 } else {
                     return JAXBContext.newInstance(cls);
                 }
             } catch (JAXBException e) {
                 e.printStackTrace();
                 return null;
             }
         }
         @SuppressWarnings("unchecked")
         public static JavaWsdlMappingType read(Source src, boolean xsdValidation, boolean disableSecureXmlProcessing) throws IOException, JAXBException {
             JAXBContext ctx = jaxbContext(disableSecureXmlProcessing);
             try {
                 Unmarshaller um = ctx.createUnmarshaller();
                 if (xsdValidation) {
                     if (schema == null) {
                         //TODO 0 warning for schema == null
                     }
                     um.setSchema(schema);
                 }
                 Object o = um.unmarshal(src);
                 return getJavaWsdlMapping(o);
             } catch (JAXBException e) {
                 // throw new
                 // WebServiceException(WsDatabindingMessages.mappingFileCannotRead
                 // (src.getSystemId()), e);
                 URL url = new URL(src.getSystemId());
                 Source s = new StreamSource(url.openStream());
                 Unmarshaller um = ctx.createUnmarshaller();
                 if (xsdValidation) {
                     if (schema == null) {
                         //TODO 0 warning for schema == null
                     }
                     um.setSchema(schema);
                 }
                 Object o = um.unmarshal(s);
                 return getJavaWsdlMapping(o);
             }
         }
         private static JAXBContext jaxbContext(boolean disableSecureXmlProcessing) {
             // as it is supposed to have security enabled in most cases, we create and don't cache
             // "insecure" JAXBContext - these should be corner cases
             return disableSecureXmlProcessing ? createJaxbContext(true) : jaxbContext;
         }
         public static JavaWsdlMappingType transformAndRead(Source src, boolean disableSecureXmlProcessing) throws TransformerException, JAXBException {
             Source xsl = new StreamSource(Util.class.getResourceAsStream(TRANSLATE_NAMESPACES_XSL));
             JAXBResult result = new JAXBResult(jaxbContext(disableSecureXmlProcessing));
             TransformerFactory tf = XmlUtil.newTransformerFactory(!disableSecureXmlProcessing);
             Transformer transformer = tf.newTemplates(xsl).newTransformer();
             transformer.transform(src, result);
             return getJavaWsdlMapping(result.getResult());
         }
         static JavaWsdlMappingType getJavaWsdlMapping(Object o) {
             Object val = (o instanceof JAXBElement) ? ((JAXBElement) o).getValue() : o;
             if (val instanceof JavaWsdlMappingType) return (JavaWsdlMappingType) val;
             //    else if (val instanceof JavaWsdlMappings)
             //      for (JavaWsdlMappingType m: ((JavaWsdlMappings) val).getJavaWsdlMapping())
             //        if (seiName.equals(m.javaTypeName)) return m;
             return null;
         }
         static <T> T findInstanceOf(Class<T> type, List<Object> objects) {
             for (Object o : objects) {
                 if (type.isInstance(o)) {
                     return type.cast(o);
                 }
             }
             return null;
         }
         static public <T> T annotation(JavaWsdlMappingType jwse, Class<T> anntype) {
             if (jwse == null || jwse.getClassAnnotation() == null) {
                 return null;
             }
             return findInstanceOf(anntype, jwse.getClassAnnotation());
         }
         static public <T> T annotation(JavaMethod jm, Class<T> anntype) {
             if (jm == null || jm.getMethodAnnotation() == null) {
                 return null;
             }
             return findInstanceOf(anntype, jm.getMethodAnnotation());
         }
         static public <T> T annotation(JavaParam jp, Class<T> anntype) {
             if (jp == null || jp.getParamAnnotation() == null) {
                 return null;
             }
             return findInstanceOf(anntype, jp.getParamAnnotation());
         }
         static public Element[] annotation(JavaMethod jm) {
             if (jm == null || jm.getMethodAnnotation() == null) {
                 return null;
             }
             return findElements(jm.getMethodAnnotation());
         }
         static public Element[] annotation(JavaParam jp) {
             if (jp == null || jp.getParamAnnotation() == null) {
                 return null;
             }
             return findElements(jp.getParamAnnotation());
         }
         private static Element[] findElements(List<Object> objects) {
             List<Element> elems = new ArrayList<Element>();
             for (Object o : objects) {
                 if (o instanceof Element) {
                     elems.add((Element) o);
                 }
             }
             return elems.toArray(new Element[elems.size()]);
         }
         static String documentRootNamespace(Source src, boolean disableSecureXmlProcessing) throws XMLStreamException {
             XMLInputFactory factory;
             factory = XmlUtil.newXMLInputFactory(!disableSecureXmlProcessing);
             XMLStreamReader streamReader = factory.createXMLStreamReader(src);
             XMLStreamReaderUtil.nextElementContent(streamReader);
             String namespaceURI = streamReader.getName().getNamespaceURI();
             XMLStreamReaderUtil.close(streamReader);
             return namespaceURI;
         }
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/model/ExternalMetadataReader.java@0989ad8c0860 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/ExternalMetadataReader.java