RestTemplate源码解析

最新推荐文章于 2022-09-03 12:17:40 发布
最新推荐文章于 2022-09-03 12:17:40 发布
阅读量632 收藏 3
点赞数 3
分类专栏： Java系核心技术 文章标签： java restful 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_SAVIOR/article/details/126287826
版权
本文详细介绍了RestTemplate的类结构，从getForObject方法入手，逐步解析其执行流程，包括创建请求、执行请求和处理响应的过程。RestTemplate通过封装HttpURLConnection，提供了一种更优雅的方式来调用RESTful服务，利用HttpMessageConverter进行响应数据的转换。
摘要由CSDN通过智能技术生成

文章目录


上一篇文章，我们介绍了RestTemplate在各种场景下的使用，今天我们来分析一下它的源码。

类结构

在这里插入图片描述
RestOperations是一个接口，意为Rest操作，抽象出了具有restful风格的操作方法，我们常用的getForObject、postForEntity、exchange都是里面定义的接口方法。

HttpAccessor则是一个抽象类，意为Http访问器，内部保存了请求的工厂类，即ClientHttpRequestFactory类，使用createRequest生产ClientHttpRequest，RestTemplate最终会将请求构造成ClientHttpRequest，由ClientHttpRequest负责与服务端进行交互。

流程解析

入口：

result = restTemplate.getForObject("http://localhost:9001/producer", String.class);

getForObject是RestOperation中的方法

public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
       //获取请求回调
	RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
       //获取http消息转化抽取器，HttpMessageConverterExtractor实现了ResponseExtractor，可以将http响应的文本数据转化成相应的java对象。
	HttpMessageConverterExtractor<T> responseExtractor =
			new HttpMessageConverterExtractor<>(responseType, getMessageConverters(), logger);
	return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
}

acceptHeaderRequestCallback(responseType)

	public <T> RequestCallback acceptHeaderRequestCallback(Class<T> responseType) {
		// 返回了AcceptHeaderRequestCallback实例
		return new AcceptHeaderRequestCallback(responseType);
	}

进入execute方法中

	public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback,
			@Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {
        //拼接uri
		URI expanded = getUriTemplateHandler().expand(url, uriVariables);
		return doExecute(expanded, method, requestCallback, responseExtractor);
	}

进入doExecute中【核心代码】

	protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
			@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {
 		// url和请求方法不能为null
		Assert.notNull(url, "URI is required");
		Assert.notNull(method, "HttpMethod is required");
		ClientHttpResponse response = null;
		try {
            //创建文章开头所说的ClientHttpRequest 
			ClientHttpRequest request = createRequest(url, method);
			if (requestCallback != null) {
                //执行请求回调
				requestCallback.doWithRequest(request);
			}
            //执行请求，获取响应结果
			response = request.execute();
            //处理响应结果
			handleResponse(url, method, response);
            //利用响应抽取器抽取data返回预先定义的java对象，例如例子中的String
			return (responseExtractor != null ? responseExtractor.extractData(response) : null);
		}
		catch (IOException ex) {
			String resource = url.toString();
			String query = url.getRawQuery();
			resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
			throw new ResourceAccessException("I/O error on " + method.name() +
					" request for \"" + resource + "\": " + ex.getMessage(), ex);
		}
		finally {
			if (response != null) {
				response.close();
			}
		}
	}

createRequest(url, method)，此处调用的是HttpAccessor中的createRequest方法

    protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
        //this.getRequestFactory()返回默认的SimpleClientHttpRequestFactory
        ClientHttpRequest request = this.getRequestFactory().createRequest(url, method);
        this.initialize(request);
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("HTTP " + method.name() + " " + url);
        }
 
        return request;
    }

其中getRequestFactory方法被InterceptingHttpAccessor（在类图结构中有该类）重写了

	public ClientHttpRequestFactory getRequestFactory() {
		List<ClientHttpRequestInterceptor> interceptors = getInterceptors();
		if (!CollectionUtils.isEmpty(interceptors)) {
			ClientHttpRequestFactory factory = this.interceptingRequestFactory;
			if (factory == null) {
				factory = new InterceptingClientHttpRequestFactory(super.getRequestFactory(), interceptors);
				this.interceptingRequestFactory = factory;
			}
			return factory;
		}
		else {
			return super.getRequestFactory();
		}
	}

可以看到，一上来先获取拦截器，不过我们并没有设置拦截器。因此直接返回了父类即HttpAccessor中的RequestFactory

public abstract class HttpAccessor {
 
	/** Logger available to subclasses. */
	protected final Log logger = HttpLogging.forLogName(getClass());
 
	private ClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
  
    .....
}

而HttpAccessor中使用的是SimpleClientHttpRequestFactory类。

接着走进SimpleClientHttpRequestFactory的createRequest方法

public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    //打开连接
	HttpURLConnection connection = openConnection(uri.toURL(), this.proxy);
    //前期准备工作
	prepareConnection(connection, httpMethod.name());
    //默认为true
	if (this.bufferRequestBody) {
		return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming);
	}
	else {
		return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming);
	}
}

openConnection(uri.toURL(), this.proxy)

	protected HttpURLConnection openConnection(URL url, @Nullable Proxy proxy) throws IOException {
		URLConnection urlConnection = (proxy != null ? url.openConnection(proxy) : url.openConnection());
		if (!(urlConnection instanceof HttpURLConnection)) {
			throw new IllegalStateException(
					"HttpURLConnection required for [" + url + "] but got: " + urlConnection);
		}
		return (HttpURLConnection) urlConnection;
	}

到这里，仿佛明白了什么，原来RestTemplate对原生的http请求URLConnection 进行了一层封装。
prepareConnection(connection, httpMethod.name())

	protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {
        //设置连接超时时间
		if (this.connectTimeout >= 0) {
			connection.setConnectTimeout(this.connectTimeout);
		}
        //设置读取超时时间
		if (this.readTimeout >= 0) {
			connection.setReadTimeout(this.readTimeout);
		}
        //设置请求方法等
		boolean mayWrite =
				("POST".equals(httpMethod) || "PUT".equals(httpMethod) ||
						"PATCH".equals(httpMethod) || "DELETE".equals(httpMethod));
 
		connection.setDoInput(true);
		connection.setInstanceFollowRedirects("GET".equals(httpMethod));
		connection.setDoOutput(mayWrite);
		connection.setRequestMethod(httpMethod);
	}

prepareConnection比较简单，进行了一些简单的设置工作。当我们自己利用URLConnection进行http请求时，这些设置也是我们必须要去做的，RestTemplate只是封装好了罢了

createRequest流程走完了，返回了一个封装URLConnection的ClientHttpRequest对象

接下来到了requestCallback.doWithRequest(request)，即在执行请求之前，先去执行请求回调的doWithRequest方法

public void doWithRequest(ClientHttpRequest request) throws IOException {
	if (this.responseType != null) {
		List<MediaType> allSupportedMediaTypes = getMessageConverters().stream()
				.filter(converter -> canReadResponse(this.responseType, converter))
				.flatMap((HttpMessageConverter<?> converter) -> getSupportedMediaTypes(this.responseType, converter))
				.distinct()
				.sorted(MediaType.SPECIFICITY_COMPARATOR)
				.collect(Collectors.toList());
		if (logger.isDebugEnabled()) {
			logger.debug("Accept=" + allSupportedMediaTypes);
		}
		request.getHeaders().setAccept(allSupportedMediaTypes);
	}
}

接下来需要真正去执行调用了，即request.execute()

execute方法在AbstractClientHttpRequest类中

	public final ClientHttpResponse execute() throws IOException {
        //检查ClientHttpRequest是否被执行过，如果执行过，则直接报错
		assertNotExecuted();
		ClientHttpResponse result = executeInternal(this.headers);
        //在执行请求之后，将标志位设置为true
		this.executed = true;
		return result;
	}

进入executeInternal方法中，位于AbstractBufferingClientHttpRequest中

	protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException {
		byte[] bytes = this.bufferedOutput.toByteArray();
		if (headers.getContentLength() < 0) {
			headers.setContentLength(bytes.length);
		}
		ClientHttpResponse result = executeInternal(headers, bytes);
		this.bufferedOutput = new ByteArrayOutputStream(0);
		return result;
	}

其中核心的是executeInternal(headers, bytes)方法，位于SimpleBufferingClientHttpRequest中

	protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {
        //将请求头设置进connection中
		addHeaders(this.connection, headers);
		// JDK <1.8 doesn't support getOutputStream with HTTP DELETE
		if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {
			this.connection.setDoOutput(false);
		}
		if (this.connection.getDoOutput() && this.outputStreaming) {
			this.connection.setFixedLengthStreamingMode(bufferedOutput.length);
		}
		this.connection.connect();
		if (this.connection.getDoOutput()) {
            //将缓存区的数据复制进connection的输出流中
			FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());
		}
		else {
			// Immediately trigger the request in a no-output scenario as well
			this.connection.getResponseCode();
		}
		return new SimpleClientHttpResponse(this.connection);
	}

该方法使用HttpURLConnection与服务端建立了连接，并返回一个SimpleClientHttpResponse。单纯包裹着此HttpURLConnection对象。

request.execute()也就走完了，接着走主流程的下一步

handleResponse(url, method, response)

	protected void handleResponse(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
        //获取错误处理器
		ResponseErrorHandler errorHandler = getErrorHandler();
		boolean hasError = errorHandler.hasError(response);
		if (logger.isDebugEnabled()) {
			try {
				int code = response.getRawStatusCode();
				HttpStatus status = HttpStatus.resolve(code);
				logger.debug("Response " + (status != null ? status : code));
			}
			catch (IOException ex) {
				// ignore
			}
		}
        //如果出现错误的话，例如状态码为500，则进入到错误处理流程中
		if (hasError) {
			errorHandler.handleError(url, method, response);
		}
	}

这一步主要是检查状态码是否是4或者5开头的，如果是的话，则走相应的错误处理流程。

如果没有错误的话，则进入到最后一步

responseExtractor.extractData(response)，抽取响应中的数据

responseExtractor是HttpMessageConverterExtractor类型的

	public T extractData(ClientHttpResponse response) throws IOException {
		MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);
		if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {
			return null;
		}
		MediaType contentType = getContentType(responseWrapper);
 
		try {
            //遍历HttpMessageConverter
			for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
				if (messageConverter instanceof GenericHttpMessageConverter) {
					GenericHttpMessageConverter<?> genericMessageConverter =
							(GenericHttpMessageConverter<?>) messageConverter;
					if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
						if (logger.isDebugEnabled()) {
							ResolvableType resolvableType = ResolvableType.forType(this.responseType);
							logger.debug("Reading to [" + resolvableType + "]");
						}
						return (T) genericMessageConverter.read(this.responseType, null, responseWrapper);
					}
				}
				if (this.responseClass != null) {
                    //如果该messageConverter能够读取该contentType，并且能转化成responseClass类型
					if (messageConverter.canRead(this.responseClass, contentType)) {
						if (logger.isDebugEnabled()) {
							String className = this.responseClass.getName();
							logger.debug("Reading to [" + className + "] as \"" + contentType + "\"");
						}
                        //将响应数据转化成对应的java类型
						return (T) messageConverter.read((Class) this.responseClass, responseWrapper);
					}
				}
			}
		}
		catch (IOException | HttpMessageNotReadableException ex) {
			throw new RestClientException("Error while extracting response for type [" +
					this.responseType + "] and content type [" + contentType + "]", ex);
		}
 
		throw new UnknownContentTypeException(this.responseType, contentType,
				response.getRawStatusCode(), response.getStatusText(), response.getHeaders(),
				getResponseBody(response));
	}

extractData和核心逻辑就是，遍历所有的HttpMessageConverter，如果发现某个messageConverter能够读取响应数据，则返回转化后的数据。

主流程最后一步，则是将封装的HttpURLConnection的输入流关闭。

到这里，RestTemplate的源码分析就结束了。

总结

一句话概括RestTemplate，RestTemplate封装了原生的HttpURLConnection，采用Restful的理念，更优雅地来完成对HTTP服务的调用。

_金欣
关注
专栏目录
订阅专栏
SpringBoot2.x系列教程（六十七）Spring Boot注入RestTemplate及源码解析
程序新视界
12-10 1421
引入SpringBoot本来就支持REST服务，因此在SpringBoot项目之间经常需要通过REST的形式来相互调用。本文以具体的实例带大家了解一下SpringBoot中怎么使用RestTemplate进行接口调用。同时，会讲解部分相关源码。 RestTemplate的实例化 RestTemplate实例通常需要自己进行定制，SpringBoot相关的自动配置bean。但是，SpringBoot提供了自动配置的RestTemplateBuilder，可以用它来创建RestTemplate实例。 那么，Sp
RestTemplate重试机制源码
06-14
当某些接口超时、返回的数据有问题时需要对接口进行重试，但是有的接口需要重试三次，有的需要重试两次，有的不需要重试；有的返回连接超时才重试，有的读取超时才重试，有的404才重试；有的返回－1才重试，有的返回null才重试；有的超时时间3秒，有的30秒。各种各样的场景，该源码实现了一个自定义定制化的重试RestTemplate
RestTemplate源码分析
总有刁民想害朕
02-17 278
看RestTemplate的构造函数。可以看到，RestTemplate维护了一个List的变量messageConverters，再构造方法中，往这个list中添加了各种MessageConverter（存在指定的JSON工具包时就添加到这个List中）。 public class RestTemplate extends InterceptingHttpAccessor implements RestOperations { private static final boolean romePr
RestTemplate 解析
wangqiubo2010的博客
08-15 2061
本文主要讲解RestTemplate 的原理，具体的使用会链接其他博文。 RestTemplate的本质就是再Http的网络请求中增加一个马甲，用户只要通过 url即可进行服务器访问，也就是RestTemplate底层只是封装了一层网络请求，这就是RestTemplate的本质所在。 RestTemplate是Spring提供的用于访问Rest服务的客户端， RestTemplate提供了多...
Spring Cloud之RestTemplate和Feign的使用和源码解析
m0_38105115的博客
04-22 1068
介绍 在Spring cloud有两种服务调用方式，一种是ribbon+restTemplate，另一种是feign，feign注解化更方便使用。 ribbon是一个负载均衡客户端，可以很好的控制http和tcp的一些行为。Feign默认集成了ribbon。RestTemplate中 @LoadBalanced表明这个restRemplate开启负载均衡的功能。 Feign 1，添加依赖 <...
SpringBoot RestTemplate源码分析
zhanjianshinian的专栏
07-02 1404
类定义为public class RestTemplate extends InterceptingHttpAccessor implements RestOperations，
RestTemplate例子
06-01
NULL 博文链接：https://kanpiaoxue.iteye.com/blog/2111780
RestTemplate源码解读
打酱油的葫芦娃
04-25 5738
引言 SpringCloud的微服务均是以Http接口的形式来暴露自身服务的，因此在调用远程服务的时候必须使用HTTP客户端，可选的方案有JDK原生的URL Connection、Apache的Http Client、Netty的异步Http Client，Spring的RestTemplate和Fegin。 今天主要介绍一下Spring的RestTemplate。 源码跟读 通过源码可以看到Re...
RestTemplate源码浅析
weixin_42073629的博客
07-04 278
近几年来,以信息为中心的表述性状态转移(Representational State Transfer，REST)已经称为替代传统SOAP Web 服务的流行方案。 REST与RPC几乎没有任何关系。RPC是面向服务的，并关注于行为和动作；而REST是面向资源的，强调描述应用程序的事物和名词。 RestTemplate定义了36个与REST资源交互的方法，其中的大多数都对应于HTTP的方法。 其实，这里面只有11个独立的方法，其中有十个有三种重载形式，而第十一个则重载了六次，这样一共形成了36个方法。
RestTemplate源码分析一
那年的夏天的博客
11-21 271
RestTemplate源码分析一设计模式 设计模式 1.AbstractClientHttpRequest这个抽象类使用了模板方法设计模式，在这个方法里面定义了基础的执行流程，子类只需继承实现抽象方法即可。 /* * Copyright 2002-2014 the original author or authors. * * Licensed under the Apache Licen...
Spring中RestTemplate源码解析
MieMieFly的专栏
10-21 253
在实现客户端的负载均衡中，有一种简单的方式就是通过调用被@LoadBalanced注解过的RestTemplate来实现面向服务的接口调用。 例如： @Bean @LoadBalanced RestTemplate restTemplate() { //return new RestTemplate(); return new SimpleRestTemplateBuilder().build(); } 这里我没有使用默认的new RestTemplate()，我使用了自定义的配
简单了解RestTemplate源码
Leon_Jinhai_Sun的博客
01-14 136
RestTemplate需要使用一个实现了ClientHttpRequestFactory接口的类为其提供ClientHttpRequest实现。而ClientHttpRequest则实现封装了组装、发送HTTP消息，以及解析响应的的底层细节。 目前（5.1.8.RELEASE）的RestTemplate主要有四种ClientHttpRequestFactory的实现，它们分别是： 1. 基于JDK HttpURLConnection的SimpleClientHttpRe...
Spring RestTemplate源码分析
zhouping118的博客
07-24 1098
1.问题 本人在为pingss-sys脚手架(项目地址)写测试用例时，需要传送多项参数。在post请求中接收参数的方式： @PostMapping(value = "/save") public ApiResponse save(User entity) 此方式参数体必须为"name=test&sex=1"格式，但是在TestRestTemplate传送参数时，如果参数体为一个实体类...
Spring-Web（一） RestTemplate使用与源码浅析
Hello World!
09-03 826
RestTemplate 是 Spring Web 模块封装的一个基于Rest规范提供HTTP请求服务的工具，用于访问第三方的Rest接口。
Spring Cloud Ribbon源码解析：初始化与调用机制详解
总结来说，Spring Cloud Ribbon的源码解读揭示了它如何通过配置类的初始化和`RestTemplate`的巧妙设计，实现了服务的自动发现、负载均衡和异步请求处理。理解这些核心机制对于开发者在实际项目中运用Spring Cloud ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_金欣

谢谢老板的打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值