httpclient保存cooki session。okhttp3。RestTemplate。OkHttp3ClientHttpRequestFactory等。

天海华兮

1363人浏览 · 2024-02-06 17:51:45

天海华兮 · 2024-02-06 17:51:45 发布

一、httpclient保存cooki session

1. 各种http客户端说明

httpcomponents.httpclient
ok http 3
Spring 的：org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
1. package org.springframework.web.client.RestTemplate

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.14</version>
        </dependency>

2. 创建 CookieStore

CookieStore 里放置 BasicClientCookie

    private static CookieStore createCookieStore() {
        // 创建一个 BasicCookieStore 对象
        //chat还这样创建，报错：new InMemoryCookieStore();
        CookieStore cookieStore = new BasicCookieStore();

        // 创建一个 Cookie 对象
        BasicClientCookie cookie = new BasicClientCookie("CAREYE_CORE_C_ID", "35302ee4-160d-458d-9cbc-963ea55a27eb");
        cookie.setDomain("localhost"); // 设置域名
        cookie.setPath("/"); // 设置路径

        cookieStore.addCookie(cookie);
        return cookieStore;
    }

3. response 解析出来

    public static String processResponse(CloseableHttpResponse response) throws IOException {
        //1.获取Entity
        HttpEntity entity = response.getEntity();
        //2.不为null
        if (entity != null) {
            //3.获取内容，内容是个输入流
            try (InputStream inputStream = entity.getContent();
                 //4.创建成 缓冲流
                 BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                //5.定义 builder对象
                StringBuilder responseString = new StringBuilder();
                String line;
                //6.读取一行
                while ((line = reader.readLine()) != null) {
                    //7.添加到后面
                    responseString.append(line);
                }
                //返回
                return responseString.toString();
            }
        }
        return null;
    }

只解析 1024数组

    private static void myPrint(CloseableHttpResponse execute) throws Exception {
    	//读取
        byte[] bytes = new byte[1024];
        int read = execute.getEntity().getContent().read(bytes);
        
        //复制
        byte[] trueByte = Arrays.copyOf(bytes, read);
        System.out.println("结果为：" + new String(trueByte));
    }

4. 主逻辑创建http client post

4.1 设置COOKIE_STORE

        //1.创建 httpClient
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        //2.创建HttpPost
        HttpPost httpPost = new HttpPost("http://localhost:8088/car/getListCarInfo");
        //这里不设置也行，session也能正常访问
        //httpPost.addHeader("Cookie", "JSESSIONID=589060a1-8823-4442-974a-837ef2b49e3c");

        //3.创建上下文
        HttpCoreContext httpContext = HttpCoreContext.create();
        //创建cookie
        httpContext.setAttribute(HttpClientContext.COOKIE_STORE, createCookieStore());

        //4.执行请求
        CloseableHttpResponse response = httpClient.execute(httpPost, httpContext);

        //打印
        String s = processResponse(response);

        System.out.println(s);

4.2 无关紧要header头

        // 创建 HttpGet 对象，并设置请求参数。POST也一样
        //HttpGet httpGet = new HttpGet();
        //httpGet.addHeader("Cookie", "JSESSIONID=" + sessionId);

        //Headers headers = Headers.of("abc-token", "123456");/

4.3 主流程2：获取cookie session 请求参数

    private void main2(String[] args) throws Exception {

        //创建 client 和 context 和  uri
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpCoreContext httpContext = HttpCoreContext.create();
        String url = "http://localhost:8088/usr/login";
        HttpPost httpPost = new HttpPost(url);

        //设置参数：方式1
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("checkCode", "admin"));
        params.add(new BasicNameValuePair("loginName", "admin"));
        params.add(new BasicNameValuePair("password", "qqqq"));
        httpPost.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
        //设置参数：方式2
        //StringEntity entity = new StringEntity("json", StandardCharsets.UTF_8);
        //httpPost.setEntity(entity);

        //机型请求
        CloseableHttpResponse execute = httpClient.execute(httpPost, httpContext);

        // 从 HttpContext 中获取生成的 session
        //String sessionId = (String) httpContext.getAttribute(ClientContext.COOKIE_STORE);

        //获取:CookieStore
        //旧的是：ClientContext.COOKIE_STORE
        BasicCookieStore store = (BasicCookieStore) httpContext.getAttribute(HttpClientContext.COOKIE_STORE);
        //获取到 列表
        List<Cookie> cookies = store.getCookies();
        //获取单个cookies
        Cookie cookie = cookies.get(0);
        //获取到 sessionID
        String sessionId = cookie.getValue();
        //session名字
        String name = cookie.getName();
        System.out.println(name + ":" + sessionId);

        //打印结果
        processResponse(execute);


        HttpPost httpPost2 = new HttpPost("http://localhost:8088/car/getListCarInfo");
        //再次执行请求，上下文是同一个，什么都不用改
        CloseableHttpResponse response = httpClient.execute(httpPost2, httpContext);
        processResponse(response);
    }

4.5 HttpClients.crete和HttpClientBuilder

        //CloseableHttpClient build = HttpClientBuilder.create().build(); 另一种

        //底层使用：HttpClientBuilder.create().build()
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {

    public String get(String url) throws IOException {
        //new HttpPost(url)
        return send(new HttpGet(url));
    }
    public String send(HttpUriRequest uri) throws IOException {
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 设置 session
            uri.setHeader("Cookie", "JSESSIONID=" + session);
            //创建上下文
            HttpContext httpContext = new BasicHttpContext();
            //设置 cookie
            httpContext.setAttribute(HttpClientContext.COOKIE_STORE, createCookieStore()); // 设置 cookie store

            //发送请求
            try (CloseableHttpResponse response = httpClient.execute(uri, httpContext)) {
                //请求处理
                return processResponse(response);
            }
        }
    }

4.6 方式2：置超时 HttpClientBuilder

    //@Component
    //@Value("${http.connection.timeout}")
    private int connectionTimeout = 10000;

    //@Value("${http.socket.timeout}")
    private int socketTimeout = 10000;

    public String get(String url, Map<String, String> headers) throws IOException {
        //1.创建
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

            //2.创建上下文
            HttpCoreContext httpContext = HttpCoreContext.create();
            //创建cookie
            httpContext.setAttribute(HttpClientContext.COOKIE_STORE, createCookieStore());

            //3. get对象
            HttpGet httpGet = new HttpGet(url);

            //4.请求配置
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(connectionTimeout)
                    .setSocketTimeout(socketTimeout)
                    .build();
            httpGet.setConfig(requestConfig);

            //5.处理 header
            if (headers != null && !headers.isEmpty()) {
                headers.forEach(httpGet::addHeader);
            }
            //6.发送请求
            try (CloseableHttpResponse response = httpClient.execute(httpGet, httpContext)) {
                //7.处理返回
                return processResponse(response);
            }
        }
    }

    public String post(String url, String body, Map<String, String> headers) throws IOException {
        //客户端 和 URI
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {
            HttpPost httpPost = new HttpPost(url);

            //创建上下文
            HttpCoreContext httpContext = HttpCoreContext.create();
            //创建cookie
            httpContext.setAttribute(HttpClientContext.COOKIE_STORE, createCookieStore());

            //配置
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(connectionTimeout)
                    .setSocketTimeout(socketTimeout)
                    .build();
            httpPost.setConfig(requestConfig);

            //设置头
            if (headers != null && !headers.isEmpty()) {
                headers.forEach(httpPost::addHeader);
            }

            //处理body
            if (body != null && !body.isEmpty()) {
                //创建 entity对象
                StringEntity entity = new StringEntity(body, StandardCharsets.UTF_8);
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }

            //返回
            try (CloseableHttpResponse response = httpClient.execute(httpPost, httpContext)) {
                return processResponse(response);
            }
        }
    }

4.7 无用尝试调用

public class HttpSessionHttpUtil {

    private String session; // 保存登录后获取的 session

    // 假设登录接口返回的响应中包含了 session 信息，这里简化处理
    public void login(String username, String password) {
        // 模拟登录操作，获取 session
        this.session = "35302ee4-160d-458d-9cbc-963ea55a27eb";
    }

    public static void main(String[] args) throws IOException {

        HttpSessionHttpUtil httpUtil = new HttpSessionHttpUtil();
        //session要赋值
        httpUtil.login("username", "password");


        String result = httpUtil.post("http://localhost:8088/car/getListCarInfo");

        System.out.println(result);
    }

二，其他

1. spingWeb的okHttp3

import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;

        String url = "http://localhost:8088/car/getListCarInfo";

		//创URL
        URI uri = URI.create(url);
		//发请求
        ClientHttpRequest request = new OkHttp3ClientHttpRequestFactory().createRequest(uri, HttpMethod.POST);
		//执行
        ClientHttpResponse execute = request.execute();
		//获取返回
        System.out.println(execute.getStatusCode());


        byte[] bytes = new byte[1024];
        int read = execute.getBody().read(bytes);
        byte[] trueByte = Arrays.copyOf(bytes, read);
        System.out.println(new String(trueByte));

2. okhttp3 挺好

发现：Cookie 类，应该是用来处理的
OkHttpClient

@Data
@Component
public class UrlProperties {

    /*@Value("${weatherconfig.gdUrl}")
    private String gdUrl;*/
}

package org.jeecg.common.util.http.outproject;

import okhttp3.*;

import java.io.File;
import java.io.IOException;
import java.util.Map;

public class HttpUtil {
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    private final OkHttpClient client = new OkHttpClient();

       /*Request request = new Request.Builder()
                .url("https://api.github.com/user")
                .header("User-Agent", "OkHttp Headers.java")
                .build();
        Response response = client.newCall(request).execute();*/

    //上传
    public String upload(String url, File file) throws IOException {
        //设备 头信息为 data
        RequestBody fileBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
        //创建 MultipartBody，类型为 form，name名为 pdf
        MultipartBody multipartBody = (new MultipartBody.Builder())
                .setType(MultipartBody.FORM)
                .addFormDataPart("pdf", file.getName(), fileBody)
                .build();
        //发送post请求
        Request request = (new Request.Builder()).url(url).post(multipartBody).build();
        return getResponseBody(request);
    }

    public Request form(String url, Map<String, String> form) {
        //构建form请求
        FormBody.Builder formBody = new FormBody.Builder();

        //循环 map，添加到 form请求里
        if (form != null && !form.isEmpty())
            for (Map.Entry<String, String> entry : form.entrySet())
                formBody.add(entry.getKey(), entry.getValue());

        //form再次构建，成 外部类
        FormBody formBody1 = formBody.build();
        //构建请求，使用 post
        return (new Request.Builder()).url(url).post(formBody1).build();
    }

    //创建form请求
    public String form(String url, Map<String, String> form, Headers headers) throws IOException {
        //使用构建好的，添加头信息，构建成 请求
        Request request = form(url, form).newBuilder().headers(headers).build();
        return getResponseBody(request);
    }


    public String post(String url, String json) throws IOException {
        //创建json对象
        RequestBody requestBody = RequestBody.create(JSON, json);
        //创建post请求
        Request request = (new Request.Builder()).url(url).post(requestBody).build();
        return getResponseBody(request);
    }

    public String get(String url) throws IOException {
        //创建get请求，不带参数。url就是get请求
        Request request = (new Request.Builder()).url(url).build();
        return getResponseBody(request);
    }

    //发起请求
    private String getResponseBody(Request request) throws IOException {
        //发起请求
        Response response = this.client.newCall(request).execute();
        //获取返回对象
        ResponseBody responseBody = response.body();
        //如果未null，就返回空
        if (responseBody == null)
            return "";
        //返回的String
        String result = responseBody.string();
        //相应关闭
        response.close();
        //返回
        return result;
    }


    public static void main(String[] args) throws Exception {

        String url = "http://localhost:8088/car/getListCarInfo";
        String result = new HttpUtil().get(url);

        System.out.println(result);
    }
}

3. jeecg工具类 RestUtil

        String url = "http://localhost:8088/car/getListCarInfo";
        //Headers headers = Headers.of("abc-token", "123456");

        //在工具类的第237行，添加header代码 即可
        JSONObject result = RestUtil.post(url);

		//底层使用：
		package org.springframework.web.client;
		//RestTemplate

31. 其他处理域名

package com.careye.api.util.shiro.responce;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Map;

/**
 * 调用 Restful 接口 Util
 *
 * @author sunjianlei
 */
@Slf4j
public class RestUtil {

    private static String domain = null;
    private static String path = null;

    private static String getDomain() {
        if (domain == null) {
            domain = SpringContextUtils.getDomain();
            // issues/2959
            // 微服务版集成企业微信单点登录
            // 因为微服务版没有端口号，导致 SpringContextUtils.getDomain() 方法获取的域名的端口号变成了:-1所以出问题了，只需要把这个-1给去掉就可以了。
            String port = ":-1";
            if (domain.endsWith(port)) {
                domain = domain.substring(0, domain.length() - 3);
            }
        }
        return domain;
    }

    private static String getPath() {
        if (path == null) {
            path = SpringContextUtils.getApplicationContext().getEnvironment().getProperty("server.servlet.context-path");
        }
        return oConvertUtils.getString(path);
    }

    public static String getBaseUrl() {
        String basepath = getDomain() + getPath();
        log.info(" RestUtil.getBaseUrl: " + basepath);
        return basepath;
    }

3.2 基本超时配置

    /**
     * RestAPI 调用器
     */
    private final static RestTemplate RT;

    static {
        //连接 和 读取超时都是 3秒
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(3000);
        requestFactory.setReadTimeout(3000);
        RT = new RestTemplate(requestFactory);
        // 解决乱码问题
        RT.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
    }

    public static RestTemplate getRestTemplate() {
        return RT;
    }

3.3 get请求 3种情况

 /**
     * 1.发送 get 请求。无参数
     */
    public static JSONObject get(String url) {
        return getNative(url, null, null).getBody();
    }

    /**
     * 2.发送 get 请求。有变量
     */
    public static JSONObject get(String url, JSONObject variables) {
        return getNative(url, variables, null).getBody();
    }

    /**
     * 3.发送 get 请求。有变量，有参数。解释：variables会转成这样的：a=1&b=2&c=3。params放在body里，(JSONObject) params 或 toString
     */
    public static JSONObject get(String url, JSONObject variables, JSONObject params) {
        return getNative(url, variables, params).getBody();
    }

    /**
     * 发送 get 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> getNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.GET, variables, params);
    }

3.4 post请求 3种情况

/**
     * 4.发送 Post 请求。无变量
     */
    public static JSONObject post(String url) {
        return postNative(url, null, null).getBody();
    }

    /**
     * 5. 发送 Post 请求。有参数
     */
    public static JSONObject post(String url, JSONObject params) {
        return postNative(url, null, params).getBody();
    }

    /**
     * 6. 发送 Post 请求。有变量，有参数
     */
    public static JSONObject post(String url, JSONObject variables, JSONObject params) {
        //ResponseEntity<JSONObject>的泛型对应
        return postNative(url, variables, params).getBody();
    }

    /**
     * 发送 POST 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> postNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.POST, variables, params);
    }

3.5 put请求 3种情况

	/**
     * 7.发送 put 请求。不带参数
     */
    public static JSONObject put(String url) {
        return putNative(url, null, null).getBody();
    }

    /**
     * 8.发送 put 请求。带参数
     */
    public static JSONObject put(String url, JSONObject params) {
        return putNative(url, null, params).getBody();
    }

    /**
     * 9.发送 put 请求。带url参数 和 参数
     */
    public static JSONObject put(String url, JSONObject variables, JSONObject params) {
        return putNative(url, variables, params).getBody();
    }

    /**
     * 发送 put 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> putNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.PUT, variables, params);
    }

3.6 delete请求 1种情况

 	/**
     * 10.发送 delete 请求。不带参数
     */
    public static JSONObject delete(String url) {
        return deleteNative(url, null, null).getBody();
    }

    /**
     * 11.发送 delete 请求。待url参数 和 参数
     */
    public static JSONObject delete(String url, JSONObject variables, JSONObject params) {
        return deleteNative(url, variables, params).getBody();
    }

    /**
     * 发送 delete 请求，返回原生 ResponseEntity 对象
     */
    public static ResponseEntity<JSONObject> deleteNative(String url, JSONObject variables, JSONObject params) {
        return request(url, HttpMethod.DELETE, null, variables, params, JSONObject.class);
    }

3.7 request 组装请求


    /**
     * 发送请求
     */
    public static ResponseEntity<JSONObject> request(String url, HttpMethod method, JSONObject variables, JSONObject params) {
        return request(url, method, getHeaderApplicationJson(), variables, params, JSONObject.class);
    }

    /**
     * 发送请求
     *
     * @param url          请求地址
     * @param method       请求方式
     * @param headers      请求头  可空
     * @param variables    请求url参数 可空
     * @param params       请求body参数 可空
     * @param responseType 返回类型
     * @return ResponseEntity<responseType>
     */
    public static <T> ResponseEntity<T> request(String url, HttpMethod method, HttpHeaders headers, JSONObject variables, Object params, Class<T> responseType) {
        log.info(" RestUtil  --- request ---  url = " + url);
        if (StringUtils.isEmpty(url)) {
            throw new RuntimeException("url 不能为空");
        }
        if (method == null) {
            throw new RuntimeException("method 不能为空");
        }
        //如果 头不存在，就创建
        if (headers == null) {
            headers = new HttpHeaders();
        }
        // 请求体
        String body = "";
        //参数不为null
        if (params != null) {
            //如果是 json
            if (params instanceof JSONObject) {
                //使用json的序列化
                body = ((JSONObject) params).toJSONString();
            } else {
                //使用String的序列化
                body = params.toString();
            }
        }
        // 拼接 url 参数
        if (variables != null && !variables.isEmpty()) {
            url += ("?" + asUrlVariables(variables));
        }
        // 发送请求：String类型的body
        HttpEntity<String> request = new HttpEntity<>(body, headers);
        return RT.exchange(url, method, request, responseType);
    }

3.8 处理Headers

	/**
     * 获取JSON请求头：json类型的header，ContentType 和 Accept
     */
    public static HttpHeaders getHeaderApplicationJson() {
        //application/json;charset=UTF-8
        return getHeader(MediaType.APPLICATION_JSON_UTF8_VALUE);
    }

    /**
     * 获取请求头
     */
    public static HttpHeaders getHeader(String mediaType) {
        //创建 header
        HttpHeaders headers = new HttpHeaders();
        //设置 ContentType ，为json
        headers.setContentType(MediaType.parseMediaType(mediaType));
        //添加头信息
        headers.add("Accept", mediaType);
        return headers;
    }

3.9 把参数组成url传输

/**
     * 将 JSONObject 转为 a=1&b=2&c=3...&n=n 的形式
     */
    public static String asUrlVariables(JSONObject variables) {
        //转成map
        Map<String, Object> source = variables.getInnerMap();
        //获取key的迭代器
        Iterator<String> it = source.keySet().iterator();
        //定义结果
        StringBuilder urlVariables = new StringBuilder();
        while (it.hasNext()) {
            String key = it.next();
            String value = "";
            Object object = source.get(key);
            if (object != null) {
                //如果对象不为null
                if (!StringUtils.isEmpty(object.toString())) {
                    //赋值
                    value = object.toString();
                }
            }
            //拼接 &a=1
            urlVariables.append("&").append(key).append("=").append(value);
        }
        // 去掉第一个&
        return urlVariables.substring(1);
    }

}

三，本次工具类

package org.jeecg.common.util.http;

/**
 * Created on 2024/2/5.
 *
 * @author hua
 */

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.CookieStore;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.cookie.Cookie;
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.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.apache.http.protocol.HttpCoreContext;
import org.jeecg.common.exception.JeecgBootException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Component
public class HttpSessionUtil {

    // 保存登录后获取的 session
    private String session;

    //设置连接请求超时
    //@Value("${http.connection.timeout}")
    private int connectionTimeout = 30000;

    //套接字超时时间
    //@Value("${http.socket.timeout}")
    private int socketTimeout = 30000;

    @Value("${httpBy.url:http://localhost:8088/}")
    private String URL;

    @Value("${httpBy.domain:localhost}")
    private String DOMAIN;

    @Value("${httpBy.userName:admin}")
    private String USER_NAME;

    @Value("${httpBy.databasePwd:xxx}")
    private String DATABASE_PWD;

    /*public static String URL = "http://192.168.70.125/api/";
    public static String DOMAIN = "192.168.70.125";*/
    //HttpClientBuilder.create().build() 一样。定义到这里交给Spring反而更慢。
    //private static final CloseableHttpClient INSTANCE = HttpClients.createDefault();
    //上下文
    //private static final BasicHttpContext CONTEXT = new BasicHttpContext();

    //测试
    public static void main(String[] args) throws IOException {
        HttpSessionUtil httpUtil = new HttpSessionUtil();
        //session要赋值
        //httpUtil.login();
        //String post = httpUtil.post("car/getListCarInfo", null, null);
        /*ReturnBean returnBean = JSONUtil.toBean(post, ReturnBean.class);
        List<CarInfo> list = returnBean.getResultData().getData();
        list.stream().forEach(v -> System.out.println(v.getCarnumber()));
        System.out.println(list);*/
        //System.out.println(post);
    }

    //登录接口返回的响应中包含了 session。String username, String password
    private void login() throws IOException {
        //创建 client 和 context 和  uri
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();//INSTANCE
        HttpCoreContext httpContext = HttpCoreContext.create();
        String url = URL + "usr/clientLoginV2";
        HttpPost httpPost = new HttpPost(url);

        //设置参数：方式1
        List<NameValuePair> params = new ArrayList<>();

        //params.add(new BasicNameValuePair("checkCode", "admin"));
        //params.add(new BasicNameValuePair("loginName", "admin"));
        //params.add(new BasicNameValuePair("password", "@111^")); 对应接口：clientLogin

        params.add(new BasicNameValuePair("loginname", USER_NAME));
        params.add(new BasicNameValuePair("password", DATABASE_PWD));//密文对应v2接口
        httpPost.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
        //设置参数：方式2
        //StringEntity entity = new StringEntity("json", StandardCharsets.UTF_8);
        //httpPost.setEntity(entity);

        //进行机型请求 CloseableHttpResponse execute =
        httpClient.execute(httpPost, httpContext);

        //获取:CookieStore。旧的是：ClientContext.COOKIE_STORE
        BasicCookieStore store = (BasicCookieStore) httpContext.getAttribute(HttpClientContext.COOKIE_STORE);
        //获取到 列表
        List<Cookie> cookies = store.getCookies();
        //获取单个cookies
        Cookie cookie = cookies.get(0);
        //获取到 sessionID
        String sessionId = cookie.getValue();

        System.out.println("请求了Session，ID为：" + sessionId);

        // 模拟登录操作，获取 session
        this.session = sessionId;
    }
    //session名字
    //String name = cookie.getName();
    //System.out.println(name + ":" + sessionId);
    //打印结果
    //processResponse(execute);
    //HttpPost httpPost2 = new HttpPost("/car/getListCarInfo");
    //再次执行请求，上下文是同一个，什么都不用改
    //CloseableHttpResponse response = httpClient.execute(httpPost2, httpContext);
    //processResponse(response);

    /**
     * 获取配置对象
     *
     * @return
     */
    private RequestConfig getRequestConfig() {
        //4.请求配置
        return RequestConfig.custom()
                .setConnectTimeout(connectionTimeout)
                .setSocketTimeout(socketTimeout)
                .build();
    }

    /**
     * 获取http上下文
     *
     * @return
     */
    @NotNull
    private HttpContext getHttpContext() {
        //创建上下文
        HttpContext httpContext = new BasicHttpContext();
        //设置 cookie
        httpContext.setAttribute(HttpClientContext.COOKIE_STORE, createCookieStore()); // 设置 cookie store
        return httpContext;
    }

    /**
     * Get方式发送请求
     *
     * @param url
     * @param headers
     * @return
     */
    public String get(String url, Map<String, String> headers) {
        //1.创建 INSTANCE
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

            //2.创建上下文
            HttpContext httpContext = getHttpContext();

            //3. get对象
            HttpGet httpGet = new HttpGet(URL + url);

            RequestConfig requestConfig = getRequestConfig();
            httpGet.setConfig(requestConfig);

            //5.处理 header
            if (headers != null && !headers.isEmpty()) {
                headers.forEach(httpGet::addHeader);
            }
            //6.发送请求
            try (CloseableHttpResponse response = httpClient.execute(httpGet, httpContext)) {
                //7.处理返回
                String result = processResponse(response);
                result = againRequest(httpClient, httpGet, result);
                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new JeecgBootException("http post error" + url);
        }
    }


    /**
     * post方式发送请求的基本方法
     *
     * @param url
     * @param headers
     * @param formEntity
     * @param stringEntity
     * @return
     */
    private ReturnBean basePost(String url, Map<String, String> headers, UrlEncodedFormEntity formEntity, StringEntity stringEntity) {
        //客户端 和 URI
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {// INSTANCE

            HttpPost httpPost = new HttpPost(URL + url);

            //创建上下文
            HttpContext httpContext = getHttpContext();

            //配置
            RequestConfig requestConfig = getRequestConfig();
            httpPost.setConfig(requestConfig);

            //设置头
            if (headers != null && !headers.isEmpty()) {
                headers.forEach(httpPost::addHeader);
            }

            //判断使用那种方式
            if (null != formEntity) {
                //如果form方式不为null
                httpPost.setEntity(formEntity);
            } else if (null != stringEntity) {
                //如果StringEntity方式不不为null
                httpPost.setEntity(stringEntity);
            }
            //返回
            try (CloseableHttpResponse response = httpClient.execute(httpPost, httpContext)) {
                //获取结果
                String result = processResponse(response);
                result = againRequest(httpClient, httpPost, result);

                //转换成返回对象
                return JSONUtil.toBean(result, ReturnBean.class);

                //return (JSONObject 或 JSONArray) returnBean.getResultData();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new JeecgBootException("http post error" + url);
        }
    }

    /**
     * post使用form方式发送
     *
     * @param url
     * @param obj
     * @param headers
     * @return
     */
    public ReturnBean postByParam(String url, Object obj, Map<String, String> headers) {
        List<NameValuePair> params = getNameValuePairs(obj);

        return basePost(url, headers, new UrlEncodedFormEntity(params, StandardCharsets.UTF_8), null);
    }

    public ReturnBean postByUpload(String url, MultipartFile sourceFile, Integer type) {

        //目前代码为先登录一下
        try {
            login();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //客户端 和 URI
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

            HttpPost httpPost = new HttpPost(URL + url);

            //创建上下文
            HttpContext httpContext = getHttpContext();

            //配置
            RequestConfig requestConfig = getRequestConfig();
            httpPost.setConfig(requestConfig);

            //创建文件请求
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            //获取文件名
            String fileName = sourceFile.getOriginalFilename();
            //获取内容
            InputStream fileContent = sourceFile.getInputStream();
            //构造请求
            builder.addBinaryBody("file", fileContent, ContentType.MULTIPART_FORM_DATA, fileName);

            //设置相关参数
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            builder.setCharset(java.nio.charset.Charset.forName("UTF-8"));

            //设置其他参数
            //决中文乱码。没遇见乱码，不知道服务器上怎样。 参考：https://blog.csdn.net/fraya1234/article/details/134524193
            ContentType contentType = ContentType.create(HTTP.PLAIN_TEXT_TYPE, Consts.UTF_8);
            builder.addTextBody("type", String.valueOf(type), contentType);
            httpPost.setEntity(builder.build());

            //返回
            try (CloseableHttpResponse response = httpClient.execute(httpPost, httpContext)) {
                //获取结果
                String result = processResponse(response);
                //这里重试会报错Cannot retry request with a non-repeatable request entity

                //转换成返回对象
                return JSONUtil.toBean(result, ReturnBean.class);
                //return (JSONObject 或 JSONArray) returnBean.getResultData();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new JeecgBootException("http post error" + url);
        }
        //设置其他表单字段（非必需）
        //List<NameValuePair> params = new ArrayList<>();
        //params.add(new BasicNameValuePair("type", String.valueOf(type)));
        //new UrlEncodedFormEntity(params);
        //builder.addPart("params", );
    }


    public void postByExport(HttpServletResponse sourceResponse, String url, Object obj, Map<String, String> headers) {

        //目前代码为先登录一下
        try {
            login();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //客户端 和 URI
        try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

            HttpPost httpPost = new HttpPost(URL + url);

            //创建上下文
            HttpContext httpContext = getHttpContext();

            //配置
            RequestConfig requestConfig = getRequestConfig();
            httpPost.setConfig(requestConfig);

            //设置头
            if (headers != null && !headers.isEmpty()) {
                headers.forEach(httpPost::addHeader);
            }

            //判断
            if (null != obj) {
                List<NameValuePair> params = getNameValuePairs(obj);
                //如果form方式不为null
                httpPost.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));
            }
            //返回
            try (CloseableHttpResponse closeableHttpResponse = httpClient.execute(httpPost, httpContext)) {
                //获取实体
                HttpEntity entity = closeableHttpResponse.getEntity();
                if (entity != null) {
                    //获取实体的 输入流
                    try (InputStream inStream = entity.getContent()) {
                        //设置响应的内容类型：从实体里设置
                        sourceResponse.setContentType(entity.getContentType().getValue());

                        // 从输入流读取数据并写入到响应输出流中
                        int bytesRead;
                        //每次读取 1024字节
                        byte[] buffer = new byte[1024];
                        //如果读取到了
                        while ((bytesRead = inStream.read(buffer)) != -1) {
                            //输出流写入
                            sourceResponse.getOutputStream().write(buffer, 0, bytesRead);
                        }//循环读取
                        //文件名 前端处理
                    }//实体的输入流
                }//实体不为null
            }//执行请求
        } catch (Exception e) {
            e.printStackTrace();
            throw new JeecgBootException("http post error" + url);
        }
    }

    /*try {
        //获取文件名头信息
        Header[] closeableHeaders = closeableHttpResponse.getHeaders("Content-disposition");
        String headerValue = closeableHeaders[0].getValue();
        //判断后设置
        if (StringUtils.isNotBlank(headerValue)) {
            //headerValue = new String(headerValue.getBytes(), "iso8859-1"); 无作用
            sourceResponse.setHeader("Content-disposition", "attachment; filename=" + "huatest1.xls");
        }
        //定义输出类型
        sourceResponse.setContentType("application/vnd.ms-excel;charset=UTF-8");
    } catch (Exception e) {
        System.out.println("处理文件名失败");
        e.printStackTrace();
    }//处理文件名*/

    @NotNull
    private List<NameValuePair> getNameValuePairs(Object obj) {
        JSONObject variables = JSONUtil.parseObj(obj);

        //设置参数：方式1
        List<NameValuePair> params = new ArrayList<>();

        Set<String> strings = variables.keySet();
        for (String key : strings) {
            params.add(new BasicNameValuePair(key, String.valueOf(variables.get(key))));
        }
        return params;
    }

    /**
     * post使用 body方式发送
     *
     * @param url
     * @param body
     * @param headers
     * @return
     */
    public ReturnBean post(String url, String body, Map<String, String> headers) {
        StringEntity entity = null;
        //处理body
        if (body != null && !body.isEmpty()) {
            //创建 entity对象
            entity = new StringEntity(body, StandardCharsets.UTF_8);
            entity.setContentType("application/json");
        }
        return basePost(url, headers, null, entity);
    }

    /**
     * 参数拼接成 a=1&b=1，暂未使用
     *
     * @param obj
     * @return
     */
    public static String asUrlVariables(Object obj) {
        JSONObject variables = JSONUtil.parseObj(obj);

        //定义结果
        StringBuilder urlVariables = new StringBuilder();

        Set<String> strings = variables.keySet();
        for (String key : strings) {

            Object object = variables.get(key);

            String value = "";

            if (object != null) {
                //如果对象不为null
                if (!StringUtils.isEmpty(object.toString())) {
                    //赋值
                    value = object.toString();
                }
            }
            //拼接 &a=1
            urlVariables.append("&").append(key).append("=").append(value);
        }

        // 去掉第一个&
        return urlVariables.substring(1);
    }

    /**
     * 重试请求方法
     *
     * @param httpClient
     * @param httpPostOrGet
     * @param result
     * @return
     * @throws IOException
     */
    @Nullable
    private String againRequest(CloseableHttpClient httpClient, HttpUriRequest httpPostOrGet, String result) throws
            IOException {
        //如果结果是未登录
        if (result.equals("{\"errCode\":2000,\"resultMsg\":\"用户未登录!\"}")) {
            login();
            try (CloseableHttpResponse responseAgain = httpClient.execute(httpPostOrGet, getHttpContext())) {
                result = processResponse(responseAgain);
            }
        }
        return result;
    }

    /**
     * 创建 cookie仓库
     *
     * @return
     */
    private CookieStore createCookieStore() {
        // 创建一个 BasicCookieStore 对象
        CookieStore cookieStore = new BasicCookieStore();
        // 创建一个 Cookie 对象
        BasicClientCookie cookie = new BasicClientCookie("CAREYE_CORE_C_ID", session);
        cookie.setDomain(DOMAIN); // 设置域名

        cookie.setPath("/"); // 设置路径
        cookieStore.addCookie(cookie);
        return cookieStore;
    }

    /**
     * 处理http的响应
     *
     * @param response
     * @return
     * @throws IOException
     */
    private String processResponse(CloseableHttpResponse response) throws IOException {
        //1.获取Entity
        HttpEntity entity = response.getEntity();
        //2.不为null
        if (entity != null) {
            //3.获取内容，内容是个输入流
            try (InputStream inputStream = entity.getContent();
                 //4.创建成 缓冲流
                 BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                //5.定义 builder对象
                StringBuilder responseString = new StringBuilder();
                String line;
                //6.读取一行
                while ((line = reader.readLine()) != null) {
                    //7.添加到后面
                    responseString.append(line);
                }
                //返回
                return responseString.toString();
            }
        }
        return null;
    }
    /*无用：public String get(String url) throws IOException {
        //new HttpPost(url)
        HttpGet httpGet = new HttpGet(url);
        RequestConfig requestConfig = getRequestConfig();
        httpGet.setConfig(requestConfig);
        //CloseableHttpClient build = HttpClientBuilder.create().build(); 另一种方式创建
        //底层使用：HttpClientBuilder.create().build()
        try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
            // 设置 session
            httpGet.setHeader("Cookie", "JSESSIONID=" + session);
            HttpContext httpContext = getHttpContext();
            //发送请求
            try (CloseableHttpResponse response = httpClient.execute(httpGet, httpContext)) {
                //请求处理
                return processResponse(response);
            }
        }
    }*/
}