OkHttp配置，携带并管理cookie

已于 2023-05-23 11:26:17 修改
阅读量1.4k 收藏
点赞数
分类专栏： 工具类 文章标签： okhttp
于 2023-05-19 11:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muguazhi/article/details/130762871
版权 
@Configuration
public class OkHttpConfig {
    /**
     * 超时时间，单位（毫秒）
     */
    @Value("${okhttp.timeout:7000}")
    private Long timeout;

    /**
     * 最大连接数量
     */
    @Value("${okhttp.maxConnection:200}")
    private Integer maxConnection;

    /**
     * 核心连接数量
     */
    @Value("${okhttp.coreConnection:10}")
    private Integer coreConnection;

    /**
     * 连接失败是否重试
     */
    @Value("${okhttp.resetConnection:false}")
    private boolean resetConnection;

    /**
     * 单域名最大请求线程
     */
    @Value("${okhttp.maxHostConnection:30}")
    private Integer maxHostConnection;

    @Bean
    public OkHttpClient okHttpClient() {
        // 创建Dispatcher，对请求线程进行控制
        Dispatcher dispatcher = new Dispatcher();
        // 设置单域名最大连接
        dispatcher.setMaxRequestsPerHost(maxHostConnection);
        // 设置最大连接
        dispatcher.setMaxRequests(maxConnection);

        // 创建OkHttpClient连接
        return new OkHttpClient
                .Builder()
                .sslSocketFactory(sslSocketFactory(), x509TrustManager())
                .dispatcher(dispatcher)
                .retryOnConnectionFailure(resetConnection)
                .addInterceptor(new OkHttpInterceptor())
                .callTimeout(timeout, TimeUnit.MILLISECONDS)
                .connectionPool(new ConnectionPool(maxConnection, coreConnection, TimeUnit.MILLISECONDS))
//                为OkHttp设置自动携带Cookie的功能
                .cookieJar(new CookieJar() {
                    private final Map<String, List<Cookie>> cookieStore = Maps.newHashMap();

                    @Override
                    public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
                        String host = url.host();
                        List<Cookie> oldCookies = cookieStore.getOrDefault(host, Lists.newArrayList());
                        // 先移除过期的 Cookie
                        oldCookies.removeIf(cookie -> cookie.expiresAt() < System.currentTimeMillis());
                        // key：cookie的名字，value：cookie
                        Map<String, Cookie> oldMap = oldCookies.stream()
                                .collect(Collectors.toMap(Cookie::name, Function.identity(), (v1, v2) -> v2));

                        // 解决 400 Request Header Or Cookie Too Large
                        if (!CollectionUtils.isEmpty(cookies)) {
                            // key：cookie的名字，value：cookie
                            Map<String, Cookie> newMap = cookies.stream()
                                    .collect(Collectors.toMap(Cookie::name, Function.identity(), (v1, v2) -> v2));
                            // 添加新的 Cookie
                            oldMap.putAll(newMap);
                        }
                        cookieStore.put(host, Lists.newArrayList(oldMap.values()));
                    }

                    @Override
                    public List<Cookie> loadForRequest(HttpUrl url) {
                        List<Cookie> cookies = cookieStore.getOrDefault(url.host(), Lists.newArrayList());
                        // 移除过期的 Cookie
                        cookies.removeIf(cookie -> cookie.expiresAt() < System.currentTimeMillis());
                        return cookies;
                    }
                })
                .build();
    }

    @Bean
    public X509TrustManager x509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) {

            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) {

            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };
    }


    @Bean
    public SSLSocketFactory sslSocketFactory() {
        try {
            // 信任任何链接
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom());
            return sslContext.getSocketFactory();
        } catch (NoSuchAlgorithmException | KeyManagementException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Bean
    @Primary
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        objectMapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            public void serialize(Object o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
                jsonGenerator.writeString("");
            }
        });
        return objectMapper;
    }

}


@Component
@Slf4j
public class HttpUtils {

    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    private static final MediaType XML = MediaType.parse("application/xml; charset=utf-8");


    @Resource
    private OkHttpClient okHttpClient;
    @Resource
    private JsonUtils jsonUtils;

    public String get(@NonNull String url) {
        return get(url, null, null);
    }

    public String get(@NonNull String url, Map<String, Object> queryParameter) {
        return get(url, queryParameter, null);
    }


    /**
     * 构建http get请求
     *
     */
    public String get(@NonNull String url, Map<String, Object> queryParameter, Map<String, String> headerParameter) {
        Request request = processGetParameter(url, queryParameter, headerParameter);
        return execute(request);
    }


    public String postForm(@NonNull String url) {
        return postForm(url, null, null);
    }


    public String postForm(@NonNull String url, Map<String, Object> queryParameter) {
        return postForm(url, queryParameter, null);
    }

    /**
     * 构建http post请求
     *
     */
    public String postForm(@NonNull String url, Map<String, Object> queryParameter, Map<String, String> headerParameter) {
        Request request = processPostFormParameter(url, queryParameter, headerParameter);
        return execute(request);
    }


    public String postJson(@NonNull String url) {
        return postJson(url, null, null);
    }


    public String postJson(@NonNull String url, String dataJson) {
        return postJson(url, dataJson, null);
    }


    /**
     * 构建http post json 请求
     *
     */
    public String postJson(@NonNull String url, String dataJson, Map<String, String> headerParameter) {
        Request request = processPostJsonParameter(url, dataJson, headerParameter);
        return execute(request);
    }


    private String execute(Request request) {
        try (Response response = okHttpClient.newCall(request).execute()) {
            if (response.body() != null) {
                return response.body().string();
            }
            log.warn("==> http response body is null, url:{}", request.url());
            return null;
        } catch (Exception e) {
            log.error("okHttp请求异常,请求地址,{}", request.url(), e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 构建Json请求
     *
     */
    private Request processPostJsonParameter(String url, String dataJson, Map<String, String> headerParameter) {
        Request.Builder builder = new Request.Builder().url(url);
        if (!Objects.isNull(dataJson)) {
            RequestBody requestBody = RequestBody.create(JSON, dataJson);
            builder.post(requestBody);
        } else {
            RequestBody requestBody = RequestBody.create(JSON, "{}");
            builder.post(requestBody);
        }
        if (headerParameter != null) {
            builder.headers(Headers.of(headerParameter));
        }
        return builder.build();
    }


    /**
     * 构建Post请求
     *
     */
    private Request processPostFormParameter(String url, Map<String, Object> parameters, Map<String, String> headerParameter) {
        Request.Builder builder = new Request.Builder().url(url);

        if (headerParameter != null) {
            builder.headers(Headers.of(headerParameter));
        }
        if (parameters != null) {
            FormBody.Builder formBuilder = new FormBody.Builder();
            parameters.forEach((k, v) -> formBuilder.add(k, String.valueOf(v)));
            builder.post(formBuilder.build());
        }
        return builder.build();
    }


    /**
     * 构建Get请求
     *
     */
    private Request processGetParameter(String url, Map<String, Object> queryParameter, Map<String, String> headerParameter) {
        Request.Builder builder = new Request.Builder();
        StringBuilder sb = new StringBuilder(url);
        if (headerParameter != null) {
            builder.headers(Headers.of(headerParameter));
        }
        if (queryParameter != null) {
            boolean firstFlag = true;
            for (String key : queryParameter.keySet()) {
                if (firstFlag) {
                    sb.append("?").append(key).append("=").append(queryParameter.get(key));
                    firstFlag = false;
                } else {
                    sb.append("&").append(key).append("=").append(queryParameter.get(key));
                }
            }
        }
        return builder.url(sb.toString()).build();
    }

@Slf4j
@Component
public class JsonUtils {
    @Resource
    private ObjectMapper objectMapper;

    /**
     * 转字符串
     *
     */
    public String toString(Object o) {
        try {
            if (o != null) {
                return objectMapper.writeValueAsString(o);
            }
        } catch (Exception e) {
            log.error("==> toString error", e);
        }
        return null;
    }

    /**
     * 字符串转对象
     *
     */
    public <T> T toObject(String json, Class<T> valueType) {
        try {
            return StringUtils.isNotBlank(json) && !CommonConstant.STRING_NULL.equalsIgnoreCase(json) ?
                    objectMapper.readValue(json, valueType) : null;
        } catch (Exception e) {
            log.error("==> toObject error", e);
        }
        return null;
    }

    /**
     * 字符串转数组
     *
     */
    public <T> T[] toArray(String json, Class<T> valueType) {
        try {
            if (StringUtils.isNotBlank(json) && !CommonConstant.STRING_NULL.equalsIgnoreCase(json)) {
                ArrayType arrayType = objectMapper.getTypeFactory().constructArrayType(valueType);
                return objectMapper.readValue(json, arrayType);
            }
        } catch (Exception e) {
            log.error("==> toArray error", e);
        }
        return null;
    }

    /**
     * 字符串转集合
     *
     */
    public <T> List<T> toList(String json, Class<T> valueType) {
        List<T> list = Lists.newArrayList();
        try {
            if (StringUtils.isNotBlank(json) && !CommonConstant.STRING_NULL.equalsIgnoreCase(json)) {
                CollectionType listType = objectMapper.getTypeFactory().constructCollectionType(ArrayList.class, valueType);
                List<T> value = objectMapper.readValue(json, listType);
                if (CollectionUtils.isNotEmpty(value)) {
                    list.addAll(value);
                }
            }
        } catch (Exception e) {
            log.error("==> toList error", e);
        }
        return list;
    }

    /**
     * 字符串转JsonNode  可操作性高
     *
     */
    public JsonNode toJsonNode(String json) {
        try {
            return StringUtils.isNotBlank(json) && !CommonConstant.STRING_NULL.equalsIgnoreCase(json) ?
                    objectMapper.readTree(json) : null;
        } catch (Exception e) {
            log.error("==> toJsonNode error", e);
        }
        return null;
    }

    /**
     * 转对象
     *
     */
    public <T> T toObject(JsonNode jsonNode, Class<T> valueType) {
        try {
            return toObject(toString(jsonNode), valueType);
        } catch (Exception e) {
            log.error("==> toObject error", e);
        }
        return null;
    }


    public JsonNode getJsonNode(JsonNode jsonNode, String fieldName) {
        if (jsonNode != null && jsonNode.has(fieldName)) {
            return jsonNode.get(fieldName);
        }
        return null;
    }

    public String getString(JsonNode jsonNode, String fieldName) {
        if (jsonNode != null && jsonNode.has(fieldName)) {
            String result = StringUtils.trimToNull(jsonNode.get(fieldName).asText());
            return CommonConstant.STRING_NULL.equalsIgnoreCase(result) ? null : result;
        }
        return null;
    }

    public int getInt(JsonNode jsonNode, String fieldName) {
        if (jsonNode != null && jsonNode.has(fieldName)) {
            return jsonNode.get(fieldName).intValue();
        }
        return 0;
    }

}

muguazhi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android使用OkHttp进行重定向拦截处理的方法
08-27
同时，对于一些需要POST请求后携带Cookie进行GET请求的场景，也可以通过这种方式来实现。需要注意的是，不同网站的登录过程可能有所不同，可能需要处理加密的表单数据或采用其他特殊方式。总的来说，理解HTTP协议和...
java网络爬虫-通过登陆网站携带COOKIE信息爬取网站数据
11-04
在这个特定的场景中，爬虫需要处理登录过程，以便能够携带有效的COOKIE信息来访问受保护的网页，如题库数据。下面，我们将深入探讨如何实现这个功能，以及与MySQL数据库的结合。 首先，登录网站时通常需要发送一个...
OkHttp的运用与原理(cookie、缓存、源码解析)
问彡心的博客
01-26 5303
简介 作为当下最流行的网络请求底层框架,如何战胜其他框架立于不败之地,被广大人群所认可呢?相较于其他网络框架来说,其具有的优势:
android httppost cookie管理,android okhttp使用cookie请求
weixin_39982933的博客
05-25 401
释放双眼，带上耳机，听听看~！今天，简单讲讲Android的http使用cookie请求。现在，做一个功能，出现一个奇怪现象，就是老是登陆成功后，发送请求获取消息，老是提示我没有登陆。我自己都不知道是什么原因，这个也是我对网络通信这块不了解。请教了其他大神后，终于知道是请求没有加cookie的问题。这里记录一下。Request经常都要携带Cookie，上面说过request创建时可以通过heade...
okhttp添加自定义cookie
weixin_30339457的博客
10-08 1905
1 package cn.x.request; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.List; 6 7 import okhttp3.Call; 8 import okhttp3.Cookie; ...
Java OkHttp 一个cookie引发的故障
唯细水静流
04-06 1070
公司业务在腾讯广告平台推广投放，需要对接广告平台，通过API接口上报用户行为转化数据。 项目为Java工程，采用OkHttp开源库实现后台API接口上报，原先一直运行无误，突然某天凌晨运营反馈上报数据异常，公司内部平台显示订单全部上报成功，而腾讯广告后台接受数量一直为0。 最终排查原因是由于OkHttp的cookie相关的配置导致的问题产生。
Glide结合Okhttp做cookie管理实现注册需求的图片验证码短信验证码功能
KeepStudy
04-11 4600
简介有一种需求是这样子，在注册这个功能上，利用cookie进行标识当前手机，进行短信验证码的获取。 流程是这样的(有点坑，csdn好像用代码画不了下面这个图)：这时候问题来了，我们需要获取Glide请求验证码的Cookie，这该怎么解决呢？方法1结合okhttp，Glide使用okhttp进行加载，然后okhttp进行cookie管理，发送请求获取短信验证码。1. 导包导入使得glide支持okht
android cookie 格式,Android OkHttp Cookie持久化问题总结
weixin_42508241的博客
05-26 525
说明最近封装一个SDK时，遇到一个需求就是登录成功之后，APP需要持久保存Cookie，当APP退出再进入时需要从本地读取Cookie值，类似于浏览器，一个网站登录成功之后，关闭浏览器再打开，还能继续访问这个网站网页。Cookie图片来源：https://www.cnblogs.com/zhuanzhuanfe/p/8010854.html分析首先我们清除谷歌浏览器里面缓存的Cookie，当首次访...
Android OkHttp面试题汇总
Dream It Possible
03-26 2439
首先来看一个最简单的 Http 请求是如何发送的。复制.build()})这段代码看起来比较简单,OkHttp 请求过程中最少只需要接触 OkHttpClient、Request、Call、 Response，但是框架内部会进行大量的逻辑处理。所有网络请求的逻辑大部分集中在拦截器中，但是在进入拦截器之前还需要依靠分发器来调配请求任务。关于分发器与拦截器，我们在这里先简单介绍下，后续会有更加详细的讲解分发器:内部维护队列与线程池，完成请求调配;拦截器:五大默认拦截器完成整个请求过程。
okhttp
呓曲流觞的博客
03-08 316
OkHttpClient client = new OkHttpClient(); //请求器 Request request = new Request.Buidler().url(url).build(); //请求 Call call = client.newCall(request); Response response = call.execute(); ResponseBody body = response.body();
OkHttp3.6.0+Retrofit2.2.0持久化cookie
SuperRMB的博客
04-18 590
配置cookie信息: 1 保存cookie信息（一般在登录app之后保存cookie信息）： /** * Created by zhang on 2017/4/14 09 : 57. */ public class ReceivedCookiesInterceptor implements Interceptor {@Override public Response intercept(C
Android OkHttp实现全局过期token自动刷新示例
01-20
在OkHttp中配置这个拦截器，确保每次请求都会经过它： ```java // 创建OkHttpClient实例，添加TokenInterceptor OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(new TokenInterceptor()) ....
okHttp 请求封装
03-29
为了使请求更加灵活，我们还可以扩展这些基础方法，比如支持上传文件、自定义Header或者携带Cookie等。例如，增加一个上传文件的方法： ```java public class OkHttpManager { // ... (之前的代码) public ...
自己封装的OKHttp工具类，粘贴后直调用接
12-02
在实际项目中，我们还可以扩展这个工具类，增加如上传文件、下载文件、携带Cookie等功能，使其更加完善和通用。 【调用方式】： 在需要发起网络请求的地方，直接调用这个工具类提供的方法，传入相应的URL和回调即可...
openFeign配置okhttp
Crzep的博客
07-25 308
openFeign配置okhttp
pi_heif-0.17.0-pp310-pypy310_pp73-macosx_12_0_x86_64.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
mmexport1722080103662.jpg
07-27
mmexport1722080103662.jpg
matlab 20244a 6
07-27
matlab 20244a 6
okhttp配置缓存策略
07-28
回答: 在Okhttp中，可以通过配置缓存策略来实现缓存机制。Okhttp的缓存机制主要是通过设置Http协议中的缓存相关的头部字段来控制的。其中，可以使用CacheControl类来设置缓存策略。CacheControl类中的一些常用方法包括：maxAge()用于设置缓存的最大有效时间，noCache()用于禁用缓存，noStore()用于禁止缓存存储，private()用于设置缓存为私有的，public()用于设置缓存为公共的。通过使用这些方法，可以根据需求来配置Okhttp的缓存策略。\[1\] #### 引用[.reference_title] - *1* *3* [Okhttp的缓存机制](https://blog.csdn.net/qq_39339575/article/details/109682737)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [缓存策略 · liujingxing/okhttp-RxHttp Wiki · GitHub](https://blog.csdn.net/weixin_36204045/article/details/112808716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值