httpClient 工具类 post请求 发送文字json格式 加 图片（多个图片）的接口调用

最新推荐文章于 2023-09-28 17:41:10 发布
最新推荐文章于 2023-09-28 17:41:10 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tang_jian_dong/article/details/103938675
版权

有这么一个需求， 前端请求我的后端，  我的后端请求第三方的接口进行文字和图片的上传。

POM依赖：

      <dependency>
		  <groupId>commons-fileupload</groupId>
		  <artifactId>commons-fileupload</artifactId>
		  <version>1.3.3</version>
		</dependency>
		
		<dependency>
		  <groupId>commons-io</groupId>
		  <artifactId>commons-io</artifactId>
		  <version>2.6</version>
		  <type>pom</type>
		</dependency>
		
		<dependency>
		  <groupId>org.apache.httpcomponents</groupId>
		  <artifactId>httpmime</artifactId>
		  <version>4.3.2</version>
		</dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.7</version>
        </dependency>

 

 controller:   MultipartFile为数组，接收一个或多个文件

@RequestMapping(value = "/zlxf",method = {RequestMethod.POST, RequestMethod.GET})
    @ResponseBody
    public String sendfk(ZlxfDTO zlxfDTO, @RequestParam("files")MultipartFile[] files)
    {

    }

 

为项目中实际应用

httpclient   post :

/**
    *
    * (doPostMultipartFile)
    *
    * @param map 参数
    * @return 返回结果
    * @throws Exception
    * @author tangjiandong
    */
   public static String doPostMultipartFile(String url,Map<String,Object> map, MultipartFile[] files)throws Exception {
       String result = "";
       CloseableHttpClient client = HttpClients.createDefault();
       //超时设置
       RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
               .setSocketTimeout(5000).setRedirectsEnabled(true).build();
       HttpPost post = new HttpPost(url);
       post.setConfig(config);
       try{
           
           
           MultipartEntityBuilder builder = MultipartEntityBuilder.create();
           builder.setCharset(java.nio.charset.Charset.forName("UTF-8"));
           builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
           String fileName = "";
           MultipartFile multipartFile = null;
           
           //text/plain  ,不要用原生的，原生的是8859-1字符，会乱码
           ContentType contentType = ContentType.create("application/json", Charset.forName("utf-8"));
           //json文字内容
           for(Map.Entry<String, Object> entry: map.entrySet())
           {
               if(null == entry.getValue())
               {
                   continue;
               }
               builder.addTextBody(entry.getKey(), entry.getValue().toString(), contentType);
           }
           
           //不要用原生的，原生的是8859-1字符，会乱码
          ContentType contentType2 = ContentType.create("multipart/form-data", Charset.forName("utf-8"));
           //一个或多个 文件，  files,为参数名
          for (int i = 0; i < files.length; i++) 
           {
               multipartFile = files[i];
               fileName = multipartFile.getOriginalFilename();
               builder.addBinaryBody("files", multipartFile.getInputStream(), contentType2, fileName);
           }
           
           
           HttpEntity entity = builder.build();
           
           
           post.setEntity(entity);
           
           
           HttpResponse response = client.execute(post);
           if(200 == response.getStatusLine().getStatusCode())
           {
               HttpEntity resEntity = response.getEntity();
               result = EntityUtils.toString(resEntity,"UTF-8");
           }
       }catch(HttpException e)
       {
           e.printStackTrace();
           logger.error("---------http调用接口异常!",e);
           ExceptionHelper.throwExc("http调用接口异常");
       }finally{
           //释放连接
           post.releaseConnection();
       }
       return result;
   }

 

工具类

package com.htcf.spbj.init;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.htcf.frame.base.util.ExceptionHelper;
import com.htcf.frame.base.util.JsonUtil;

import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.params.HttpParams;
import org.apache.commons.lang.StringUtils;
import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
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.MultipartEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.InputStreamBody;
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.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.zookeeper.Op.Create;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class HttpClientUtil {

    private static final Logger logger = LoggerFactory.getLogger(HttpClientUtil.class);

    private static String  fileurl="http://68.174.33.43/service-spbj/uploadFile/upload";
    
    /**
     * (post)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static JSONObject post(String url, Map<String, Object> map) throws Exception {
    	 CloseableHttpClient client = HttpClients.createDefault();
         RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                 .setSocketTimeout(5000).setRedirectsEnabled(true).build();
         HttpPost post = new HttpPost(url);
         post.setConfig(config);
         
        JSONObject obj = new JSONObject();
        StringEntity entiry = new StringEntity(JsonUtil.toJsonNonNull(map), "utf-8");
        try {
            entiry.setContentEncoding("utf-8");
            entiry.setContentType("application/json;charset=UTF-8");
            post.setEntity(entiry);
            HttpResponse response = client.execute(post);

            if (200 == response.getStatusLine().getStatusCode()) {
                String str = EntityUtils.toString(response.getEntity(), "utf-8");
                obj = JSONObject.parseObject(str);
            }
        } catch (HttpException e) {
            e.printStackTrace();
            logger.error("---------http调用接口异常!", e);
            ExceptionHelper.throwExc("http调用接口异常");
        } finally {
            //释放连接
            post.releaseConnection();
        }
        return obj;
    }

    /**
     * (post)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static String doPost(String url, Map<String, Object> map) throws Exception {
        String result = "";
        CloseableHttpClient client = HttpClients.createDefault();
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                .setSocketTimeout(5000).setRedirectsEnabled(true).build();
        HttpPost post = new HttpPost(url);
        post.setConfig(config);
        try {
             /*StringEntity entiry = new StringEntity(JsonUtil.toJsonDefaults(map),"utf-8");
             entiry.setContentEncoding("utf-8");
             entiry.setContentType("application/json;charset=UTF-8");
             post.setEntity(entiry);
             HttpResponse response = client.execute(post);
            */
            List<BasicNameValuePair> list = new ArrayList<>();
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                BasicNameValuePair basicNameValuePair = new BasicNameValuePair(key, (String) map.get(key));
                list.add(basicNameValuePair);
            }
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "utf-8");
            entity.setContentType("application/json;charset=UTF-8");
            HttpResponse response = client.execute(post);
            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity, "UTF-8");
            }
        } catch (HttpException e) {
            e.printStackTrace();
            logger.error("---------http调用反馈接口异常!", e);
            ExceptionHelper.throwExc("http调用反馈接口异常");
        } finally {
            //释放连接
            post.releaseConnection();
        }
        return result;
    }

    /**
     * (post)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static JSONArray doGet(String url) throws Exception {
        CloseableHttpClient client = HttpClients.createDefault();
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                .setSocketTimeout(5000).setRedirectsEnabled(true).build();
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(config);
        try {
            HttpResponse response = client.execute(httpGet);
            
            Header firstHeader = response.getFirstHeader("Content-Disposition");
            String fileName = "未知.jpg";
            if(null != firstHeader)
            {
            	HeaderElement[] elements = firstHeader.getElements();
            	if(null != elements && elements.length > 0)
            	{
            		for (HeaderElement headerElement : elements) 
                	{
                		NameValuePair parameterByName = headerElement.getParameterByName("filename");
                		if(null != parameterByName)
                		{
                			fileName = parameterByName.getValue();
                		}
    				}
            	}
            }
            
            if (200 == response.getStatusLine().getStatusCode()) {
            	byte[] readInputStream = readInputStream(response.getEntity().getContent());
                return  doPostMultipartFile(fileurl, readInputStream, fileName);
            }
        } catch (HttpException e) {
            e.printStackTrace();
            logger.error("---------http调用接口异常!", e);
            ExceptionHelper.throwExc("http调用接口异常");
        } finally {
        	 
            //释放连接
        	httpGet.releaseConnection();
        }
    	
    	
 
        return  null;
    }

    
    /**
     * (post)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static String doGet(String url, Map<String, Object> map) throws Exception {
        String result = "";
        CloseableHttpClient client = new DefaultHttpClient();
        if (map != null) {
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                String value = (String) map.get(key);
                value = URLEncoder.encode(value, "UTF-8");
                value = URLEncoder.encode(value, "UTF-8");
                url = url + "&" + key + "=" + value;
            }
        }
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                .setSocketTimeout(5000).setRedirectsEnabled(true).build();
        HttpGet httpGet = new HttpGet(url);
        httpGet.setConfig(config);
        try {
            HttpResponse response = client.execute(httpGet);
            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity, "UTF-8");
            }
        } catch (HttpException e) {
            logger.error("---------http调用接口异常!", e);
            ExceptionHelper.throwExc("http调用接口异常");
        } finally {
            //释放连接
            client.close();
        }
        return result;
    }


    /**
     * (doPostMultipartFile)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static String doPostMultipartFile(String url, Map<String, Object> map, MultipartFile[] files) throws Exception {
        String result = "";
        CloseableHttpClient client = HttpClients.createDefault();
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                .setSocketTimeout(5000).setRedirectsEnabled(true).build();
        HttpPost post = new HttpPost(url);
        post.setConfig(config);
        try {
           /*List<BasicNameValuePair> list = new ArrayList<>();
           Set<String> keySet = map.keySet();
           for (String key:keySet) {
               BasicNameValuePair basicNameValuePair = new BasicNameValuePair(key,(String)map.get(key));
               list.add(basicNameValuePair);
           }
           UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list,"utf-8");
           entity.setContentType("application/json;charset=UTF-8");
           post.setEntity(entity);*/

            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setCharset(java.nio.charset.Charset.forName("UTF-8"));
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            String fileName = "";
            MultipartFile multipartFile = null;

            //text/plain
            ContentType contentType = ContentType.create("application/json", Charset.forName("utf-8"));
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                if (null == entry.getValue()) {
                    continue;
                }
                builder.addTextBody(entry.getKey(), entry.getValue().toString(), contentType);
            }


            ContentType contentType2 = ContentType.create("multipart/form-data", Charset.forName("utf-8"));
            for (int i = 0; i < files.length; i++) {
                multipartFile = files[i];
                fileName = multipartFile.getOriginalFilename();
                builder.addBinaryBody("files", multipartFile.getInputStream(), contentType2, fileName);
            }


            HttpEntity entity = builder.build();


            post.setEntity(entity);


            HttpResponse response = client.execute(post);
            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity resEntity = response.getEntity();
                result = EntityUtils.toString(resEntity, "UTF-8");
            }
        } catch (HttpException e) {
            e.printStackTrace();
            logger.error("---------http调用接口异常!", e);
            ExceptionHelper.throwExc("http调用接口异常");
        } finally {
            //释放连接
            post.releaseConnection();
        }
        return result;
    }

    /**
     * (doPostMultipartFile)
     *
     * @param map 参数
     * @return 返回结果
     * @throws Exception
     * @author tangjiandong
     */
    public static JSONArray doPostMultipartFile(String url,  byte[] by, String fileName) throws Exception {
        JSONArray result = null;
        CloseableHttpClient client = HttpClients.createDefault();
        RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000)
                .setSocketTimeout(5000).setRedirectsEnabled(true).build();
        HttpPost post = new HttpPost(url);
        
        post.setConfig(config);
        try {
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setCharset(java.nio.charset.Charset.forName("UTF-8"));
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

            MockMultipartFile mockMultipartFile = new MockMultipartFile(ContentType.APPLICATION_OCTET_STREAM.toString(), by);
            
            ContentType contentType2 = ContentType.create("multipart/form-data", Charset.forName("utf-8"));
             builder.addBinaryBody("files", mockMultipartFile.getInputStream(), contentType2 , fileName);

            HttpEntity entity = builder.build();
           
            post.setEntity(entity);


            HttpResponse response = client.execute(post);
            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity resEntity = response.getEntity();
                result = JSONObject.parseArray(EntityUtils.toString(resEntity, "UTF-8"));
            }
           
        } catch (HttpException e) {
            e.printStackTrace();
            logger.error("---------http调用接口异常!", e);
            ExceptionHelper.throwExc("http调用接口异常");
        } finally {
            //释放连接
            post.releaseConnection();
        }
        
        
        return result;
    }
  
    
    public static byte[] readInputStream(InputStream inputStream)
    {
    	ByteArrayOutputStream os = new ByteArrayOutputStream();
    	
    	byte[] by = new byte[1024];
    	
    	int len;
    	
    	try {
    		while((len = inputStream.read(by)) != -1)
        	{
        		os.write(by, 0, len);
        	}
        	
        	inputStream.close();
		} catch (Exception e) {
			logger.error("----------文件流读取异常!");
			e.printStackTrace();
		}
    	return os.toByteArray();
    }
}

 

 

tang_jian_dong
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClientUtil工具类发送get和post请求，支持http和https，支持发送文件
04-07
首先，HttpClientUtil工具类通常会封装HttpClient的基本操作，以便于开发者在应用中便捷地调用。GET和POST请求是HTTP协议中最常见的两种请求方法。GET请求用于获取服务器上的资源，而POST请求则常用于向服务器提交...
java调用httpclient提交post请求
daqinzl的专栏
09-10 1672
//接口 @Controller @Slf4j @RequestMapping("/service/dist") public class DistributionController { @PostMapping("/callback") @ResponseBody public Map<String, String> callback(Model model, String mid, String state, String remoteurl, HttpServl...
httpclient用法大全
安卓世界库
07-20 1676
staticfinalintdefaultMaxPerRoute=Integer.valueOf(ProperUtil.get("corePoolSize")).intValue();staticfinalintmaxTotal=Integer.valueOf(ProperUtil.get("maxTotal")).intValue();HttpPosthttpPost=newHttpPost("http//www.baidu.com");//每个主机的最大并行链接数。...
HTTPPOST使用
qq_37889636的博客
07-14 1887
一般httppost都是结合HttpClients使用CloseableHttpResponse response = null;CloseableHttpClient client = null;HttpPost httpPost = new HttpPost(url);    //需要请求的urlhttpPost.setEntity(entityParams);   //放入需要传的值clie...
httpclient HttpResponse response = client.execute(post);报空指针问题
热门推荐
黑色的记忆 chester, come on
12-10 1万+
HttpResponse response = client.execute(post);报空指针。 有点莫名奇妙的，client与post对话经过log与debug，都没有发现是null啊。，。。。 然后开始各种排错，常见的没加网络权限及网络访问没放在子线程中，都没有犯这样错啊。。。 最终注释掉post.setHeaders(headers);，又好了。。。(之前同一份代码在另一工
使用封装的axios发送请求
weixin_51118163的博客
09-28 346
使用封装的axios发送请求 1.src\api\api.js 定义请求路由方法: import URLS from '../../config/urls' import { get, post } from './ajax' let base = URLS.API_URL // 用户相关 export const postLogin = p => post(`${base}/login/`, p); export const getLogin = p => get(`${base}
HttpClient模拟get，post请求并发送请求参数（json等）
08-07
在实际项目中，我们通常会封装一个HttpClientUtil工具类，以简化请求的创建和执行过程。 例如，一个简单的HttpClientUtil工具类可能包含如下方法： ```java public class HttpClientUtil { public static ...
httpclient发送post请求
01-02
在实际项目中，为了提高代码的可复用性和可维护性，通常会将这些步骤封装到一个工具类中，例如`HttpClientUtil`，提供静态方法供其他类调用，从而简化客户端代码。 总结，HTTPClient是Java进行HTTP通信的强大工具，...
httpclient get/post请求工具类（map参数封装）
06-17
httpclient get/post请求工具类（map参数封装）,方便调用
http请求工具类HttpClientUtil，get，post请求（csdn）————程序.pdf
12-01
HttpClientUtil 是一个用于发送 HTTP 请求的工具类，主要支持 GET 和 POST 方法。它使用了 Apache HttpClient 库，这是一个强大的 Java 客户端编程工具包，用于处理 HTTP 协议。以下是对类中关键方法和概念的详细...
2.4 Java自动化之HttpClient发送请求
Following my own heart
08-18 439
一、HttpClient 简介 HttpClient 是Apache Jakarta Common 下的子项目， 可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包， 并且它支持 HTTP 协议最新的版本和建议 学习官网文档：http://www.httpclient.cn/cainiao.pdf 二、 如何结合httpclient发送请求 第一步： 修改Maven项目下pom.xml <project xmlns="http://maven.a...
【Java】Java发送httpPost，httpGet，httpPut，httpDelete请求
最新发布
m0_64210833的博客
09-28 1730
Java发送httpPost，httpGet，httpDelete请求
httpclient工具类
微微一笑满城空
09-05 1097
import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.List; import java.util.Map;import org.apache.http.NameValuePair; import org.apache.http.client.entity.
你还不知道怎么用Java代码实现发送post请求、get请求吗？
各类程序设计成品、文档、学习资料
06-16 4191
平时在大家学习工作中，会遇到给你一个接口让你去获取对应数据，里面也包含了post请求和get请求。下面给大家提供对应的工具类。二、Java代码实现发送post请求。一、Java代码实现发送get请求。在使用过程中注意：各类参数设置正确。
http 接口测试 java_基于HttpClient在HTTP协议接口测试中的使用(详解)
weixin_33603405的博客
02-15 208
HTTP协议的接口测试中，使用到最多的就是GET请求与POST请求，其中POST请求有FORM参数提交请求与RAW请求，下面我将结合HttpClient来实现一下这三种形式：一、GET请求: GET请求时，参数一般是写在链接上的，代码如下：public void get(String url){CloseableHttpClient httpClient = null;HttpGet httpGe...
httpclient 释放连接的问题 Invalid use of SingleClientConnManager: connection still allocated
weixin_34407348的博客
03-22 144
Invalid use of SingleClientConnManager: connection still allocated httpPost.releaseConnection();  该代码只会复用连接，并不会关闭当前连接，其实下面的方法client.getConnectionManager().closeIdleConnections(0, TimeUnit.MICROSECO...
HttpClientUtil发送Post/Get请求，使用fastjson解析json结果集
imVainiycos的博客
06-25 4958
由于经常需要通过后台服务端发起接口请求，在联调过程中借助HttpClientUtil工具类进行发送两位常见的网络请求，并且对返回的json结果集进行解析。作此文以方便后续查阅和学习，留个档。 一、HttpClientUtil pom依赖 <dependency> <groupId>org.wso2.apache.httpcomponents</group...
关于httpclient连接关闭问题
weixin_33991418的博客
04-13 4709
为什么80%的码农都做不了架构师？>>> ...
HttpClient方式请求发送multipart-form-data混合数据（包括多个文件和json字符串等）
震旦小读者的博客
11-16 3041
前言： 之前用了spring框架的restTemplate实现multipart-form-data混合数据（包括多个文件和json字符串等）的上传，现在使用httpClient方式来实现。 环境： <dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <version>
http post请求 json 工具类
06-02
在Java中，我们可以使用第三方库如Apache的HttpClient、Google的GSON、Jackson等来发送JSON格式的HTTP POST请求。这些库都提供了方便的API和工具类来简化HTTP POST请求的发送过程。 以下是使用Apache HttpClient和GSON库发送JSON格式的HTTP POST请求的示例： ```java import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpPost; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import com.google.gson.Gson; public class HttpUtil { public static CloseableHttpResponse sendJsonPostRequest(String url, Object obj) throws Exception { HttpPost httpPost = new HttpPost(url); Gson gson = new Gson(); String json = gson.toJson(obj); StringEntity entity = new StringEntity(json, "UTF-8"); entity.setContentType("application/json"); httpPost.setEntity(entity); CloseableHttpClient httpClient = HttpClients.createDefault(); CloseableHttpResponse response = httpClient.execute(httpPost); return response; } } ``` 这个示例中，我们定义了一个名为HttpUtil的工具类，并提供了一个名为sendJsonPostRequest的静态方法来发送JSON格式的HTTP POST请求。该方法接受两个参数：请求URL和请求数据对象。该方法使用了GSON库将请求数据对象转换为JSON格式的字符串，并使用Apache HttpClient库发送HTTP POST请求。最后返回响应结果。 我们可以在应用程序中调用该工具类的方法来发送HTTP POST请求，例如： ```java User user = new User("John", 30, "New York"); CloseableHttpResponse response = HttpUtil.sendJsonPostRequest("http://www.example.com/submit", user); ``` 在这个示例中，我们创建了一个User对象，并将其作为请求数据对象传递给sendJsonPostRequest方法。该方法会将User对象转换为JSON格式的字符串，并发送HTTP POST请求到指定的URL。最后返回响应结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值