जर्सी बाकी क्लाइंट - MediaType.APPLICATION_JSON

Question

मैं जर्सी का उपयोग कर JacksonFeature के साथ एक बाकी ग्राहक लिख रहा हूँ एक वेब सेवा है कि मुझे मजबूर करता अपने कस्टम नाम सामग्री प्रकार को निर्दिष्ट करने के लिए सक्षम के रूप में कस्टम MediaType इलाज है, भले ही यह सिर्फ नियमित रूप से JSON है। दूसरे शब्दों में, जब मैं यह करता हूं:

Request request = buildMySampleRequestPojo(); 

Response response = requestBuilder.post(
     Entity.entity(request, MediaType.APPLICATION_JSON) 
); 

सेवा शिकायत करती है कि मैं एक अवैध सामग्री प्रकार का उपयोग कर रहा हूं।

Response response = requestBuilder.post(
     Entity.entity(request, "vnd.stupidNameThatReallyIsJustJSON+json") 
); 

हालांकि, जब मैं ऐसा, मैं मिलता है:: मैं इस के आसपास MediaType.APPLICATION_JSON निरंतर के स्थान पर अपने कस्टम नाम मीडिया प्रकार को निर्दिष्ट करके प्राप्त कर सकते हैं

*SEVERE: MessageBodyWriter not found for media type=stupidNameThatReallyIsJustJSON* 

वहाँ एक रास्ता है मैं जर्सी को इस अनुकूलित मीडिया प्रकार के नाम का इलाज कर सकता हूं जैसे कि यह एक नियमित संदेशबॉडीवाइटर लिखने के बिना नियमित JSON थे?

Answer 1

मुझे लगता है कि आप जो चाहते हैं उसे प्राप्त करने के लिए आप this (JAX-RS entity providers) और this (use Jackson with Jersey) दोनों का उपयोग कर सकते हैं। संक्षेप में, @Produces("application/vnd.stupidNameThatReallyIsJustJSON+json") के साथ एनोटेटेड MessageBodyWriter पंजीकृत करें और कार्यान्वयन में केवल जैक्सन के लिए मार्शलिंग/अनमर्शलिंग का प्रतिनिधि दें।

संपादित करें:

package my.pack.age; 

import com.sun.jersey.core.provider.AbstractMessageReaderWriterProvider; 
import com.sun.jersey.core.util.ReaderWriter; 

import javax.ws.rs.Produces; 
import javax.ws.rs.WebApplicationException; 
import javax.ws.rs.core.MediaType; 
import javax.ws.rs.core.MultivaluedMap; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.lang.annotation.Annotation; 
import java.lang.reflect.Type; 

@Produces("application/vnd.stupidNameThatReallyIsJustJSON+json") 
public class MyJsonBodyWriter<T> extends AbstractMessageReaderWriterProvider<T> { 

    // T should be your pojo in this case. If you can make your pojo compatible with org.codehaus.jettison.json.JSONObject, 
    // then you can extend com.sun.jersey.json.impl.provider.entity.JSONObjectProvider and delegate all the methods of 
    // MessageBodyWriter (and MessageBodyReader) to that. Otherwise just implement them. 

    @Override 
    public T readFrom(Class<T> type, Type genericType, Annotation annotations[], MediaType mediaType,MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException { 
     try { 
//   deserialize entityStream according to the given media type and return a new instance of T. 
//    
//   You can do it like this (just an example) : 
//   JSONObject myObject = new JSONObject(); 
//   try { 
//    these names and values should come from the stream. 
//    myObject.put("name", "Agamemnon"); 
//    myObject.put("age", 32); 
//   } catch (JSONException ex) { 
//    LOGGER.log(Level.SEVERE, "Error ...", ex); 
//   } 
      return null; 
     } catch (Exception e) { 
      throw new WebApplicationException(new Exception("Error during deserialization", e),400); 
     } 
    } 

     @Override 
    public void writeTo(T t,Class<?> type, Type genericType, Annotation annotations[], MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException { 
     try { 
      OutputStreamWriter writer = new OutputStreamWriter(entityStream, ReaderWriter.getCharset(mediaType)); 
      // write t on the writer 
      writer.flush(); 
     } catch (Exception e) { 
      throw new WebApplicationException(new Exception("Error during serialization", e), 500); 
     } 
    } 

    @Override 
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { 
     // should return true if this class can serialize the given type to the given media type 
     return true; 
    } 

    @Override 
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { 
     // should return true if this class can deserialize the given type to the given media type 
     return true; 
    } 

    @Override 
    public long getSize(T t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { 
     // calculate and return content-lenght, i.e. the lenght of the serialized representation of t 
     return 0; 
    } 

} 

की तर्ज पर कुछ के साथ की कोशिश जाहिर है यह सिर्फ एक प्रारंभिक बिंदु, नहीं एक काम उदाहरण है, लेकिन यह आप के लिए पर्याप्त जानकारी शुरू करने के लिए देना चाहिए। यह भी याद रखें कि इसे कक्षा का उपयोग करने के लिए इसे जर्सी में पंजीकृत करना होगा।