使用RestTemplate进行restful调用，你真的会了吗-阿里云开发者社区

RestTemplate是一种更优雅的调用RESTful服务的方式，并且能结合Ribbon一起使用。

概述

spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接，我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。

在Spring应用程序中访问第三方REST服务与使用Spring RestTemplate类有关。RestTemplate类的设计原则与许多其他Spring *模板类(例如JdbcTemplate、JmsTemplate)相同，为执行复杂任务提供了一种具有默认行为的简化方法。

RestTemplate默认依赖JDK提供http连接的能力（HttpURLConnection），如果有需要的话也可以通过setRequestFactory方法替换为例如 Apache HttpComponents、Netty或OkHttp等其它HTTP library。

考虑到RestTemplate类是为调用REST服务而设计的，因此它的主要方法与REST的基础紧密相连就不足为奇了，后者是HTTP协议的方法:HEAD、GET、POST、PUT、DELETE和OPTIONS。例如，RestTemplate类具有headForHeaders()、getForObject()、postForObject()、put()和delete()等方法。

实现

get请求

请求接口

@GetMapping("/users")
    public String getUser1(String username, HttpServletRequest request){
        return "获取用户"+username+"的信息";
    }
    @GetMapping("/users/{username}")
    public String getUser2(@PathVariable String username){
        return "获取用户"+username+"的信息";
    }

get请求

@Test
    public void getRequestTest(){
        RestTemplate template = new RestTemplate();
        String url = "http://127.0.0.1:8080/users?username={username}";
        String url2 = "http://127.0.0.1:8080/users/laowan";
        //1、使用getForObject请求接口,  顺序传入参数
        String result1 = template.getForObject(url, String.class, "laowan");
        System.out.println("result1====================" + result1);
        //2、使用getForObject请求接口   使用HashMap传入参数
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("username", "laowan");
        String result2 = template.getForObject(url, String.class, paramMap);
        System.out.println("result2====================" + result1);
        //3、使用url路径变量PathVariable
        String result3 = template.getForObject(url2, String.class);
        System.out.println("result3====================" + result1);
        ResponseEntity<String> responseEntity = template.getForEntity(url2, String.class);
        System.out.println("getForEntity请求====================" + responseEntity.getBody());
        //4、使用exchange请求接口
        ResponseEntity<String> response2 = template.exchange(url, HttpMethod.GET, null, String.class,paramMap);
        System.out.println("result4====================" + response2.getBody());
        //5、使用exchange请求接口，可以封装HttpEntity对象传递header参数
        HttpHeaders headers = new HttpHeaders();
        headers.set("username", "laowan");
        HttpEntity httpEntity = new HttpEntity(null,headers);
        ResponseEntity<String> response5 = template.exchange(url, HttpMethod.GET, httpEntity, String.class,paramMap);
        System.out.println("result5====================" + response5.getHeaders());
    }

注意事项

1.get请求的参数传递，一定要在url后面拼接，可以使用？号后面拼接，也可以采用路径参数。

2.传递参数有2中方法，一种是传入多个参数值，会按顺序填充到url后面的参数占位符中，一种是采用map传入多个参数，这时一定要使用HashMap

3.get请求如果需要传递header参数，一定要采用exchange方法，封装HttpEntity对象

post请求

请求接口

@PostMapping("/user")
    public User addUser(String username,Integer age){
        User user = new User();
        user.setAge(age);
        user.setUsername(username);
        log.info("新增用户{}", JSON.toJSONString(user));
        return user;
    }
    @PostMapping("/user/add")
    public User addUser(User user){
        log.info("新增用户{}", JSON.toJSONString(user));
        return user;
    }
    @PostMapping("/user/json")
    public User addUserJson(@RequestBody  User user){
        log.info("新增用户{}", JSON.toJSONString(user));
        return user;
    }

post请求

@Test
    public void postRequestTest() {
        String url = "http://127.0.0.1:8080/user";
        String url2 = "http://127.0.0.1:8080/user/add";
        RestTemplate template = new RestTemplate();
        MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<String, Object>();
        paramMap.add("username", "laowan");
        paramMap.add("age", 22);
        User user = template.postForObject(url, paramMap, User.class);
        log.info("result1的结果为：{}",user);
         user = template.postForObject(url2, paramMap, User.class);
        log.info("result2的结果为：{}",user);
    }
    //postForEntity方式的json请求
    @Test
    public void postRequestTest4() {
        String url2 = "http://127.0.0.1:8080/user/json";
        RestTemplate restTemplate = new RestTemplate();
        String reqJsonStr = "{\"username\":\"laowan\", \"age\":\"12\"}";
        HttpHeaders headers = new HttpHeaders(); 
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<String> entity = new HttpEntity<String>(reqJsonStr,headers);
        ResponseEntity<User> resp = restTemplate.postForEntity(url2,entity, User.class);
        log.info("result1的结果为：{}",resp.getBody());
    }
    //通过exchange调用post请求，传递json格式参数
    @Test
    public void postRequestTest2() {
        String url2 = "http://127.0.0.1:8080/user/json";
        RestTemplate restTemplate = new RestTemplate();
        String reqJsonStr = "{\"username\":\"laowan\", \"age\":\"12\"}";
       HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<String> entity = new HttpEntity<String>(reqJsonStr,headers);
        ResponseEntity<User> resp = restTemplate.exchange(url2, HttpMethod.POST, entity, User.class);
        log.info("result1的结果为：{}",resp.getBody());
    }
    //通过exchange调用post请求，传递x-www-form-urlencoded格式参数
    @Test
    public void postRequestTest3() {
        String url2 = "http://127.0.0.1:8080/user/add";
        RestTemplate restTemplate = new RestTemplate();
        MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<String, Object>();
        paramMap.add("username", "laowan");
        paramMap.add("age", 22);
        HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<MultiValueMap<String, Object>>(paramMap,headers);
        ResponseEntity<User> resp = restTemplate.exchange(url2, HttpMethod.POST, entity, User.class);
       if( resp.getStatusCode().equals( HttpStatus.OK )){
            log.info("result1的结果为：{}",resp.getBody());
        }else{
            throw new RuntimeException( resp.toString() );
        }
    }

注意事项

1.post请求传递普通参数，一定要使用LinkedMultiValueMap对参数进行封装，不然会接收不到参数值。

2.post请求可以传递json格式参数，需要在头部参数中指定headers.setContentType(MediaType.APPLICATION_JSON);

3.返回ResponseEntity结果，主要可以从中获取返回的状态码和请求头信息。可以方便对请求结果进行判定，对请求异常进行处理。

if( resp.getStatusCode().equals( HttpStatus.OK )){
            log.info("result1的结果为：{}",resp.getBody());
        }else{
            throw new RuntimeException( resp.toString() );
        }

结合ribbon使用

RestTemplate负载均衡示例

核心是通过@LoadBalanced注解声明RestTemplate实例，主要逻辑是给RestTemplate增加拦截器，在请求之前对请求的地址进行替换，或者根据具体的负载均衡策略选择服务地址，然后再去调用，这就是@LoadBalanced的原理。

引入jar包依赖

也可以不引用，eureka中已经引用了ribbon

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    <version>2.2.2.RELEASE</version>
</dependency>

将服务rest注册到Eureka

spring.application.name=rest

使用@LoadBalanced注解声明RestTemplate实例

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

调用接口

修改调用的url，将IP+PORT改为服务名称，也就是注册到Eureka的名称。

@SpringBootTest
class RestApplicationTests {
    @Autowired
    RestTemplate restTemplate;
    @Test
    void restRibbonTest() {
        String result3 = restTemplate.getForObject("http://rest/users/laowan", String.class);
    }
}

设置底层连接方式

实现原理是通过RestTemplate(ClientHttpRequestFactory requestFactory)的构造方法，指定requestFactory。

常规配置

@Bean
    @LoadBalanced
    public RestTemplate getRestTemplate(RestTemplateBuilder restTemplateBuilder){
        return  restTemplateBuilder
                .basicAuthentication("username", "password")
                .setConnectTimeout(Duration.ofSeconds(3000))
                .setReadTimeout(Duration.ofSeconds(5000))
                .rootUri("http://api.example.com/")
                .build();
       // return new RestTemplate();
    }

改用httpclient的实现

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.4.1</version>
</dependency>

@Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
      //   restTemplate.setRequestFactory(okHttpClient());
        restTemplate.setRequestFactory(clientHttpRequestFactory());
        //restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
        return restTemplate;
    }
@Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        try {
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                @Override
                public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                    return true;
                }
            }).build();
            httpClientBuilder.setSslcontext(sslContext);
            HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
            // 注册http和https请求
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslConnectionSocketFactory).build();
            // 开始设置连接池
            PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
            poolingHttpClientConnectionManager.setMaxTotal(500); // 最大连接数500
            poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100); // 同路由并发数100
            httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);
            httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)); // 重试次数
            HttpClient httpClient = httpClientBuilder.build();
            HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient); // httpClient连接配置
            clientHttpRequestFactory.setConnectTimeout(20000);              // 连接超时
            clientHttpRequestFactory.setReadTimeout(30000);                 // 数据读取超时时间
            clientHttpRequestFactory.setConnectionRequestTimeout(20000);    // 连接不够用的等待时间
            return clientHttpRequestFactory;
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
           // log.error("初始化HTTP连接池出错", e);
        }
        return null;
    }
}

改用okhttp的实现

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.11.0</version>
</dependency>

@Configuration
public class OkHttpConfig {
     @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setRequestFactory(okHttp3ClientHttpRequestFactory());
        //restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
        return restTemplate;
    }
    @Bean
    public OkHttp3ClientHttpRequestFactory okHttp3ClientHttpRequestFactory(){
        return new OkHttp3ClientHttpRequestFactory(okHttpClient());
    }
    @Bean
    public OkHttpClient okHttpClient() {
        return new OkHttpClient.Builder()
                .sslSocketFactory(sslSocketFactory(), x509TrustManager())
                .retryOnConnectionFailure(false)
                .connectionPool(pool())
                .connectTimeout(30, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30,TimeUnit.SECONDS)
                .build();
    }
    @Bean
    public X509TrustManager x509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            }
            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            }
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };
    }
    @Bean
    public SSLSocketFactory sslSocketFactory() {
        try {
            //信任任何链接
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom());
            return sslContext.getSocketFactory();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return null;
    }
    @Bean
    public ConnectionPool pool() {
        return new ConnectionPool(200, 5, TimeUnit.MINUTES);
    }
}

可以发现，在使用httpclient和okhttp都可以配置连接池connectionPool，相信能够在一定程度上提高http请求的速度。

手动指定转换器

调用reseful接口传递的数据内容是json格式的字符串，返回的响应也是json格式的字符串。然而restTemplate.postForObject方法的请求参数RequestBean和返回参数ResponseBean却都是java类。

是RestTemplate通过HttpMessageConverter自动帮我们做了转换的操作。

默认情况下RestTemplate自动帮我们注册了一组HttpMessageConverter用来处理一些不同的contentType的请求。

如StringHttpMessageConverter来处理text/plain;

MappingJackson2HttpMessageConverter来处理application/json;

MappingJackson2XmlHttpMessageConverter来处理application/xml。

RestTemplate的无参构造方法中的转化器配置部分源码：

this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
        if (romePresent) {
            this.messageConverters.add(new AtomFeedHttpMessageConverter());
            this.messageConverters.add(new RssChannelHttpMessageConverter());
        }
        if (jackson2XmlPresent) {
            this.messageConverters.add(new MappingJackson2XmlHttpMessageConverter());
        } else if (jaxb2Present) {
            this.messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
        }
        if (jackson2Present) {
            this.messageConverters.add(new MappingJackson2HttpMessageConverter());
        } else if (gsonPresent) {
            this.messageConverters.add(new GsonHttpMessageConverter());
        } else if (jsonbPresent) {
            this.messageConverters.add(new JsonbHttpMessageConverter());
        }

你可以在org.springframework.http.converter包下找到所有spring帮我们实现好的转换器。

如果现有的转换器不能满足你的需求，你还可以实现org.springframework.http.converter.HttpMessageConverter接口自己写一个。详情参考官方api。

选好了HttpMessageConverter后怎么把它注册到我们的RestTemplate中呢。

RestTemplate restTemplate = new RestTemplate();
    //获取RestTemplate默认配置好的所有转换器
    List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
    //默认的MappingJackson2HttpMessageConverter在第7个 先把它移除掉
    messageConverters.remove(6);
    //添加上GSON的转换器
    messageConverters.add(6, new GsonHttpMessageConverter());

这个简单的例子展示了如何使用GsonHttpMessageConverter替换掉默认用来处理application/json的MappingJackson2HttpMessageConverter。

总结

1、介绍了RestTemplate的常规调用方法和注意事项

2、RestTemplate结合Ribbon的负载均衡调用

3、RestTemplate底层连接的设置

4、RestTemplate的转换器设置

使用RestTemplate进行restful调用，你真的会了吗

概述

实现

get请求

请求接口

get请求

注意事项

post请求

请求接口

post请求

注意事项

结合ribbon使用

设置底层连接方式

手动指定转换器

总结

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

使用RestTemplate进行restful调用，你真的会了吗

概述

实现

get请求

请求接口

get请求

注意事项

post请求

请求接口

post请求

注意事项

结合ribbon使用

设置底层连接方式

手动指定转换器

总结

热门文章

最新文章

相关电子书