• Java发送httpPost，httpGet，httpDelete请求

            业务场景：最近开发的项目使用的将文件图片和视频存储在Minio当中，但是准备上线申请资源的时候申请不到资源，就临时决定使用厂商提供的Api接口进行文件图片和视频上传，然后就需要在后端进行登录，文件校验和文件存储和文件检索等http请求的书写，所以下面就分享给大家，如果有不足的地方还请多指教。

    Maven依赖：

    1.         <dependency>
    2.             <groupId>org.apache.httpcomponentsgroupId>
    3.             <artifactId>httpmimeartifactId>
    4.             <version>4.5.13version> 
    5.         dependency>
    6.  
    7.         
    8.         <dependency>
    9.             <groupId>org.apache.httpcomponentsgroupId>
    10.             <artifactId>httpclientartifactId>
    11.             <version>4.5.13version> 
    12.         dependency>

    Controller：

            httpPost请求：

    1.  
    2. @RestController
    3. @Slf4j
    4. @RequestMapping("/backend/v1/upload")
    5. public class UploadDIMSController {
    6.  
    7.     @Autowired
    8.     private UploadService uploadService;
    9.  
    10.     @Autowired
    11.     private ResourceService resourceService;
    12.  
    13.     @Autowired
    14.     private DIMSConfig dimsConfig;
    15.  
    16.  
    17.     /**
    18.      * DIMS文件上传的接口
    19.      * 统一使用一个接口
    20.      */
    21.     @BackendPermissionMiddleware(slug = BPermissionConstant.RESOURCE_CATEGORY)
    22.     @PostMapping("/dims-upload")
    23.     public JsonResponse uploadDIMSHttp(@RequestParam HashMap params, MultipartFile file)
    24.             throws ServiceException {
    25.         if (file != null && !file.isEmpty()) {
    26.             try {
    27.                 //1.登录获取token
    28.                 String token = loginDIMS(dimsConfig.getDimsSysCode(), dimsConfig.getUsername(), dimsConfig.getPassword());
    29.                 if (token.equals("获取token失败") ) {
    30.                     return JsonResponse.error("服务器异常，请稍后重试；" + token);
    31.                 }
    32.                 //2.获取批次号 和scanTime
    33.                 HashMap scanTimeAndBatchCode = getBatchCode(dimsConfig.getDimsSysCode(), dimsConfig.getDimsFunCode(), token);
    34.  
    35.                 if (scanTimeAndBatchCode == null || scanTimeAndBatchCode.isEmpty()) {
    36.                     log.info("dims服务器异常,获取批次号失败。");
    37.                     return JsonResponse.error("服务器异常，请稍后重试");
    38.                 }
    39.  
    40.                 //3.上传文件 获取imageID上传的唯一标识
    41.                 String imageId = uploadFileAcquireImageId(file);
    42.  
    43.                 if (imageId.equals("文件上传失败")) {
    44.                     log.info("dims服务器异常,文件上传失败。");
    45.                     return JsonResponse.error("服务器异常，请稍后重试；" + imageId);
    46.                 }
    47.  
    48.                 //4.上传业务信息
    49.                 List arrayList = new ArrayList<>();
    50.                 InfosVO infosVO = new InfosVO();  
    51.                 arrayList.add(infosVO);
    52.  
    53.                 String code = uploadFileInfo(dimsConfig.getDimsSysCode(), token, dimsConfig.getDimsFunCode(), arrayList);
    54.                 if (code != "1") {
    55.                     log.info("dims服务器异常,上传业务信息失败。");
    56.                     return JsonResponse.error("服务器异常，请稍后重试；");
    57.                 }
    58.                 //5.文件检索，将检索的地址直接保存到数据库当中直接返回给前端，前端进行处理
    59.                 String downloadUrl = fileSearchAndSavaUrlToResource(dimsConfig.getDimsSysCode(), scanTimeAndBatchCode.get("batchCode"), token, dimsConfig.getDimsFunCode());
    60.                 if (downloadUrl.equals("文件检索失败。") ) {
    61.                     log.info("dims服务器异常,文件检索失败。");
    62.                     return JsonResponse.error("服务器异常，请稍后重试；" + downloadUrl);
    63.                 }
    64.                 
    65.  
    66.                 //获取上传到那个分类当中
    67.                 String categoryIds = MapUtils.getString(params, "category_ids");
    68.                 //传递管理员id，文件，和分类
    69.                 Resource resource = uploadService.storeDIMS(BCtx.getId(), file, categoryIds, downloadUrl );
    70.  
    71.                 if (resource != null) {
    72.                     //上传成功应该传递文件的路径
    73.                     return JsonResponse.data("上传成功。");
    74.                 } else {
    75.                     return JsonResponse.error("上传失败。");
    76.                 }
    77.  
    78.             } catch (IOException e) {
    79.                 e.printStackTrace();
    80.                 throw new ServiceException("Error uploading file to DIMS server");
    81.             }
    82.         } else {
    83.             return JsonResponse.error("文件为空。");
    84.         }
    85.  
    86.     }
    87.  
    88.  
    89.     /**
    90.      * 1.登录获取token的方法
    91.      */
    92.     public String loginDIMS(String sysCode, String userName, String password) throws IOException {
    93.         // 构建HTTP客户端
    94.         CloseableHttpClient httpClient = HttpClients.createDefault();
    95.         // 创建 HTTP POST 请求
    96.         HttpPost httpPost = new HttpPost(dimsConfig.getLoginUrl());
    97.  
    98.         // 创建要传递的参数列表
    99.         List params = new ArrayList<>();
    100.         params.add(new BasicNameValuePair("sysCode", sysCode));
    101.         params.add(new BasicNameValuePair("user", userName));
    102.         params.add(new BasicNameValuePair("pwd", password));
    103.  
    104.         // 将参数设置到请求中
    105.         httpPost.setEntity(new UrlEncodedFormEntity(params));
    106.  
    107.         try {
    108.             // 执行请求并获取响应
    109.             HttpResponse response = httpClient.execute(httpPost);
    110.             HttpEntity entity = response.getEntity();
    111.  
    112.  
    113.             // 处理响应
    114.             if (entity != null) {
    115.                 // 将响应实体转换为字符串，响应的token
    116.                 String responseText = EntityUtils.toString(entity);
    117.                 return responseText;
    118.             } else {
    119.                 return "获取token失败";
    120.             }
    121.         } finally {
    122.             // 释放资源
    123.             httpPost.releaseConnection();
    124.         }
    125.     }
    126.  
    127.     /**
    128.      * 2.获取批次号
    129.      */
    130.     public HashMap getBatchCode(String sysCode, String funCode, String token) throws IOException {
    131.         HashMap hashMap = new HashMap<>();
    132.         ObjectMapper objectMapper = new ObjectMapper();
    133.         // 构建HTTP客户端
    134.         CloseableHttpClient httpClient = HttpClients.createDefault();
    135.         // 创建 HTTP POST 请求
    136.         HttpPost httpPost = new HttpPost(dimsConfig.getBatchCodeUrl());
    137.  
    138.         // 创建要传递的参数列表
    139.         List params = new ArrayList<>();
    140.         params.add(new BasicNameValuePair("sysCode", sysCode));
    141.         params.add(new BasicNameValuePair("funCode", funCode));
    142.         params.add(new BasicNameValuePair("token", token));
    143.  
    144.         // 将参数设置到请求中
    145.         httpPost.setEntity(new UrlEncodedFormEntity(params));
    146.  
    147.         try {
    148.             // 执行请求并获取响应
    149.             HttpResponse response = httpClient.execute(httpPost);
    150.             HttpEntity entity = response.getEntity();
    151.  
    152.             // 处理响应
    153.             if (entity != null) {
    154.                 String responseText = EntityUtils.toString(entity);
    155.                 log.info("getBatchCode-entity：{}", responseText);
    156.                 //{"msg":"获取成功","data":"{\"scanTime\":\"2023-09-27 7:40:32\"}}"
    157.                 // 去除jar包返回的空字符，对接的系统的bug
    158.                 String sanitizedText = responseText.replace("\0", "");
    159.                 //  String sanitizedText = responseText.trim(); //第二种方式去除空白字符
    160.                 //{"msg":"获取成功","data":{"scanTime":"2023-09-27 7:40:32","batchCode":"sdsdas211dsdx"}}
    161.                 // 解析响应字符串
    162.                 JSONObject entries = new JSONObject(sanitizedText);
    163.                 hashMap.put("scanTime", entries.getJSONObject("data").getStr("scanTime"));
    164.                 hashMap.put("batchCode", entries.getJSONObject("data").getStr("batchCode"));
    165.                 return hashMap;
    166.             } else {
    167.                 return new HashMap<>();
    168.             }
    169.         } finally {
    170.             // 释放资源
    171.             httpPost.releaseConnection();
    172.         }
    173.     }
    174.  
    175.     /**
    176.      * 3.上传文件返回imageId
    177.      */
    178.     public String uploadFileAcquireImageId(MultipartFile file) throws IOException {
    179.         // 构建HTTP客户端
    180.         CloseableHttpClient httpClient = HttpClients.createDefault();
    181.  
    182.         // 创建HTTP POST请求
    183.         HttpPost httpPost = new HttpPost(dimsConfig.getUploadMaxFileUrl());
    184.  
    185.         // 创建一个包含文件和其他参数的多部分实体
    186.         /**
    187.          * 这是需要对接的这个接口也是用MultipartFile file进行接收的方式
    188.          * */
    189.     /*    MultipartEntityBuilder builder = MultipartEntityBuilder.create();
    190.         builder.addBinaryBody("file", file.getInputStream(), ContentType.MULTIPART_FORM_DATA, file.getOriginalFilename());
    192.         httpPost.setEntity(builder.build());*/
    193.         /**
    194.          * 接口接收二进制数据
    195.          * */
    196.         // 设置请求头，告诉服务器请求体是二进制数据
    197.         httpPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/octet-stream");
    198.  
    199.         // 将文件内容作为二进制数据设置为请求体
    200.         byte[] fileBytes = file.getBytes();
    201.         HttpEntity entity = new ByteArrayEntity(fileBytes);
    202.         httpPost.setEntity(entity);
    203.         try {
    204.             // 发送HTTP请求
    205.             HttpResponse response = httpClient.execute(httpPost);
    206.             // 处理响应
    207.             int statusCode = response.getStatusLine().getStatusCode();
    208.             String responseBody = EntityUtils.toString(response.getEntity());
    209.             if (statusCode == 200) {
    210.                 // 请求成功，根据响应处理结果
    211.                 //这里可能还是要对responseBody进行空值截取
    212.                 JSONObject entries = new JSONObject(responseBody);
    213.                 return entries.getJSONObject("data").getStr("imageId");
    214.             } else {
    215.                 // 请求失败，根据需要处理错误情况
    216. //                return new JsonResponse("Upload failed", responseBody);
    217.                 return "文件上传失败";
    218.             }
    219.         } finally {
    220.             // 释放资源
    221.             httpPost.releaseConnection();
    222.         }
    223.     }
    224.  
    225.     /**
    226.      * 4.上传业务信息
    227.      */
    228.     //            uploadFileInfo(dimsConfig.getDimsSysCode(),token,dimsConfig.getDimsFunCode(),arrayList);
    229.     public String uploadFileInfo(String sysCode, String token, String funCode, List arrayList) throws IOException {
    230.         // 创建 ObjectMapper 对象，用于将对象转换为 JSON 字符串
    231.         ObjectMapper objectMapper = new ObjectMapper();
    232.  
    233.         // 将 arrayList 转换为 JSON 字符串
    234.         String arrayListJson = objectMapper.writeValueAsString(arrayList);
    235.         // 构建HTTP客户端
    236.         CloseableHttpClient httpClient = HttpClients.createDefault();
    237.         // 创建 HTTP POST 请求
    238.         HttpPost httpPost = new HttpPost(dimsConfig.getUploadServiceInfoUrl());
    239.  
    240.         // 创建要传递的参数列表
    241.         List params = new ArrayList<>();
    242.         params.add(new BasicNameValuePair("sysCode", sysCode));
    243.         params.add(new BasicNameValuePair("token", token));
    244.         params.add(new BasicNameValuePair("funCode", funCode));
    245.         params.add(new BasicNameValuePair("infos", arrayListJson));//转换成JSON字符串
    246.  
    247.         // 将参数设置到请求中
    248.         httpPost.setEntity(new UrlEncodedFormEntity(params));
    249.  
    250.         try {
    251.             // 执行请求并获取响应
    252.             HttpResponse response = httpClient.execute(httpPost);
    253.             // 处理响应
    254.             String responseBody = EntityUtils.toString(response.getEntity());
    255.  
    256.             // 请求成功，根据响应处理结果
    257.             //这里可能还是要对responseBody进行空值截取
    258.             JSONObject entries = new JSONObject(responseBody);
    259.             return entries.getStr("code");
    260.         } finally {
    261.             // 释放资源
    262.             httpPost.releaseConnection();
    263.         }
    264.     }
    265.  
    266.     /**
    267.      * 5.文件检索，获取 downloadUrl 进行拼接进行下载
    268.      */
    269.     //            fileSearchAndSavaUrlToResource(dimsConfig.getDimsSysCode(),scanTimeAndBatchCode.get("batchCode"),token,dimsConfig.getDimsFunCode());
    270.     public String fileSearchAndSavaUrlToResource(String sysCode, String batchCode, String token, String funCOde) throws IOException {
    271.  
    272.         // 构建HTTP客户端
    273.         CloseableHttpClient httpClient = HttpClients.createDefault();
    274.         // 创建 HTTP POST 请求
    275.         HttpPost httpPost = new HttpPost(dimsConfig.getFileSearchUrl());
    276.  
    277.         // 创建要传递的参数列表
    278.         List params = new ArrayList<>();
    279.         params.add(new BasicNameValuePair("sysCode", sysCode));
    280.         params.add(new BasicNameValuePair("batchCode", batchCode));
    281.         params.add(new BasicNameValuePair("token", token));
    282.         params.add(new BasicNameValuePair("funCode", funCOde));
    283.  
    284.         // 将参数设置到请求中
    285.         httpPost.setEntity(new UrlEncodedFormEntity(params));
    286.  
    287.         try {
    288.             // 执行请求并获取响应
    289.             HttpResponse response = httpClient.execute(httpPost);
    290.             HttpEntity entity = response.getEntity();
    291.             log.info("fileSearchAndSavaUrlToResource-entity：{}", entity);
    292.  
    293.             // 处理响应
    294.             if (entity != null) {
    295.                 // 将响应实体转换为字符串
    296.                 String responseText = EntityUtils.toString(entity);
    297.                 JSONObject entries = new JSONObject(responseText);
    298.                 if (entries.getStr("code") == "1") {
    299.                     JSONArray dataArray = entries.getJSONArray("data");
    300.                     JSONObject firstElement = dataArray.getJSONObject(0);
    301.                     // 这里的 firstElement 就是第一个元素
    302.                     return firstElement.getStr("downloadUrl");//获取 downloadUrl
    303.                 } else {
    304.                     return "文件检索失败。";
    305.                 }
    306.  
    307.             } else {
    308.                 return "文件检索失败。";
    309.             }
    310.         } finally {
    311.             // 释放资源
    312.             httpPost.releaseConnection();
    313.         }
    314.  
    315.     }
    316.  
    317.     /**
    318.      * 获取上传文件的md5
    319.      *
    320.      * @param file
    321.      * @return
    322.      * @throws IOException
    323.      */
    324.     public String getMd5(MultipartFile file) {
    325.          try {
    326.             //获取文件的byte信息
    327.             byte[] uploadBytes = file.getBytes();
    328.             // 拿到一个MD5转换器
    329.             MessageDigest md5 = MessageDigest.getInstance("MD5");
    330.             byte[] digest = md5.digest(uploadBytes);
    331.             //转换为16进制
    332.             String md5Hex = new BigInteger(1, digest).toString(16);
    333.             // 确保MD5值始终是32位
    334.             while (md5Hex.length() < 32) {
    335.                 md5Hex = "0" + md5Hex;
    336.             }
    337.             return md5Hex;
    338.         } catch (Exception e) {
    339.             log.error(e.getMessage());
    340.         }
    341.         return null;
    342.     }
    343.  
    344. }

              httpGet请求：     

    1. public String loginDIMS(String sysCode, String userName, String password) throws IOException {
    2.     // 创建HTTP客户端
    3.     HttpClient httpClient = HttpClients.createDefault();
    4.  
    5.     // 构建GET请求URL
    6.     String getUrl = dimsConfig.getLoginUrl() + "?sysCode=" + sysCode + "&user=" + userName + "&pwd=" + password;
    7.  
    8.     // 创建HTTP GET请求
    9.     HttpGet httpGet = new HttpGet(getUrl);
    10.  
    11.     try {
    12.         // 执行GET请求并获取响应
    13.         HttpResponse response = httpClient.execute(httpGet);
    14.         HttpEntity entity = response.getEntity();
    15.  
    16.         // 处理响应
    17.         if (entity != null) {
    18.             // 将响应实体转换为字符串，响应的token
    19.             String responseText = EntityUtils.toString(entity);
    20.             return responseText;
    21.         } else {
    22.             return "获取token失败";
    23.         }
    24.     } finally {
    25.         // 释放资源
    26.         httpGet.releaseConnection();
    27.     }
    28. }

            httpPut请求：

    1. public JsonResponse httpPutMethod(@RequestParam HashMap params, MultipartFile file) throws IOException {
    2.         // 创建HTTP客户端
    3.         CloseableHttpClient httpClient = HttpClients.createDefault();
    4.  
    5.         // 构建PUT请求URL
    6.  
    7.         String putUrl = "http://127.0.0.1:8080/test"; // 替换为实际的上传URL
    8.  
    9.  
    10.         // 创建HTTP PUT请求
    11.         HttpPut httpPut = new HttpPut(putUrl);
    12.  
    13.         try {
    14.             // 创建请求体，使用MultipartEntityBuilder来构建
    15.             MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
    16.             entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    17.             //将file和parms参数放在请求体中
    18.             entityBuilder.addBinaryBody("file", file.getInputStream(), ContentType.MULTIPART_FORM_DATA, file.getOriginalFilename());
    19.  
    20.             entityBuilder.addTextBody("params", new Gson().toJson(params), ContentType.APPLICATION_JSON);
    21.  
    22.             // 设置请求实体
    23.             HttpEntity reqEntity = entityBuilder.build();
    24.             httpPut.setEntity(reqEntity);
    25.  
    26.             // 执行PUT请求并获取响应
    27.             HttpResponse response = httpClient.execute(httpPut);
    28.             HttpEntity responseEntity = response.getEntity();
    29.             log.info("response:{}", response);
    30.             log.info("responseEntity:{}", responseEntity);
    31.             // 处理响应
    32.             if (responseEntity != null) {
    33.                 // 将响应实体转换为字符串
    34.                 String responseText = EntityUtils.toString(responseEntity);
    35.                 log.info("responseText:{}", responseText);
    36.                 if (responseText != null) {
    37.                     return JsonResponse.data(responseText);
    38.                 }
    39.  
    40.                 return JsonResponse.error("处理失败");
    41.             } else {
    42.                 return JsonResponse.error("上传和处理失败");
    43.             }
    44.         } finally {
    45.             // 释放资源
    46.             httpPut.releaseConnection();
    47.         }
    48.     }

            httpDelete请求：

    1. public String deleteDIMS(String resourceUrl) throws IOException {
    2.     // 创建HTTP客户端
    3.     HttpClient httpClient = HttpClients.createDefault();
    4.  
    5.     // 构建DELETE请求
    6.     HttpDelete httpDelete = new HttpDelete(resourceUrl);
    7.  
    8.     try {
    9.         // 执行DELETE请求并获取响应
    10.         HttpResponse response = httpClient.execute(httpDelete);
    11.         int statusCode = response.getStatusLine().getStatusCode();
    12.  
    13.         // 处理响应
    14.         if (statusCode == 200) {
    15.             // 处理成功的响应，根据需要返回结果
    16.             return "删除成功";
    17.         } else {
    18.             // 处理失败的响应，根据需要返回错误信息
    19.             return "删除失败，状态码：" + statusCode;
    20.         }
    21.     } finally {
    22.         // 释放资源
    23.         httpDelete.releaseConnection();
    24.     }
    25. }

    还有一个小知识：就是在对接厂商提供的接口的时候获取返回的JSON数据发现数据格式为

    {"msg":"获取成功","data":"{\"scanTime\":\"2023-09-27 7:40:32\"}}"

    其实就是JSON格式，但是就是识别不出来，最后发现这段数据中{”msg“前面有一个空字符，特别神奇，也不知道他们响应是如何响应的，然后我通过

    String sanitizedText = responseText.replace("\0", "");

    这个方法把这个小问题给解决了，也可以使用

    String sanitizedText = responseText.trim(); //第二种方式去除空白字符

    进行解决。

  • 相关阅读:
    Vue中图片上传组件封装-antd的a-upload二次封装-案例
    不规则形状的图例制作
    vivo自研AI大模型即将问世，智能手机行业加速迈向AI时代
    Util应用框架 7.x 来了
    Node.js 入门教程 3 如何安装 Node.js
    艾美捷Immunochemistry MitoPT JC-1试剂盒
    解决 urllib2 中 CookiesMiddleware 的 cookie 问题
    AppScan介绍和安装
    vim的基本操作
    [docker]笔记-网络故障处理
  • 原文地址：https://blog.csdn.net/m0_64210833/article/details/133387364