[Daily Business Development] Common ways for Java to call third-party http interfaces

News 2023-10-03 04:41:29 views: null

[Daily Business Development] Common ways for Java to call third-party http interfaces

Overview

In the actual development process, we often need to call the interface provided by the other party or test whether the interface we wrote is suitable. Many projects encapsulate and specify the interface specifications of their own projects, so most of them need to call the interface provided by the other party or a third-party interface (text messages, weather, etc.).

Common ways to call third-party interfaces in Java projects are:

  1. Via JDK network classesJava.net.HttpURLConnection

  2. Packaged through Apache commonHttpClient

  3. Packaged through ApacheCloseableHttpClient

  4. passOkHttp

  5. via SpringRestTemplate

  6. viahutoolHttpUtil

How Java calls third-party http interface

Via JDK network class Java.net.HttpURLConnection

Introduction: http requests provided by the native java api under the java.net package.

Steps for usage:

  1. Get the connector (java.net.URLConnection) through the Uniform Resource Locator (java.net.URL).

  2. Set the parameters of the request.

  3. send request.

  4. Get the returned content in the form of an input stream.

  5. Close the input stream.

A relatively primitive calling method, here put the get request and post request in one method, and directly enter the code:

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * @ClassName: HttpUrlConnectionToInterface
 * @Description: jdk类HttpURLConnection调用第三方http接口
 */
public class HttpUrlConnectionToInterface {
    
    

    /**
     * 以post方式调用对方接口方法
     * @param pathUrl
     */
    public static void doPost(String pathUrl, String data){
    
    
        OutputStreamWriter out = null;
        BufferedReader br = null;
        String result = "";
        try {
    
    
            URL url = new URL(pathUrl);

            //打开和url之间的连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            //设定请求的方法为"POST"，默认是GET
            //post与get的不同之处在于post的参数不是放在URL字串里面，而是放在http请求的正文内。
            conn.setRequestMethod("POST");

            //设置30秒连接超时
            conn.setConnectTimeout(30000);
            //设置30秒读取超时
            conn.setReadTimeout(30000);

            // 设置是否向httpUrlConnection输出，因为这个是post请求，参数要放在http正文内，因此需要设为true, 默认情况下是false;
            conn.setDoOutput(true);
            // 设置是否从httpUrlConnection读入，默认情况下是true;
            conn.setDoInput(true);

            // Post请求不能使用缓存
            conn.setUseCaches(false);

            //设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");  //维持长链接
            conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");

            //连接，从上述url.openConnection()至此的配置必须要在connect之前完成，
            conn.connect();

            /**
             * 下面的三句代码，就是调用第三方http接口
             */
            //获取URLConnection对象对应的输出流
            //此处getOutputStream会隐含的进行connect(即：如同调用上面的connect()方法，所以在开发中不调用上述的connect()也可以)。
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            //发送请求参数即数据
            out.write(data);
            //flush输出流的缓冲
            out.flush();

            /**
             * 下面的代码相当于，获取调用第三方http接口后返回的结果
             */
            //获取URLConnection对象对应的输入流
            InputStream is = conn.getInputStream();
            //构造一个字符流缓存
            br = new BufferedReader(new InputStreamReader(is));
            String str = "";
            while ((str = br.readLine()) != null){
    
    
                result += str;
            }
            System.out.println(result);
            //关闭流
            is.close();
            //断开连接，disconnect是在底层tcp socket链接空闲时才切断，如果正在被其他线程使用就不切断。
            conn.disconnect();

        } catch (Exception e) {
    
    
            e.printStackTrace();
        }finally {
    
    
            try {
    
    
                if (out != null){
    
    
                    out.close();
                }
                if (br != null){
    
    
                    br.close();
                }
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
    }

    /**
     * 以get方式调用对方接口方法
     * @param pathUrl
     */
    public static void doGet(String pathUrl){
    
    
        BufferedReader br = null;
        String result = "";
        try {
    
    
            URL url = new URL(pathUrl);

            //打开和url之间的连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            //设定请求的方法为"GET"，默认是GET
            //post与get的不同之处在于post的参数不是放在URL字串里面，而是放在http请求的正文内。
            conn.setRequestMethod("GET");

            //设置30秒连接超时
            conn.setConnectTimeout(30000);
            //设置30秒读取超时
            conn.setReadTimeout(30000);

            // 设置是否向httpUrlConnection输出，因为这个是post请求，参数要放在http正文内，因此需要设为true, 默认情况下是false;
            conn.setDoOutput(true);
            // 设置是否从httpUrlConnection读入，默认情况下是true;
            conn.setDoInput(true);

            // Post请求不能使用缓存(get可以不使用)
            conn.setUseCaches(false);

            //设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");  //维持长链接
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");

            //连接，从上述url.openConnection()至此的配置必须要在connect之前完成，
            conn.connect();

            /**
             * 下面的代码相当于，获取调用第三方http接口后返回的结果
             */
            //获取URLConnection对象对应的输入流
            InputStream is = conn.getInputStream();
            //构造一个字符流缓存
            br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            String str = "";
            while ((str = br.readLine()) != null){
    
    
                result += str;
            }
            System.out.println(result);
            //关闭流
            is.close();
            //断开连接，disconnect是在底层tcp socket链接空闲时才切断，如果正在被其他线程使用就不切断。
            conn.disconnect();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }finally {
    
    
            try {
    
    
                if (br != null){
    
    
                    br.close();
                }
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
    
    
        //post请求一般都是把实体对象转为Json字符串
        doGet("https://weather.cma.cn/api/climate?stationid=57516");
    }
}

HttpClient encapsulated through apache common

Introduction: The latest version of http client so far is version 5.1, official website address: http://hc.apache.org/. The Http client is designed for promotion and provides strong support for the basic http protocol. Although the java.net package provides basic functions for access via http, it does not provide the functions required by many applications.

Steps for usage:

  1. Generate an HttpClient object and set the corresponding parameters;
  2. Generate a GetMethod object or PostMethod and set the response parameters;
  3. Use the object generated by HttpClient to execute the Get method generated by GetMethod;
  4. Handle response status codes;
  5. If the response is normal, process the HTTP response content;
  6. Release the connection. Regardless of whether the execution method is successful or not, the connection must be released.
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.1</version>
</dependency>
<!--HttpClient-->
<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpMethodParams;

import java.io.IOException;

/**
 * @ClassName: HttpClientToInterface
 * @Description: HttpClient模拟get、post请求并发送请求参数（json等）
 */
public class HttpClientToInterface {
    
    

    /**
     * httpClient的get请求方式
     * 使用GetMethod来访问一个URL对应的网页实现步骤：
     * 1.生成一个HttpClient对象并设置相应的参数；
     * 2.生成一个GetMethod对象并设置响应的参数；
     * 3.用HttpClient生成的对象来执行GetMethod生成的Get方法；
     * 4.处理响应状态码；
     * 5.若响应正常，处理HTTP响应内容；
     * 6.释放连接。
     *
     * @param url
     * @param charset
     * @return
     */
    public static String doGet(String url, String charset) {
    
    
        /**
         * 1.生成HttpClient对象并设置参数
         */
        HttpClient httpClient = new HttpClient();
        //设置Http连接超时为5秒
        httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(5000);

        /**
         * 2.生成GetMethod对象并设置参数
         */
        GetMethod getMethod = new GetMethod(url);
        //设置get请求超时为5秒
        getMethod.getParams().setParameter(HttpMethodParams.SO_TIMEOUT, 5000);
        //设置请求重试处理，用的是默认的重试处理：请求三次
        getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());

        String response = "";

        /**
         * 3.执行HTTP GET 请求
         */
        try {
    
    
            int statusCode = httpClient.executeMethod(getMethod);

            /**
             * 4.判断访问的状态码
             */
            if (statusCode != HttpStatus.SC_OK) {
    
    
                System.err.println("请求出错：" + getMethod.getStatusLine());
            }

            /**
             * 5.处理HTTP响应内容
             */
            //HTTP响应头部信息，这里简单打印
            Header[] headers = getMethod.getResponseHeaders();
            for (Header h : headers) {
    
    
                System.out.println(h.getName() + "---------------" + h.getValue());
            }
            //读取HTTP响应内容，这里简单打印网页内容
            //读取为字节数组
            byte[] responseBody = getMethod.getResponseBody();
            response = new String(responseBody, charset);
            System.out.println("-----------response:" + response);
            //读取为InputStream，在网页内容数据量大时候推荐使用
            //InputStream response = getMethod.getResponseBodyAsStream();

        } catch (HttpException e) {
    
    
            //发生致命的异常，可能是协议不对或者返回的内容有问题
            System.out.println("请检查输入的URL!");
            e.printStackTrace();
        } catch (IOException e) {
    
    
            //发生网络异常
            System.out.println("发生网络异常!");
        } finally {
    
    
            /**
             * 6.释放连接
             */
            getMethod.releaseConnection();
        }
        return response;
    }

    /**
     * post请求
     *
     * @param url
     * @param json
     * @return
     */
    public static String doPost(String url, JSONObject json) {
    
    
        HttpClient httpClient = new HttpClient();
        PostMethod postMethod = new PostMethod(url);

        postMethod.addRequestHeader("accept", "*/*");
        postMethod.addRequestHeader("connection", "Keep-Alive");
        //设置json格式传送
        postMethod.addRequestHeader("Content-Type", "application/json;charset=utf-8");
        //必须设置下面这个Header
        postMethod.addRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
        //添加请求参数
        postMethod.addParameter("commentId", json.getString("commentId"));

        String res = "";
        try {
    
    
            int code = httpClient.executeMethod(postMethod);
            if (code == 200) {
    
    
                res = postMethod.getResponseBodyAsString();
                System.out.println(res);
            }
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return res;
    }

    public static void main(String[] args) {
    
    
        doGet("http://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=13026194071", "UTF-8");
        System.out.println("-----------分割线------------");
        System.out.println("-----------分割线------------");
        System.out.println("-----------分割线------------");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("commentId", "13026194071");
        doPost("http://tcc.taobao.com/cc/json/mobile_tel_segment.htm", jsonObject);
    }
}

CloseableHttpClient encapsulated by Apache

CloseableHttpClient is modified and updated based on HttpClient. It also involves the setting of request header token (request verification). Fastjson is used to convert the request or return the result string into json format. Of course, the above two methods can also set the request header. Token and json are only explained below.

Import the following jar package:

<!--CloseableHttpClient-->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.28</version>
</dependency>

import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;

import java.io.IOException;


/**
 * @ClassName: CloseableHttpClientToInterface
 * @Description: Apache封装好的CloseableHttpClient
 */

public class CloseableHttpClientToInterface {
    
    
    private static String tokenString = "";
    private static String AUTH_TOKEN_EXPIRED = "AUTH_TOKEN_EXPIRED";
    private static CloseableHttpClient httpClient = null;

    /**
     * 以get方式调用第三方接口
     *
     * @param url
     * @return
     */
    public static String doGet(String url, String token) {
    
    
        //创建HttpClient对象
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpGet get = new HttpGet(url);

        try {
    
    
//            if (tokenString != null && !tokenString.equals("")) {
    
    
//                tokenString = getToken();
//            }
//            //api_gateway_auth_token自定义header头，用于token验证使用
//            get.addHeader("api_gateway_auth_token", tokenString);
            get.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");
            HttpResponse response = httpClient.execute(get);
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
    
    
                //返回json格式
                String res = EntityUtils.toString(response.getEntity());
                return res;
            }
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 以post方式调用第三方接口
     *
     * @param url
     * @param json
     * @return
     */
    public static String doPost(String url, JSONObject json) {
    
    

        try {
    
    
            if (httpClient == null) {
    
    
                httpClient = HttpClientBuilder.create().build();
            }

            HttpPost post = new HttpPost(url);

            if (tokenString != null && !tokenString.equals("")) {
    
    
                tokenString = getToken();
            }

            //api_gateway_auth_token自定义header头，用于token验证使用
            post.addHeader("api_gateway_auth_token", tokenString);
            post.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");

            StringEntity s = new StringEntity(json.toString());
            s.setContentEncoding("UTF-8");
            //发送json数据需要设置contentType
            s.setContentType("application/x-www-form-urlencoded");
            //设置请求参数
            post.setEntity(s);
            HttpResponse response = httpClient.execute(post);

            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
    
    
                //返回json格式
                String res = EntityUtils.toString(response.getEntity());
                return res;
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if (httpClient != null) {
    
    
                try {
    
    
                    httpClient.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * 获取第三方接口的token
     */
    public static String getToken(){
    
    

        String token = "";

        JSONObject object = new JSONObject();
        object.put("appid", "appid");
        object.put("secretkey", "secretkey");

        try {
    
    
            if (httpClient == null){
    
    
                httpClient = HttpClientBuilder.create().build();
            }
            HttpPost post = new HttpPost("http://localhost/login");

            post.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36");

            StringEntity s = new StringEntity(object.toString());
            s.setContentEncoding("UTF-8");
            //发送json数据需要设置contentType
            s.setContentType("application/x-www-form-urlencoded");
            //设置请求参数
            post.setEntity(s);
            HttpResponse response = httpClient.execute(post);

            //这里可以把返回的结果按照自定义的返回数据结果，把string转换成自定义类
            //ResultTokenBO result = JSONObject.parseObject(response, ResultTokenBO.class);

            //把response转为jsonObject
            JSONObject result = JSONObject.parseObject(String.valueOf(response));
            if (result.containsKey("token")){
    
    
                token = result.getString("token");
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return token;
    }


    public static void main(String[] args) {
    
    
        System.out.println(doGet("https://weather.cma.cn/api/climate?stationid=57516", null));
    }
}

by OkHttp

Introduction: OkHttp is an HTTP client that works by default. Performing HTTP efficiently can speed up your load and save bandwidth. If your service has multiple IP addresses, OkHttp will try an alternate address if the first connection fails. This is required for IPv4 + IPv6 and services hosted in redundant data centers. OkHttp initiates new connections with modern TLS capabilities (SNI, ALPN) and falls back to TLS 1.0 on handshake failure. OkHttp supports Android 2.3 and higher. For Java, the minimum requirement is 1.7.

Steps:

  1. Create OkhttpClient.

  2. mClient executes newCall to convert the Request into a Call.

  3. Finally, call executes excute synchronously, and enqueue executes asynchronously.

  4. Request is mainly built through Request.Builder.

  5. cache.

  6. Cancel request.

Import the following jar package:

<!--okhttp3-->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.1</version>
</dependency>

import okhttp3.*;

import java.io.IOException;

/**
 * @ClassName: OkHttpToInterface
 * @Description: 通过OkHttp调用第三方http接口
 */
public class OkHttpToInterface {
    
    

    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    /**
     * 以get方式调用第三方接口
     *
     * @param url
     */
    public static void doGet(String url) {
    
    
        OkHttpClient okHttpClient = new OkHttpClient();
        final Request request = new Request.Builder()
                .url(url)
                .get()//默认就是GET请求，可以不写
                .build();
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
    
    
            @Override
            public void onFailure(Call call, IOException e) {
    
    
                System.out.println("onFailure: ");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
    
    
                System.out.println("onResponse: " + response.body().string());
            }
        });
    }

    /**
     * post请求
     *
     * @param url
     * @param json
     */
    public static void doPost(String url, String json) {
    
    
        MediaType mediaType = MediaType.parse("text/x-markdown; charset=utf-8");
        String requestBody = json;
        Request request = new Request.Builder()
                .url(url)
                .post(RequestBody.create(mediaType, requestBody))
                .build();
        OkHttpClient okHttpClient = new OkHttpClient();
        okHttpClient.newCall(request).enqueue(new Callback() {
    
    
            @Override
            public void onFailure(Call call, IOException e) {
    
    
                System.out.println("onFailure: " + e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
    
    
                System.out.println(response.protocol() + " " + response.code() + " " + response.message());
                Headers headers = response.headers();
                for (int i = 0; i < headers.size(); i++) {
    
    
                    System.out.println(headers.name(i) + ":" + headers.value(i));
                }
                System.out.println("onResponse: " + response.body().string());
            }
        });
    }

    public static void main(String[] args) {
    
    
//        doGet("http://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=13026194071");
//        doPost("https://api.github.com/markdown/raw", "I am Jdqm.");
        doGet("https://weather.cma.cn/api/climate?stationid=57516");
    }
}

Via Spring's RestTemplate

RestTemple is the culmination of the first three methods, making it easier to write code. Currently, the third-party interfaces that can be used are:

  • delete() performs an HTTP DELETE operation on a resource at a specific URL
  • exchange()Execute a specific HTTP method on the URL and return a ResponseEntity containing the object mapped from the response body
  • execute()Execute a specific HTTP method on the URL, returning an object mapped from the response body
  • getForEntity()Send an HTTP GET request, and the returned ResponseEntity contains the object mapped to the response body.
  • getForObject() Send an HTTP GET request, and the returned request body will be mapped to an object
  • postForEntity()POST data to a URL, returning a ResponseEntity containing an object mapped from the response body
  • postForObject() POST data to a URL and return an object formed based on response body matching
  • headForHeaders() sends an HTTP HEAD request and returns the HTTP header containing the URL of the specific resource.
  • optionsForAllow() sends an HTTP OPTIONS request and returns the Allow header information for a specific URL.
  • postForLocation() POST data to a URL and return the URL of the newly created resource
  • put() PUT resource to a specific URL

Note: Currently the ones marked in red are commonly used ones.

Steps:

  1. Use the default construction method new an instance new RestTemplate().

  2. RestTemplate internally calls the doExecute method to first obtain the ClientHttpRequest.

  3. RestTemplate implements the abstract class HttpAccessor, so the createRequest of the parent class can be called.

  4. SimpleClientHttpRequestFactory implements ClientHttpRequest and also implements methods.

  5. 执行 requestCallback.doWithRequest(request)。

  6. Execute response = request.execute().

  7. Finally parse the response.

First import the web package of springboot

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.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>
        <scope>test</scope>
    </dependency>
</dependencies>

Configuration class

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
 
@Configuration
public class RestTemplateConfig {
    
    
 
    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
    
    
        return new RestTemplate(factory);
    }
 
    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
    
    
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}

import cn.zysheep.domain.entity.User;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.web.client.RestTemplate;

/**
 * @ClassName: RestTemplateToInterface
 * @Description: 通过restTemplate调用第三方http接口
 */
public class RestTemplateToInterface {
    
    
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 以get方式请求第三方http接口 getForEntity
     *
     * @param url
     * @return
     */
    public User doGetWith1(String url) {
    
    
        ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class);
        User user = responseEntity.getBody();
        return user;
    }

    /**
     * 以get方式请求第三方http接口 getForObject
     * 返回值返回的是响应体，省去了我们再去getBody()
     *
     * @param url
     * @return
     */
    public User doGetWith2(String url) {
    
    
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }

    /**
     * 以post方式请求第三方http接口 postForEntity
     *
     * @param url
     * @return
     */
    public String doPostWith1(String url) {
    
    
        User user = new User("小白", 20);
        ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, user, String.class);
        String body = responseEntity.getBody();
        return body;
    }

    /**
     * 以post方式请求第三方http接口 postForEntity
     *
     * @param url
     * @return
     */
    public String doPostWith2(String url) {
    
    
        User user = new User("小白", 20);
        String body = restTemplate.postForObject(url, user, String.class);
        return body;
    }

    /**
     * exchange
     *
     * @return
     */
    public String doExchange(String url, Integer age, String name) {
    
    
        //header参数
        HttpHeaders headers = new HttpHeaders();
        String token = "asdfaf2322";
        headers.add("authorization", token);
        headers.setContentType(MediaType.APPLICATION_JSON);

        //放入body中的json参数
        JSONObject obj = new JSONObject();
        obj.put("age", age);
        obj.put("name", name);

        //组装
        HttpEntity<JSONObject> request = new HttpEntity<>(obj, headers);
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, request, String.class);
        String body = responseEntity.getBody();
        return body;
    }
}

HttpUtil via hutool

Introduction: For information on how to use the Hutool tool class HttpUtil, please refer to the official document Hutool HttpUtil

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.1</version>
</dependency>

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.http.HttpUtil;

import java.util.HashMap;

/**
 * @ClassName: HttpUtilToInterface
 * @Description: 通过hutool工具类调用第三方http接口
 */
public class HttpUtilToInterface {
    
    
    /**
     * get请求示例
     */
    public static void doGet() {
    
    
        // 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS
        String result1 = HttpUtil.get("https://www.baidu.com");

        // 当无法识别页面编码的时候，可以自定义请求页面的编码
        String result2 = HttpUtil.get("https://www.baidu.com", CharsetUtil.CHARSET_UTF_8);

        //可以单独传入http参数，这样参数会自动做URL编码，拼接在URL中
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("city", "北京");
        String result3 = HttpUtil.get("https://www.baidu.com", paramMap);
    }

    public static void main(String[] args) {
    
    
        doGet();
    }

     /**
     * post请求示例
     */
    public static void doPost() {
    
    
        String url = "http://localhost:9001/xss/saveMap";

        //post普通请求示例
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("city", "北京");

        // application/x-www-form-urlencoded
        String result = HttpUtil.post(url, paramMap);
        System.out.println(result);

        // application/json
        String body = HttpUtil.createPost(url).body(JSON.toJSONString(paramMap)).execute().body();
        System.out.println(body);

        //文件上传示例
//        HashMap<String, Object> paramMap1 = new HashMap<>();
//        //文件上传只需将参数中的键指定（默认file），值设为文件对象即可，对于使用者来说，文件上传与普通表单提交并无区别
//        paramMap1.put("file", FileUtil.file("D:\\face.jpg"));
//        String result1 = HttpUtil.post("https://www.baidu.com", paramMap1);
//
//        //下载文件（很少用）
//        String fileUrl = "http://mirrors.sohu.com/centos/8.4.2105/isos/x86_64/CentOS-8.4.2105-x86_64-dvd1.iso";
//        //将文件下载后保存在E盘，返回结果为下载文件大小
//        long size = HttpUtil.downloadFile(fileUrl, FileUtil.file("e:/"));
//        System.out.println("Download size: " + size);
    }

    public static void main(String[] args) {
    
    
        doPost();
    }
}

Summarize

In daily development, we generally use spring's resttemplate and hutool's HttpUtil more often, especially hutool, which is highly recommended because it contains many worry-free tools.

Guess you like

Origin blog.csdn.net/qq_45297578/article/details/133036964
Recommended
The United States plans to restrict the export of large AI models to China and Russia
Apple to reach agreement with OpenAI to bring ChatGPT to iPhone
Ranking
whisper-webui installation tutorial is silky and easy to use
[Base] Laravel concepts laravel basis, the custom service provider: Contracts, ServiceContainer, ServiceProvider, Facades relations
Import torchvision error problem solving DLL: module not found
observer & watch & notify = pub & sub
A small turntable program [HTML + CSS + JS]
CorelDRAW 2018 shortcuts Daquan
Supervise el botón de menú para lograr un gatillo de presión prolongada
JS将时间秒转换成天小时分钟秒的字符串
RIP basic configuration
[Deleted] solution to a problem a few questions (Noip1994)
Daily
More
2024-05-11(32)
2024-05-10(34)
2024-05-09(32)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)
2024-05-03(8)
2024-05-02(0)

Code World

© 2018 codetd.com