springboot spark 提交远程 springboot远程调用接口

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

• 说明
• 远程服务接口代码

• 项目结构如下
• pom.xml文件代码
• UserParam请求对象代码
• TestController代码
• application.yml代码

• PostMan本地调用接口效果
• RestTemplate调用服务代码

• 项目结构如下
• pom.xml文件代码
• UserParam请求对象代码
• RestTemplateConfig配置代码
• HttpComponentsClientRestfulHttpRequestFactory代码
• application.yml配置代码
• RestTestController代码

• 测试结果如下:

说明

这里记录一下我简单学习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>

UserParam请求对象代码

package com.project.test.dto;

import lombok.Data;

@Data
public class UserParam {

    private String username;
    private String password;
}

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;
    }

}

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>

UserParam请求对象代码

package com.project.restdemo.dto;

import lombok.Data;

@Data
public class UserParam {

    private String username;
    private String password;
}

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;
    }
}

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();

        }
    }
}

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<String, Object> 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<String> 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;
    }

}

测试结果如下:

调用接口getForObjectNonparametricTest如下:

调用接口getForEntityNonparametricTest如下:

调用接口getForObjectParameterGetRequestTest如下:

调用接口getForEntityParameterGetRequestTest如下:

调用接口getForObjectObjectGetRequestTest如下:

调用接口getForObjectPlaceholderGetRequestTest如下:

调用接口getForEntityPlaceholderGetRequestTest如下:

调用接口getForObjectNonparametricPostTest如下:

调用接口getForEntityNonparametricPostTest如下:

调用接口getForObjectParameterPostRequestTest如下:

调用接口getForEntityParameterPostRequestTest如下:

调用接口getForObjectParameterPostRequestTest2如下:

这个接口只是在代码里面在请求头里面加了请求数据格式，请求的数据和getForObjectParameterPostRequestTest是一样的。

调用接口getForObjectObjectPostRequestTest如下:

调用接口getForEntityObjectPostRequestTest如下:

调用接口getForObjectPlaceholderPostRequestTest如下:

调用接口getForEntityPlaceholderPostRequestTest如下:

调用接口test如下:

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