Java Examples for org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

@Bean
public RestTemplate restTemplate(HttpMessageConverters converters) {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {

        @Override
        protected boolean hasError(HttpStatus statusCode) {
            return statusCode != HttpStatus.NOT_FOUND && super.hasError(statusCode);
        }
    });
    List<? extends HttpMessageConverter<?>> httpMessageConverters = Collections.singletonList(new MappingJackson2HttpMessageConverter());
    restTemplate.setMessageConverters((List<HttpMessageConverter<?>>) httpMessageConverters);
    return restTemplate;
}

public RestTemplate get() {
    final RestTemplate restTemplate = new RestTemplate(new SimpleClientHttpRequestFactory());
    //remove the existing MappingJacksonHttpMessageConverter - we're going to be using our own
    final Iterator<HttpMessageConverter<?>> iterator = restTemplate.getMessageConverters().iterator();
    while (iterator.hasNext()) {
        final HttpMessageConverter<?> converter = iterator.next();
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            iterator.remove();
        }
    }
    //handle json data
    final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    jsonConverter.setObjectMapper(jsonObjectMapper);
    restTemplate.getMessageConverters().add(0, jsonConverter);
    return restTemplate;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    MappingJackson2HttpMessageConverter jackson = new MappingJackson2HttpMessageConverter();
    jackson.setObjectMapper(new CustomObjectMapper());
    jackson.getObjectMapper().disable(SerializationFeature.WRITE_NULL_MAP_VALUES).enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING).setSerializationInclusion(JsonInclude.Include.NON_NULL);
    converters.add(jackson);
}

private void findJacksonMapperAndReplaceObjectMapper(List<HttpMessageConverter<?>> messageConverters) {
    MappingJackson2HttpMessageConverter jacksonMapper = (MappingJackson2HttpMessageConverter) Iterables.find(messageConverters, Predicates.instanceOf(MappingJackson2HttpMessageConverter.class));
    jacksonMapper.setObjectMapper(new ObjectMapperTestBuilder(memberRepository).buildObjectMapper());
}

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof MappingJackson2HttpMessageConverter) {
        MappingJackson2HttpMessageConverter jsonConverter = (MappingJackson2HttpMessageConverter) bean;
        ObjectMapper objectMapper = jsonConverter.getObjectMapper();
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //            objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        jsonConverter.setObjectMapper(objectMapper);
    }
    return bean;
}

@Override
public RestTemplate createRestTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    // Set Converters
    final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    final List<HttpMessageConverter<?>> listHttpMessageConverters = restTemplate.getMessageConverters();
    listHttpMessageConverters.add(jsonConverter);
    restTemplate.setMessageConverters(listHttpMessageConverters);
    return restTemplate;
}

@Override
protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new ByteArrayHttpMessageConverter());
    super.addDefaultHttpMessageConverters(converters);
    for (HttpMessageConverter<?> converter : converters) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            ((MappingJackson2HttpMessageConverter) converter).setObjectMapper(ObjectMappers.getJsonMapper());
        }
    }
}

@Override
public RestTemplate createRestTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    // web services support json responses
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    final List<HttpMessageConverter<?>> listHttpMessageConverters = restTemplate.getMessageConverters();
    listHttpMessageConverters.add(jsonConverter);
    restTemplate.setMessageConverters(listHttpMessageConverters);
    return restTemplate;
}

/**
     *jackson个性化�置
     * @return MappingJackson2HttpMessageConverter
     */
private MappingJackson2HttpMessageConverter createFastJsonHttpMessageConverter() {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    jsonConverter.setObjectMapper(objectMapper);
    return jsonConverter;
}

/**
     * This method creates a custom {@link org.springframework.http.converter.HttpMessageConverter} which ensures that:
     *
     * <ul>
     *     <li>Null values are ignored.</li>
     *     <li>
     *         The new Java 8 date objects are serialized in standard
     *         <a href="http://en.wikipedia.org/wiki/ISO_8601" target="_blank">ISO-8601</a> string representation.
     *     </li>
     * </ul>
     *
     * @return
     */
static MappingJackson2HttpMessageConverter jacksonDateTimeConverter() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    objectMapper.registerModule(new JSR310Module());
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(objectMapper);
    return converter;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    addDefaultHttpMessageConverters(converters);
    for (HttpMessageConverter<?> converter : converters) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = (MappingJackson2HttpMessageConverter) converter;
            jackson2HttpMessageConverter.setObjectMapper(objectMapper);
            break;
        }
    }
}

//    @Autowired
//    private SessionFactory sessionFactory;
@Bean
public MappingJackson2HttpMessageConverter jacksonMessageConverter() {
    MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper mapper = new ObjectMapper();
    //Registering Hibernate4Module to support lazy objects
    mapper.registerModule(new Hibernate4Module());
    messageConverter.setObjectMapper(mapper);
    return messageConverter;
}

public String getGoogleTopResult(String keyword) {
    try {
        // http://code.google.com/apis/websearch/docs/#fonje
        final String url = "https://ajax.googleapis.com/ajax/services/search/web?v=1.0" + //
        "&q=" + keyword + //
        "&key=" + apiKey + "&userip=" + InetAddress.getLocalHost().getHostAddress();
        MappingJackson2HttpMessageConverter conv = new MappingJackson2HttpMessageConverter();
        conv.setSupportedMediaTypes(Collections.singletonList(new MediaType("text", "javascript", Charset.forName("UTF-8"))));
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(conv);
        SearchResponse res = restTemplate.getForObject(url, SearchResponse.class);
        if (res.responseData != null && ArrayUtils.isNotEmpty(res.responseData.results)) {
            SearchResult result = res.responseData.results[0];
            // HTML 코드 처리
            return result.content.replace("<b>", HIGH_INTENSITY).replace("</b>", LOW_INTENSITY).replace(""", "\"").replace("'", "'").replace(">", ">").replace("<", "<").replace("&", "&").replace("\n", "") + " : " + result.unescapedUrl;
        }
    } catch (IOException e) {
        logger.warn(e.getMessage(), e);
    }
    return null;
}

private static boolean checkSpring() {
    try {
        Class.forName("org.springframework.web.context.request.async.DeferredResult");
        Class.forName("org.springframework.web.client.RestTemplate");
        Class.forName("org.springframework.http.converter.json.MappingJackson2HttpMessageConverter");
        Class.forName("org.springframework.util.LinkedMultiValueMap");
        Class.forName("org.springframework.util.MultiValueMap");
        Class.forName("org.springframework.http.HttpHeaders");
        Class.forName("org.springframework.http.HttpMethod");
        Class.forName("org.springframework.http.RequestEntity");
        Class.forName("org.springframework.http.ResponseEntity");
        Class.forName("org.springframework.http.converter.HttpMessageNotWritableException");
        Class.forName("org.springframework.util.MultiValueMap");
        Class.forName("org.springframework.web.client.HttpStatusCodeException");
        Class.forName("org.springframework.web.client.RestTemplate");
        Class.forName("org.springframework.core.ParameterizedTypeReference");
    } catch (ClassNotFoundException e) {
        return false;
    }
    return true;
}

@Test
public void test() {
    RestTemplate rt = new RestTemplate();
    rt.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    rt.getMessageConverters().add(new StringHttpMessageConverter());
    MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
    params.add("username", "pnema");
    params.add("password", "a5c527de-c77d-4b74-9186-efc3f29d65ef");
    params.add("queryName", "getUserByNameAuth");
    final User user = new User();
    try {
        JsonNode obj = rt.postForObject(OTF_SERVICE_URL, params, JsonNode.class);
        JsonNode userObj = obj.get("user");
        String userName = userObj.findValue("name").asText();
        String status = userObj.findValue("status").asText();
        Assert.notNull(status, "Status can not be empty");
        user.setUsername(userName);
        assertNotNull(user);
        //now check if user has access to Refset app.
        params = new LinkedMultiValueMap<String, String>();
        params.add("username", "pnema");
        params.add("queryName", "getUserApps");
        JsonNode appJson = rt.postForObject(OTF_SERVICE_URL, params, JsonNode.class);
        assertNotNull(appJson);
        JsonNode apps = appJson.get("apps");
        if (apps.isArray()) {
            for (Object object : apps) {
                System.out.println(object);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    jsonConverter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    objectMapper.registerModule(new Jackson2HalModule());
    jsonConverter.setObjectMapper(objectMapper);
    return jsonConverter;
}

@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    jsonConverter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    objectMapper.registerModule(new Jackson2HalModule());
    jsonConverter.setObjectMapper(objectMapper);
    return jsonConverter;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new StringHttpMessageConverter());
    //correct order
    //converters.add(httpMessageConverterConfig.mappingJackson2HttpMessageConverter());
    //converters.add(httpMessageConverterConfig.mappingJackson2XmlHttpMessageConverter());
    //NOT correct order
    converters.add(new MappingJackson2XmlHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
}

/* On POST to /token Microsoft returns JSON as "text/html" (should be application/json), which results in:
    ---
    org.springframework.web.client.RestClientException: Could not extract response: no suitable
    HttpMessageConverter found for response type [interface java.util.Map] and content type
    [text/html;charset=utf-8]
    ---
    Adding support for handling text/html to the MappingJackson2HttpMessageConverter */
@Override
protected RestTemplate createRestTemplate() {
    RestTemplate template = super.createRestTemplate();
    for (HttpMessageConverter<?> converter : template.getMessageConverters()) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            List<MediaType> supportedMediaTypes = new ArrayList<MediaType>();
            // Add all default
            supportedMediaTypes.addAll(converter.getSupportedMediaTypes());
            // And also handle text/html json returned on POST to /token
            supportedMediaTypes.add(new MediaType("text", "html", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET));
            ((MappingJackson2HttpMessageConverter) converter).setSupportedMediaTypes(supportedMediaTypes);
        }
    }
    return template;
}

@Bean
public RestTemplate restTemplate() {
    final RestTemplate restTemplate = new RestTemplate();
    for (int i = 0; i < restTemplate.getMessageConverters().size(); i++) {
        final HttpMessageConverter<?> httpMessageConverter = restTemplate.getMessageConverters().get(i);
        if (httpMessageConverter instanceof MappingJackson2HttpMessageConverter) {
            restTemplate.getMessageConverters().set(i, httpMessageConverter);
        }
    }
    return restTemplate;
}

@Override
protected MappingJackson2HttpMessageConverter getJsonMessageConverter() {
    MappingJackson2HttpMessageConverter converter = super.getJsonMessageConverter();
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
    mapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
    mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
    mapper.registerModule(new TradeKingModule());
    mapper.registerModule(new JodaModule());
    converter.setObjectMapper(mapper);
    return converter;
}

private static final MappingJackson2HttpMessageConverter getHalConverter() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new Jackson2HalModule());
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(mapper);
    converter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
    return converter;
}

/**
     * generate BRAT JSON for the collection informations
     *
     * @throws IOException if an I/O error occurs.
     */
@Test
public void testGenerateBratJsonGetCollection() throws IOException {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    String jsonFilePath = "target/test-output/output_cas_to_json_collection.json";
    GetCollectionInformationResponse collectionInformation = new GetCollectionInformationResponse();
    List<AnnotationLayer> layerList = new ArrayList<AnnotationLayer>();
    AnnotationLayer layer = new AnnotationLayer();
    layer.setDescription("span annoattion");
    layer.setName("pos");
    layer.setType(WebAnnoConst.SPAN_TYPE);
    TagSet tagset = new TagSet();
    tagset.setDescription("pos");
    tagset.setLanguage("de");
    tagset.setName("STTS");
    Tag tag = new Tag();
    tag.setDescription("noun");
    tag.setName("NN");
    tag.setTagSet(tagset);
    layerList.add(layer);
    collectionInformation.addCollection("/Collection1/");
    collectionInformation.addCollection("/Collection2/");
    collectionInformation.addCollection("/Collection3/");
    collectionInformation.addDocument("/Collection1/doc1");
    collectionInformation.addDocument("/Collection2/doc1");
    collectionInformation.addDocument("/Collection3/doc1");
    collectionInformation.addDocument("/Collection1/doc2");
    collectionInformation.addDocument("/Collection2/doc2");
    collectionInformation.addDocument("/Collection3/doc2");
    collectionInformation.setSearchConfig(new ArrayList<String[]>());
    List<String> tagSetNames = new ArrayList<String>();
    tagSetNames.add(de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst.POS);
    tagSetNames.add(de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst.DEPENDENCY);
    tagSetNames.add(de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst.NAMEDENTITY);
    tagSetNames.add(de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst.COREFERENCE);
    tagSetNames.add(de.tudarmstadt.ukp.clarin.webanno.api.WebAnnoConst.COREFRELTYPE);
    JSONUtil.generatePrettyJson(jsonConverter, collectionInformation, new File(jsonFilePath));
    String reference = FileUtils.readFileToString(new File("src/test/resources/output_cas_to_json_collection_expected.json"), "UTF-8");
    String actual = FileUtils.readFileToString(new File("target/test-output/output_cas_to_json_collection.json"), "UTF-8");
    assertEquals(reference, actual);
}

@SuppressWarnings("Duplicates")
private RestTemplate buildRestTemplate() {
    final MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter();
    final List<MediaType> supportedMediaTypes = new ArrayList<MediaType>();
    supportedMediaTypes.add(MediaType.TEXT_PLAIN);
    supportedMediaTypes.add(MediaType.APPLICATION_JSON);
    jsonMessageConverter.setSupportedMediaTypes(supportedMediaTypes);
    return restTemplateBuilder.additionalMessageConverters(jsonMessageConverter).additionalMessageConverters(new FormHttpMessageConverter()).build();
}

@Before
public void setup() {
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
    converters.add(new StringHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
    this.restTemplate = new RestTemplate();
    this.restTemplate.setMessageConverters(converters);
    this.mockServer = MockRestServiceServer.createServer(this.restTemplate);
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}

/**
     * Render model and view.
     *
     * @param model the model
     * @param response the response
     */
public static void render(final Object model, final HttpServletResponse response) {
    try {
        final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
        jsonConverter.setPrettyPrint(true);
        final MediaType jsonMimeType = MediaType.APPLICATION_JSON;
        jsonConverter.write(model, jsonMimeType, new ServletServerHttpResponse(response));
    } catch (final Exception e) {
        throw Throwables.propagate(e);
    }
}

/**
	 * configure the message converters with the date formatter.
	 */
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    // Configure JSON support
    MappingJackson2HttpMessageConverter mappingJacksonHttpMessageConverter = new MappingJackson2HttpMessageConverter();
    mappingJacksonHttpMessageConverter.setSupportedMediaTypes(Arrays.asList(MediaType.APPLICATION_JSON));
    //mappingJacksonHttpMessageConverter.getObjectMapper().configure(
    //		Feature.WRITE_DATES_AS_TIMESTAMPS, true);
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:SS");
    // There is no need to set the timezone as Jackson uses GMT and not the
    // local time zone (which is exactly what you want)
    // Note: While SimpleDateFormat is not threadsafe, Jackson Marshaller's
    // StdSerializerProvider clones the configured formatter for each thread
    mappingJacksonHttpMessageConverter.getObjectMapper().setDateFormat(format);
    //mappingJacksonHttpMessageConverter.getObjectMapper().configure(
    //		Feature.INDENT_OUTPUT, true);
    // mappingJacksonHttpMessageConverter.getObjectMapper().getSerializationConfig().setSerializationInclusion(Inclusion.NON_NULL);
    converters.add(mappingJacksonHttpMessageConverter);
}

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    this.mockMvc = standaloneSetup(controller).setMessageConverters(new MappingJackson2HttpMessageConverter()).build();
    when(orderService.createOrder(any(CreateOrderEvent.class))).thenReturn(orderCreated(UUID.fromString("f3512d26-72f6-4290-9265-63ad69eccc13")));
}

protected RestTemplate getRestTemplate() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.registerModule(new Jackson2HalModule());
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
    converter.setObjectMapper(mapper);
    return new RestTemplate(Collections.<HttpMessageConverter<?>>singletonList(converter));
}

private RestTemplate createRestTemplate() {
    // jackson message converter
    MappingJackson2HttpMessageConverter mappingJacksonHttpMessageConverter = new MappingJackson2HttpMessageConverter();
    mappingJacksonHttpMessageConverter.setObjectMapper(objectMapper);
    // create message converters list
    List<HttpMessageConverter<?>> httpMessageConverters = new ArrayList<HttpMessageConverter<?>>();
    httpMessageConverters.add(mappingJacksonHttpMessageConverter);
    // create rest template
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(httpMessageConverters);
    // configure proxy
    HttpHost httpHost = new HttpHost(System.getProperty("http.proxyHost"), Integer.parseInt(System.getProperty("http.proxyPort")));
    DefaultProxyRoutePlanner defaultProxyRoutePlanner = new DefaultProxyRoutePlanner(httpHost);
    HttpClient httpClient = HttpClients.custom().setRoutePlanner(defaultProxyRoutePlanner).build();
    restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
    return restTemplate;
}

private List<HttpMessageConverter<?>> getHttpMessageConverters() {
    List<HttpMessageConverter<?>> converters = new ArrayList<>();
    converters.add(new StringHttpMessageConverter(Charset.forName("UTF-8")));
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new Jackson2HalModule());
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(mapper);
    converter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
    converters.add(converter);
    return converters;
}

protected HttpMessageConvertingResponseWriter createResponseWriter() {
    ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
    factoryBean.afterPropertiesSet();
    ContentNegotiationManager contentNegotiationManager = factoryBean.getObject();
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
    List<JsonSerializer<?>> serializers = new ArrayList<>();
    serializers.add(new ObjectIdSerializer());
    Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<>();
    deserializers.put(ObjectId.class, new ObjectIdDeserializer());
    CustomSerializationObjectMapper objectMapper = new CustomSerializationObjectMapper();
    objectMapper.setSerializers(serializers);
    objectMapper.setDeserializers(deserializers);
    objectMapper.init();
    MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter();
    jsonMessageConverter.setObjectMapper(objectMapper);
    messageConverters.add(jsonMessageConverter);
    return new HttpMessageConvertingResponseWriter(contentNegotiationManager, messageConverters);
}

@Test
public void mock_mvc_example_for_get_greeting_controller() throws Exception {
    MockMvc mockMvc = standaloneSetup(new GreetingController()).setMessageConverters(new MappingJackson2HttpMessageConverter()).build();
    String contentAsString = mockMvc.perform(get("/greeting?name={name}", "Johan").accept(APPLICATION_JSON)).andReturn().getResponse().getContentAsString();
    JsonPath jsonPath = new JsonPath(contentAsString);
    assertThat(jsonPath.getInt("id"), equalTo(1));
    assertThat(jsonPath.getString("content"), equalTo("Hello, Johan!"));
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    for (HttpMessageConverter<?> httpMessageConverter : converters) {
        if (httpMessageConverter instanceof MappingJackson2HttpMessageConverter) {
            final MappingJackson2HttpMessageConverter converter = (MappingJackson2HttpMessageConverter) httpMessageConverter;
            converter.getObjectMapper().addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class);
        }
    }
}

/**
	 * Configures the Jackson {@link ObjectMapper} to ignore unknown properties on the client side. E.g.
	 * {@link LineItem#getTotal()} causes Jackson to consider {@code total} a property and fails to bind the object as
	 * there's no setter accepting a value.
	 * 
	 * @return
	 */
@Bean
public RestOperations restOperations() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(mapper);
    converter.setSupportedMediaTypes(Arrays.asList(MediaType.APPLICATION_JSON));
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
    converters.add(converter);
    RestTemplate template = new RestTemplate();
    template.setMessageConverters(converters);
    return template;
}

@Test
public void resolveArgumentParameterizedType() throws Exception {
    String content = "[{\"name\" : \"Jad\"}, {\"name\" : \"Robert\"}]";
    this.servletRequest.setContent(content.getBytes("UTF-8"));
    this.servletRequest.setContentType(MediaType.APPLICATION_JSON_VALUE);
    List<HttpMessageConverter<?>> converters = new ArrayList<>();
    converters.add(new MappingJackson2HttpMessageConverter());
    RequestResponseBodyMethodProcessor processor = new RequestResponseBodyMethodProcessor(converters);
    @SuppressWarnings("unchecked") List<SimpleBean> result = (List<SimpleBean>) processor.resolveArgument(paramGenericList, container, request, factory);
    assertNotNull(result);
    assertEquals("Jad", result.get(0).getName());
    assertEquals("Robert", result.get(1).getName());
}

/**
	 * Creates a new {@link HttpMessageConverter} to support HAL.
	 * 
	 * @return
	 */
private static final HttpMessageConverter<?> getHalConverter() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new Jackson2HalModule());
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(mapper);
    converter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
    return converter;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
    stringConverter.setWriteAcceptCharset(false);
    // if your argument is a byte[]
    converters.add(new ByteArrayHttpMessageConverter());
    converters.add(stringConverter);
    converters.add(new FormHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
    converters.add(jaxbConverter());
    converters.add(new ResourceHttpMessageConverter());
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new ByteArrayHttpMessageConverter());
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
    stringConverter.setWriteAcceptCharset(false);
    converters.add(stringConverter);
    converters.add(new ResourceHttpMessageConverter());
    converters.add(new SourceHttpMessageConverter<>());
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setPrettyPrint(true);
    converters.add(converter);
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    log.info("Configuring http message converters...");
    MappingJackson2HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter();
    List<MediaType> types = new ArrayList<>(1);
    types.add(ApplicationMediaType.APPLICATION_JSON);
    types.add(ApplicationMediaType.APPLICATION_BEARCHOKE_V1_JSON);
    types.add(ApplicationMediaType.APPLICATION_BEARCHOKE_V2_JSON);
    jacksonConverter.setSupportedMediaTypes(types);
    jacksonConverter.setObjectMapper(objectMapper);
    converters.add(jacksonConverter);
}

@Override
public Map<String, Object> createUser(Serializable userData) throws IdManagementException {
    UAAUserRequest req = (UAAUserRequest) userData;
    HTTPClient<HashMap<String, Object>> http = new HTTPClient<>();
    ResponseEntity<HashMap> responseEntity = null;
    String url = this.UAAUrl + "/Users";
    HttpHeaders headers = http.createBasicAuthenticationHttpHeaders(username, password);
    LOG.debug("Setting token to:" + getOauthAdminAuthToken());
    LOG.info("Retrieving token from UAA successful");
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.set("Authorization", "Bearer " + getOauthAdminAuthToken());
    headers.add("Accept", "application/json;charset=utf-8");
    RestTemplate restTemplate = new RestTemplate();
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
    messageConverters.add(new MappingJackson2HttpMessageConverter());
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    restTemplate.setMessageConverters(messageConverters);
    try {
        HttpEntity request = new HttpEntity(req, headers);
        responseEntity = restTemplate.exchange(url, HttpMethod.POST, request, HashMap.class);
    } catch (HttpClientErrorException ce) {
        if (ce.getStatusCode().equals(HttpStatus.CONFLICT))
            throw new IdManagementException("Username already exists", null, LOG, "Conflict while attempting to create a user " + url + " response: " + ce.getResponseBodyAsString(), Level.ERROR, ce.getStatusCode().value());
        if (ce.getStatusCode().equals(HttpStatus.UNAUTHORIZED))
            throw new IdManagementException("An error ocurred during HTTP communication", ce, LOG, "Admin account in UAA is not authorized to create users!. This shouldn't happen!! HttClientError  while attempting to create a User. StatusCode:" + ce.getStatusCode() + ce.getStatusText() + " response Message" + ce.getResponseBodyAsString(), Level.ERROR, 500);
        throw new IdManagementException("An error ocurred during HTTP communication", ce, LOG, "HttClientError  while attempting to create a User. StatusCode:" + ce.getStatusCode() + ce.getStatusText() + " response Message" + ce.getResponseBodyAsString(), Level.ERROR, 500);
    } catch (Exception e) {
        throw new IdManagementException("An error ocurred during HTTP communication", e, LOG, "Unknown exception while trying to create a user: Exception" + e.getClass(), Level.ERROR, 500);
    }
    if (!responseEntity.getStatusCode().equals(HttpStatus.CREATED) && !responseEntity.getStatusCode().equals(HttpStatus.OK))
        LOG.error("Error ocurred during creation or a UAA user, status code: " + responseEntity.getStatusCode().value());
    return responseEntity.getBody();
}

protected List<HttpMessageConverter<?>> getHttpMessageConverters() {
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
    messageConverters.add(new ByteArrayHttpMessageConverter());
    messageConverters.add(new StringHttpMessageConverter());
    messageConverters.add(new ResourceHttpMessageConverter());
    messageConverters.add(new MappingJackson2HttpMessageConverter());
    return messageConverters;
}

@Override
public RestTemplate createRestTemplate() {
    RestTemplate restTemplate = new RestTemplate() {

        @Override
        protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
            ClientHttpRequest request = super.createRequest(url, method);
            HttpHeaders headers = request.getHeaders();
            headers.setAcceptEncoding(ContentCodingType.GZIP);
            return request;
        }
    };
    // bug on http connection for Android < 2.2
    // http://android-developers.blogspot.fr/2011/09/androids-http-clients.html
    // but still a problem for upload with Spring-android on android 4.1
    System.setProperty("http.keepAlive", "false");
    // set timeout for requests
    ClientHttpRequestFactory factory = restTemplate.getRequestFactory();
    if (factory instanceof HttpComponentsClientHttpRequestFactory) {
        HttpComponentsClientHttpRequestFactory advancedFactory = (HttpComponentsClientHttpRequestFactory) factory;
        advancedFactory.setConnectTimeout(WEBSERVICES_TIMEOUT);
        advancedFactory.setReadTimeout(WEBSERVICES_TIMEOUT);
    } else if (factory instanceof SimpleClientHttpRequestFactory) {
        SimpleClientHttpRequestFactory advancedFactory = (SimpleClientHttpRequestFactory) factory;
        advancedFactory.setConnectTimeout(WEBSERVICES_TIMEOUT);
        advancedFactory.setReadTimeout(WEBSERVICES_TIMEOUT);
    }
    // web services support json responses
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    FormHttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
    StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
    final List<HttpMessageConverter<?>> listHttpMessageConverters = restTemplate.getMessageConverters();
    listHttpMessageConverters.add(jsonConverter);
    listHttpMessageConverters.add(formHttpMessageConverter);
    listHttpMessageConverters.add(stringHttpMessageConverter);
    restTemplate.setMessageConverters(listHttpMessageConverters);
    return restTemplate;
}

public RTM startRTM(String slackToken) {
    try {
        restTemplate = new RestTemplate();
        rtm = new RTM();
        // Custom Deserializers
        List<HttpMessageConverter<?>> httpMessageConverters = new ArrayList<>();
        MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
        Jackson2ObjectMapperBuilder mapperBuilder = new Jackson2ObjectMapperBuilder();
        mapperBuilder.deserializerByType(RTM.class, new JsonDeserializer<RTM>() {

            @Override
            public RTM deserialize(JsonParser p, DeserializationContext ctxt) {
                try {
                    final ObjectMapper objectMapper = new ObjectMapper();
                    JsonNode node = p.readValueAsTree();
                    RTM rtm = new RTM();
                    rtm.setWebSocketUrl(node.get("url").asText());
                    rtm.setUser(objectMapper.treeToValue(node.get("self"), User.class));
                    List<String> dmChannels = new ArrayList<>();
                    Iterator<JsonNode> iterator = node.get("ims").iterator();
                    while (iterator.hasNext()) {
                        dmChannels.add(iterator.next().get("id").asText());
                    }
                    rtm.setDmChannels(dmChannels);
                    List<User> users = new ArrayList<>();
                    Iterator<JsonNode> userIterator = node.get("users").iterator();
                    while (userIterator.hasNext()) {
                        users.add(objectMapper.treeToValue(userIterator.next(), User.class));
                    }
                    rtm.setUsers(users);
                    return rtm;
                } catch (Exception e) {
                    logger.error("Error de-serializing RTM.start(): ", e);
                    return null;
                }
            }
        });
        jsonConverter.setObjectMapper(mapperBuilder.build());
        httpMessageConverters.add(jsonConverter);
        restTemplate.setMessageConverters(httpMessageConverters);
        ResponseEntity<RTM> response = restTemplate.getForEntity(rtmUrl, RTM.class, slackToken);
        if (response.getBody() != null) {
            rtm.setWebSocketUrl(response.getBody().getWebSocketUrl());
            rtm.setDmChannels(response.getBody().getDmChannels());
            rtm.setUser(response.getBody().getUser());
            rtm.setUsers(response.getBody().getUsers());
            logger.debug("RTM connection successful. WebSocket URL: {}", rtm.getWebSocketUrl());
        } else {
            logger.debug("RTM response invalid. Response: {}", response);
        }
    } catch (RestClientException e) {
        logger.error("RTM connection error. Exception: {}", e.getMessage());
    }
    return rtm;
}

private RestTemplate provideRestTemplate(ConfigurableListableBeanFactory configurableListableBeanFactory) {
    if (beanResolver.beanNotDefinedExplicitly(configurableListableBeanFactory, RestTemplate.class)) {
        ArrayList<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        messageConverters.add(new StringHttpMessageConverter());
        messageConverters.add(new MappingJackson2HttpMessageConverter());
        configurableListableBeanFactory.registerSingleton(RESTEETH_REST_TEMPLATE_BEAN_NAME, new RestTemplate(messageConverters));
    }
    return configurableListableBeanFactory.getBean(RestTemplate.class);
}

@Override
protected String doInBackground(MediaType... params) {
    try {
        if (params.length <= 0) {
            return null;
        }
        MediaType mediaType = params[0];
        // The URL for making the POST request
        final String url = getString(R.string.base_uri) + "/sendmessage";
        HttpHeaders requestHeaders = new HttpHeaders();
        // Sending a JSON or XML object i.e. "application/json" or "application/xml"
        requestHeaders.setContentType(mediaType);
        // Populate the Message object to serialize and headers in an
        // HttpEntity object to use for the request
        HttpEntity<Message> requestEntity = new HttpEntity<Message>(message, requestHeaders);
        // Create a new RestTemplate instance
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
        if (mediaType == MediaType.APPLICATION_JSON) {
            restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
        } else if (mediaType == MediaType.APPLICATION_XML) {
            restTemplate.getMessageConverters().add(new SimpleXmlHttpMessageConverter());
        }
        // Make the network request, posting the message, expecting a String in response from the server
        ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        // Return the response body to display to the user
        return response.getBody();
    } catch (Exception e) {
        Log.e(TAG, e.getMessage(), e);
    }
    return null;
}

@Test
public void jacksonMapperPresentFromDefault() {
    AdminServerWebConfiguration config = new AdminServerWebConfiguration(null, null, null, null);
    List<HttpMessageConverter<?>> converters = new ArrayList<>();
    converters.add(new MappingJackson2HttpMessageConverter());
    config.extendMessageConverters(converters);
    assertThat(converters, hasItem(isA(MappingJackson2HttpMessageConverter.class)));
    assertThat(converters.size(), is(1));
}

private static void initRestTemplate() {
    // 长连接��30秒
    PoolingHttpClientConnectionManager pollingConnectionManager = new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
    // 总连接数
    pollingConnectionManager.setMaxTotal(1000);
    // �路由的并�数
    pollingConnectionManager.setDefaultMaxPerRoute(1000);
    HttpClientBuilder httpClientBuilder = HttpClients.custom();
    httpClientBuilder.setConnectionManager(pollingConnectionManager);
    // �试次数，默认是3次，没有开�
    httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(2, true));
    // ��长连接�置，需�在头添加Keep-Alive
    httpClientBuilder.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy());
    //        RequestConfig.Builder builder = RequestConfig.custom();
    //        builder.setConnectionRequestTimeout(200);
    //        builder.setConnectTimeout(5000);
    //        builder.setSocketTimeout(5000);
    //
    //        RequestConfig requestConfig = builder.build();
    //        httpClientBuilder.setDefaultRequestConfig(requestConfig);
    List<Header> headers = new ArrayList<>();
    headers.add(new BasicHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.16 Safari/537.36"));
    headers.add(new BasicHeader("Accept-Encoding", "gzip,deflate"));
    headers.add(new BasicHeader("Accept-Language", "zh-CN"));
    headers.add(new BasicHeader("Connection", "Keep-Alive"));
    httpClientBuilder.setDefaultHeaders(headers);
    HttpClient httpClient = httpClientBuilder.build();
    // httpClient连接�置，底层是�置RequestConfig
    HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
    // 连接超时
    clientHttpRequestFactory.setConnectTimeout(5000);
    // 数�读�超时时间，�SocketTimeout
    clientHttpRequestFactory.setReadTimeout(5000);
    // 连接�够用的等待时间，�宜过长，必须设置，比如连接�够用时，时间过长将是�难性的
    clientHttpRequestFactory.setConnectionRequestTimeout(200);
    // 缓冲请求数�，默认值是true。通过POST或者PUT大���数�时，建议将此属性更改为false，以�耗尽内存。
    // clientHttpRequestFactory.setBufferRequestBody(false);
    // 添加内容转�器
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
    messageConverters.add(new StringHttpMessageConverter(Charset.forName("UTF-8")));
    messageConverters.add(new FormHttpMessageConverter());
    messageConverters.add(new MappingJackson2XmlHttpMessageConverter());
    messageConverters.add(new MappingJackson2HttpMessageConverter());
    restTemplate = new RestTemplate(messageConverters);
    restTemplate.setRequestFactory(clientHttpRequestFactory);
    restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
    LOGGER.info("RestClient�始化完�");
}

@Before
public void setup() {
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
    converters.add(new StringHttpMessageConverter());
    converters.add(new Jaxb2RootElementHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
    restTemplate.setMessageConverters(converters);
    initializeDatabase();
}

@Override
protected MappingJackson2HttpMessageConverter getJsonMessageConverter() {
    MappingJackson2HttpMessageConverter converter = super.getJsonMessageConverter();
    converter.setSupportedMediaTypes(Arrays.asList(new MediaType("text", "javascript")));
    objectMapper = new ObjectMapper();
    objectMapper.registerModule(new MixcloudModule());
    converter.setObjectMapper(objectMapper);
    return converter;
}

// private helper
private void registerTripItJsonModule(RestTemplate restTemplate) {
    List<HttpMessageConverter<?>> converters = restTemplate.getMessageConverters();
    for (HttpMessageConverter<?> converter : converters) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            MappingJackson2HttpMessageConverter jsonConverter = (MappingJackson2HttpMessageConverter) converter;
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.registerModule(new TripItModule());
            jsonConverter.setObjectMapper(objectMapper);
        }
    }
}

@Override
protected MappingJackson2HttpMessageConverter getJsonMessageConverter() {
    MappingJackson2HttpMessageConverter converter = super.getJsonMessageConverter();
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new WunderlistModule());
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    converter.setObjectMapper(mapper);
    return converter;
}

public static RestTemplate buildRestTemplate(String adminUri, String user, String password) {
    BasicCredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT), new UsernamePasswordCredentials(user, password));
    HttpClient httpClient = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
    // Set up pre-emptive basic Auth because the rabbit plugin doesn't currently support challenge/response for PUT
    // Create AuthCache instance
    AuthCache authCache = new BasicAuthCache();
    // Generate BASIC scheme object and add it to the local; from the apache docs...
    // auth cache
    BasicScheme basicAuth = new BasicScheme();
    URI uri;
    try {
        uri = new URI(adminUri);
    } catch (URISyntaxException e) {
        throw new RabbitAdminException("Invalid URI", e);
    }
    authCache.put(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()), basicAuth);
    // Add AuthCache to the execution context
    final HttpClientContext localContext = HttpClientContext.create();
    localContext.setAuthCache(authCache);
    RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory(httpClient) {

        @Override
        protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri) {
            return localContext;
        }
    });
    restTemplate.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(new MappingJackson2HttpMessageConverter()));
    return restTemplate;
}

@Test
public void testSaveWithJson() throws Exception {
    User user = new User();
    user.setId(1L);
    user.setName("zhang");
    String uri = baseUri;
    String createdLocation = baseUri + "/" + 1;
    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(new MappingJackson2HttpMessageConverter()));
    ResponseEntity<User> responseEntity = restTemplate.postForEntity(uri, user, User.class);
    assertEquals(createdLocation, responseEntity.getHeaders().get("Location").get(0));
    assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
    assertEquals(user, responseEntity.getBody());
}

@PostConstruct
private void init() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setReadTimeout(API_TIMEOUT_IN_MILLIS);
    factory.setConnectTimeout(API_TIMEOUT_IN_MILLIS);
    ObjectMapper mapper = new ObjectMapper();
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    mapper.setPropertyNamingStrategy(new PropertyNamingStrategy.SnakeCaseStrategy());
    restTemplate = new RestTemplate(Collections.singletonList(new MappingJackson2HttpMessageConverter(mapper)));
    restTemplate.setRequestFactory(factory);
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    jsonConverter.setObjectMapper(jacksonObjectMapper());
    HeaderTypeHttpMessageConverter<Object> headerJsonConverter = new HeaderTypeHttpMessageConverter<>(jsonConverter);
    headerJsonConverter.addMapping("PiloteCommand", //
    PiloteCommand.class).addMapping("EmployeCommand", EmployeCommand.class).addMapping("MecanicienDetail", MecanicienDetailDto.class).addMapping("PiloteDetail", PiloteDetailDto.class);
    converters.add(headerJsonConverter);
    Jaxb2AbstractTypeHttpMessageConverter jaxbConverter = new Jaxb2AbstractTypeHttpMessageConverter();
    jaxbConverter.addTypeMapping(HangarCommand.class, JaxbHangarCommand.class).addTypeMapping(VaisseauCommand.class, JaxbVaisseauCommand.class).addTypeMapping(EmployeCommand.class, JaxbEmployeCommand.class).addTypeMapping(PiloteCommand.class, JaxbPiloteCommand.class);
    HeaderTypeHttpMessageConverter<Object> headerJaxbConverter = new HeaderTypeHttpMessageConverter<>(jaxbConverter);
    headerJaxbConverter.addMapping("PiloteCommand", //
    PiloteCommand.class).addMapping("EmployeCommand", EmployeCommand.class).addMapping("MecanicienDetail", MecanicienDetailDto.class).addMapping("PiloteDetail", PiloteDetailDto.class);
    converters.add(headerJaxbConverter);
}

//	private MappingJacksonHttpMessageConverter getMappingJacksonHttpMessageConverter(){
private MappingJackson2HttpMessageConverter getMappingJackson2HttpMessageConverter() {
    for (HttpMessageConverter httpMessageConverter : this.messageConverters) {
        if (httpMessageConverter instanceof MappingJackson2HttpMessageConverter) {
            return (MappingJackson2HttpMessageConverter) httpMessageConverter;
        }
    }
    /*
		 * FIXME : Arreglar
		 */
    throw new RuntimeException(" ERROR ");
}

@PostConstruct
public void init() {
    restTemplate = new RestTemplate();
    SimpleClientHttpRequestFactory rf = (SimpleClientHttpRequestFactory) restTemplate.getRequestFactory();
    rf.setReadTimeout(portalConfig.readTimeout());
    rf.setConnectTimeout(portalConfig.connectTimeout());
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setSupportedMediaTypes(Arrays.asList(MediaType.APPLICATION_JSON, MediaType.APPLICATION_OCTET_STREAM));
    restTemplate.setMessageConverters(Arrays.asList(converter, new FormHttpMessageConverter()));
}

public static HttpMessageConverter<Object> createMappingJackson2HttpMessageConverter() {
    final Jackson2ObjectMapperFactoryBean objectMapperFactoryBean = new Jackson2ObjectMapperFactoryBean();
    objectMapperFactoryBean.setFailOnEmptyBeans(true);
    objectMapperFactoryBean.setIndentOutput(true);
    objectMapperFactoryBean.setDateFormat(new SimpleDateFormat("MM/dd/yyyy"));
    objectMapperFactoryBean.setFeaturesToDisable(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    objectMapperFactoryBean.setFeaturesToEnable(com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_COMMENTS, com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_SINGLE_QUOTES, com.fasterxml.jackson.databind.DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
    objectMapperFactoryBean.afterPropertiesSet();
    final MappingJackson2HttpMessageConverter httpMessageConverter = new MappingJackson2HttpMessageConverter();
    httpMessageConverter.setObjectMapper(objectMapperFactoryBean.getObject());
    return httpMessageConverter;
}

/**
     * Must have "session" scope
     */
@Bean(name = "githubOauth2RestTemplate")
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public OAuth2RestTemplate geoServerOauth2RestTemplate() {
    OAuth2RestTemplate oAuth2RestTemplate = new OAuth2RestTemplate(geoServerOAuth2Resource(), new DefaultOAuth2ClientContext(getAccessTokenRequest()));
    AuthorizationCodeAccessTokenProvider authorizationCodeAccessTokenProvider = new AuthorizationCodeAccessTokenProvider();
    authorizationCodeAccessTokenProvider.setStateMandatory(false);
    AccessTokenProvider accessTokenProviderChain = new AccessTokenProviderChain(Arrays.<AccessTokenProvider>asList(authorizationCodeAccessTokenProvider, new ImplicitAccessTokenProvider(), new ResourceOwnerPasswordAccessTokenProvider(), new ClientCredentialsAccessTokenProvider()));
    oAuth2RestTemplate.setAccessTokenProvider(accessTokenProviderChain);
    List<HttpMessageConverter<?>> messageConverters = oAuth2RestTemplate.getMessageConverters();
    messageConverters.add(new MappingJackson2HttpMessageConverter());
    return oAuth2RestTemplate;
}

@Bean
public MappingJackson2HttpMessageConverter halConverter() {
    CurieProvider curieProvider = curieProvider();
    RelProvider relProvider = new DelegatingRelProvider(relProviderRegistry);
    ObjectMapper halObjectMapper = new ObjectMapper();
    halObjectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
    halObjectMapper.registerModule(new Jackson2HalModule());
    halObjectMapper.setHandlerInstantiator(new Jackson2HalModule.HalHandlerInstantiator(relProvider, curieProvider));
    MappingJackson2HttpMessageConverter halConverter = new MappingJackson2HttpMessageConverter();
    halConverter.setSupportedMediaTypes(Arrays.asList(MediaTypes.HAL_JSON));
    halConverter.setObjectMapper(halObjectMapper);
    return halConverter;
}

/**
	 * Install message converters we're interested in, with json coming before xml.
	 */
@SuppressWarnings("deprecation")
public static List<HttpMessageConverter<?>> installMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
    messageConverters.add(new AllEncompassingFormHttpMessageConverter());
    if (jackson2Present) {
        messageConverters.add(new MappingJackson2HttpMessageConverter());
    } else if (jacksonPresent) {
        // avoiding import of MappingJacksonHttpMessageConverter to prevent deprecation warning
        messageConverters.add(new org.springframework.http.converter.json.MappingJacksonHttpMessageConverter());
    }
    if (jaxb2Present) {
        Jaxb2RootElementHttpMessageConverter jaxbConverter = new Jaxb2RootElementHttpMessageConverter();
        initializeJAXBContexts(jaxbConverter);
        messageConverters.add(jaxbConverter);
    }
    return messageConverters;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    Map<String, Class> aliases = new HashMap<String, Class>();
    aliases.put("jobInstanceInfo", JobInstanceInfoResource.class);
    aliases.put("jobExecutionInfo", JobExecutionInfoResource.class);
    aliases.put("link", Link.class);
    aliases.put("jobExecution", JobExecution.class);
    aliases.put("jobParameter", JobParameter.class);
    aliases.put("stepExecution", StepExecution.class);
    Map<Class<?>, String> omittedFields = new HashMap<Class<?>, String>();
    omittedFields.put(JobExecutionInfoResource.class, "dateFormat");
    omittedFields.put(JobExecutionInfoResource.class, "durationFormat");
    omittedFields.put(JobExecutionInfoResource.class, "timeFormat");
    omittedFields.put(JobExecutionInfoResource.class, "converter");
    omittedFields.put(StepExecution.class, "jobExecution");
    omittedFields.put(Link.class, "template");
    XStreamMarshaller marshaller = new XStreamMarshaller();
    marshaller.setAliasesByType(aliases);
    marshaller.setOmittedFields(omittedFields);
    marshaller.setConverters(new SingleValueConverter() {

        @Override
        public String toString(Object obj) {
            return ((TimeZone) obj).getID();
        }

        @Override
        public Object fromString(String str) {
            return TimeZone.getTimeZone(str);
        }

        @Override
        public boolean canConvert(Class type) {
            return TimeZone.class.isAssignableFrom(type);
        }
    });
    marshaller.afterPropertiesSet();
    MarshallingHttpMessageConverter converter = new MarshallingHttpMessageConverter(marshaller);
    converters.add(converter);
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper objectMapper = jsonConverter.getObjectMapper();
    objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    objectMapper.setDateFormat(new ISO8601DateFormatWithMilliSeconds());
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
    objectMapper.addMixInAnnotations(JobParameters.class, JobParametersJacksonMixIn.class);
    objectMapper.addMixInAnnotations(JobParameter.class, JobParameterJacksonMixIn.class);
    objectMapper.addMixInAnnotations(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
    objectMapper.addMixInAnnotations(ExitStatus.class, ExitStatusJacksonMixIn.class);
    converters.add(jsonConverter);
}

@Test
public void noObjectMapperMeansNoConverter() throws Exception {
    this.context.register(HttpMessageConvertersAutoConfiguration.class);
    this.context.refresh();
    assertThat(this.context.getBeansOfType(ObjectMapper.class)).isEmpty();
    assertThat(this.context.getBeansOfType(MappingJackson2HttpMessageConverter.class)).isEmpty();
    assertThat(this.context.getBeansOfType(MappingJackson2XmlHttpMessageConverter.class)).isEmpty();
}

/**
	 * Will augment the provided {@link RestTemplate} with the Jackson Mixins required by
	 * Spring Cloud Data Flow, specifically:
	 * <p>
	 * <ul>
	 * <li>{@link JobExecutionJacksonMixIn}
	 * <li>{@link JobParametersJacksonMixIn}
	 * <li>{@link JobParameterJacksonMixIn}
	 * <li>{@link JobInstanceJacksonMixIn}
	 * <li>{@link ExitStatusJacksonMixIn}
	 * <li>{@link StepExecutionJacksonMixIn}
	 * <li>{@link ExecutionContextJacksonMixIn}
	 * <li>{@link StepExecutionHistoryJacksonMixIn}
	 * </ul>
	 * <p>
	 * Furthermore, this method will also register the {@link Jackson2HalModule}
	 *
	 * @param restTemplate Can be null. Instantiates a new {@link RestTemplate} if null
	 * @return RestTemplate with the required Jackson Mixins
	 */
public static RestTemplate prepareRestTemplate(RestTemplate restTemplate) {
    if (restTemplate == null) {
        restTemplate = new RestTemplate();
    }
    restTemplate.setErrorHandler(new VndErrorResponseErrorHandler(restTemplate.getMessageConverters()));
    boolean containsMappingJackson2HttpMessageConverter = false;
    for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            containsMappingJackson2HttpMessageConverter = true;
            final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
            jacksonConverter.getObjectMapper().registerModule(new Jackson2HalModule()).addMixIn(JobExecution.class, JobExecutionJacksonMixIn.class).addMixIn(JobParameters.class, JobParametersJacksonMixIn.class).addMixIn(JobParameter.class, JobParameterJacksonMixIn.class).addMixIn(JobInstance.class, JobInstanceJacksonMixIn.class).addMixIn(ExitStatus.class, ExitStatusJacksonMixIn.class).addMixIn(StepExecution.class, StepExecutionJacksonMixIn.class).addMixIn(ExecutionContext.class, ExecutionContextJacksonMixIn.class).addMixIn(StepExecutionHistory.class, StepExecutionHistoryJacksonMixIn.class);
        }
    }
    if (!containsMappingJackson2HttpMessageConverter) {
        throw new IllegalArgumentException("The RestTemplate does not contain a required " + "MappingJackson2HttpMessageConverter.");
    }
    return restTemplate;
}

/**
     * Returns default {@link HttpMessageConverter} instances, i.e.:
     *
     * <ul>
     *     <li>{@linkplain ByteArrayHttpMessageConverter}</li>
     *     <li>{@linkplain StringHttpMessageConverter}</li>
     *     <li>{@linkplain ResourceHttpMessageConverter}</li>
     *     <li>{@linkplain Jaxb2RootElementHttpMessageConverter} (when JAXB is present)</li>
     *     <li>{@linkplain MappingJackson2HttpMessageConverter} (when Jackson 2.x is present)</li>
     *     <li>{@linkplain org.springframework.http.converter.json.MappingJacksonHttpMessageConverter}
     *         (when Jackson 1.x is present and 2.x not)</li>
     * </ul>
     *
     * <p>Note: It does not return all of the default converters defined in Spring, but just thus
     * usable for exception responses.</p>
     */
@SuppressWarnings("deprecation")
public static List<HttpMessageConverter<?>> getDefaultHttpMessageConverters() {
    List<HttpMessageConverter<?>> converters = new ArrayList<>();
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
    // See SPR-7316
    stringConverter.setWriteAcceptCharset(false);
    converters.add(new ByteArrayHttpMessageConverter());
    converters.add(stringConverter);
    converters.add(new ResourceHttpMessageConverter());
    if (isJaxb2Present()) {
        converters.add(new Jaxb2RootElementHttpMessageConverter());
    }
    if (isJackson2Present()) {
        converters.add(new MappingJackson2HttpMessageConverter());
    } else if (isJacksonPresent()) {
        try {
            Class<?> clazz = Class.forName("org.springframework.http.converter.json.MappingJacksonHttpMessageConverter");
            converters.add((HttpMessageConverter<?>) clazz.newInstance());
        } catch (ClassNotFoundException ex) {
        } catch (InstantiationExceptionIllegalAccessException |  ex) {
            throw new IllegalStateException(ex);
        }
    }
    return converters;
}

@Override
protected List<HttpMessageConverter<?>> getMessageConverters() {
    MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.configure(WRITE_DATES_AS_TIMESTAMPS, false);
    objectMapper.configure(FAIL_ON_EMPTY_BEANS, false);
    objectMapper.setSerializationInclusion(NON_NULL);
    jsonConverter.setObjectMapper(objectMapper);
    FormHttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
    formHttpMessageConverter.addPartConverter(jsonConverter);
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
    messageConverters.add(jsonConverter);
    messageConverters.add(new ByteArrayHttpMessageConverter());
    messageConverters.add(formHttpMessageConverter);
    messageConverters.add(new ResourceHttpMessageConverter());
    return messageConverters;
}

/**
	 * Creates the {@link RestTemplate} used to communicate with the provider's
	 * OAuth 2 API. This implementation creates a RestTemplate with a minimal
	 * set of HTTP message converters ({@link FormHttpMessageConverter} and
	 * {@link MappingJacksonHttpMessageConverter}). May be overridden to
	 * customize how the RestTemplate is created. For example, if the provider
	 * returns data in some format other than JSON for form-encoded, you might
	 * override to register an appropriate message converter.
	 */
protected RestTemplate createRestTemplate(boolean json) {
    HttpHeaders httpHeaders = new HttpHeaders();
    httpHeaders.add("User-Agent", getUserAgent());
    RestTemplate restTemplate = new RestTemplateWithHeaders(ClientHttpRequestFactorySelector.getRequestFactory(), httpHeaders);
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(2);
    converters.add(new FormHttpMessageConverter());
    if (json) {
        converters.add(new MappingJackson2HttpMessageConverter());
    }
    restTemplate.setMessageConverters(converters);
    return restTemplate;
}

@Before
public void setup() throws Exception {
    //Add handling of text/javascript content type
    final MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    final List<MediaType> supportedMediaTypes = new LinkedList<MediaType>(converter.getSupportedMediaTypes());
    final MediaType textJavascriptMediaType = new MediaType("text", "javascript", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET);
    supportedMediaTypes.add(textJavascriptMediaType);
    converter.setSupportedMediaTypes(supportedMediaTypes);
    restTemplate.getMessageConverters().add(converter);
    this.googleSearchController.setRestOperations(restTemplate);
    //Uncomment to make real requests
    //restTemplate.setRequestFactory(new CommonsClientHttpRequestFactory());
    when(clientHttpRequest.getHeaders()).thenReturn(requestHttpHeaders);
    when(clientHttpRequest.execute()).thenReturn(clientHttpResponse);
    when(clientHttpResponse.getStatusCode()).thenReturn(HttpStatus.OK);
    when(clientHttpResponse.getHeaders()).thenReturn(responseHttpHeaders);
    when(responseHttpHeaders.getContentType()).thenReturn(textJavascriptMediaType);
}

//  @Test
public void testSendEncodedDocument() throws Exception {
    String filename = "TWB_Source_" + System.currentTimeMillis() + ".csv";
    //decide whether its better to send file or content
    String content = "被害�ダウ";
    byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
    final String url = BASE_URL + "/documents";
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.add("X-Proz-API-Key", API_KEY);
    requestHeaders.setContentType(new MediaType("multipart", "form-data"));
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(StandardCharsets.UTF_8));
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<String, Object>();
    map.add("document", bytes);
    map.add("name", "translation_source.csv");
    HttpEntity<LinkedMultiValueMap<String, Object>> requestEntity = new HttpEntity<LinkedMultiValueMap<String, Object>>(map, requestHeaders);
    ResponseEntity<Map> result = restTemplate.exchange(url, HttpMethod.POST, requestEntity, Map.class);
    Map resultMap = result.getBody();
    String download_Link = (String) resultMap.get("download_link");
    String returnedDocumentContent = getTranslationDocumentContent(download_Link);
    assert (returnedDocumentContent.equals(content));
}

@Bean
public MappingJackson2HttpMessageConverter defaultJsonMessageConverter() {
    Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
    builder.serializationInclusion(JsonInclude.Include.NON_EMPTY).defaultViewInclusion(false).indentOutput(apiIndent).simpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(builder.build());
    List<MediaType> mediaTypes = new ArrayList<>();
    mediaTypes.add(API_V3_MEDIA_TYPE);
    mediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
    converter.setSupportedMediaTypes(mediaTypes);
    return converter;
}

/**
     * Spring MVC use a default objectMapper. Objects passed to and returned from the controllers are converted to and from HTTP messages by HttpMessageConverter
     * instances. We must use our {{@link #objectMapper}} because of the subtypes.... So we declare two message converters
     * <ul>
     * <li>StringHttpMessageConverter to format the String sent by HTTP like a JSON object representation</li>
     * <li>MappingJackson2HttpMessageConverter to use our {{@link #objectMapper}}</li>
     * </ul>To declare a JacksonHttpMessageConvet
     */
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    //Add a converter for the String sent via HTTP
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
    // see SPR-7316
    stringConverter.setWriteAcceptCharset(false);
    converters.add(stringConverter);
    //Use our custom Jackson serializer
    MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter(objectMapper);
    mappingJackson2HttpMessageConverter.setSupportedMediaTypes(supportedMediaTypes());
    converters.add(mappingJackson2HttpMessageConverter);
}

@BeforeClass
public static void init() {
    InitializingService initializingService = new InitializingService();
    try {
        initializingService.afterPropertiesSet();
    } catch (Exception e1) {
        e1.printStackTrace();
    }
    ErrorRequestMessageConverter messageConverter = new ErrorRequestMessageConverter();
    messageConverter.setJsonMessageConverter(new MappingJackson2HttpMessageConverter());
    messageConverter.setXmlMessageConverter(new Jaxb2RootElementHttpMessageConverterExt());
    filter = new CheckOpenServiceFilter();
    filter.setMessageConverter(messageConverter);
    try {
        Field field = filter.getClass().getDeclaredField("methodVersionMap");
        field.setAccessible(true);
        Multimap<String, String> methodVersionMap = (Multimap<String, String>) field.get(filter);
        methodVersionMap.put("user.get", "1.0.0");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private void initRestTemplate() {
    this.restTemplate = new RestTemplate();
    final List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
    // Create a list for the message converters
    final List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(messageConverters);
    final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    // Add the Jackson Message converter
    converters.add(jsonConverter);
    this.restTemplate.setMessageConverters(converters);
}

@Bean
public List<HttpMessageConverter<?>> defaultMessageConverters() {
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
    if (config().getMetadataConfiguration().alpsEnabled()) {
        messageConverters.add(alpsJsonHttpMessageConverter());
    }
    if (config().getDefaultMediaType().equals(MediaTypes.HAL_JSON)) {
        messageConverters.add(halJacksonHttpMessageConverter());
        messageConverters.add(jacksonHttpMessageConverter());
    } else {
        messageConverters.add(jacksonHttpMessageConverter());
        messageConverters.add(halJacksonHttpMessageConverter());
    }
    MappingJackson2HttpMessageConverter fallbackJsonConverter = new MappingJackson2HttpMessageConverter();
    fallbackJsonConverter.setObjectMapper(basicObjectMapper());
    messageConverters.add(fallbackJsonConverter);
    messageConverters.add(uriListHttpMessageConverter());
    configurerDelegate.configureHttpMessageConverters(messageConverters);
    return messageConverters;
}

@Before
public void createRestTemplate() {
    restTemplate = new RestTemplate(createHttpClientFactory(server.getHost(), server.getPort()));
    final ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setAnnotationIntrospector(new JaxbAnnotationIntrospector());
    objectMapper.enableDefaultTyping(DefaultTyping.JAVA_LANG_OBJECT, As.PROPERTY);
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
    converters.add(new StringHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter() {

        {
            setObjectMapper(objectMapper);
        }
    });
    restTemplate.setMessageConverters(converters);
}

@Bean
public OAuth2RestTemplate facebookRestTemplate(OAuth2ClientContext clientContext) {
    OAuth2RestTemplate template = new OAuth2RestTemplate(facebook(), clientContext);
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setSupportedMediaTypes(Arrays.asList(MediaType.APPLICATION_JSON, MediaType.valueOf("text/javascript")));
    template.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(converter));
    return template;
}

// private helpers
private void registerXingInJsonModule() {
    List<HttpMessageConverter<?>> converters = getRestTemplate().getMessageConverters();
    for (HttpMessageConverter<?> converter : converters) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            MappingJackson2HttpMessageConverter jsonConverter = (MappingJackson2HttpMessageConverter) converter;
            objectMapper = new ObjectMapper();
            objectMapper.registerModule(new XingModule());
            objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
            objectMapper.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, true);
            objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES);
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            jsonConverter.setObjectMapper(objectMapper);
        }
    }
}

/**
	 * Creates an OAuth2 rest template that provides facilities to deal with OAuth2 auth.
	 * @param credential The user credential.
	 * @return A new OAut2 Rest Template.
	 */
protected RestTemplate createOAuthTemplate(GMMCredential credential) {
    ResourceOwnerPasswordResourceDetails details = new ResourceOwnerPasswordResourceDetails();
    details.setClientId(CLIENT_ID);
    details.setClientSecret(CLIENT_SECRET);
    details.setUsername(credential.getUsername());
    details.setPassword(credential.getPassword());
    details.setAccessTokenUri(OAUTH_TOK);
    OAuth2RestTemplate template = new OAuth2RestTemplate(details);
    template.getMessageConverters().add(new FormHttpMessageConverter());
    template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    return template;
}

/**
     * Performs and authorization_code grant, but uses a token to assert the user's identity.
     * @param tokenRequest - a configured TokenRequest
     * @return an authenticated {@link UaaContext}
     */
protected UaaContext authenticateAuthCodeWithToken(final TokenRequest tokenRequest) {
    List<OAuth2AccessTokenSupport> providers = Collections.singletonList(new AuthorizationCodeAccessTokenProvider() {

        @Override
        protected ResponseExtractor<OAuth2AccessToken> getResponseExtractor() {
            // force initialization
            getRestTemplate();
            MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
            return new HttpMessageConverterExtractor<OAuth2AccessToken>(CompositeAccessToken.class, Arrays.asList(converter));
        }
    });
    enhanceRequestParameters(tokenRequest, providers.get(0));
    AuthorizationCodeResourceDetails details = new AuthorizationCodeResourceDetails();
    details.setPreEstablishedRedirectUri(tokenRequest.getRedirectUri().toString());
    configureResourceDetails(tokenRequest, details);
    setClientCredentials(tokenRequest, details);
    setRequestScopes(tokenRequest, details);
    details.setUserAuthorizationUri(tokenRequest.getAuthorizationEndpoint().toString());
    DefaultOAuth2ClientContext oAuth2ClientContext = new DefaultOAuth2ClientContext();
    oAuth2ClientContext.getAccessTokenRequest().setStateKey(tokenRequest.getState());
    oAuth2ClientContext.setPreservedState(tokenRequest.getState(), details.getPreEstablishedRedirectUri());
    oAuth2ClientContext.getAccessTokenRequest().setCurrentUri(details.getPreEstablishedRedirectUri());
    Map<String, List<String>> headers = (Map<String, List<String>>) oAuth2ClientContext.getAccessTokenRequest().getHeaders();
    headers.put("Authorization", Arrays.asList("bearer " + tokenRequest.getAuthCodeAPIToken()));
    OAuth2RestTemplate template = new OAuth2RestTemplate(details, oAuth2ClientContext);
    skipSslValidation(tokenRequest, template, providers);
    OAuth2AccessToken token = template.getAccessToken();
    return new UaaContextImpl(tokenRequest, template, (CompositeAccessToken) token);
}

// subclassing hooks
/**
	 * Creates the {@link RestTemplate} used to communicate with the provider's OAuth 2 API.
	 * This implementation creates a RestTemplate with a minimal set of HTTP message converters ({@link FormHttpMessageConverter} and {@link MappingJackson2HttpMessageConverter}).
	 * May be overridden to customize how the RestTemplate is created.
	 * For example, if the provider returns data in some format other than JSON for form-encoded, you might override to register an appropriate message converter.
	 * @return a {@link RestTemplate} used to communicate with the provider's OAuth 2 API 
	 */
protected RestTemplate createRestTemplate() {
    ClientHttpRequestFactory requestFactory = ClientHttpRequestFactorySelector.getRequestFactory();
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(2);
    converters.add(new FormHttpMessageConverter());
    converters.add(new FormMapHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
    restTemplate.setMessageConverters(converters);
    restTemplate.setErrorHandler(new LoggingErrorHandler());
    if (!useParametersForClientAuthentication) {
        List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
        if (// defensively initialize list if it is null. (See SOCIAL-430)
        interceptors == null) {
            interceptors = new ArrayList<ClientHttpRequestInterceptor>();
            restTemplate.setInterceptors(interceptors);
        }
        interceptors.add(new PreemptiveBasicAuthClientHttpRequestInterceptor(clientId, clientSecret));
    }
    return restTemplate;
}

/**
	 * @param discussionEntry
	 * @param urlForDocuments
	 * @param authenticationCookie
	 * @return http location of the newly created DiscussionEntry. Empty String if unsuccesful.  
	 */
private String submitDiscussionEntry(DiscussionEntry discussionEntry, String urlForDocuments, String authenticationCookie, boolean disableComputeWithForm) {
    String returnString = "";
    //Using a simple class to hold what gets submitted - keeps things simpler
    DiscussionEntryForSubmitting entryToSubmit = new DiscussionEntryForSubmitting();
    entryToSubmit.createFromDiscussionEntry(discussionEntry);
    String formForSubmit = "";
    String parentid = entryToSubmit.getParentid();
    if (parentid != null && parentid.length() > 0) {
        formForSubmit = "Response";
    } else {
        formForSubmit = "MainTopic";
    }
    String url = urlForDocuments + "?form=" + formForSubmit + "&computewithform=";
    // Discussion template
    if (disableComputeWithForm) {
        url = url + "false";
    } else {
        url = url + "true";
    }
    if (parentid != null && parentid.length() > 0) {
        url = url + "&parentid=" + parentid;
    }
    RestTemplate restTemplate = new RestTemplate();
    HttpHeaders requestHeaders = new HttpHeaders();
    requestHeaders.setAcceptEncoding(ContentCodingType.GZIP);
    requestHeaders.setContentType(MediaType.APPLICATION_JSON);
    List<MediaType> acceptableMediaTypes = new ArrayList<MediaType>();
    acceptableMediaTypes.add(MediaType.APPLICATION_JSON);
    requestHeaders.setAccept(acceptableMediaTypes);
    requestHeaders.add("Cookie", authenticationCookie);
    HttpEntity<DiscussionEntryForSubmitting> requestEntity = new HttpEntity<DiscussionEntryForSubmitting>(entryToSubmit, requestHeaders);
    //		ApplicationLog.d(getClass().getSimpleName() + " Adding MappingJackson2HttpMessageConverter AND StringHttpMessageConverter to restTemplate", shouldCommitToLog);
    restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
    restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    ApplicationLog.d(getClass().getSimpleName() + " POST to " + url, shouldCommitToLog);
    ResponseEntity<String> httpResponse;
    try {
        httpResponse = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        ApplicationLog.d(getClass().getSimpleName() + " resultString: " + httpResponse.toString(), shouldCommitToLog);
        ApplicationLog.d(getClass().getSimpleName() + " statuscode: " + httpResponse.getStatusCode().value(), shouldCommitToLog);
        if (httpResponse.hasBody()) {
            ApplicationLog.d(getClass().getSimpleName() + " body: " + httpResponse.getBody().toString(), shouldCommitToLog);
        } else {
            ApplicationLog.d(getClass().getSimpleName() + " body: None received", shouldCommitToLog);
        }
        HttpHeaders responseHeaders = httpResponse.getHeaders();
        if (responseHeaders.isEmpty()) {
            ApplicationLog.d("No response headers - then the POST did not succeeed", shouldCommitToLog);
        } else {
            List<String> locationList = responseHeaders.get("Location");
            if (null != locationList) {
                //Assuming the header we are looking for will always be first - unlikely to have two
                String location = locationList.get(0);
                ApplicationLog.d("Location of newly created Note: " + location, shouldCommitToLog);
                returnString = location;
            }
        }
    } catch (RestClientException e) {
        e.printStackTrace();
        String errorMessage = e.getMessage();
        if (errorMessage == null) {
            errorMessage = "Error message not available";
        }
        ApplicationLog.e("Exception: " + errorMessage);
    }
    return returnString;
}

private List<HttpMessageConverter<?>> getMessageConverters() {
    List<HttpMessageConverter<?>> xs = new ArrayList<HttpMessageConverter<?>>();
    final Jackson2ObjectMapperBuilder bldr = Jackson2ObjectMapperBuilder.json().serializationInclusion(JsonInclude.Include.NON_NULL);
    xs.add(new MappingJackson2HttpMessageConverter(bldr.build()));
    return xs;
}

public static void init(List<HttpMessageConverter<?>> messageConverters) {
    messageConverters.add(new ByteArrayHttpMessageConverter());
    messageConverters.add(new StringHttpMessageConverter());
    messageConverters.add(new ResourceHttpMessageConverter());
    // if javax.xml.transform is not available, fall back to standard Form message converter
    if (javaxXmlTransformPresent) {
        messageConverters.add(new SourceHttpMessageConverter<Source>());
        messageConverters.add(new AllEncompassingFormHttpMessageConverter());
    } else {
        messageConverters.add(new FormHttpMessageConverter());
    }
    if (simpleXmlPresent) {
        messageConverters.add(new SimpleXmlHttpMessageConverter());
    }
    if (jackson2Present) {
        messageConverters.add(new MappingJackson2HttpMessageConverter());
    } else if (gsonPresent) {
        messageConverters.add(new GsonHttpMessageConverter());
    }
}

default MockMvc mvc() {
    final ObjectMapper mapper = mapper();
    return MockMvcBuilders.standaloneSetup(new ExampleRestController()).setControllerAdvice(unit()).setMessageConverters(new MappingJackson2HttpMessageConverter(mapper)).build();
}

@Bean
RestTemplate restTemplate(ObjectMapper objectMapper) {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(Lists.newArrayList(jaxb2RootElementHttpMessageConverter(), new StringHttpMessageConverter(), new MappingJackson2HttpMessageConverter(objectMapper)));
    return restTemplate;
}

@Bean
public HttpMessageConverters getJacksonHttpMessageConverters(ObjectMapper objectMapper) {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(objectMapper);
    converter.setSupportedMediaTypes(Arrays.asList(MediaType.APPLICATION_JSON_UTF8, MediaType.TEXT_HTML, MediaType.TEXT_PLAIN));
    return new HttpMessageConverters(converter);
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new MappingJackson2HttpMessageConverter());
}

@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(new MappingJackson2HttpMessageConverter(), new StringHttpMessageConverter()));
    return restTemplate;
}

@Bean(name = "jacksonMessageConverter")
public MappingJackson2HttpMessageConverter jsonConverter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setPrettyPrint(true);
    converter.getObjectMapper().configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    return converter;
}

@Bean
public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false));
    return converter;
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new MappingJackson2HttpMessageConverter());
    super.configureMessageConverters(converters);
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.getObjectMapper().setSerializationInclusion(JsonInclude.Include.NON_NULL);
    converters.add(converter);
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    converters.add(new MappingJackson2HttpMessageConverter());
    converters.add(new Jaxb2RootElementHttpMessageConverter());
    converters.add(new Jaxb2CollectionHttpMessageConverter<>());
    converters.add(new HtmlMessageConverter());
}

protected HttpMessageConverter<?>[] mockMvcMessageConverters() {
    final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
    jsonConverter.setObjectMapper(objectMapper);
    return new HttpMessageConverter[] { jsonConverter, new ResourceHttpMessageConverter() };
}

@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    HttpMessageConverter<?> messageConverter = new MappingJackson2HttpMessageConverter(TcSerializationUtils.OBJECT_MAPPER);
    converters.add(messageConverter);
    super.configureMessageConverters(converters);
}

@Bean
public HttpMessageConverter<?> mappingJackson2HttpMessageConverter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(objectMapper());
    return converter;
}

@Bean
public MappingJackson2HttpMessageConverter jacksonConverter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(objectMapper());
    return converter;
}

private static MappingJackson2HttpMessageConverter defaultJsonConverter() {
    final MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    converter.setObjectMapper(new ObjectMapper().findAndRegisterModules());
    return converter;
}

@Bean
public HttpMessageConverter<?> mappingJackson2HttpMessageConverter() {
    return new MappingJackson2HttpMessageConverter();
}

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    this.mockMvc = MockMvcBuilders.standaloneSetup(controller).setMessageConverters(new MappingJackson2HttpMessageConverter()).build();
}