java http请求工具类全功能(get、put、delete、post、文件上传)，使用easy-okhttp

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量8.8k 收藏 9
点赞数 1
分类专栏： java宝藏 文章标签： java http请求工具类 get、put、delete post、文件上传 easy-okhttp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjq_ku/article/details/124020912
版权

java http请求工具类全功能(get、put、delete、post、文件上传)，使用easy-okhttp

酷酷的韩金群
大家好，我是酷酷的韩~

1.简介

本文提供的是java http请求工具类,使用easy-okhttp封装，包含各种方法，含部分测试demo，有疑问可在公屏讨论。

2.为什么使用easy-okhttp

easy-okhttp是对OkHttp网络框架封装，提供文件上传和下载，表单(含文件)提交，链式调用，支持HTTPS和自定义签名证书等特性。 OkHttp网络框架的流行始于Android，但是在Java后端仍然是Apache HttpClient网络框架，这个框架功能非常强大，但缺点在于设计非常的复杂且jar的比较大。 所以才有easy-okhttp

3.pom依赖

<dependency>
    <groupId>com.mzlion</groupId>
    <artifactId>easy-okhttp</artifactId>
    <version>1.1.4</version>
</dependency>

4.工具类代码

package com.hjq.demo.common.utils;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.hjq.demo.common.json.AjaxJson;
import com.mzlion.easyokhttp.HttpClient;
import com.mzlion.easyokhttp.request.GetRequest;
import com.mzlion.easyokhttp.request.PostRequest;
import com.mzlion.easyokhttp.request.TextBodyRequest;
import com.mzlion.easyokhttp.response.callback.Callback;
import com.mzlion.easyokhttp.response.handle.DataHandler;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.zip.GZIPInputStream;

public class HttpRequestUtils2 {

    private static Logger logger = LoggerFactory.getLogger(HttpRequestUtils2.class);
    private static final int DEFAULT_TIMEOUT = 2000;

    //PUT请求-------------------------------------------------------------------------**

    /**
     * @param url        请求的url地址
     * @param headers    请求头参数map
     * @param parameters 请求参数map
     * @return 请求的结果字符串
     * 发起PUT同步请求
     */
    public static String doPut(String url, Map<String, String> headers, Map<String, String> parameters, String jsonStr) throws UnsupportedEncodingException {
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpPut httpPut = new HttpPut(url);
        addParameters(httpPut, parameters, jsonStr);
        return getResultStr(headers, httpClient, httpPut);
    }

    private static void addParameters(HttpEntityEnclosingRequestBase postPutRequest, Map<String, String> parameters, String jsonStr) throws UnsupportedEncodingException, UnsupportedEncodingException {
        if (!StringUtils.isEmpty(jsonStr)) {
            postPutRequest.setHeader("Content-Type", "application/json;charset=UTF-8");
            postPutRequest.setEntity(new StringEntity(jsonStr, Charset.forName("UTF-8")));
        } else {
            // 1、构造list集合，往里面存请求的数据
            List<NameValuePair> list = new ArrayList<>();
            for (String key : parameters.keySet()) {
                String value = parameters.get(key);
                BasicNameValuePair basicNameValuePair = new BasicNameValuePair(key, value);
                list.add(basicNameValuePair);
            }
            //2 我们发现Entity是一个接口，所以只能找实现类，发现实现类又需要一个集合，集合的泛型是NameValuePair类型
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(list);
            //3 通过setEntity 将我们的entity对象传递过去
            postPutRequest.setEntity(formEntity);
        }

    }

    private static String getResultStr(Map<String, String> headers, CloseableHttpClient httpClient, HttpRequestBase httpRequest) {
        String body = null;
        CloseableHttpResponse response;
        //设置请求头的参数
        setHeaders(headers, httpRequest);
        try {
            //执行请求
            response = httpClient.execute(httpRequest);
            //请求成功执行
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                //获取返回的数据
                HttpEntity entity = response.getEntity();
                //转换成字符串
                body = EntityUtils.toString(entity);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
        return body;
    }

    private static void setHeaders(Map<String, String> headers, HttpRequestBase httpRequest) {
        if (headers != null && !headers.isEmpty()) {
            for (String key : headers.keySet()) {
                String value = headers.get(key);
                httpRequest.setHeader(key, value);
            }
        }
    }


    //DELETE请求-------------------------------------------------------------------------**

    /**
     * @author Binean
     * @Description 发送delete请求
     */
    public static String doDelete(String url, Map<String, String> headers, String encode) {
        if (encode == null) {
            encode = "utf-8";
        }
        String content = null;
        CloseableHttpClient closeableHttpClient = HttpClientBuilder.create().build();
        HttpDelete httpdelete = new HttpDelete(url);
        //设置header
        if (headers != null && headers.size() > 0) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpdelete.setHeader(entry.getKey(), entry.getValue());
            }
        }
        CloseableHttpResponse httpResponse = null;
        try {
            httpResponse = closeableHttpClient.execute(httpdelete);
            HttpEntity entity = httpResponse.getEntity();
            content = EntityUtils.toString(entity, encode);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                httpResponse.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {   //关闭连接、释放资源
            closeableHttpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return content;
    }


    //各种GET请求-------------------------------------------------------------------------**

    public static <T> T doGet(String url, Map<String, String> paramMap, Map<String, String> headMap, Class<T> clz) {
        try {
            GetRequest request = HttpClient.get(url);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.queryString(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            T result = null;
            if (clz.equals(String.class)) {
                result = (T) request.execute().asString();
            } else {
                result = request.execute().asBean(clz);
            }
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static <T> T doGet(String url, Map<String, String> paramMap, Map<String, String> headMap, Class<T> clz,
                              Integer timeout) {
        try {
            if (timeout == null) {
                timeout = DEFAULT_TIMEOUT;
            }
            GetRequest request = HttpClient.get(url).readTimeout(timeout);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.queryString(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            T result = null;
            if (clz.equals(String.class)) {
                result = (T) request.execute().asString();
            } else {
                result = request.execute().asBean(clz);
            }
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static String doUpzipGet(String url, Map<String, String> paramMap, Map<String, String> headMap,
                                    Integer timeout) {
        try {
            if (timeout == null) {
                timeout = DEFAULT_TIMEOUT;
            }
            GetRequest request = HttpClient.get(url).readTimeout(timeout);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.queryString(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }

            request.header("Connection", "close");
            String result = null;
            result = request.execute().custom(new DataHandler<String>() {

                @Override
                public String handle(Response response) throws IOException {
                    // TODO Auto-generated method stub
                    String rs = null;
                    GZIPInputStream gis = null;
                    ByteArrayOutputStream baos = null;
                    try {
                        if ("gzip".equals(response.header("Content-Encoding"))) {
                            byte[] buffer = new byte[4096];
                            int size = 0;
                            baos = new ByteArrayOutputStream();
                            gis = new GZIPInputStream(response.body().byteStream());
                            while ((size = gis.read(buffer)) != -1) {
                                baos.write(buffer, 0, size);
                            }
                            Charset cs = java.nio.charset.Charset.forName("UTF-8");
                            rs = new String(baos.toByteArray(), cs);
                        } else {
                            rs = response.body().string();
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    if (gis != null) {
                        gis.close();
                    }
                    if (baos != null) {
                        baos.close();
                    }
                    return rs;
                }
            });
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static String doGet(String url, Map<String, String> paramMap) {
        try {
            return doGet(url, paramMap, null, String.class);
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static <T> void doAsyncGet(String url, Map<String, String> paramMap, Map<String, String> headMap,
                                      Callback<T> callback) {
        try {
            GetRequest request = HttpClient.get(url);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.queryString(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            request.execute(callback);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public static String doGet(String url, Map<String, String> paramMap, Integer timeout) {
        try {
            return doGet(url, paramMap, null, String.class, timeout);
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static <T> T doGet(String url, Map<String, String> paramMap, Class<T> clz) {
        return doGet(url, paramMap, null, clz);
    }


    //各种POST请求-------------------------------------------------------------------------**

    public static <T> void doAsyncPost(String url, Map<String, String> paramMap, Map<String, String> headMap,
                                       Callback<T> callback) {
        try {
            PostRequest request = HttpClient.post(url);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.param(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            request.execute(callback);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public static <T> T doPost(String url, Map<String, String> paramMap, Map<String, String> headMap, Class<T> clz) {
        try {
            PostRequest request = HttpClient.post(url);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.param(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            T result = null;
            if (clz.equals(String.class)) {
                result = (T) request.execute().asString();
            } else {
                result = request.execute().asBean(clz);
            }
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static <T> T doPost(String url, Map<String, String> paramMap, Map<String, String> headMap, Class<T> clz,
                               Integer timeout) {
        try {
            if (timeout == null) {
                timeout = DEFAULT_TIMEOUT;
            }
            PostRequest request = HttpClient.post(url).readTimeout(timeout);
            if (paramMap != null && !paramMap.isEmpty()) {
                request = request.param(paramMap);
            }
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            request.header("Connection", "close");
            T result = null;
            if (clz.equals(String.class)) {
                result = (T) request.execute().asString();
            } else {
                result = request.execute().asBean(clz);
            }
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static String postWithFiles(String url, String fileName, byte[] content, String mediaType, Map<String, String> headers) {
        try {
            Headers httpHeader = Headers.of(headers);
            OkHttpClient client = new OkHttpClient();
            RequestBody formBody = new MultipartBody.Builder().setType(MultipartBody.FORM)
                    .addFormDataPart("file", fileName, RequestBody.create(MediaType.parse(mediaType), content))
                    .addFormDataPart("other_field", "other_field_value").build();
            Request request = new Request.Builder().url(url).headers(httpHeader).post(formBody).build();
            Response response = client.newCall(request).execute();
            return response.body().string();
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static <T> T doPost(String url, Map<String, String> paramMap, Class<T> clz) {
        return doPost(url, paramMap, null, clz);
    }

    public static String doPost(String url, Map<String, String> paramMap) {
        try {
            return doPost(url, paramMap, null, String.class);
        } catch (Exception e) {
            // e.printStackTrace();
            logger.error(e.getMessage());
            return null;
        }
    }

    public static String doPost(String url, Map<String, String> paramMap, Integer timeout) {
        try {
            return doPost(url, paramMap, null, String.class, timeout);
        } catch (Exception e) {
            // e.printStackTrace();
            logger.error(e.getMessage());
            return null;
        }
    }

    public static String doPost(String url, Map<String, String> paramMap, String cookie) {
        PostRequest request = HttpClient.post(url);
        if (paramMap != null && !paramMap.isEmpty()) {
            request = request.param(paramMap);
        }
        request.header("Connection", "close");
        request.header("Cookie", cookie);
        String result = request.execute().asString();
        return result;
    }

    public static String doPost(String url, Map<String, String> paramMap, Map<String, String> headMap) {
        return doPost(url, paramMap, headMap, String.class);
    }

    public static String doPostJson(String url, String json) {
        try {
            String result = HttpClient.textBody(url).json(json).charset("utf-8").execute().asString();
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static <T> void doAsyncPostJson(String url, String json, Callback<T> callback) {
        try {
            HttpClient.textBody(url).json(json).charset("utf-8").execute(callback);
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }

    public static String doPostJson(String url, String json, String cookie) {
        try {
            TextBodyRequest request = HttpClient.textBody(url).json(json).charset("utf-8");
            request.header("Cookie", cookie);
            request.header("Connection", "close");
            String result = request.execute().asString();
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static <T> T doPostJson(String url, String json, String cookie, Class<T> clz) {
        try {
            TextBodyRequest request = HttpClient.textBody(url).json(json).charset("utf-8");
            request.header("Cookie", cookie);
            request.header("Connection", "close");
            T result = request.execute().asBean(clz);
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static String doPostJson(String url, String json, Map<String, String> headMap, String cookie) {
        try {
            TextBodyRequest request = HttpClient.textBody(url).json(json).charset("utf-8");
            if (cookie != null) {
                request.header("Cookie", cookie);
            }
            request.header("Connection", "close");
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            String result = request.execute().asString();
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static <T> T doPostJson(String url, String json, String cookie, Class<T> clz, Integer timeout) {
        try {
            TextBodyRequest request = HttpClient.textBody(url).json(json).charset("utf-8").readTimeout(timeout);
            request.header("Cookie", cookie);
            request.header("Connection", "close");
            T result = request.execute().asBean(clz);
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static <T> T doPostJson(String url, String json, Map<String, String> headMap, Class<T> clz, Integer timeout) {
        try {
            if (timeout == null) {
                timeout = DEFAULT_TIMEOUT;
            }
            TextBodyRequest request = HttpClient.textBody(url).json(json).charset("utf-8").readTimeout(timeout);
            request.header("Connection", "close");
            if (headMap != null && !headMap.isEmpty()) {
                for (Entry<String, String> item : headMap.entrySet()) {
                    request = request.header(item.getKey(), item.getValue());
                }
            }
            T result = request.execute().asBean(clz);
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }

    }

    public static String doPostXml(String url, String xml) {
        try {
            String result = HttpClient.textBody(url).xml(xml).charset("utf-8").execute().asString();
            return result;
        } catch (Exception e) {
            logger.error(e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) {
        //get请求
//        String url = "test";
//        Map<String, String> paramMap = new HashMap<>();
//        paramMap.put("orgId", "1");
//        Map<String, String> headerMap = new HashMap<>();
//        headerMap.put("accessToken", "AT-633-8c2x1GtKbD-vTVIbtV-YnnLqRpNZfXYx");
//        AjaxJson ajaxJson = doGet(url, paramMap, headerMap, AjaxJson.class, null);
//        System.out.println(JSONObject.toJSONString(ajaxJson));
        //post请求
        String url = "test";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("orgId", 1425);
        Map<String, String> headerMap = new HashMap<>();
        headerMap.put("accessToken", "AT-633-8c2x1GtKbD-vTVIbtV-YnnLqRpNZfXYx");
//        headerMap.put("Content-Type", "application/json;charset=utf-8");
        String paramJson = JSONObject.toJSONString(paramMap, SerializerFeature.WriteMapNullValue);
        AjaxJson ajaxJson = doPostJson(url, paramJson, headerMap, AjaxJson.class, null);
        System.out.println(JSONObject.toJSONString(ajaxJson));
    }
}

请看我漂亮的坚持。------酷酷的韩~

韩金群
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
FastHttpClient：封装OkHttp3，对外提供了POST请求，GET请求，上传文件，下载文件，https请求，cookie管理等功能
02-03
FastHttpClient 封装OkHttp3 支持多线程异步请求 支持Http / Https协议 支持同步/异步请求 支持初步逐步执行 支持Cookie持久化 支持JSON，表单提交 支持文件和图片上传/批量上传，支持同步/逐步上传，支持进度提示 支持文件流上传 下载 下载jar或通过Maven抢： < dependency> < groupId>com.github.icecooly</ groupId> < artifactId>FastHttpClient</ artifactId> < version>1.7</ version> </ depende
Java中Http请求restful接口POST、GET、PUT、DELETE等
ZHOU_0522的博客
09-20 2726
Java中Http请求restful接口POST、GET、PUT、DELETE等； springboot http请求controller接口；
java HTTP请求工具类，2024Java春招面试真题详解
2301_76328475的博客
03-27 914
很多人感叹“学习无用”，实际上之所以产生无用论，是因为自己想要的与自己所学的匹配不上，这也就意味着自己学得远远不够。无论是学习还是工作，都应该有主动性，所以如果拥有大厂梦，那么就要自己努力去实现它。最后祝愿各位身体健康，顺利拿到心仪的offer！由于文章的篇幅有限，所以这次的蚂蚁金服和京东面试题答案整理在了PDF文档里实现它。最后祝愿各位身体健康，顺利拿到心仪的offer！由于文章的篇幅有限，所以这次的蚂蚁金服和京东面试题答案整理在了PDF文档里。
EasyOkHttp：对OkHttp进行了简单的封装，从而更好的被用户使用
02-10
1.添加依赖 allprojects { repositories { ... maven { url 'https://jitpack.io' } } } dependencies { implementation 'com.github.Mashiro2019:EasyOkHttp:V1.0.1' } 2.支持请求 目前仅支持get和post请求 3.优缺点 3.1优点 简单易用，适合上手 3.2缺点 只支持get和post两种请求格式，而且需要配合LiveData使用 4使用示例 我们以登录作为范例 _user定义 privateval _user = MutableLiveData < User> () 获取请求结果字符串登录Res val loginRes = Transformations .switchMap(_user){ // _u
java request类_Java的HttpRequest请求工具类
weixin_39861624的博客
02-20 615
packagecom.xieh;importjava.io.BufferedReader;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.IOException;importjava.io.Input...
JAVA http请求工具类
weixin_66204660的博客
04-10 1421
路由在这里就不展开讲了。在没有 PATCH 之前，都是用 PUT 进行更新操作，这时候我们的接口中通常会有一个逻辑规则，如：如果对象的一个属性值为null，那么就不更新该属性（字段）值，通过这种方式来避免全部覆盖的操作。另外，PATCH 是非幂等的。按照 REST 建议，查询操作要使用 GET 方法，但是实际情况中处理起来比较麻烦，如：报表统计查询，需要传递的参数很多，如果采用 GET 方法，那么接口接收的参数非常多，接口很难看，通常会封装为 java 对象，但 GET 方法又不支持对象传参，所以很蛋疼；
java http 发送 put delete post get请求
12-22
是一个Java 发送http put、delete、 post、 get 请求的工具类。可用在与restful service 进行通讯的代码中。
java的Http的PUT请求
热门推荐
辰辰呐的博客
07-12 1万+
重点在这一句：httpurlconnection.setRequestMethod("PUT");如果想改成post请求，就该成httpurlconnection.setRequestMethod("POST");就可以了。 public static String httpPut(String urlPath, String data, String charSet, String[]
使用okhttp的PUT方式上传文件
03-21 953
代码实现 /** * @param mediaType MediaType * @param uploadUrl put请求地址 * @param localPath 本地文件路径 * @return 响应的结果 和 HTTP status code * @throws IOException */ public S
Java Post/Get请求 工具类
LiuJie 的微博
04-22 3975
一、工具类 import com.alibaba.fastjson.JSONObject; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpPost; import org.apache.http.conn.ConnectTimeoutExce
https的get和post请求，去除ssl校验的java工具类
12-04
java的get和post请求，获取json的工具类，https时会存在ssl校验的问题，工具会自动去除ssl校验。
Android中使用OkHttp包处理HTTP的get和post请求的方法
09-02
OkHttp包为安卓开发中的HTTP协议网络编程带来了很大的便利,这里我们就来看一下最基本的、Android中使用OkHttp包处理HTTP的get和post请求的方法:
08-01 OKHttp3的post和get请求
07-26
08-01 OKHttp3的post和get请求 08-01 OKHttp3的post和get请求
Android-OkHttp3.0网络工具类
08-13
OkHttp3.0封装框架，内部使用gson解析json数据
链表刷题集
yajunjiao的专栏
04-30 813
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1801
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1349
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 653
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
使用okhttp3写一个http请求工具类
04-29
好的，以下是一个简单的使用OkHttp3进行HTTP请求的工具类： ```java import okhttp3.*; import java.io.IOException; import java.util.Map; public class HttpUtil { private static final MediaType JSON = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

韩金群

你的鼓励将是我创作的最大动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值