import feign.codec.DecodeException; //导入依赖的package包/类
@Test
public void decodingExceptionGetWrappedInDecode404Mode() throws Exception {
  server.enqueue(new MockResponse().setResponseCode(404));
  thrown.expect(DecodeException.class);
  thrown.expectCause(isA(NoSuchElementException.class));;

  TestInterface api = new TestInterfaceBuilder()
      .decode404()
      .decoder(new Decoder() {
        @Override
        public Object decode(Response response, Type type) throws IOException {
          assertEquals(404, response.status());
          throw new NoSuchElementException();
        }
      }).target("http://localhost:" + server.getPort());
  api.post();
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
@Test
public void okIfDecodeRootCauseHasNoMessage() throws Exception {
  server.enqueue(new MockResponse().setBody("success!"));
  thrown.expect(DecodeException.class);

  TestInterface api = new TestInterfaceBuilder()
      .decoder(new Decoder() {
        @Override
        public Object decode(Response response, Type type) throws IOException {
          throw new RuntimeException();
        }
      }).target("http://localhost:" + server.getPort());

  api.post();
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
@Override
public Object decode(Response response, Type type) throws IOException, DecodeException {
  if (response.status() == 404) return Util.emptyValueOf(type);
  if (response.body() == null) return null;
  ContentHandlerWithResult.Factory<?> handlerFactory = handlerFactories.get(type);
  checkState(handlerFactory != null, "type %s not in configured handlers %s", type,
             handlerFactories.keySet());
  ContentHandlerWithResult<?> handler = handlerFactory.create();
  try {
    XMLReader xmlReader = XMLReaderFactory.createXMLReader();
    xmlReader.setFeature("http://xml.org/sax/features/namespaces", false);
    xmlReader.setFeature("http://xml.org/sax/features/validation", false);
    /* Explicitly control sax configuration to prevent XXE attacks */
    xmlReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
    xmlReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
    xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false);
    xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
    xmlReader.setContentHandler(handler);
    InputStream inputStream = response.body().asInputStream();
    try {
      xmlReader.parse(new InputSource(inputStream));
    } finally {
      ensureClosed(inputStream);
    }
    return handler.result();
  } catch (SAXException e) {
    throw new DecodeException(e.getMessage(), e);
  }
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
@Override
public Object decode(Response response, Type type) throws IOException, DecodeException, FeignException {
	Collection<String> contentTypes = response.headers().get("Content-Type");
	if (contentTypes.contains(MimeTypeUtils.TEXT_PLAIN.toString())) {
		return defaultDecoder.decode(response, type);
	}
	else {
		return gsonDecoder.decode(response, type);
	}
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
public Object decode(Response resp, Type type) throws IOException, DecodeException, FeignException {
	Request request = resp.request();

	String reqTransactionStr = this.getHeaderValue(request, HEADER_TRANCACTION_KEY);
	String reqPropagationStr = this.getHeaderValue(request, HEADER_PROPAGATION_KEY);

	String respTransactionStr = this.getHeaderValue(resp, HEADER_TRANCACTION_KEY);
	String respPropagationStr = this.getHeaderValue(resp, HEADER_PROPAGATION_KEY);

	if (StringUtils.isBlank(reqTransactionStr)) {
		return this.delegate.decode(resp, type);
	} else if (StringUtils.isBlank(reqPropagationStr)) {
		return this.delegate.decode(resp, type);
	}

	try {
		String transactionStr = StringUtils.isBlank(respTransactionStr) ? reqTransactionStr : respTransactionStr;
		String propagationStr = StringUtils.isBlank(respPropagationStr) ? reqPropagationStr : respPropagationStr;

		byte[] byteArray = ByteUtils.stringToByteArray(transactionStr);
		TransactionContext transactionContext = (TransactionContext) CommonUtils.deserializeObject(byteArray);

		SpringCloudBeanRegistry beanRegistry = SpringCloudBeanRegistry.getInstance();
		RemoteCoordinator remoteCoordinator = beanRegistry.getConsumeCoordinator(propagationStr);

		TransactionResponseImpl response = new TransactionResponseImpl();
		response.setTransactionContext(transactionContext);
		response.setSourceTransactionCoordinator(remoteCoordinator);
	} catch (IOException ex) {
		logger.error("Error occurred while decoding response({})!", resp, ex);
	}

	return this.delegate.decode(resp, type);
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
@Override
public Object decode(final Response response, Type type)
		throws IOException, FeignException {
	if (type instanceof Class || type instanceof ParameterizedType
			|| type instanceof WildcardType) {
		@SuppressWarnings({ "unchecked", "rawtypes" })
		HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor(
				type, this.messageConverters.getObject().getConverters());

		return extractor.extractData(new FeignResponseAdapter(response));
	}
	throw new DecodeException(
			"type is not an instance of Class or ParameterizedType: " + type);
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
@Test
public void networkStatusCantParse() throws Exception {
  thrown.expect(DecodeException.class);
  thrown.expectMessage("Content is not allowed in prolog.");

  server.enqueue(new MockResponse().setBody("{\"foo\": \"bar\"}"));

  mockApi().getNeustarNetworkStatus();
}
 

import feign.codec.DecodeException; //导入依赖的package包/类
/**
 * Transforms HTTP response body into object using decoder.
 *
 * @param response HTTP response
 *
 * @return decoded result
 *
 * @throws IOException IO exception during the reading of InputStream of
 *      response
 * @throws DecodeException when decoding failed due to a checked or unchecked
 *      exception besides IOException
 * @throws FeignException when decoding succeeds, but conveys the operation
 *      failed
 */
private Object decode(final Response response) throws IOException,
    FeignException {
  try {
    return decoder.decode(response, metadata.returnType());
  } catch (FeignException feignException) {
    /* All feign exception including decode exceptions */
    throw feignException;
  } catch (RuntimeException unexpectedException) {
    /* Any unexpected exception */
    throw new DecodeException(
        unexpectedException.getMessage(), unexpectedException);
  }
}