SpringBoot使用RestTemplate远程调用其他服务接口

说明

这里记录一下我简单学习RestTemplate远程调用其他服务接口的过程。怕以后忘记怎么使用，先做个笔记。

远程服务接口代码

这里我新建了一个项目，结构很简单，用来模拟远程服务。不涉及数据库表查询。

项目结构如下

pom.xml文件代码

		<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.project</groupId>
    <artifactId>test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test</name>
    <description>test</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--web依赖,内嵌入tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--lombok依赖,用来对象省略写set、get方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

UserParam请求对象代码

package com.project.test.dto;

import lombok.Data;

@Data
public class UserParam {

    private String username;
    private String password;
}
1
2
3
4
5
6
7
8
9
10

TestController代码

假设接口是以如下的http接口形式

package com.project.test.controller;

import com.project.test.dto.UserParam;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping(value = "/test")
public class TestController {

    /**
     *无参get请求
     */
    @GetMapping(value = "/queryNonparametricGetRequestTest")
    public Map<String, Object> queryNonparametricGetRequestTest(){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("name","张三");
        map.put("city","上海");
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("name","李四");
        map1.put("city","北京");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参get请求
     */
    @GetMapping(value = "/queryParameterGetRequestTest")
    public Map<String, Object> queryParameterGetRequestTest(@RequestParam(value = "username", required = false) String username,
                                                            @RequestParam(value = "password", required = false) String password){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("username",username);
        map.put("password",password);
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("username","李四");
        map1.put("password","test1234");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参get请求,以对象json形式
     */
    @GetMapping(value = "/queryObjectGetRequestTest")
    public Map<String, Object> queryObjectGetRequestTest(@RequestBody UserParam userParam){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("username",userParam.getUsername());
        map.put("password",userParam.getPassword());
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("username","李四");
        map1.put("password","test1234");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参get请求,以参数占位符形式
     */
    @GetMapping(value = "/queryPlaceholderGetRequestTest/{id}")
    public Map<String, Object> queryPlaceholderGetRequestTest(@PathVariable Long id){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("id",id);
        data.add(map);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *无参post请求
     */
    @PostMapping(value = "/queryNonparametricPostRequestTest")
    public Map<String, Object> queryNonparametricPostRequestTest(){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("name","张三");
        map.put("city","广州");
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("name","李四");
        map1.put("city","深圳");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参post请求,以参数形式
     */
    @PostMapping(value = "/queryParameterPostRequestTest")
    public Map<String, Object> queryParameterPostRequestTest(@RequestParam(value = "username", required = false) String username,
                                                            @RequestParam(value = "password", required = false) String password){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("username",username);
        map.put("password",password);
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("username","李四");
        map1.put("password","test1234");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参post请求,以对象json形式
     */
    @PostMapping(value = "/queryObjectPostRequestTest")
    public Map<String, Object> queryObjectPostRequestTest(@RequestBody UserParam userParam){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("username",userParam.getUsername());
        map.put("password",userParam.getPassword());
        data.add(map);
        Map<String, Object> map1=new HashMap<>();
        map1.put("username","李四");
        map1.put("password","test1234");
        data.add(map1);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

    /**
     *有参post请求,以参数占位符形式
     */
    @PostMapping(value = "/queryPlaceholderPostRequestTest/{id}")
    public Map<String, Object> queryPlaceholderPostRequestTest(@PathVariable Long id){
        Map<String, Object> returnMap = new HashMap<>();
        //此处省略业务sql查询。。。使用假数据模拟
        List<Map<String, Object>> data=new ArrayList<>();
        Map<String, Object> map=new HashMap<>();
        map.put("id",id);
        data.add(map);
        returnMap.put("code","200");
        returnMap.put("message","查询成功!");
        returnMap.put("result",data);
        return returnMap;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

application.yml代码

这里只设置了端口号为8081，怕与其他项目端口冲突

PostMan本地调用接口效果

这里在本地先用postman调用接口看一下返回的数据结构。
无参get请求queryNonparametricGetRequestTest接口方法返回结果如下:

有参get请求queryParameterGetRequestTest接口方法返回结果如下:

以json形式传参,有参get请求queryObjectGetRequestTest接口方法返回结果如下:

以占位符形式传参,有参get请求queryPlaceholderGetRequestTest接口方法返回结果如下:

无参post请求queryNonparametricPostRequestTest接口方法返回结果如下:

有参post请求queryParameterPostRequestTest接口方法返回结果如下:

以json形式传参,有参post请求queryObjectPostRequestTest接口方法返回结果如下:

以占位符形式传参,有参post请求queryPlaceholderPostRequestTest接口方法返回结果如下:

测试接口没有问题，然后我把这个服务打成jar包放到一台linux机器上面并使用nohup启动。

RestTemplate调用服务代码

这里我新建了一个项目，结构很简单，用来模拟调用远程服务。不涉及数据库表查询。

项目结构如下

pom.xml文件代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.project</groupId>
    <artifactId>rest-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rest-demo</name>
    <description>rest-demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!--web依赖,内嵌入tomcat,RestTempLate使用该依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--当使用get请求需要携带 body中的参数的时候 需要重写Http 版本号必须是4.3以上版本-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <!--用来将string的json格式字符串转换成json对象-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>
        <!--lombok依赖,用来对象省略写set、get方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

UserParam请求对象代码

package com.project.restdemo.dto;

import lombok.Data;

@Data
public class UserParam {

    private String username;
    private String password;
}
1
2
3
4
5
6
7
8
9
10

RestTemplateConfig配置代码

package com.project.restdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@Component
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());
        //支持http请求get方式以json对象的形式请求
        restTemplate.setRequestFactory(new HttpComponentsClientRestfulHttpRequestFactory());
        return restTemplate;
    }

    // 设置超时时间
    public ClientHttpRequestFactory clientHttpRequestFactory(){
        //创建一个httpClient简单工厂
        SimpleClientHttpRequestFactory factory=new SimpleClientHttpRequestFactory();
        //设置连接超时时间,单位ms
        factory.setConnectTimeout(15000);
        //设置读取超时时间,单位ms
        factory.setReadTimeout(10000);
        return factory;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

HttpComponentsClientRestfulHttpRequestFactory代码

package com.project.restdemo.config;

import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpUriRequest;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;

import java.net.URI;

public class HttpComponentsClientRestfulHttpRequestFactory extends HttpComponentsClientHttpRequestFactory {
    @Override
    protected HttpUriRequest createHttpUriRequest(HttpMethod httpMethod, URI uri) {

        if (httpMethod == HttpMethod.GET) {
            return new HttpGetRequestWithEntity(uri);
        }
        return super.createHttpUriRequest(httpMethod, uri);
    }

    /**
     * 定义HttpGetRequestWithEntity实现HttpEntityEnclosingRequestBase抽象类，以支持GET请求携带body数据
     */
    private static final class HttpGetRequestWithEntity extends HttpEntityEnclosingRequestBase {
        public HttpGetRequestWithEntity(final URI uri) {
            super.setURI(uri);
        }

        @Override
        public String getMethod() {
            return HttpMethod.GET.name();

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

application.yml配置代码

只配置了端口号，这样多个项目同时启动不会端口冲突

RestTestController代码

这里面每一个调用远程服务方法都写了怎么使用getForObject或者getForEntity或者postForObject或者postForEntity，之所以这么写是为了看下getForObject和getForEntity有什么区别。
这里一共写了17个方法，最后一个方法更偏向实际应用，前面16个方法参数值都是写死的。

package com.project.restdemo.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.project.restdemo.dto.UserParam;
import org.springframework.http.*;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping(value = "/rest")
public class RestTestController {

    @Resource
    private RestTemplate restTemplate;

    /**
     *测试远程服务无参get请求queryNonparametricGetRequestTest方法
     * restTemplate里面的getForObject方法，也就是以get的形式访问接口
     */
    @GetMapping(value = "/getForObjectNonparametricTest")
    public String getForObjectNonparametricTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryNonparametricGetRequestTest";

        // 发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.getForObject(url, String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务无参get请求queryNonparametricGetRequestTest方法
     * restTemplate里面的getForEntity方法，也就是以get的形式访问接口
     */
    @GetMapping(value = "/getForEntityNonparametricTest")
    public String getForEntityNonparametricTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryNonparametricGetRequestTest";

        // 发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是getForEntity比getForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务有参get请求queryParameterGetRequestTest方法
     * restTemplate里面的getForObject方法，也就是以get的形式访问接口
     */
    @PostMapping(value = {"/getForObjectParameterGetRequestTest"})
    public String getForObjectParameterGetRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryParameterGetRequestTest?username={username}&password={password}";

        //提交参数设置,这里map里面的key要与请求地址里面占位符名一样,{username}对应map的key:username
        Map<String, Object> map = new HashMap<>();
        map.put("username", "张三");
        map.put("password", "test111");

        // 发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        //第3个参数：参数值，这里有Map和 可变参数两种形式
        //第一种方式通过map参数占位符形式填充参数
        String result = restTemplate.getForObject(url, String.class,map);
        //第二种方式通过可变参数形式直接填充参数,这种方式就不需要map集合了,二者执行结果一致。
        //String result = restTemplate.getForObject(url, String.class,"张三","test111");
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参get请求queryParameterGetRequestTest方法,以拼接方式接收参数
     *restTemplate里面的getForEntity方法，也就是以get的形式访问接口
     */
    @PostMapping(value = {"/getForEntityParameterGetRequestTest"})
    public String getForEntityParameterGetRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryParameterGetRequestTest?username={username}&password={password}";

        //提交参数设置,这里map里面的key要与请求地址里面占位符名一样,{username}对应map的key:username
        Map<String, Object> map = new HashMap<>();
        map.put("username", "张三");
        map.put("password", "test111");

        // 发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        //第3个参数：参数值，这里有Map和 可变参数两种形式
        //第一种方式通过map参数占位符形式填充参数
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class,map);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是getForEntity比getForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务有参get请求queryObjectGetRequestTest方法,以json对象方式接收参数
     * 特殊形式请求,原restTemplate不支持get以son对象方式传递参数
     * 这种形式的远程接口必须要依赖httpclient的jar包，扩展支持get请求以json对象形式接收参数,只用getForObject或者getForEntity方法无法完成请求
     */
    @PostMapping(value = {"/getForObjectObjectGetRequestTest"})
    public String getForObjectObjectGetRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryObjectGetRequestTest";

        // 请求头设置,application/json格式的数据
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
        headers.add("Accept",MediaType.APPLICATION_JSON.toString());
        headers.add("Accept-Charset","UTF-8");

        //提交参数设置
        UserParam userParam=new UserParam();
        userParam.setUsername("张三");
        userParam.setPassword("test111");

        // 组装请求体
        HttpEntity<?> request = new HttpEntity<>(userParam, headers);

        // 发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求方式
        //第3个参数：请求数据格式加参数值
        //第4个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, request, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是getForEntity比getForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务有参get请求queryPlaceholderGetRequestTest方法
     * restTemplate里面的getForObject方法，也就是以get的形式访问接口
     */
    @PostMapping(value = {"/getForObjectPlaceholderGetRequestTest"})
    public String getForObjectPlaceholderGetRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryPlaceholderGetRequestTest/{id}";

        //提交参数设置,这里map里面的key要与请求地址里面占位符名一样,{id}对应map的key:id
        //Map map = new HashMap<>();
        //map.put("id", 11);

        //发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        //第3个参数：参数值，这里有Map和直接填充参数两种形式
        //第一种方式通过map参数占位符形式填充参数
        //String result = restTemplate.getForObject(url, String.class,map);
        //第二种方式通过直接填充参数,这种方式就不需要map集合了,二者执行结果一致。
        String result = restTemplate.getForObject(url, String.class,11);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参get请求queryPlaceholderGetRequestTest方法
     * restTemplate里面的getForEntity方法，也就是以get的形式访问接口
     */
    @PostMapping(value = {"/getForEntityPlaceholderGetRequestTest"})
    public String getForEntityPlaceholderGetRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryPlaceholderGetRequestTest/{id}";

        //提交参数设置,这里map里面的key要与请求地址里面占位符名一样,{id}对应map的key:id
        Map<String, Object> map = new HashMap<>();
        map.put("id", 11);

        //发送get请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        //第3个参数：参数值，这里有Map和直接填充参数两种形式
        //第一种方式通过map参数占位符形式填充参数
        ResponseEntity<String> responseEntity = restTemplate.getForEntity(url, String.class,map);
        //第二种方式通过直接填充参数,这种方式就不需要map集合了,二者执行结果一致。
        //ResponseEntity responseEntity = restTemplate.getForEntity(url, String.class,11);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是getForEntity比getForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务无参post请求queryNonparametricPostRequestTest方法
     * restTemplate里面的postForObject方法，也就是以post的形式访问接口
     */
    @GetMapping(value = "/getForObjectNonparametricPostTest")
    public String getForObjectNonparametricPostTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryNonparametricPostRequestTest";

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, null,String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务无参post请求queryNonparametricPostRequestTest方法
     * restTemplate里面的postForEntity方法，也就是以post的形式访问接口
     */
    @GetMapping(value = "/getForEntityNonparametricPostTest")
    public String getForEntityNonparametricPostTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryNonparametricPostRequestTest";

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, null, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是postForEntity比postForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务有参post请求queryParameterPostRequestTest方法
     * restTemplate里面的postForObject方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForObjectParameterPostRequestTest")
    public String getForObjectParameterPostRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryParameterPostRequestTest";

        //post请求不能用HashMap来传递参数，接口接收不到参数会报错
        //提交参数设置
        MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("username", "张三");
        map.add("password", "test111");

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, map,String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参post请求queryParameterPostRequestTest方法
     * restTemplate里面的postForEntity方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForEntityParameterPostRequestTest")
    public String getForEntityParameterPostRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryParameterPostRequestTest";

        //post请求不能用HashMap来传递参数，接口接收不到参数会报错
        //提交参数设置
        MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("username", "张三");
        map.add("password", "test111");

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, map, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是postForEntity比postForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     * 指定提交的数据格式
     *测试远程服务有参post请求queryParameterPostRequestTest方法
     * restTemplate里面的postForObject方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForObjectParameterPostRequestTest2")
    public String getForObjectParameterPostRequestTest2(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryParameterPostRequestTest";

        // 请求头设置,指定数据以x-www-form-urlencoded格式的数据传递参数
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

        //post请求不能用HashMap来传递参数，接口接收不到参数会报错
        //提交参数设置
        MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("username", "张三");
        map.add("password", "test111");

        // 组装请求体
        HttpEntity<MultiValueMap<String, Object>> request = new HttpEntity<MultiValueMap<String, Object>>(map, headers);

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, request,String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参post请求queryObjectPostRequestTest方法
     * restTemplate里面的postForObject方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForObjectObjectPostRequestTest")
    public String getForObjectObjectPostRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryObjectPostRequestTest";

        // 请求头设置,指定数据以application/json格式的数据格式的数据传递参数
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
        headers.add("Accept",MediaType.APPLICATION_JSON.toString());
        headers.add("Accept-Charset","UTF-8");

        //提交参数设置
        UserParam userParam=new UserParam();
        userParam.setUsername("张三");
        userParam.setPassword("test111");

        // 组装请求体
        HttpEntity<UserParam> request = new HttpEntity<>(userParam, headers);

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, request,String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参post请求queryObjectPostRequestTest方法
     * restTemplate里面的postForEntity方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForEntityObjectPostRequestTest")
    public String getForEntityObjectPostRequestTest(){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryObjectPostRequestTest";

        // 请求头设置,指定数据以application/json格式的数据格式的数据传递参数
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
        headers.add("Accept",MediaType.APPLICATION_JSON.toString());
        headers.add("Accept-Charset","UTF-8");

        //提交参数设置
        UserParam userParam=new UserParam();
        userParam.setUsername("张三");
        userParam.setPassword("test111");

        // 组装请求体
        HttpEntity<UserParam> request = new HttpEntity<>(userParam, headers);

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, request, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是postForEntity比postForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试远程服务有参post请求queryPlaceholderPostRequestTest方法
     * restTemplate里面的postForObject方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForObjectPlaceholderPostRequestTest")
    public String getForObjectPlaceholderPostRequestTest(@RequestParam(value = "id", required = false) Integer id){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryPlaceholderPostRequestTest/"+id;

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, null,String.class);
        System.out.println(result);
        return result;
    }

    /**
     *测试远程服务有参post请求queryPlaceholderPostRequestTest方法
     * restTemplate里面的postForEntity方法，也就是以post的形式访问接口
     */
    @PostMapping(value = "/getForEntityPlaceholderPostRequestTest")
    public String getForEntityPlaceholderPostRequestTest(@RequestParam(value = "id", required = false) Integer id){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryPlaceholderPostRequestTest/"+id;

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, null, String.class);
        String body = responseEntity.getBody(); // 获取响应体
        System.out.println("HTTP 响应body：" + body);

        //以下是postForEntity比postForObject多出来的内容
        HttpStatus statusCode = responseEntity.getStatusCode(); // 获取响应码
        int statusCodeValue = responseEntity.getStatusCodeValue(); // 获取响应码值
        HttpHeaders httpHeaders = responseEntity.getHeaders(); // 获取响应头

        System.out.println("HTTP 响应状态：" + statusCode);
        System.out.println("HTTP 响应状态码：" + statusCodeValue);
        System.out.println("HTTP Headers信息：" + httpHeaders);
        return body;
    }

    /**
     *测试
     */
    @PostMapping(value = "/test")
    public Object test(@RequestBody UserParam userParam){
        // 请求地址
        String url = "http://你的远程服务ip:服务端口号/test/queryObjectPostRequestTest";

        // 请求头设置,指定数据以application/json格式的数据格式的数据传递参数
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
        headers.add("Accept",MediaType.APPLICATION_JSON.toString());
        headers.add("Accept-Charset","UTF-8");

        // 组装请求体
        HttpEntity<UserParam> request = new HttpEntity<>(userParam, headers);

        // 发送post请求，并打印结果，以String类型接收响应结果JSON字符串
        //第1个参数：请求的url地址
        //第2个参数：请求的字段参数加数据格式
        //第3个参数：返回的结果类型，这里String.class表示返回结果是一个字符串。
        String result = restTemplate.postForObject(url, request,String.class);
        System.out.println(result);
        JSONObject jsonObject =  JSON.parseObject(result);
        System.out.println(jsonObject);
        return jsonObject;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516

测试结果如下:

调用接口getForObjectNonparametricTest如下:


调用接口getForEntityNonparametricTest如下:


调用接口getForObjectParameterGetRequestTest如下:


调用接口getForEntityParameterGetRequestTest如下:


调用接口getForObjectObjectGetRequestTest如下:


调用接口getForObjectPlaceholderGetRequestTest如下:


调用接口getForEntityPlaceholderGetRequestTest如下:


调用接口getForObjectNonparametricPostTest如下:


调用接口getForEntityNonparametricPostTest如下:


调用接口getForObjectParameterPostRequestTest如下:


调用接口getForEntityParameterPostRequestTest如下:


调用接口getForObjectParameterPostRequestTest2如下:
这个接口只是在代码里面在请求头里面加了请求数据格式，请求的数据和getForObjectParameterPostRequestTest是一样的。
调用接口getForObjectObjectPostRequestTest如下:


调用接口getForEntityObjectPostRequestTest如下:


调用接口getForObjectPlaceholderPostRequestTest如下:


调用接口getForEntityPlaceholderPostRequestTest如下:


调用接口test如下:

好了，就先写这些通用方法的get和post远程调用方法。这里只写了在开发过程中可能遇到的请求形式。等以后有新的在补充一下。