Adding SOAP CoDec (+ JAXB modifications)

Pierre Lakreb · pilak · commit 62941553be26 · 2018-10-14T19:35:53.000+02:00
diff --git a/jaxb/src/main/java/feign/jaxb/JAXBContextFactory.java b/jaxb/src/main/java/feign/jaxb/JAXBContextFactory.java
@@ -14,8 +14,8 @@
 package feign.jaxb;
 
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
@@ -29,8 +29,8 @@
  */
 public final class JAXBContextFactory {
 
-  private final ConcurrentHashMap<Class, JAXBContext> jaxbContexts =
-      new ConcurrentHashMap<Class, JAXBContext>(64);
+  private final ConcurrentHashMap<Class<?>, JAXBContext> jaxbContexts =
+      new ConcurrentHashMap<>(64);
   private final Map<String, Object> properties;
 
   private JAXBContextFactory(Map<String, Object> properties) {
@@ -41,26 +41,21 @@ private JAXBContextFactory(Map<String, Object> properties) {
    * Creates a new {@link javax.xml.bind.Unmarshaller} that handles the supplied class.
    */
   public Unmarshaller createUnmarshaller(Class<?> clazz) throws JAXBException {
-    JAXBContext ctx = getContext(clazz);
-    return ctx.createUnmarshaller();
+    return getContext(clazz).createUnmarshaller();
   }
 
   /**
    * Creates a new {@link javax.xml.bind.Marshaller} that handles the supplied class.
    */
   public Marshaller createMarshaller(Class<?> clazz) throws JAXBException {
-    JAXBContext ctx = getContext(clazz);
-    Marshaller marshaller = ctx.createMarshaller();
+    Marshaller marshaller = getContext(clazz).createMarshaller();
     setMarshallerProperties(marshaller);
     return marshaller;
   }
 
   private void setMarshallerProperties(Marshaller marshaller) throws PropertyException {
-    Iterator<String> keys = properties.keySet().iterator();
-
-    while (keys.hasNext()) {
-      String key = keys.next();
-      marshaller.setProperty(key, properties.get(key));
+    for (Entry<String, Object> en : properties.entrySet()) {
+      marshaller.setProperty(en.getKey(), en.getValue());
     }
   }
 
@@ -74,11 +69,11 @@ private JAXBContext getContext(Class<?> clazz) throws JAXBException {
   }
 
   /**
-   * Creates instances of {@link feign.jaxb.JAXBContextFactory}
+   * Creates instances of {@link feign.jaxb.JAXBContextFactory}.
    */
   public static class Builder {
 
-    private final Map<String, Object> properties = new HashMap<String, Object>(5);
+    private final Map<String, Object> properties = new HashMap<>(10);
 
     /**
      * Sets the jaxb.encoding property of any Marshaller created by this factory.
@@ -120,6 +115,24 @@ public Builder withMarshallerFragment(Boolean value) {
       return this;
     }
 
+    /**
+     * Sets the given property of any Marshaller created by this factory.
+     * 
+     * <p>
+     * Example : <br>
+     * <br>
+     * <code>
+     *    new JAXBContextFactory.Builder()
+     *      .withProperty("com.sun.xml.internal.bind.xmlHeaders", "&lt;!DOCTYPE Example SYSTEM \&quot;example.dtd\&quot;&gt;")
+     *      .build();
+     * </code>
+     * </p>
+     */
+    public Builder withProperty(String key, Object value) {
+      properties.put(key, value);
+      return this;
+    }
+
     /**
      * Creates a new {@link feign.jaxb.JAXBContextFactory} instance.
      */
diff --git a/jaxb/src/main/java/feign/jaxb/JAXBDecoder.java b/jaxb/src/main/java/feign/jaxb/JAXBDecoder.java
@@ -14,13 +14,11 @@
 package feign.jaxb;
 
 import java.io.IOException;
-import java.lang.reflect.Type;
 import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParserFactory;
-import javax.xml.transform.Source;
 import javax.xml.transform.sax.SAXSource;
 import feign.Response;
 import feign.Util;
@@ -51,15 +49,15 @@
  */
 public class JAXBDecoder implements Decoder {
 
-  private final JAXBContextFactory jaxbContextFactory;
+  final JAXBContextFactory jaxbContextFactory;
   private final boolean namespaceAware;
 
   public JAXBDecoder(JAXBContextFactory jaxbContextFactory) {
     this.jaxbContextFactory = jaxbContextFactory;
     this.namespaceAware = true;
   }
 
-  private JAXBDecoder(Builder builder) {
+  JAXBDecoder(Builder builder) {
     this.jaxbContextFactory = builder.jaxbContextFactory;
     this.namespaceAware = builder.namespaceAware;
   }
@@ -90,15 +88,10 @@ public Object decode(Response response, Type type) throws IOException {
           false);
       saxParserFactory.setNamespaceAware(namespaceAware);
 
-      Source source = new SAXSource(saxParserFactory.newSAXParser().getXMLReader(),
-          new InputSource(response.body().asInputStream()));
-      Unmarshaller unmarshaller = jaxbContextFactory.createUnmarshaller((Class) type);
-      return unmarshaller.unmarshal(source);
-    } catch (JAXBException e) {
-      throw new DecodeException(e.toString(), e);
-    } catch (ParserConfigurationException e) {
-      throw new DecodeException(e.toString(), e);
-    } catch (SAXException e) {
+      return jaxbContextFactory.createUnmarshaller((Class<?>) type).unmarshal(new SAXSource(
+          saxParserFactory.newSAXParser().getXMLReader(),
+          new InputSource(response.body().asInputStream())));
+    } catch (JAXBException | ParserConfigurationException | SAXException e) {
       throw new DecodeException(e.toString(), e);
     } finally {
       if (response.body() != null) {
@@ -108,8 +101,8 @@ public Object decode(Response response, Type type) throws IOException {
   }
 
   public static class Builder {
-    private boolean namespaceAware = true;
-    private JAXBContextFactory jaxbContextFactory;
+    boolean namespaceAware = true;
+    JAXBContextFactory jaxbContextFactory;
 
     /**
      * Controls whether the underlying XML parser is namespace aware. Default is true.
diff --git a/jaxb/src/main/java/feign/jaxb/JAXBEncoder.java b/jaxb/src/main/java/feign/jaxb/JAXBEncoder.java
@@ -43,7 +43,7 @@
  */
 public class JAXBEncoder implements Encoder {
 
-  private final JAXBContextFactory jaxbContextFactory;
+  final JAXBContextFactory jaxbContextFactory;
 
   public JAXBEncoder(JAXBContextFactory jaxbContextFactory) {
     this.jaxbContextFactory = jaxbContextFactory;
@@ -56,7 +56,7 @@ public void encode(Object object, Type bodyType, RequestTemplate template) {
           "JAXB only supports encoding raw types. Found " + bodyType);
     }
     try {
-      Marshaller marshaller = jaxbContextFactory.createMarshaller((Class) bodyType);
+      Marshaller marshaller = jaxbContextFactory.createMarshaller((Class<?>) bodyType);
       StringWriter stringWriter = new StringWriter();
       marshaller.marshal(object, stringWriter);
       template.body(stringWriter.toString());
diff --git a/jaxb/src/main/java/feign/jaxb/SOAPDecoder.java b/jaxb/src/main/java/feign/jaxb/SOAPDecoder.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign.jaxb;
+
+import java.io.IOException;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import javax.xml.bind.JAXBException;
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import feign.Response;
+import feign.Util;
+import feign.codec.DecodeException;
+
+public class SOAPDecoder extends JAXBDecoder {
+
+  public SOAPDecoder(JAXBContextFactory jaxbContextFactory) {
+    super(jaxbContextFactory);
+  }
+
+  private SOAPDecoder(Builder builder) {
+    super(builder);
+  }
+
+  @Override
+  public Object decode(Response response, Type type) throws IOException {
+    if (response.status() == 404)
+      return Util.emptyValueOf(type);
+    if (response.body() == null)
+      return null;
+    while (type instanceof ParameterizedType) {
+      ParameterizedType ptype = (ParameterizedType) type;
+      type = ptype.getRawType();
+    }
+    if (!(type instanceof Class)) {
+      throw new UnsupportedOperationException(
+          "SOAP only supports decoding raw types. Found " + type);
+    }
+
+    try {
+      SOAPMessage message =
+          MessageFactory.newInstance().createMessage(null, response.body().asInputStream());
+      return jaxbContextFactory.createUnmarshaller((Class<?>) type)
+          .unmarshal(message.getSOAPBody().extractContentAsDocument());
+    } catch (JAXBException | SOAPException e) {
+      throw new DecodeException(e.toString(), e);
+    } finally {
+      if (response.body() != null) {
+        response.body().close();
+      }
+    }
+
+  }
+
+  public static class Builder extends JAXBDecoder.Builder {
+    @Override
+    public SOAPDecoder build() {
+      if (jaxbContextFactory == null) {
+        throw new IllegalStateException("JAXBContextFactory must be non-null");
+      }
+      return new SOAPDecoder(this);
+    }
+  }
+
+}
diff --git a/jaxb/src/main/java/feign/jaxb/SOAPEncoder.java b/jaxb/src/main/java/feign/jaxb/SOAPEncoder.java
@@ -0,0 +1,106 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign.jaxb;
+
+import feign.RequestTemplate;
+import feign.codec.EncodeException;
+import org.w3c.dom.Document;
+
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.soap.MessageFactory;
+import javax.xml.soap.SOAPException;
+import javax.xml.soap.SOAPMessage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+
+public class SOAPEncoder extends JAXBEncoder {
+
+    private final boolean writeXmlDeclaration;
+    private final Charset charsetEncoding;
+
+    private SOAPEncoder(Builder builder) {
+        this(builder.jaxbContextFactory, builder.writeXmlDeclaration, builder.charsetEncoding);
+    }
+
+    public SOAPEncoder(JAXBContextFactory jaxbContextFactory) {
+        this(jaxbContextFactory, true, Charset.defaultCharset());
+    }
+
+    SOAPEncoder(JAXBContextFactory jaxbContextFactory,
+                boolean writeXmlDeclaration, Charset charsetEncoding) {
+        super(jaxbContextFactory);
+        this.writeXmlDeclaration = writeXmlDeclaration;
+        this.charsetEncoding = charsetEncoding;
+    }
+
+    @Override
+    public void encode(Object object, Type bodyType, RequestTemplate template) {
+        if (!(bodyType instanceof Class)) {
+            throw new UnsupportedOperationException(
+                    "SOAP only supports encoding raw types. Found " + bodyType);
+        }
+        try {
+            Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
+            Marshaller marshaller = jaxbContextFactory.createMarshaller((Class<?>) bodyType);
+            marshaller.marshal(object, document);
+            SOAPMessage soapMessage = MessageFactory.newInstance().createMessage();
+            soapMessage.setProperty(SOAPMessage.WRITE_XML_DECLARATION,
+                    Boolean.toString(writeXmlDeclaration));
+            soapMessage.setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charsetEncoding.displayName());
+            soapMessage.getSOAPBody().addDocument(document);
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            soapMessage.writeTo(bos);
+            template.body(new String(bos.toByteArray()));
+        } catch (SOAPException | JAXBException | ParserConfigurationException | IOException e) {
+            throw new EncodeException(e.toString(), e);
+        }
+    }
+
+    /**
+     * Creates instances of {@link SOAPEncoder}.
+     */
+    public static class Builder {
+
+        private JAXBContextFactory jaxbContextFactory;
+        private boolean writeXmlDeclaration = true;
+        private Charset charsetEncoding = Charset.defaultCharset();
+
+        public Builder withCharsetEncoding(Charset charsetEncoding) {
+            this.charsetEncoding = charsetEncoding;
+            return this;
+        }
+
+        public Builder withWriteXmlDeclaration(boolean writeXmlDeclaration) {
+            this.writeXmlDeclaration = writeXmlDeclaration;
+            return this;
+        }
+
+        public Builder withJAXBContextFactory(JAXBContextFactory jaxbContextFactory) {
+            this.jaxbContextFactory = jaxbContextFactory;
+            return this;
+        }
+
+        public SOAPEncoder build() {
+            if (jaxbContextFactory == null) {
+                throw new IllegalStateException("JAXBContextFactory must be non-null");
+            }
+            return new SOAPEncoder(this);
+        }
+    }
+}
diff --git a/jaxb/src/test/java/feign/jaxb/SOAPCodecTest.java b/jaxb/src/test/java/feign/jaxb/SOAPCodecTest.java
diff --git a/pom.xml b/pom.xml
