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

-:8c0b6bccfe47
+:0989ad8c0860
+/*
+* 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 / file comparison

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

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