修改文件上传类型限制

mitao

2025-05-20 179c4d64313c9b7572778da4aaaf6c6584fe457d

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/utlis/HttpClientUtil.java

@@ -1,30 +1,49 @@
package com.panzhihua.common.utlis;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import com.panzhihua.common.constants.HttpConstant;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
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.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.springframework.util.ObjectUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import com.panzhihua.common.constants.HttpConstant;

import lombok.extern.slf4j.Slf4j;

import javax.net.ssl.SSLContext;

import static com.panzhihua.common.utlis.wx.WXPayConstants.USER_AGENT;

/**
 * @program: springcloud_k8s_panzhihuazhihuishequ
@@ -36,21 +55,28 @@
public class HttpClientUtil {
    /**
     * 通过post方式调用http接口
     * @param url     url路径
     * @param jsonParam    json格式的参数
     * @param reSend     重发次数
     * @param headerKey     header键值
     * @param headerValue     headervalue
     * 
     * @param url
     *            url路径
     * @param jsonParam
     *            json格式的参数
     * @param reSend
     *            重发次数
     * @param headerKey
     *            header键值
     * @param headerValue
     *            headervalue
     * @return
     * @throws Exception
     */
    public static String sendPostByJson(String url, String jsonParam,int reSend,String headerKey,String headerValue) {
        //声明返回结果
    public static String sendPostByJson(String url, String jsonParam, int reSend, String headerKey,
        String headerValue) {
        // 声明返回结果
        String result = "";
        //开始请求API接口时间
        long startTime=System.currentTimeMillis();
        //请求API接口的响应时间
        long endTime= 0L;
        // 开始请求API接口时间
        long startTime = System.currentTimeMillis();
        // 请求API接口的响应时间
        long endTime = 0L;
        HttpEntity httpEntity = null;
        HttpResponse httpResponse = null;
        HttpClient httpClient = null;
@@ -59,68 +85,69 @@
            httpClient = HttpClientFactory.getInstance().getHttpClient();
            // 设置请求头和报文
            HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
            Header header=new BasicHeader("Accept-Encoding",null);
            Header header = new BasicHeader("Accept-Encoding", null);
            httpPost.setHeader(header);
            if (!ObjectUtils.isEmpty(headerKey)) {
                httpPost.setHeader(headerKey,headerValue);
                httpPost.setHeader(headerKey, headerValue);
            }
            // 设置报文和通讯格式
            StringEntity stringEntity = new StringEntity(jsonParam, HttpConstant.UTF8_ENCODE);
            stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
            stringEntity.setContentType(HttpConstant.APPLICATION_JSON);
            httpPost.setEntity(stringEntity);
            log.info("请求{}接口的参数为{}",url,jsonParam);
            //执行发送，获取相应结果
//            log.info("请求{}接口的参数为{}", url, jsonParam);
            // 执行发送，获取相应结果
            httpResponse = httpClient.execute(httpPost);
            httpEntity= httpResponse.getEntity();
            httpEntity = httpResponse.getEntity();
            result = EntityUtils.toString(httpEntity);
        } catch (Exception e) {
            log.error("请求{}接口出现异常",url,e);
            log.error("请求{}接口出现异常", url, e);
            if (reSend > 0) {
                log.info("请求{}出现异常:{}，进行重发。进行第{}次重发",url,e.getMessage(),(HttpConstant.REQ_TIMES-reSend +1));
                result = sendPostByJson(url, jsonParam, reSend - 1,headerKey,headerValue);
                log.info("请求{}出现异常:{}，进行重发。进行第{}次重发", url, e.getMessage(), (HttpConstant.REQ_TIMES - reSend + 1));
                result = sendPostByJson(url, jsonParam, reSend - 1, headerKey, headerValue);
                if (result != null && !"".equals(result)) {
                    return result;
                }
            }
        }finally {
        } finally {
            try {
                EntityUtils.consume(httpEntity);
            } catch (IOException e) {
                log.error("http请求释放资源异常",e);
                log.error("http请求释放资源异常", e);
            }
        }
        //请求接口的响应时间
        endTime=System.currentTimeMillis();
        log.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒",url,result,(endTime-startTime));
        // 请求接口的响应时间
        endTime = System.currentTimeMillis();
//        log.info("请求{}接口的响应报文内容为{},本次请求API接口的响应时间为:{}毫秒", url, result, (endTime - startTime));
        return result;

    }

    /**
     * 使用http请求调用接口，参数类型为xml
     * @param urlStr    请求地址
     * @param data  请求参数
     * @return  调用结果
     * 
     * @param urlStr
     *            请求地址
     * @param data
     *            请求参数
     * @return 调用结果
     */
    public static String httpsRequest(String urlStr,String data) {
    public static String httpsRequest(String urlStr, String data) {
        try {
            URL url = new URL(urlStr);
            URLConnection con = url.openConnection();
            con.setDoOutput(true);
//            con.setRequestProperty("Pragma:", "no-cache");
            // con.setRequestProperty("Pragma:", "no-cache");
            con.setRequestProperty("Cache-Control", "no-cache");
            con.setRequestProperty("Content-Type", "text/xml");

            OutputStreamWriter out = new OutputStreamWriter(con
                    .getOutputStream());
            OutputStreamWriter out = new OutputStreamWriter(con.getOutputStream());
            log.info("urlStr=" + urlStr);
            log.info("xmlInfo=" + data);
            out.write(new String(data.getBytes("UTF-8")));
            out.flush();
            out.close();
            BufferedReader br = new BufferedReader(new InputStreamReader(con
                    .getInputStream()));
            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String line = "";
            StringBuffer sb = new StringBuffer();
            for (line = br.readLine(); line != null; line = br.readLine()) {
@@ -134,7 +161,6 @@
        }
        return "";
    }


    /**
     * http请求工具类，get请求
@@ -158,7 +184,7 @@
                    key = iterator.next();
                    Object val = params.get(key);
                    if (val instanceof List) {
                        List v = (List) val;
                        List v = (List)val;
                        for (Object o : v) {
                            stringBuilder.append(key).append("=").append(o.toString()).append("&");
                        }
@@ -175,10 +201,10 @@
            HttpResponse httpResponse = defaultHttpClient.execute(httpGet);
            if (httpResponse.getStatusLine().getStatusCode() != 200) {
                String errorLog = "请求失败，errorCode:" + httpResponse.getStatusLine().getStatusCode();
                log.info(errorLog);
                log.info("errorLog:{}"+errorLog);
                throw new Exception(url + errorLog);
            }
            //读取返回信息
            // 读取返回信息
            String charSet = "utf-8";
            if (resonseCharSet != null && resonseCharSet.length > 0)
                charSet = resonseCharSet[0];
@@ -201,11 +227,15 @@
        }
    }



    /**
     * http请求工具类，post请求
     *
     * @param url    url
     * @param param 参数值 仅支持String
     * @param url
     *            url
     * @param param
     *            参数值 仅支持String
     * @return
     * @throws Exception
     */
@@ -215,7 +245,7 @@
        try {
            defaultHttpClient = new DefaultHttpClient();
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json;charset=ut-8");
            httpPost.setHeader("Content-Type", "application/json;charset=utf-8");
            if (StringUtils.isNotBlank(param)) {
                log.info("参数值：{}", param);
                HttpEntity httpEntity = new StringEntity(param, "utf-8");
@@ -227,13 +257,14 @@
                log.info(errorLog);
                throw new Exception(url + errorLog);
            }
            //读取返回信息
            // 读取返回信息
            String output;
            bufferedReader = new BufferedReader(new InputStreamReader(httpResponse.getEntity().getContent(), "utf-8"));
            StringBuilder stringBuilder = new StringBuilder();
            while ((output = bufferedReader.readLine()) != null) {
                stringBuilder.append(output);
            }
            log.info("调用微信接口返回的参数：" + stringBuilder.toString());
            return stringBuilder.toString();
        } catch (IOException e) {
            e.printStackTrace();
@@ -248,5 +279,302 @@



    // HTTP GET请求
    public static String sendGet(String url) throws Exception {
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        //默认值GET
        con.setRequestMethod("GET");
        //添加请求头
        con.setRequestProperty("User-Agent", USER_AGENT);
        int responseCode = con.getResponseCode();
        log.info("发送 'GET' 请求到 URL:{}" + url);
        log.info("Response Code:{}" + responseCode);
        BufferedReader in = new BufferedReader(
                new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();
        //打印结果
        log.info("uu洗车返回:{}"+response.toString());
        return response.toString();
    }

    /**
     * http请求工具类，post请求
     *
     * @param url
     *            url
     * @param param
     *            参数值 仅支持String
     * @return
     * @throws Exception
     */
    public static String httpPostAndToken(String url, String param,Map headerMap) throws Exception {
        DefaultHttpClient defaultHttpClient = null;
        BufferedReader bufferedReader = null;
        try {
            defaultHttpClient = new DefaultHttpClient();
            HttpPost httpPost = new HttpPost(url);
            httpPost.setHeader("Content-Type", "application/json;charset=utf-8");
//            httpPost.setHeader("Authorization", headerMap.get("Authorization").toString());
//            httpPost.setHeader("Host", headerMap.get("Host").toString());

            for (Object key : headerMap.keySet()) {
                httpPost.setHeader(key.toString(), headerMap.get(key).toString());
            }
            if (StringUtils.isNotBlank(param)) {
                log.info("参数值：{}", param);
                HttpEntity httpEntity = new StringEntity(param, "utf-8");
                httpPost.setEntity(httpEntity);
//                httpPost.setHeader("Content-Length", String.valueOf(httpEntity.getContentLength()));
            }
            HttpResponse httpResponse = defaultHttpClient.execute(httpPost);
            if (httpResponse.getStatusLine().getStatusCode() != 200) {
                int statusCode = httpResponse.getStatusLine().getStatusCode();
                String errorLog = "请求失败，errorCode:" + httpResponse.getStatusLine().getStatusCode();
                log.info(errorLog);
                throw new Exception(url + errorLog);
            }
            // 读取返回信息
            String output;
            bufferedReader = new BufferedReader(new InputStreamReader(httpResponse.getEntity().getContent(), "utf-8"));
            StringBuilder stringBuilder = new StringBuilder();
            while ((output = bufferedReader.readLine()) != null) {
                stringBuilder.append(output);
            }
            log.info("调用接口返回的参数：" + stringBuilder.toString());
            return stringBuilder.toString();
        } catch (IOException e) {
            e.printStackTrace();
            throw e;
        } finally {
            if (defaultHttpClient != null)
                defaultHttpClient.getConnectionManager().shutdown();
            if (bufferedReader != null)
                bufferedReader.close();
        }
    }

    public static void main(String[] args) throws IOException {
        DefaultHttpClient  defaultHttpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost("https://dptest.d-power.com.cn:14404/v1/face");
//        httpPost.setHeader("Content-Type", "application/json;charset=utf-8");
        httpPost.setHeader("Authorization", "DpToken P3JHgjLbyljfLrFnS9OZbATRJmacdt4b");
        httpPost.setHeader("Host", "123.60.2.66");
//        httpPost.setHeader("Content-Length", String.valueOf(entity.getContentLength()));

//        httpPost.setHeader("User-Agent", "Apache-HttpClient/4.5.12 (Java/1.8.0_162)[\\r][\\n]");
        httpPost.setEntity(new StringEntity("{\"positions\":[{\"role\":\"occupant\",\"communityId\":\"64f99b2ed26106d4f0fe93f4\",\"unitId\":\"64f99b2ed26106d4f0fe93f7\"}],\"tel\":\"15696695118\",\"name\":\"四月里3\",\"timeout\":10,\"image\":\"fsdfsdfsdf\"}", "utf-8"));
//        httpPost.setHeader("Content-Length", String.valueOf(entity.getContentLength()));
        HttpResponse httpResponse = defaultHttpClient.execute(httpPost);
        System.out.println(httpResponse.getEntity());
    }

    /**
     * get请求
     * 
     * @param url
     *            请求地址（get请求时参数自己组装到url上）
     * @param headerMap
     *            请求头
     * @return 响应文本
     */
    public static String get(String url, Map<String, String> headerMap, String param) {
        // 请求地址，以及参数设置
        HttpPost post = new HttpPost(url);
        if (headerMap != null) {
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                post.setHeader(entry.getKey(), entry.getValue());
            }
        }
        if (StringUtils.isNotBlank(param)) {
            log.info("参数值：{}", param);
            HttpEntity httpEntity = new StringEntity(param, "utf-8");
            post.setEntity(httpEntity);
        }
        // 执行请求，获取相应
        return getRespString(post);
    }

    /**
     * get请求
     *
     * @param url
     *            请求地址（get请求时参数自己组装到url上）
     * @param headerMap
     *            请求头
     * @return 响应文本
     */
    public static String getUU(String url, Map<String, String> headerMap, String param) {
        // 请求地址，以及参数设置
        HttpPost post = new HttpPost(url);

        SSLContext sslContext = null;
        try {
            sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {
                @Override
                public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                    return true;
                }
            }).build();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }

        CloseableHttpClient client = HttpClients.custom().setSslcontext(sslContext).
                setSSLHostnameVerifier(new NoopHostnameVerifier()).build();


        //请求超时时间设置
        post.setConfig(RequestConfig.custom()// 连接超时时间
                .setConnectTimeout(5000)
        // 请求超时时间
                .setConnectionRequestTimeout(5000)
        // Socket读取超时时间
                .setSocketTimeout(5000)
        // 是否允许重定向
                .setRedirectsEnabled(false)
                .build());

         //发送请求
        CloseableHttpResponse response = null;
        try {
            response = client.execute(post);
        } catch (IOException e) {
            e.printStackTrace();
            log.error("request error. ");

        }
        HttpEntity entity = response.getEntity();
        try {
            if (entity != null) {
                //按指定编码转换结果实体为String类型
                return EntityUtils.toString(entity, "UTF-8");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }



    /**
     * 获取响应信息（String）
     */
    public static String getRespString(HttpUriRequest request) {
        // 获取响应流
        InputStream in = getRespInputStream(request);

        StringBuilder sb = new StringBuilder();
        String line;

        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        try {
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        String str = sb.toString();
        return str;
    }

    /**
     * 获取响应信息（InputStream）
     */
    public static InputStream getRespInputStream(HttpUriRequest request) {
        // 获取响应对象
        HttpResponse response = null;
        try {
            response = HttpClients.createDefault().execute(request);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (response == null) {
            return null;
        }
        // 获取Entity对象
        HttpEntity entity = response.getEntity();
        // 获取响应信息流
        InputStream in = null;
        if (entity != null) {
            try {
                in = entity.getContent();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return in;
    }

    /**
     * 退款请求微信
     * @param url   请求地址
     * @param data  请求数据
     * @param mchId 商户id
     * @param isTest    是否是测试
     * @return  退款结果
     * @throws Exception    抛出异常
     */
    public static String doRefund(String url, String data,String mchId,Boolean isTest) throws Exception{
        KeyStore keyStore  = KeyStore.getInstance("PKCS12");
        //P12文件目录 证书路径，这里需要你自己修改，linux下还是windows下的根路径
        String filepath = "/mnt/data/refund/huacheng/";

        System.out.println("filepath->"+filepath);
        FileInputStream instream = new FileInputStream(filepath+"apiclient_cert.p12");
        try {
            keyStore.load(instream, mchId.toCharArray());//这里写密码..默认是你的MCHID
        } finally {
            instream.close();
        }

        // Trust own CA and all self-signed certs
        SSLContext sslcontext = SSLContexts.custom()
                .loadKeyMaterial(keyStore, mchId.toCharArray())//这里也是写密码的
                .build();
        // Allow TLSv1 protocol only
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslcontext,
                SSLConnectionSocketFactory.getDefaultHostnameVerifier());
        CloseableHttpClient httpclient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .build();
        try {
            HttpPost httpost = new HttpPost(url); // 设置响应头信息
            httpost.addHeader("Connection", "keep-alive");
            httpost.addHeader("Accept", "*/*");
            httpost.addHeader("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
            httpost.addHeader("Host", "api.mch.weixin.qq.com");
            httpost.addHeader("X-Requested-With", "XMLHttpRequest");
            httpost.addHeader("Cache-Control", "max-age=0");
            httpost.addHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0) ");
            httpost.setEntity(new StringEntity(data, "UTF-8"));
            CloseableHttpResponse response = httpclient.execute(httpost);
            try {
                HttpEntity entity = response.getEntity();

                String jsonStr = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.info("请求微信退款接口返回结果：" + JSONObject.toJSONString(jsonStr));
                EntityUtils.consume(entity);
                return jsonStr;
            } finally {
                response.close();
            }
        } finally {
            httpclient.close();
        }

    }
}