天天看点
返回

Springboot RestTemplate post/get请求所有情况

项目结构附图如下：

Springboot RestTemplate post/get请求所有情况

1. 准备服务提供者

1.1 创建service-provider的项目

1.1.1 pom.xml如下： 

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.16.RELEASE</version>
    </parent>
 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

1.1.2 application.yml如下 

server:
  port: 8080
spring:
  application:
    name: post-get-provider

1.1.4 入口类App.java 

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

1.1.5 接口类TestController.java，主要是为了给restTemplate提供访问的地址准备的。 

@RestController
public class TestController {

    /**
     * 1.无参数get请求
     */
    @GetMapping("/get")
    public String get() {
        return "无参数 get";
    }

    /**
     * 2.有参数get请求  问号传参
     */
    @GetMapping("/get1")
    public String get1(@RequestParam("name") String name) {
        return "有参 get :" + name;
    }

    /**
     * 3.有参get请求 restful风格
     */
    @GetMapping("/get2/{name}")
    public List<User> get2(@PathVariable("name") String name) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            User user = new User();
            user.setId(i);
            user.setName("tom--" + i);
            user.setHobby("cup-" + i);
            list.add(user);
        }
        return list;
    }

    /**
     * 4.get需要设置header
     */
    @GetMapping("/get3")
    public String get3(@RequestParam("name") String name, @RequestHeader("token") String token) {
        return "设置header的get: name: " + name + ",token:" + token;
    }

    /**
     * 4.1 .get需要设置header 返回值是List
     */
    @GetMapping("/get4")
    public List<User> get4(@RequestParam("name") String name, @RequestHeader("token") String token) {
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            User user = new User();
            user.setId(i);
            user.setName("tom--" + i);
            user.setHobby("cup-" + i);
            list.add(user);
        }
        return list;
    }

    /**
     * 4.2 .get需要设置header 返回值是对象
     */
    @GetMapping("/get5")
    public User get5(@RequestParam("name") String name, @RequestHeader("token") String token) {
        User user = new User();
        user.setId(1111);
        user.setName("tom");
        user.setHobby("baskeball");
        return user;
    }

    /**
     * 4.3 .get需要设置header 返回值是对象 带有泛型
     */
    @GetMapping("/get6")
    public Student<User> get6(@RequestParam("name") String name, @RequestHeader("token") String token) {
        User user = new User();
        user.setId(1111);
        user.setName("tom");
        user.setHobby("baskeball");
        Student<User> su = new Student<>();
        su.setId(user.getId() + "");
        su.setName(user.getName());
        su.setT(user);
        System.out.println(su.toString());
        return su;
    }
    
    /**
     * 5.post请求
     */
    @PostMapping("/post")
    public User post1(@RequestBody User user) {
        user.setId(1111);
        user.setName("tom");
        user.setHobby("baskeball");
        return user;
    }

    /**
     * 6.post请求 带有header
     */
    @PostMapping("/post2")
    public User post2(@RequestBody User user, @RequestHeader("token") String token) {
        user.setId(1111);
        user.setName(user.getName() + ":" + token);
        user.setHobby(user.getHobby() + ":" + token);
        return user;
    }

    /**
     * 7.post请求 带有header 带有问号传参
     */
    @PostMapping("/post3")
    public User post3(@RequestParam("name")String name,
                      @RequestBody User user,
                      @RequestHeader String token){
        user.setName(name);
        user.setId(11111);
        user.setHobby(token);
        return user;
    }

    /**
     * 8.post请求 带有header 带有restful风格传参
     */
    @PostMapping("/post4/{name}")
    public User post4(@PathVariable("name")String name,
                      @RequestBody User user,
                      @RequestHeader("token") String token){
        user.setName(name);
        user.setId(11111);
        user.setHobby(token);
        return user;
    }

    /**
     * 9.post请求 form表单提交参数
     */
    @PostMapping("/post5")
    public User post5(User user){
        user.setHobby("post5");
        user.setId(999);
        user.setName("9090");
        return user;
    }

    /**
     * 9.post请求 form表单提交对象参数，带有header，带有问号传参
     */
    @PostMapping("/post6")
    public User post6(User user,@RequestParam("name")String name,@RequestHeader("token")String token){
        user.setHobby("post5");
        user.setId(999);
        user.setName("9090");
        return user;
    }
}

1.1.6 实体类User.java，省略get/set方法 

public class User {
    private int id;
    private String name;
    private String hobby;
}

1.1.7 实体类Student.java，省略get/set方法 

public class Student<T> {
    private String id;
    private String name;
    private T t;
}

1.1.8 运行App.java,提供接口服务。

2.服务消费者

2.1 创建service-consumer的项目

2.1.1 pom.xml如下： 

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.16.RELEASE</version>
    </parent>
 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>
    </dependencies>

2.1.2 application.yml 

server:
  port: 8081
spring:
  application:
    name: post-get-consumer

2.1.3 App.java启动类 

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

2.1.4 RestTemplateConfig.java配置类 

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

2.1.5 实体类Student.java 

public class Student<T> {
    private String id;
    private String name;
    private T t;
}

2.1.6 实体类User.java 

public class User {
    private int id;
    private String name;
    private String hobby;
}

2.1.7 测试类AppTest.java 

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public class AppTest {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 1.无参数 get请求
     */
    @Test
    public void test1() {
        String result = restTemplate.getForObject("http://localhost:8080/get", String.class);
        System.out.println(result);
    }

    /**
     * 2.有参数 get请求 问号传参
     */
    @Test
    public void test2() {
        String result = restTemplate.getForObject("http://localhost:8080/get1?name=zs", String.class);
        System.out.println(result);
    }

    /**
     * 3.有参数 get请求 restful风格参数 返回值是List
     */
    @Test
    public void test3() {
        List result = restTemplate.getForObject("http://localhost:8080/get2/lisi", List.class);
        System.out.println(result);
    }

    /**
     * 4.有参数 get请求 需要设置header值  返回值是基础类型String
     */
    @Test
    public void test4() {
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("token", "123456");
        HttpEntity httpEntity = new HttpEntity(map);
        //设置header和返回值类型
        RequestCallback requestCallback = restTemplate.httpEntityCallback(httpEntity, String.class);
        //设置响应值解析
        ResponseExtractor<ResponseEntity<String>> responseExtractor = restTemplate.responseEntityExtractor(String.class);
        ResponseEntity<String> response = restTemplate.execute("http://localhost:8080/get3?name=ww", HttpMethod.GET, requestCallback, responseExtractor);
        System.out.println(response.getBody());
    }

    /**
     * 5.有参数 get请求 需要设置header值  返回值是List类型
     */
    @Test
    public void test5() {
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("token", "123456");
        HttpEntity httpEntity = new HttpEntity(map);
        //设置header和返回值类型
        RequestCallback requestCallback = restTemplate.httpEntityCallback(httpEntity, List.class);
        //设置响应值解析
        ResponseExtractor<ResponseEntity<List>> responseExtractor = restTemplate.responseEntityExtractor(List.class);
        ResponseEntity<List> response = restTemplate.execute("http://localhost:8080/get4?name=ww", HttpMethod.GET, requestCallback, responseExtractor);
        System.out.println(response.getBody());
    }

    /**
     * 6.有参数 get请求 需要设置header值  返回值是对象类型
     */
    @Test
    public void test6() {
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("token", "123456");
        HttpEntity httpEntity = new HttpEntity(map);
        //设置header和返回值类型
        RequestCallback requestCallback = restTemplate.httpEntityCallback(httpEntity, User.class);
        //设置响应值解析
        ResponseExtractor<ResponseEntity<User>> responseExtractor = restTemplate.responseEntityExtractor(User.class);
        ResponseEntity<User> response = restTemplate.execute("http://localhost:8080/get5?name=ww", HttpMethod.GET, requestCallback, responseExtractor);
        System.out.println(response.getBody().toString());
    }

    /**
     * 7.有参数 get请求 需要设置header值  返回值是对象类型 带有泛型
     */
    @Test
    public void test7() {
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("token", "123456");
        HttpEntity httpEntity = new HttpEntity(map);
        //设置header和返回值类型
        RequestCallback requestCallback = restTemplate.httpEntityCallback(httpEntity, Student.class);
        //设置响应值解析
        ResponseExtractor<ResponseEntity<Student>> responseExtractor = restTemplate.responseEntityExtractor(Student.class);
        ResponseEntity<Student> response = restTemplate.execute("http://localhost:8080/get6?name=ww", HttpMethod.GET, requestCallback, responseExtractor);
        System.out.println(response.getBody().toString());
    }

    /**
     * 7.有参数 get请求 需要设置header值  返回值是对象 使用Object 接收
     */
    @Test
    public void test8() {
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("token", "123456");
        HttpEntity httpEntity = new HttpEntity(map);
        //设置header和返回值类型
        RequestCallback requestCallback = restTemplate.httpEntityCallback(httpEntity, Object.class);
        //设置响应值解析
        ResponseExtractor<ResponseEntity<Object>> responseExtractor = restTemplate.responseEntityExtractor(Object.class);
        ResponseEntity<Object> response = restTemplate.execute("http://localhost:8080/get6?name=ww", HttpMethod.GET, requestCallback, responseExtractor);
        System.out.println(response.toString());
        //使用JSON   new TypeReference带上泛型，解析Object
        Student<User> result = JSON.parseObject(JSON.toJSONString(response.getBody()), new TypeReference<Student<User>>() {
        });
        System.out.println(result.toString());
    }


    //-----------------------------post------------------------------------------------------------

    /**
     * post  请求   对象参数  postForEntity
     */
    @Test
    public void test9() {
        String url = "http://localhost:8080/post";
        JSONObject param = new JSONObject();
        param.put("id", 1);
        param.put("name", "adff");
        param.put("hobby", "afdfasdfds");
        /**
         * postForEntity::
         * url: 请求的地址
         * param: 请求的参数-必须是JSONObject
         * User.class: 返回值的泛型class
         */
        ResponseEntity<User> rs = restTemplate.postForEntity(url, param, User.class);
        System.out.println(JSON.toJSONString(rs.getBody()));
    }

    /**
     * post 请求 对象参数  方式二  postForObject
     */
    @Test
    public void test10() {
        String url = "http://localhost:8080/post";
        User user = new User();
        user.setId(222);
        user.setName("fdafdsf");
        user.setHobby("Fdsafds");
        /**
         * postForObject:
         * url: 请求的地址
         * user: 请求的参数-必须是实体对象
         * User.class: 返回值的泛型class
         */
        User rs = restTemplate.postForObject(url, user, User.class);
        System.out.println(JSON.toJSONString(rs.toString()));
    }

    /**
     * post 请求  对象参数 带有header
     */
    @Test
    public void test11() {
        String url = "http://localhost:8080/post2";
        //创建Header对象，设置header信息和请求方式
        HttpHeaders headers = new HttpHeaders();
        headers.add("token","xxx");
        headers.setContentType(MediaType.APPLICATION_JSON);
        User user1 = new User();
        user1.setId(1111);
        user1.setName("fdasf");
        user1.setHobby("fdsaf");
        //将header信息和请求参数封装在HttpEntity中
        HttpEntity<User> userHttpEntity = new HttpEntity<>(user1, headers);
        User user = restTemplate.postForObject(url, userHttpEntity, User.class);
        System.out.println(user.toString());
    }

    /**
     * post 请求  对象参数  带有header 带有问号传参
     */
    @Test
    public void test12(){
        String url = "http://localhost:8080/post3?name=nihao";
        //创建Header对象，设置header信息和请求方式
        HttpHeaders headers = new HttpHeaders();
        headers.add("token","xxx");
        headers.setContentType(MediaType.APPLICATION_JSON);
        User user1 = new User();
        user1.setId(1111);
        user1.setName("fdasf");
        user1.setHobby("fdsaf");
        //将header信息和请求参数封装在HttpEntity中
        HttpEntity<User> userHttpEntity = new HttpEntity<>(user1, headers);
        User user = restTemplate.postForObject(url, userHttpEntity, User.class);
        System.out.println(user.toString());
    }

    /**
     * post 请求  对象参数  带有header 带有restful风格传参
     */
    @Test
    public void test13(){
        String url = "http://localhost:8080/post4/ww";
        //创建Header对象，设置header信息和请求方式
        HttpHeaders headers = new HttpHeaders();
        headers.add("token","xxx");
        headers.setContentType(MediaType.APPLICATION_JSON);
        User user1 = new User();
        user1.setId(1111);
        user1.setName("fdasf");
        user1.setHobby("fdsaf");
        //将header信息和请求参数封装在HttpEntity中
        HttpEntity<User> userHttpEntity = new HttpEntity<>(user1, headers);
        User user = restTemplate.postForObject(url, userHttpEntity, User.class);
        System.out.println(user.toString());
    }

    /**
     * post 请求  对象参数  表单请求方式  直接使用对象传参
     */
    @Test
    public void test14(){
        String url = "http://localhost:8080/post5";
        User user = new User();
        user.setId(222);
        user.setName("fdafdsf");
        user.setHobby("Fdsafds");
        /**
         * postForObject:
         * url: 请求的地址
         * user: 请求的参数-必须是实体对象
         * User.class: 返回值的泛型class
         */
        User rs = restTemplate.postForObject(url, user, User.class);
        System.out.println(JSON.toJSONString(rs.toString()));
    }

    /**
     * post 请求  对象参数  表单请求方式  使用MultiValueMap传递参数
     */
    @Test
    public void test15(){
        String url = "http://localhost:8080/post5";
        LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("id",111);
        map.add("name","fdasf");
        map.add("hobby","fdsafdsa");
        /**
         * postForObject:
         * url: 请求的地址
         * user: 请求的参数-必须是实体对象
         * User.class: 返回值的泛型class
         */
        User rs = restTemplate.postForObject(url, map, User.class);
        System.out.println(JSON.toJSONString(rs.toString()));
    }

    /**
     * post 请求 表单请求方式  对象传参  问号传参 带有header 方式2： 使用MultiValueMap传参
     */
    @Test
    public void test16(){
        String url = "http://localhost:8080/post6?name=nihao";
        //创建Header对象，设置header信息和请求方式
        HttpHeaders headers = new HttpHeaders();
        headers.add("token","xxx");
        headers.setContentType(MediaType.APPLICATION_JSON);
        User user1 = new User();
        user1.setId(1111);
        user1.setName("fdasf");
        user1.setHobby("fdsaf");
        //将header信息和请求参数封装在HttpEntity中
        HttpEntity<User> userHttpEntity = new HttpEntity<>(user1, headers);
        User user = restTemplate.postForObject(url, userHttpEntity, User.class);
        System.out.println(user.toString());
    }

    /**
     * post 请求 表单请求方式  对象传参  问号传参 带有header 方式1： 使用对象传参
     */
    @Test
    public void test17(){
        String url = "http://localhost:8080/post6?name=nihao";
        //创建Header对象，设置header信息和请求方式
        HttpHeaders headers = new HttpHeaders();
        headers.add("token","xxx");
        headers.setContentType(MediaType.APPLICATION_JSON);
        LinkedMultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
        map.add("id",111);
        map.add("name","fdasf");
        map.add("hobby","fdsafdsa");
        //将header信息和请求参数封装在HttpEntity中
        HttpEntity<LinkedMultiValueMap<String, Object>> entity = new HttpEntity<>(map, headers);
        User user = restTemplate.postForObject(url, entity, User.class);
        System.out.println(user.toString());
    }
}
Java篇
上一篇: linux如何编写crontab定时脚本,linux下编写定时任务crontab
下一篇: leetcode-- 674. 最长连续递增序列一、题目二、代码

继续阅读