JAVA实现HTTP请求的

最新推荐文章于 2024-05-03 21:17:42 发布
最新推荐文章于 2024-05-03 21:17:42 发布
阅读量385 收藏
点赞数 1
分类专栏： java基础 文章标签： java http apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46616045/article/details/126130783
版权

一、maven依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.12</version>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpmime</artifactId>
    <version>4.4</version>
</dependency>

二、拼接请求的方法

//https请求构建
private static HttpClient wrapClient(String host) {
    HttpClient httpClient = new DefaultHttpClient();
    if (host.startsWith("https://")) {
        sslClient(httpClient);
    }
    return httpClient;
}

private static void sslClient(HttpClient httpClient) {
    try {
        SSLContext ctx = SSLContext.getInstance("TLS");
        X509TrustManager tm = new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

            }

            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };
        ctx.init(null, new TrustManager[]{tm}, null);
        SSLSocketFactory ssf = new SSLSocketFactory(ctx);
        ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        ClientConnectionManager ccm = httpClient.getConnectionManager();
        SchemeRegistry registry = ccm.getSchemeRegistry();
        registry.register(new Scheme("https", 443, ssf));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

//拼接请求的地址
private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
    StringBuilder sbUrl = new StringBuilder();
    sbUrl.append(host);
    if (StringUtils.isNotBlank(path)) {
        sbUrl.append(path);
    }
    if (null != querys) {
        StringBuilder sbQuery = new StringBuilder();
        for (Map.Entry<String, String> query : querys.entrySet()) {
            if (sbQuery.length() > 0) {
                sbQuery.append("&");
            }
            if (StringUtils.isBlank(query.getKey()) && StringUtils.isNotBlank(query.getValue())) {
                sbQuery.append(query.getValue());
            }
            if (StringUtils.isNotBlank(query.getKey())) {
                sbQuery.append(query.getKey());
                if (StringUtils.isNotBlank(query.getValue())) {
                    sbQuery.append("=");
                    sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                }
            }
        }
        if (sbQuery.length() > 0) {
            sbUrl.append("?").append(sbQuery);
        }
    }
    return sbUrl.toString();
}

三、GET请求

/**
     * GET请求一
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     */
public static HttpResponse doGet(String host, String path,
                                 Map<String, String> headers,
                                 Map<String, String> querys) throws Exception {
    HttpClient httpClient = wrapClient(host);
    HttpGet request = new HttpGet(buildUrl(host, path, querys));
    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }
    return httpClient.execute(request);

}

/**
     * GET请求二 请求链接和Cookie
     *
     * @param url
     * @param cookie
     * @return
     */
public static String doGet(String url, String cookie) {
    try {
        HttpClient client = HttpClientBuilder.create().build();
        URI uri = new URI(url);
        HttpGet get = new HttpGet(uri);
        get.setHeader("Cookie", cookie);
        //执行请求
        HttpResponse response = client.execute(get);

        if (response.getStatusLine().getStatusCode() == 200) {
            StringBuffer buffer = new StringBuffer();
            InputStream in = null;
            try {
                in = response.getEntity().getContent();
                BufferedReader reader = new BufferedReader(new InputStreamReader(in, "utf-8"));
                String line = null;
                while ((line = reader.readLine()) != null) {
                    buffer.append(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    in.close();
                }
            }
            return buffer.toString();
        }

    } catch (Exception e) {
        e.printStackTrace();
    }

    return null;
}

四、POST请求

/**
     * POST请求，适合form-data传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
public static HttpResponse doPost(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys,
                                  Map<String, String> bodys) throws Exception {
    HttpClient httpClient = wrapClient(host);

    HttpPost request = new HttpPost(buildUrl(host, path, querys));

    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }
    if (bodys != null) {
        List<NameValuePair> nameValuePairList = new ArrayList<>();
        for (String key : bodys.keySet()) {
            nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
        }
        UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
        formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
        request.setEntity(formEntity);
    }

    return httpClient.execute(request);
}

/**
     * POST请求，适合json传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
public static HttpResponse doPost(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys,
                                  String body) throws Exception {
    HttpClient httpClient = wrapClient(host);

    HttpPost request = new HttpPost(buildUrl(host, path, querys));

    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }

    if (StringUtils.isNotBlank(body)) {
        request.setEntity(new StringEntity(body, "utf-8"));
    }
    return httpClient.execute(request);
}


/**
     * POST请求，适合字节传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
public static HttpResponse doPost(String host, String path, String method,
                                  Map<String, String> headers,
                                  Map<String, String> querys,
                                  byte[] body) throws Exception {
    HttpClient httpClient = wrapClient(host);

    HttpPost request = new HttpPost(buildUrl(host, path, querys));

    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }

    if (body != null) {
        request.setEntity(new ByteArrayEntity(body));
    }
    return httpClient.execute(request);
}

/**
     * post请求传参是文件
     * @param host
     * @param path
     * @param fileMap
     * @param fileNameMap
     * @param headers
     * @param bodys
     * @return
     * @throws Exception
     */
public static HttpResponse doPost(String host, String path,
                                  Map<String, File> fileMap,
                                  Map<String ,String> fileNameMap,
                                  Map<String, String> headers,
                                  Map<String, String> bodys) throws Exception {
    try {
        CloseableHttpClient client = HttpClients.createDefault();
        HttpPost post  = new HttpPost(host + path);
        MultipartEntityBuilder builder = MultipartEntityBuilder.create().setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

        for (Map.Entry<String, String> header : headers.entrySet()) {
            post.addHeader(header.getKey(), header.getValue());
        }

        //拼接文件的请求体
        for (Map.Entry<String, File> fileEntry : fileMap.entrySet()) {
            String defaultName = "defaultName";
            String fileName = fileNameMap.get(fileEntry.getKey());
            if (StringUtils.isNotBlank(fileName)){
                defaultName = fileName;
            }
            builder.setCharset(StandardCharsets.UTF_8)
                .addBinaryBody(fileEntry.getKey() , fileEntry.getValue() , ContentType.MULTIPART_FORM_DATA ,defaultName);
        }

        //拼接正常参数的请求体
        if(bodys != null){
            for (Map.Entry<String, String> body : bodys.entrySet()) {
                builder.addTextBody(body.getKey() , body.getValue());
            }
        }

        HttpEntity entity = builder.build();
        post.setEntity(entity);
        HttpResponse response = client.execute(post);
        return response;

    }catch (Exception e){
        e.printStackTrace();
    }
    return null;

}

五、PUT和DELETE请求

/**
     * PUT请求，适合json传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
public static HttpResponse doPut(String host, String path, String method,
                                 Map<String, String> headers,
                                 Map<String, String> querys,
                                 String body) throws Exception {
    HttpClient httpClient = wrapClient(host);
    HttpPut request = new HttpPut(buildUrl(host, path, querys));

    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }
    if (StringUtils.isNotBlank(body)) {
        request.setEntity(new StringEntity(body, "utf-8"));
    }
    return httpClient.execute(request);
}

/**
     * DELETE请求
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     */
public static HttpResponse doDelete(String host, String path,
                                    Map<String, String> headers,
                                    Map<String, String> querys) throws Exception {
    HttpClient httpClient = wrapClient(host);
    HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
    for (Map.Entry<String, String> header : headers.entrySet()) {
        request.addHeader(header.getKey(), header.getValue());
    }
    return httpClient.execute(request);

}

六、完整的工具类代码

package com.it520.bookkeepingcommon.util;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.*;
import java.net.URI;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpUtils {

    /**
     * GET请求一
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     */
    public static HttpResponse doGet(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys) throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }
        return httpClient.execute(request);

    }

    /**
     * GET请求二 请求链接和Cookie
     *
     * @param url
     * @param cookie
     * @return
     */
    public static String doGet(String url, String cookie) {
        try {
            HttpClient client = HttpClientBuilder.create().build();
            URI uri = new URI(url);
            HttpGet get = new HttpGet(uri);
            get.setHeader("Cookie", cookie);
            //执行请求
            HttpResponse response = client.execute(get);

            if (response.getStatusLine().getStatusCode() == 200) {
                StringBuffer buffer = new StringBuffer();
                InputStream in = null;
                try {
                    in = response.getEntity().getContent();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in, "utf-8"));
                    String line = null;
                    while ((line = reader.readLine()) != null) {
                        buffer.append(line);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (in != null) {
                        in.close();
                    }
                }
                return buffer.toString();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * POST请求，适合form-data传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      Map<String, String> bodys) throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));

        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }
        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<>();
            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }

        return httpClient.execute(request);
    }

    /**
     * POST请求，适合json传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body) throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));

        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        return httpClient.execute(request);
    }


    /**
     * POST请求，适合字节传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      byte[] body) throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));

        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }
        return httpClient.execute(request);
    }

    /**
     * post请求传参是文件
     * @param host
     * @param path
     * @param fileMap
     * @param fileNameMap
     * @param headers
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, File> fileMap,
                                      Map<String ,String> fileNameMap,
                                      Map<String, String> headers,
                                      Map<String, String> bodys) throws Exception {
        try {
            CloseableHttpClient client = HttpClients.createDefault();
            HttpPost post  = new HttpPost(host + path);
            MultipartEntityBuilder builder = MultipartEntityBuilder.create().setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

            for (Map.Entry<String, String> header : headers.entrySet()) {
                post.addHeader(header.getKey(), header.getValue());
            }

            //拼接文件的请求体
            for (Map.Entry<String, File> fileEntry : fileMap.entrySet()) {
                String defaultName = "defaultName";
                String fileName = fileNameMap.get(fileEntry.getKey());
                if (StringUtils.isNotBlank(fileName)){
                    defaultName = fileName;
                }
                builder.setCharset(StandardCharsets.UTF_8)
                        .addBinaryBody(fileEntry.getKey() , fileEntry.getValue() , ContentType.MULTIPART_FORM_DATA ,defaultName);
            }

            //拼接正常参数的请求体
            if(bodys != null){
                for (Map.Entry<String, String> body : bodys.entrySet()) {
                    builder.addTextBody(body.getKey() , body.getValue());
                }
            }

            HttpEntity entity = builder.build();
            post.setEntity(entity);
            HttpResponse response = client.execute(post);
            return response;

        }catch (Exception e){
            e.printStackTrace();
        }
        return null;

    }

    /**
     * PUT请求，适合json传参
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body) throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPut request = new HttpPut(buildUrl(host, path, querys));

        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }
        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        return httpClient.execute(request);
    }

    /**
     * DELETE请求
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     */
    public static HttpResponse doDelete(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys) throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> header : headers.entrySet()) {
            request.addHeader(header.getKey(), header.getValue());
        }
        return httpClient.execute(request);

    }

    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }
        return httpClient;
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                @Override
                public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

                }

                @Override
                public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {

                }

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }
            };
            ctx.init(null, new TrustManager[]{tm}, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (StringUtils.isNotBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (sbQuery.length() > 0) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && StringUtils.isNotBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (StringUtils.isNotBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (StringUtils.isNotBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (sbQuery.length() > 0) {
                sbUrl.append("?").append(sbQuery);
            }
        }
        return sbUrl.toString();
    }

}
dreamer_0423
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
盘点JAVA发送HTTP请求的四种方式
xiaoweids的博客
05-17 1673
到此这篇关于JAVA发送HTTP请求的文章就介绍到这了,希望对你有所帮助。
java实现HTTP请求的四种方式
顺其自然~专栏
04-11 3万+
目前JAVA实现HTTP请求的方法用的最多的有两种： 1、通过HTTPClient这种第三方的开源框架去实现。HTTPClient对HTTP的封装性比较不错，通过它基本上能够满足我们大部分的需求，HttpClient3.1 是 org.apache.commons.httpclient下操作远程 url的工具包，虽然已不再更新，但实现工作中使用httpClient3.1的代码还是很多，HttpClient4.5是org.apache.http.client下操作远程 url的工具包，最新的； 2、通过Ht
java中HttpClient使用【含例子】
最新发布
hac1322的博客
05-03 1122
但是，如果你在使用Java 11之前的版本，并且想要使用类似的功能，你可能需要引入第三方库的依赖，如Apache HttpClient。通过HttpRequest对象，您可以设置请求的URL、请求方法、请求头、请求体等信息，并构建一个完整的HTTP请求对象，用于发送给服务器。它提供了一种简单且一致的方式来执行HTTP操作，包括同步和异步的请求发送、连接池管理、请求和响应的拦截器等功能。被设计成与Java平台更好地集成，使得开发者能够更轻松地处理HTTP请求和响应，同时减少了对外部库的依赖。
Http及maven配置
m0_51067047的博客
06-10 977
1、HTTP 1.1、什么是HTTP HTTP(超文本传输协议)是一个简单的请求-响应协议，它通常运行在TCP之上。 文本：html，字符串~ 超文本：文字，图片，音乐，视频，定位… 80 Https：安全的 443 1.2、两个时代 http/1.0：客户端与web服务器连接后，只能获得一个web资源，断开连接，想再请求，得重新连接 http/1.1：客户端可以与web服务器连接后，可以获得多个web资源。 1.3、Http请求 客户端—>发请求—服务器 百度： Request URL: htt
Springboot2.5集成HttpClient依赖，封装HTTP请求类并配置连接池
我思故我在的博客空间
12-10 5064
先看需要引入的依赖： <!--Http服务器的访问功能--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpasyncclient</artifactId> </dependency> <!-- http通信 --> <dependency> <groupId>o
Java实现Http请求
Cqi的博客
02-05 203
import com.alibaba.fastjson.JSONObject; import java.io.*; import java.net.HttpURLConnection; import java.net.MalformedURLException; import java.net.URL; public class App{ public static String postRequest(String urlString ,String reqString) {
JAVA实现HTTP请求
11-21
这个是我自己集成框架的时候写的一个HTTP请求的辅助类，主要是通过HttpURLConnection 来实现JAVA的HTTP请求，有的人会问、为什么有些网站发请求没问题，有些网站发请求却返回数据，在给网站发送请求的时候，请看清楚...
Https请求工具类，Java实现http请求，https请求
12-14
Https请求工具类，Java实现http请求，https请求 本篇文章将详细介绍如何使用Java语言实现Http和Https请求的工具类，包括如何建立Https连接、如何实现Post请求、如何处理SSL验证等内容。 在Java中，使用...
JAVA实现Python requests模块（JAVA实现Http请求）-附件资源
03-05
JAVA实现Python requests模块（JAVA实现Http请求）-附件资源
详解java实现HTTP请求的三种方式
08-26
Java 实现 HTTP 请求的三种方式 Java 实现 HTTP 请求的三种方式是 Java 开发者经常遇到的问题。其中，主要有三种方式：使用 HttpURLConnection、使用 HttpClient 库和使用 OkHttp 库。下面将对这三种方式进行详细的...
java 实现http请求的四种方式工具类
09-09
java模拟网络请求，get post put delete四种模式，请求头处理参数处理。此文件仅供大家参考，稍作修改即可。
Java模拟http请求
fantasyleaves的博客
11-17 752
Java实现http请求主要有3种方式：URLConnection、HttpURLConnection、HttpClient 一 URLConnection 抽象类，属于Java发送http请求的原生api，操作简单 1. 构造URL对象 2. 获取URL对应的URLConnection对象 3. 设置URLConnection的属性值 4. 获取输出流写入数据 5. 获取输...
如何在java中发起http请求
qq_33391644的博客
06-06 6259
注意：get请求中参数值为中文的必须通过URLEncoder.encode("参数","utf-8");进行转义 http请求类 public class SendHttpRequest { /** * post请求方法 * @param url 请求地址 * @param params 参数 * @return */ pu...
Java程序中请求http接口
weixin_43751885的博客
06-02 4788
Java请求http接口 方法1 此方法需要httpclient-4.4.jar，httpcore-4.4.jar，并在头部引入包 import org.apache.http.HttpResponse; import org.apache.http.StatusLine; import org.apache.http.client.HttpClient; import org.apache.ht...
使用httpclient需要的maven依赖
吴成伟的博客
04-15 3万+
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore --> <dependency> <groupId>org.apache.httpcomponents</groupId> <art...
Java Http各个请求类型详细介绍
a342874650的专栏
01-11 1492
HTTP请求类型是构建Web应用程序的重要组成部分。常见的请求类型包括GET、POST、PUT和DELETE，每种类型都有其特定的用途和特点。本文将详细比较这四种请求类型，帮助您在开发过程中做出明智的选择。
java模拟Http请求
lBovinl的博客
10-21 216
   http请求分多种，接下来只考虑post方式-非喜勿喷，求拍砖~    使用java编程模拟http请求以post方式大致分为以下步骤：    一、通过抓包工具（或者浏览器自带的调试工具）来获取http请求的具体信息，如Request URL、User-Agent、Accept-Language、Accept-Encoding、cookie等信息，其中较关键的是要先找出Request...
java 常见几种发送http请求案例
热门推荐
u010197591的专栏
05-18 7万+
下面是作者在工作中总结的几种比较常见的使用java语言发送http请求的方式，希望对大家有所帮助，代码或注解处有不对的地方，欢迎大家留言指正，共同学习共同成长，谢谢大家！
Java实现Http/Https请求的方式
流浪的虾壳
04-17 7785
        工作中发现很多服务都是通过Http来提供服务：各模块之间通过Http来请求数据、外部服务例如各种Api（微信公众号小程序接口等）。作为用Java为开发语言的后端开发，实现Http请求的方式有原始Socket、URLConnection、HttpURLConnection、第三方工具HttpClient等。网络上已经有很多前人做了归纳，这里做个笔记：       1. java.ne...
java 实现http请求
08-23
以上是三种常见的Java实现HTTP请求的方法，你可以根据具体的需求选择适合的方式来发送HTTP请求。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3*...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值