| /* |
| * 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 disableXmlSecurity) { |
| |
| if (files != null) { |
| for (File file : files) { |
| try { |
| String namespace = Util.documentRootNamespace(newSource(file), disableXmlSecurity); |
| JavaWsdlMappingType externalMapping = parseMetadata(xsdValidation, newSource(file), namespace, disableXmlSecurity); |
| 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), disableXmlSecurity); |
| JavaWsdlMappingType externalMapping = parseMetadata(xsdValidation, newSource(resourcePath, classLoader), namespace, disableXmlSecurity); |
| 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 disableXmlSecurity) throws JAXBException, IOException, TransformerException { |
| if (NAMESPACE_WEBLOGIC_WSEE_DATABINDING.equals(namespace)) { |
| return Util.transformAndRead(source, disableXmlSecurity); |
| } if (NAMESPACE_JAXWS_RI_EXTERNAL_METADATA.equals(namespace)) { |
| return Util.read(source, xsdValidation, disableXmlSecurity); |
| } 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 disableXmlSecurity) throws IOException, JAXBException { |
| JAXBContext ctx = jaxbContext(disableXmlSecurity); |
| 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 disableXmlSecurity) { |
| // 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 disableXmlSecurity ? createJaxbContext(true) : jaxbContext; |
| } |
| |
| public static JavaWsdlMappingType transformAndRead(Source src, boolean disableXmlSecurity) throws TransformerException, JAXBException { |
| Source xsl = new StreamSource(Util.class.getResourceAsStream(TRANSLATE_NAMESPACES_XSL)); |
| JAXBResult result = new JAXBResult(jaxbContext(disableXmlSecurity)); |
| TransformerFactory tf = XmlUtil.newTransformerFactory(!disableXmlSecurity); |
| 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 disableXmlSecurity) throws XMLStreamException { |
| XMLInputFactory factory; |
| factory = XmlUtil.newXMLInputFactory(!disableXmlSecurity); |
| XMLStreamReader streamReader = factory.createXMLStreamReader(src); |
| XMLStreamReaderUtil.nextElementContent(streamReader); |
| String namespaceURI = streamReader.getName().getNamespaceURI(); |
| XMLStreamReaderUtil.close(streamReader); |
| return namespaceURI; |
| } |
| } |
| |
| |
| } |
