WINK-380 - Add support for structured syntax suffix in media types (e.g. application/vnd.custom+json)

lresende · lresende · commit b7aea86696ed · 2013-03-17T16:20:25.000Z
git-svn-id: https://svn.apache.org/repos/asf/wink/trunk@1457479 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/wink-common/src/main/java/org/apache/wink/common/internal/registry/ProvidersRegistry.java b/wink-common/src/main/java/org/apache/wink/common/internal/registry/ProvidersRegistry.java
@@ -735,7 +735,7 @@ public Collection<ProviderRecord<T>> getProviderRecords() {
         private List<OFHolder<T>> internalGetProvidersByMediaType(MediaType mediaType, Class<?> cls) {
             Set<OFHolder<T>> compatible = new TreeSet<OFHolder<T>>(Collections.reverseOrder());
             for (Entry<MediaType, HashSet<PriorityObjectFactory<T>>> entry : entrySet) {
-                if (entry.getKey().isCompatible(mediaType)) {
+                if (areMediaTypesCompatible(entry.getKey(), mediaType)) {
                     // media type is compatible, check generic type of the
                     // subset
                     for (PriorityObjectFactory<T> of : entry.getValue()) {
@@ -760,6 +760,52 @@ private List<OFHolder<T>> internalGetProvidersByMediaType(MediaType mediaType, C
             return Arrays.asList(tmp);
         }
 
+        /**
+         * Allow providers to be registered with a structured syntax suffix (e.g. '+xml'
+         * or '+json') to narrow (or broaden) the applicability of a provider.
+         * <p>
+         * The structured syntax suffix (SSS) is defined in RFC6838, section 4.2.8 and
+         * RFC6839, section 3.<br/>
+         * For providers, the SSS is used <em>in addition to</em> to the mimetype's main
+         * type. For example, a mediatype of "application/vnd.custom+json" should be
+         * considered compatible with a provider registered as either
+         * "application/vnd.custom+json" or "application/json", but not with "text/json"
+         * or "application/vnd.custom+xml".
+         * </p>
+         * @param providerMediaType the media type of the provider to check for
+         *        compatibility, cannot be <code>null</code>;
+         * @param candidateMediaType the media type of check against, cannot be
+         *        <code>null</code>.
+         * @return <code>true</code> if the given media types are compatible,
+         *         <code>false</code> otherwise.
+         * @see http://tools.ietf.org/html/rfc6838#section-4.2.8
+         * @see http://tools.ietf.org/html/rfc6839#section-3
+         */
+        private boolean areMediaTypesCompatible(MediaType providerMediaType, MediaType candidateMediaType) {
+          if (providerMediaType.isCompatible(candidateMediaType)) {
+            // Easy case: directly compatible media types...
+            return true;
+          }
+
+          // Are main types equal? If not, we're done really quickly...
+          if (!providerMediaType.getType().equals(candidateMediaType.getType())) {
+            return false;
+          }
+
+          // If the provider has a SSS in its subtype, it means that it is *specifically*
+          // registered for that particular subtype + SSS, so do not strip it from the
+          // subtype...
+          String subtype1 = providerMediaType.getSubtype();
+          String subtype2 = candidateMediaType.getSubtype();
+          int idx = subtype2.indexOf('+');
+          if (idx >= 0) {
+            // subtype contains a structured syntax suffix...
+            subtype2 = subtype2.substring(idx + 1);
+          }
+
+          return subtype1.equals(subtype2);
+        }
+
         public Set<MediaType> getProvidersMediaTypes(Class<?> type) {
             Set<MediaType> mediaTypes = new LinkedHashSet<MediaType>();
 
diff --git a/wink-common/src/test/java/org/apache/wink/common/internal/registry/ProvidersRegistryTest.java b/wink-common/src/test/java/org/apache/wink/common/internal/registry/ProvidersRegistryTest.java
@@ -21,16 +21,20 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Set;
 
+import javax.ws.rs.Consumes;
 import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.MultivaluedMap;
 import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
 import javax.ws.rs.ext.Provider;
 
 import junit.framework.TestCase;
@@ -110,6 +114,86 @@ public void testOverrideSystemProvider() throws Exception {
         // make there is only one provider in the list to conform to JAX-RS 4.1 first sentence
         assertEquals(1, readers.size());
     }
+
+    /**
+     * Tests that a structured syntax suffix is handled correctly for determining a writer.
+     *
+     * @throws Exception
+     */
+    public void testProvidesStructuredSyntaxSuffixHandledOk() throws Exception {
+      ProvidersRegistry providersRegistry =
+          new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
+      providersRegistry.addProvider(GenericProvider.class);
+      providersRegistry.addProvider(SpecificProvider.class);
+
+      MediaType mediaType;
+      MessageBodyWriter<String> writer;
+
+      mediaType = MediaType.valueOf("application/json"); // use generic provider
+
+      writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
+      assertTrue(writer instanceof GenericProvider);
+
+      mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider
+
+      writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
+      assertTrue(writer instanceof GenericProvider);
+
+      mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider
+
+      writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
+      assertTrue(writer instanceof SpecificProvider);
+
+      mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic
+
+      writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
+      assertNull(writer);
+
+      mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic
+
+      writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
+      assertNull(writer);
+    }
+
+    /**
+     * Tests that a structured syntax suffix is handled correctly for determining a reader.
+     *
+     * @throws Exception
+     */
+    public void testConsumesStructuredSyntaxSuffixHandledOk() throws Exception {
+      ProvidersRegistry providersRegistry =
+          new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
+      providersRegistry.addProvider(GenericProvider.class);
+      providersRegistry.addProvider(SpecificProvider.class);
+
+      MediaType mediaType;
+      MessageBodyReader<String> reader;
+
+      mediaType = MediaType.valueOf("application/json"); // use generic provider
+
+      reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
+      assertTrue(reader instanceof GenericProvider);
+
+      mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider
+
+      reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
+      assertTrue(reader instanceof GenericProvider);
+
+      mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider
+
+      reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
+      assertTrue(reader instanceof SpecificProvider);
+
+      mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic
+
+      reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
+      assertNull(reader);
+
+      mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic
+
+      reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
+      assertNull(reader);
+    }
     
     // TODO:  perhaps future tests should be added to actually exercise the providersCache code, but it would be an involved,
     // multi-threaded test that dynamically adds providers at just the right time to ensure no problems with
@@ -140,4 +224,69 @@ public String readFrom(Class<String> type, Type genericType,
         }
     }
     
+    @Provider
+    @Produces({"application/subschema+json"})
+    @Consumes({"application/subschema+json"})
+    public static class SpecificProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
+      public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return String.class.isAssignableFrom(type);
+      }
+
+      public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return -1L;
+      }
+
+      public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+          MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
+          WebApplicationException
+      {
+      }
+
+      public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return String.class.isAssignableFrom(type);
+      }
+
+      public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+          MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
+          WebApplicationException
+      {
+        return null;
+      }
+    }
+
+    @Provider
+    @Produces({"application/json"})
+    @Consumes({"application/json"})
+    public static class GenericProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
+      public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return String.class.isAssignableFrom(type);
+      }
+
+      public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return -1L;
+      }
+
+      public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+          MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
+          WebApplicationException
+      {
+      }
+
+      public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
+      {
+        return String.class.isAssignableFrom(type);
+      }
+
+      public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+          MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
+          WebApplicationException
+      {
+        return null;
+      }
+    }
 }
