Springboot-发送HTTP请求两种方式

最新推荐文章于 2025-07-03 10:30:00 发布
原创 最新推荐文章于 2025-07-03 10:30:00 发布 · 8.2k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#http #restful #spring

  • Spring生态内RestTemplate方式来发HTTP请求 

                

        //url       
         String url ="xxx";
        //定义参数
        Map<String, Object> params = new HashMap<>();
        params.put("xx", xx);
        params.put("xx", xx);
        params.put("xx", xx);
        //定义headers
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(params, headers);

        long start=System.currentTimeMillis();
        logger.info("==sendHttpPost 开始调用远程方法==");
        //执行HTTP请求
        try {
        	ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
            JSONObject jsonObject = JSONObject.parseObject(response.getBody());
            //json对象转Map
            Map<String, Object> map = (Map<String, Object>) jsonObject;
            if (200 == ParamsUtils.getIntParam(map.get("code"), 0)) {
                return ResultUtil.successResult(map.get("data"));
            }

            return ResultUtil.errorResult(map.get("msg"));
        } catch (RestClientException e) {
            logger.error(e.getMessage());
            return ResultUtil.errorResult("接口服务器异常");
        }finally {
            long end=System.currentTimeMillis();
            logger.info("==sendHttpPost 调用远程方法结束==");
            logger.info("==sendHttpPost cost=="+(end-start));
        }

  • apache的HttpClient开发方式来发HTTP请求   
    • import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.FormBodyPart;
import org.apache.http.entity.mime.FormBodyPartBuilder;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;
import java.util.Map.Entry;

public class HttpClientUtils
{
	private static final Logger logger = LoggerFactory.getLogger(HttpClientUtils.class);
	// 编码格式。发送编码格式统一用UTF-8
	private static final String ENCODING = "UTF-8";
	
	// 设置连接超时时间，单位毫秒。
	private static final int CONNECT_TIMEOUT = 60000;
	
	// 请求获取数据的超时时间(即响应时间)，单位毫秒。
	private static final int SOCKET_TIMEOUT = 60000;
	
	/**
	 * 发送get请求；不带请求头和请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doGet(String url) throws Exception
	{
		return doGet(url, null, null);
	}
	
	/**
	 * 发送get请求；带请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param params
	 *            请求参数集合
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doGet(String url, Map<String, String> params) throws Exception
	{
		return doGet(url, null, params);
	}
	
	/**
	 * 发送get请求；带请求头和请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param headers
	 *            请求头集合
	 * @param params
	 *            请求参数集合
	 * @return
	 * @throws Exception
	 */
	private static HttpClientResult doGet(String url, Map<String, String> headers,
			Map<String, String> params)
	{
		try(CloseableHttpClient httpClient = HttpClients.createDefault();
			CloseableHttpResponse httpResponse = null;)
		{

		// 创建访问的地址
		URIBuilder uriBuilder = new URIBuilder(url);
		if (params != null)
		{
			Set<Entry<String, String>> entrySet = params.entrySet();
			for (Entry<String, String> entry : entrySet)
			{
				uriBuilder.setParameter(entry.getKey(), entry.getValue());
			}
		}
		
		// 创建http对象
		HttpGet httpGet = new HttpGet(uriBuilder.build());
		/**
		 * setConnectTimeout：设置连接超时时间，单位毫秒。
		 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
		 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
		 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
		 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
		 */
		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
				.setSocketTimeout(SOCKET_TIMEOUT).build();
		httpGet.setConfig(requestConfig);
		
		// 设置请求头
		packageHeader(headers, httpGet);

		// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpGet);
		}catch (Exception e){
			logger.warn(e.getMessage());
		}
		return new  HttpClientResult();
	}

    public static HttpClientResult doGet(CloseableHttpClient httpClient, String url, Map<String, String> headers,
                                         Map<String, String> params) throws Exception
    {
        // 创建访问的地址
        URIBuilder uriBuilder = new URIBuilder(url);
        if (params != null)
        {
            Set<Entry<String, String>> entrySet = params.entrySet();
            for (Entry<String, String> entry : entrySet)
            {
                uriBuilder.setParameter(entry.getKey(), entry.getValue());
            }
        }

        // 创建http对象
        HttpGet httpGet = new HttpGet(uriBuilder.build());
        /**
         * setConnectTimeout：设置连接超时时间，单位毫秒。
         * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
         * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
         * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
         * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
         */
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
                .setSocketTimeout(SOCKET_TIMEOUT).build();
        httpGet.setConfig(requestConfig);

        // 设置请求头
        packageHeader(headers, httpGet);

        // 创建httpResponse对象
        CloseableHttpResponse httpResponse = null;

        try
        {
            // 执行请求并获得响应结果
            return getHttpClientResult(httpResponse, httpClient, httpGet);
        }
        finally
        {
            // 释放资源
            release(httpResponse, httpClient);
        }
    }
	
	/**
	 * 发送post请求；不带请求头和请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doPost(String url) throws Exception
	{
		return doPost(url, null, new HashMap<String, String>());
	}
	
	/**
	 * 发送post请求；带请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param params
	 *            参数集合
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doPost(String url, Map<String, String> params) throws Exception
	{
		return doPost(url, null, params);
	}

    /*入参说明
     *
     * param url 请求地址
     * param map 请求的Map<String, Object>数据
     *
     * */
    public static String sendPost(String url, Map<String, Object> map) {
        CloseableHttpClient httpClient = null;
        HttpPost httpPost = null;
        String result = null;
        try {
            httpClient = HttpClients.createDefault();
            httpPost = new HttpPost(url);//设置参数
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            Iterator iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, String> elem = (Map.Entry<String, String>) iterator.next();
                list.add(new BasicNameValuePair(elem.getKey(), String.valueOf(elem.getValue())));
            }
            if (list.size() > 0) {
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list,"UTF-8");
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            if (response != null) {
                HttpEntity resEntity = response.getEntity();
                if (resEntity != null) {
                    result = EntityUtils.toString(resEntity, "UTF-8");
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return result;
    }
	
	public static HttpClientResult doPost(CloseableHttpClient httpClient, String url, Map<String, String> params) throws Exception
	{
		return doPost(httpClient, url, null, params);
	}
	
	/**
	 * 发送post请求；带请求头和请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param headers
	 *            请求头集合
	 * @param params
	 *            请求参数集合
	 * @return
	 * @throws Exception
	 */
	private static HttpClientResult doPost(String url, Map<String, String> headers,
			Map<String, String> params)
	{
		try(CloseableHttpClient httpClient = HttpClients.createDefault();
			CloseableHttpResponse httpResponse = null;){
			// 创建httpClient对象


			// 创建http对象
			HttpPost httpPost = new HttpPost(url);
			/**
			 * setConnectTimeout：设置连接超时时间，单位毫秒。
			 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
			 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
			 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
			 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
			 */
			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
					.setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPost.setConfig(requestConfig);
			// 设置请求头
			/*
			 * httpPost.setHeader("Cookie", ""); httpPost.setHeader("Connection",
			 * "keep-alive"); httpPost.setHeader("Accept", "application/json");
			 * httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
			 * httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
			 * httpPost.setHeader("User-Agent",
			 * "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
			 * );
			 */
			packageHeader(headers, httpPost);
			// 封装请求参数
			packageParam(params, httpPost);

			// 创建httpResponse对象


				// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);

		}catch (Exception e){
			logger.warn(e.getMessage());
		}
		return new HttpClientResult();
	}
	
	public static HttpClientResult doPost(CloseableHttpClient httpClient, String url, Map<String, String> headers,
			Map<String, String> params) throws Exception
	{
		// 创建http对象
		HttpPost httpPost = new HttpPost(url);
		/**
		 * setConnectTimeout：设置连接超时时间，单位毫秒。
		 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
		 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
		 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
		 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
		 */
		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
				.setSocketTimeout(SOCKET_TIMEOUT).build();
		httpPost.setConfig(requestConfig);
		// 设置请求头
		/*
		 * httpPost.setHeader("Cookie", ""); httpPost.setHeader("Connection",
		 * "keep-alive"); httpPost.setHeader("Accept", "application/json");
		 * httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
		 * httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
		 * httpPost.setHeader("User-Agent",
		 * "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
		 * );
		 */
		packageHeader(headers, httpPost);
		// 封装请求参数
		packageParam(params, httpPost);
		
		// 创建httpResponse对象
		CloseableHttpResponse httpResponse = null;
		
		try
		{
			// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);
		}
		finally
		{
			// 释放资源
			release(httpResponse, httpClient);
		}
	}
	
	public static HttpClientResult doPost(CloseableHttpClient httpClient, String url,
			Map<String, String> headers, String jsonString) throws Exception
	{
		// 创建http对象
		HttpPost httpPost = new HttpPost(url);
		/**
		 * setConnectTimeout：设置连接超时时间，单位毫秒。
		 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
		 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
		 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
		 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
		 */
		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
				.setSocketTimeout(SOCKET_TIMEOUT).build();
		httpPost.setConfig(requestConfig);
		// 设置请求头
		/*
		 * httpPost.setHeader("Cookie", ""); httpPost.setHeader("Connection",
		 * "keep-alive"); httpPost.setHeader("Accept", "application/json");
		 * httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
		 * httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
		 * httpPost.setHeader("User-Agent",
		 * "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
		 * );
		 */
		packageHeader(headers, httpPost);
		httpPost.setHeader("Content-Type", "application/json");
		// 封装请求参数
		httpPost.setEntity(new StringEntity(jsonString, ENCODING));
		
		// 创建httpResponse对象
		CloseableHttpResponse httpResponse = null;
		
		try
		{
			// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);
		}
		finally
		{
			// 释放资源
			release(httpResponse, httpClient);
		}
	}
	
	public static HttpClientResult doPost(String url, Map<String, String> headers,
			String jsonString)
	{
		try(CloseableHttpClient httpClient = HttpClients.createDefault();
			CloseableHttpResponse httpResponse = null;){
			// 创建http对象
			HttpPost httpPost = new HttpPost(url);
			/**
			 * setConnectTimeout：设置连接超时时间，单位毫秒。
			 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
			 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
			 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
			 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
			 */
			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
					.setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPost.setConfig(requestConfig);
			// 设置请求头
			/*
			 * httpPost.setHeader("Cookie", ""); httpPost.setHeader("Connection",
			 * "keep-alive"); httpPost.setHeader("Accept", "application/json");
			 * httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
			 * httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
			 * httpPost.setHeader("User-Agent",
			 * "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
			 * );
			 */
			packageHeader(headers, httpPost);
			httpPost.setHeader("Content-Type", "application/json");
			// 封装请求参数
			httpPost.setEntity(new StringEntity(jsonString, ENCODING));
			// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);

		}catch (SocketTimeoutException es) {
			logger.warn("服务器响应超时 es={}",es.getMessage());
		}catch (ConnectTimeoutException ex) {
			logger.warn("服务器请求超时 ex={}",ex.getMessage());
		}catch (Exception e){
			logger.warn(e.getMessage());
		}
		return new HttpClientResult();
	}


	public static HttpClientResult doPost(String url, HttpEntity entity) {
		return  doPost(url, null, entity);
	}

	public static HttpClientResult doPost(String url, Map<String, String> headers, HttpEntity entity) {
		try(CloseableHttpClient httpClient = HttpClients.createDefault();
			CloseableHttpResponse httpResponse = null){
			// 创建http对象
			HttpPost httpPost = new HttpPost(url);
			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
					.setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPost.setConfig(requestConfig);
			// 设置请求头
			httpPost.setHeader("Cookie", "");
			httpPost.setHeader("Connection", "keep-alive");
			httpPost.setHeader("Accept", "*/*");
			httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
			httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
			httpPost.setHeader("User-Agent",
			  "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
			 );
			packageHeader(headers, httpPost);
			// 封装请求参数
			httpPost.setEntity(entity);
			// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);
		}catch (Exception e){
			logger.error(e.getMessage());
		}
		return new HttpClientResult();
	}

	/**
	 * 发送post请求；带请求头和请求参数(参数为File)
	 *
	 * @param url 请求地址
	 * @param headers 请求头集合
	 * @param fileUrl 请求参数文件
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doPostFile(String url, Map<String, String> headers, String fileUrl, String jsonStr, Integer jsonLen) {
		try (CloseableHttpClient httpClient = HttpClients.createDefault();
			 CloseableHttpResponse httpResponse = null;) {
			// 创建http对象
			HttpPost httpPost = new HttpPost(url);
			/**
			 * setConnectTimeout：设置连接超时时间，单位毫秒。
			 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
			 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
			 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
			 */
			RequestConfig requestConfig =
					RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPost.setConfig(requestConfig);
			// 设置请求头
			/*httpPost.setHeader("Cookie", "");
			httpPost.setHeader("Connection", "keep-alive");
			httpPost.setHeader("Accept", "application/json");
			httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
			httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
			httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325
			.181 Safari/537.36");
			*/
			packageHeader(headers, httpPost);

			// 封装请求参数
			packageParamForFile(fileUrl, httpPost, jsonStr, jsonLen);

			try {
				// 执行请求并获得响应结果
				return getHttpClientResult(httpResponse, httpClient, httpPost);
			} finally {
				// 释放资源
				release(httpResponse, httpClient);
			}
		} catch (Exception e) {
			logger.error(e.getMessage());
		}
		return new HttpClientResult();
	}

	/**
	 * Description: 封装请求参数(参数为File)
	 *
	 * @param
	 * @param httpMethod
	 * @throws UnsupportedEncodingException
	 */
	public static void packageParamForFile(String fileUrl, HttpEntityEnclosingRequestBase httpMethod,String jsonStr,Integer jsonLen){
		try {
			FileBody bin = new FileBody(new File(fileUrl));
			StringBody comment = new StringBody("This is comment", ContentType.TEXT_PLAIN);
			// 封装请求参数
			MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create()
					.setCharset(Charset.forName("UTF-8"))
					.setMode(HttpMultipartMode.BROWSER_COMPATIBLE)
					.addPart("file", bin)
					.addPart("comment", comment);
			if (StringUtils.isNotEmpty(jsonStr)) {
				FormBodyPart formBodyPart = FormBodyPartBuilder.create().setName("blh").setBody(new StringBody(jsonStr,
						ContentType.DEFAULT_TEXT)).build();
				multipartEntityBuilder.addPart(formBodyPart);
            }
			if (null !=jsonLen) {
				FormBodyPart formBodyPart2 = FormBodyPartBuilder.create().setName("index").setBody(new StringBody(String.valueOf(jsonLen),
						ContentType.DEFAULT_TEXT)).build();
				multipartEntityBuilder.addPart(formBodyPart2);
			}
			// 设置到请求的http对象中
			httpMethod.setEntity(multipartEntityBuilder.build());
		} catch (Exception e) {
			logger.error("packageParamForFile={}",e.getMessage());
		}
	}
	
	public static HttpClientResult doPost(String url, Map<String, String> headers,
			String jsonString, Map<String, String> params)
	{
		try(CloseableHttpClient httpClient = HttpClients.createDefault();
			CloseableHttpResponse httpResponse = null;){
			// 创建httpClient对象

			// 创建访问的地址
			URIBuilder uriBuilder = new URIBuilder(url);
			if (params != null)
			{
				Set<Entry<String, String>> entrySet = params.entrySet();
				for (Entry<String, String> entry : entrySet)
				{
					uriBuilder.setParameter(entry.getKey(), entry.getValue());
				}
			}

			// 创建http对象
			HttpPost httpPost = new HttpPost(uriBuilder.build());
			/**
			 * setConnectTimeout：设置连接超时时间，单位毫秒。
			 * setConnectionRequestTimeout：设置从connect Manager(连接池)获取Connection
			 * 超时时间，单位毫秒。这个属性是新加的属性，因为目前版本是可以共享连接池的。
			 * setSocketTimeout：请求获取数据的超时时间(即响应时间)，单位毫秒。
			 * 如果访问一个接口，多少时间内无法返回数据，就直接放弃此次调用。
			 */
			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
					.setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPost.setConfig(requestConfig);
			// 设置请求头
			/*
			 * httpPost.setHeader("Cookie", ""); httpPost.setHeader("Connection",
			 * "keep-alive"); httpPost.setHeader("Accept", "application/json");
			 * httpPost.setHeader("Accept-Language", "zh-CN,zh;q=0.9");
			 * httpPost.setHeader("Accept-Encoding", "gzip, deflate, br");
			 * httpPost.setHeader("User-Agent",
			 * "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36"
			 * );
			 */
			packageHeader(headers, httpPost);
			httpPost.setHeader("Content-Type", "application/json");
			// 封装请求参数
			httpPost.setEntity(new StringEntity(jsonString, ENCODING));

			// 创建httpResponse对象



			// 执行请求并获得响应结果
			return getHttpClientResult(httpResponse, httpClient, httpPost);
		}catch (Exception e){
			logger.warn(e.getMessage());
		}
		return new HttpClientResult();
	}
	
	/**
	 * 发送put请求；不带请求参数
	 * 
	 * @param url
	 *            请求地址
	 *
	 * @return 请求结果
	 */
	public static HttpClientResult doPut(String url) {
		return doPut(url);
	}
	
	/**
	 * 发送put请求；带请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param params
	 *            参数集合
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doPut(String url, Map<String, String> params) throws Exception
	{
		try (CloseableHttpClient httpClient = HttpClients.createDefault();
			 CloseableHttpResponse httpResponse = null;){

			HttpPut httpPut = new HttpPut(url);
			RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
					.setSocketTimeout(SOCKET_TIMEOUT).build();
			httpPut.setConfig(requestConfig);

			packageParam(params, httpPut);




			return getHttpClientResult(httpResponse, httpClient, httpPut);

		}catch (Exception e){
			logger.warn(e.getMessage());
		}

		return new HttpClientResult();
	}
	
	/**
	 * 发送delete请求；不带请求参数
	 * 
	 * @param url
	 *            请求地址
	 *            参数集合
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doDelete(String url) throws Exception
	{
		CloseableHttpClient httpClient = HttpClients.createDefault();
		HttpDelete httpDelete = new HttpDelete(url);
		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT)
				.setSocketTimeout(SOCKET_TIMEOUT).build();
		httpDelete.setConfig(requestConfig);
		
		CloseableHttpResponse httpResponse = null;
		try
		{
			return getHttpClientResult(httpResponse, httpClient, httpDelete);
		}
		finally
		{
			release(httpResponse, httpClient);
		}
	}
	
	/**
	 * 发送delete请求；带请求参数
	 * 
	 * @param url
	 *            请求地址
	 * @param params
	 *            参数集合
	 * @return
	 * @throws Exception
	 */
	public static HttpClientResult doDelete(String url, Map<String, String> params) throws Exception
	{
		if (params == null)
		{
			params = new HashMap<String, String>();
		}
		
		params.put("_method", "delete");
		return doPost(url, params);
	}
	
	/**
	 * Description: 封装请求头
	 * 
	 * @param params
	 * @param httpMethod
	 */
	public static void packageHeader(Map<String, String> params, HttpRequestBase httpMethod)
	{
		// 封装请求头
		if (params != null)
		{
			Set<Entry<String, String>> entrySet = params.entrySet();
			for (Entry<String, String> entry : entrySet)
			{
				// 设置到请求头到HttpRequestBase对象中
				httpMethod.setHeader(entry.getKey(), entry.getValue());
			}
		}
	}
	
	/**
	 * Description: 封装请求参数
	 * 
	 * @param params
	 * @param httpMethod
	 * @throws UnsupportedEncodingException
	 */
	public static void packageParam(Map<String, String> params,
			HttpEntityEnclosingRequestBase httpMethod) throws UnsupportedEncodingException
	{
		// 封装请求参数
		if (params != null)
		{
			List<NameValuePair> nvps = new ArrayList<NameValuePair>();
			Set<Entry<String, String>> entrySet = params.entrySet();
			for (Entry<String, String> entry : entrySet)
			{
				nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}
			
			// 设置到请求的http对象中
			httpMethod.setEntity(new UrlEncodedFormEntity(nvps, ENCODING));
		}
	}
	
	/**
	 * Description: 获得响应结果
	 * 
	 * @param httpResponse
	 * @param httpClient
	 * @param httpMethod
	 * @return
	 * @throws Exception
	 */
	private static HttpClientResult getHttpClientResult(CloseableHttpResponse httpResponse,
			CloseableHttpClient httpClient, HttpRequestBase httpMethod) throws Exception
	{

		if (httpResponse == null){
			httpResponse = httpClient.execute(httpMethod);
		}


		// 获取返回结果
		if (httpResponse != null && httpResponse.getStatusLine() != null)
		{
			String content = "";
			if (httpResponse.getEntity() != null)
			{
				content = EntityUtils.toString(httpResponse.getEntity(), ENCODING);
			}
			Header[] headers = httpResponse.getAllHeaders();
			Map<String, String> headerMap = new HashMap<>();
			for (Header header : headers)
			{
				headerMap.put(header.getName(), header.getValue());
			}
			return new HttpClientResult(httpResponse.getStatusLine()
					.getStatusCode(), content, headerMap);
		}
		return new HttpClientResult(HttpStatus.SC_INTERNAL_SERVER_ERROR);
	}
	
	/**
	 * Description: 释放资源
	 * 
	 * @param httpResponse
	 * @param httpClient
	 * @throws IOException
	 */
	public static void release(CloseableHttpResponse httpResponse, CloseableHttpClient httpClient)
			throws IOException
	{
		// 释放资源
		if (httpResponse != null)
		{
			httpResponse.close();
		}
		if (httpClient != null)
		{
			httpClient.close();
		}
	}
	
	public static CloseableHttpClient getIgnoeSSLClient() throws Exception
	{
		SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy()
		{
			@Override
			public boolean isTrusted(X509Certificate[] x509Certificates, String s)
					throws CertificateException
			{
				return true;
			}
			
		}).build();
		
		// 创建httpClient
		CloseableHttpClient client = HttpClients.custom().setSSLContext(sslContext)
				.setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
		return client;
	}

}

Springboot -- 用更优雅的方式发HTTP请求(RestTemplate详解) - 简书 (jianshu.com)https://www.jianshu.com/p/27a82c494413

Springboot -- 用更优雅的方式发HTTP请求(RestTemplate详解)_来日可期的博客-CSDN博客https://blog.csdn.net/lairikeqi/article/details/106606144?spm=1001.2101.3001.6650.1&utm_medium=distribute.pc_relevant.none-task-blog-2~default~OPENSEARCH~default-1.no_search_link&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2~default~OPENSEARCH~default-1.no_search_link

Springboot-发送短信有哪些方法？
兴趣是最好的老师
08-24 497
首先，你需要在你的 Spring Boot 项目中添加 Axis2 的依赖。使用 SOAP 协议的 WebService 接口发送短信可以通过 Axis2 来实现。通过上述改进，我们增强了 SmsService 类的异常处理逻辑，提高了程序的健壮性和可用性。服务 URL: 请替换 SERVICE_URL 为你的 SOAP 服务的实际 URL。主要分为两类：使用第三方短信服务提供商的 API 和直接使用运营商提供的网关。直接使用运营商网关: 可能需要更多的集成工作，但可以更好地控制发送过程。
springboot RestTemple 发送post请求
07-31 1431
springboot RestTemple 发送post请求，postForObject，postForEntity header设置，发送map数据，json数据，实体对象
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
ACGkaka的博客
07-04 4175
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
SpringBoot使用RestTemplate发送http请求（实操版）
weixin_47316183的博客
08-03 1万+
RestTmplate是Spring框架提供的 ，可用于在应用中调用 rest 服务，它简化了与 http 服务的通信方式，统一了RESTful的标准，封装了 http 链接， 我们只需要传入url及返回值类型即可。相较于之前常用的 HttpClient，RestTemplate 是一种更优雅的调用 RESTful 服务的方式。怎么样，是不是特别的方便和简单~
Spring Boot 3 - 用 @HttpExchange 注解完成第三方接口调用
weixin_46619605的博客
07-03 1132
Spring Boot 3 - 用 @HttpExchange 注解完成第三方接口调用
SpringBoot发送http请求
LifeBackwards的专栏
05-26 2540
此外，需要定义一个RestTemplate配置类。HttpUtils工具类如下。
Springboot整合RestTemplate发送http请求
程序员一博
10-17 8140
目录 一 概述 二 RestTemplate 1、简述RestTemplate 2、使用 3、自定义设置 手动指定转换器(HttpMessageConverter) 设置底层连接方式 设置拦截器(ClientHttpRequestInterceptor) 一 概述 通过向指定的第三方地址发送对应格式的数据以便换取所需数据这一需求是平时开发经常碰到的需求。可以同通过apache的HttpClient开发，但是代码复杂，还得操心资源回收等，冗余代码多。spring提供了一种简...
springboot发送HTTP请求
热门推荐
JFENG14的博客
03-17 1万+
1、添加依赖 使用RestTemplate进行发送请求，添加相关依赖 <!--发送请求的依赖--> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.5&
springboot-httpinvoker-demo.zip
05-25
HTTP Invoker是Spring框架提供的一个基于HTTP协议的远程调用机制，它通过序列化对象并将其作为HTTP请求的body发送到远程服务器，然后由服务器反序列化并执行相应的方法。这种方式相比于传统的RMI或者Hessian，更加...
springboot-springboot + vue 物流系统
12-06
后端代码则负责处理前端发送的请求，与数据库进行数据交互，并将处理结果返回给前端。这两部分代码的协同工作是整个系统运行的核心。 值得注意的是，项目的标签中提到了“毕业设计”和“课程作业”，这表明本项目...
Spring Boot发送http请求
a983677218的博客
08-27 676
有些网站会做反爬机制，所以在创建URL的时候，加上这句 connection.setRequestProperty("User-Agent","Mozilla/4.0 compatible;因为项目要调用第三方网站接口获取信息（类似python爬虫），所以在后端项目中需要前端axios一样去构建请求获取信息。下面用简单的获取IP地址为例。
spring boot中使用http请求的示例代码
08-28
本篇文章主要介绍了spring boot中 使用http请求的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot发送http请求
wzluestc的博客
12-01 3527
Springboot发送http请求(使用RestTemplate) 零、关键类介绍 public class HttpEntity<T> { public static final HttpEntity<?> EMPTY = new HttpEntity(); private final HttpHeaders headers; @Nullable private final T body; protected HttpEntity() {
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
ACGkaka的博客
09-22 3469
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
Springboot -- 用更优雅的方式发HTTP请求(RestTemplate详解)
BASK2312的博客
12-27 7901
是Spring提供的用于访问Rest服务的客户端，提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。我之前的HTTP开发是用apache的HttpClient开发，代码复杂，还得操心资源回收等。代码很复杂，冗余代码多，稍微截个图，这是我封装好的一个post请求工具：本教程将带领大家实现Spring生态内RestTemplate的Get请求和Post请求还有的实践和核心方法源码的分析，看完你就会用优雅的方式来发HTTP请求。
Spring Boot之发送HTTP请求（RestTemplate详解）
诚的博客
11-19 2785
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法 1.简述RestTemplate RestTemplate能大幅简化了提交表单数据的难度，并且附带了自动转换JSON数据的功能 HTTP方式 RestTemplate方法 GET getForObject() getForEntity() POST postForLocation() postFor
SpringBoot发送HTTP请求
Kiyonobu的博客
06-23 1145
使用的HTTP是Spring自带的工具RestTemplate org.springframework.web.client.RestTemplate 启动类添加Bean @Bean public RestTemplate getrestTemplate() { return new RestTemplate(); } Service层自动注入 @Autowired RestTemplate restTemplate; 发送GET请求 注意：发送GET请求时，请求地址需要使用{}占位符，不然另一个项
SpringBoot使用RestTemplate实现发送HTTP请求
pan_junbiao的博客
10-19 1670
RestTemplate 是 Spring 框架提供的一个用于访问 RESTful 服务的客户端工具，它简化了与 RESTful 服务的交互，并提供了一系列方便的方法来发送 HTTP 请求、处理响应以及处理错误。RestTemplate 提供了一组简单易用的方法，使得发送HTTP请求变得非常简单和直观。RestTemplate 可以自动将请求和响应的 JSON/XML 数据转换为 Java 对象，简化了数据的处理过程。
Springboot使用Feign客户端发送HTTP请求，代替​RestTemplate​远程调用
Xmi2599的博客
06-12 3702
在 Spring Boot 中，可以使用 Feign 来创建 HTTP 客户端，通过简单的注解方式即可实现服务间的远程调用。Feign是一种声明式、模板化的HTTP客户端，在往常的 HTTP 调用中，一直都是使用的官方提供的来进行远程调用，该调用方式将组装代码冗余到正常业务代码中，不够优雅，因此，可以考虑用Feign来替代。
springboot框架发送post请求
最新发布
07-22
<think>首先，用户的问题是关于在Spring Boot框架中发送POST请求的方法。系统级指令要求我使用中文回答，并遵循特定的格式：行内数学表达式用$...$，独立公式用$$...$$，语法正确，生成相关问题，并在引用末尾添加引用标识。 用户的问题："我想在Spring Boot框架中发送POST请求的方法 请问how to send a POST request using Spring Boot framework"。这是一个中文问题，所以我需要用中文回答。 关键点： - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠。 - 生成相关问题。 - 引用站内内容时添加引用标识，如[^1]。系统提供了示例引用：[^1]: Spring Boot offers a fast way to build applications. ... 但系统说这个仅供参考，我应该基于用户的问题和我的回答来引用。 用户的问题是关于发送POST请求的，所以我需要解释如何在Spring Boot中实现这个。Spring Boot 通常使用Spring MVC或WebFlux来处理HTTP请求。 步骤： 1. **理解问题**：用户想发送一个POST请求，这意味着创建一个客户端或服务端处理POST请求。用户说"发送POST请求"，可能指的是作为客户端发送请求，或者设置服务端处理POST请求。在上下文中，可能是设置服务端处理POST请求，因为Spring Boot常用于构建后端服务。 - 在Spring Boot中，发送POST请求通常涉及： - 作为服务端：定义一个控制器处理POST请求。 - 作为客户端：使用RestTemplate或WebClient发送POST请求到外部服务。 用户的问题："send a POST request"，可能指的是客户端发送请求。但在Spring Boot框架中，常见的是服务端处理。我需要澄清或覆盖两种情况。 回顾用户输入："我想在Spring Boot框架中发送POST请求的方法"，结合英文部分"how to send a POST request"，可能指的是客户端发送POST请求。 在Spring Boot中，发送HTTP请求（作为客户端）可以使用RestTemplate或WebClient。 2. **结构化回答**： - 介绍方法。 - 逐步解释。 - 提供代码示例。 - 确保真实可靠：基于Spring Boot文档和最佳实践。 3. **代码示例**：使用Java代码，因为Spring Boot是Java框架。 - 对于客户端：使用RestTemplate或WebClient。 - 对于服务端：定义@RestController和@RequestMapping。 用户指定了"发送POST请求"，所以我将专注于客户端发送。 4. **引用**：系统要求添加引用标识。示例引用是关于Spring Boot的，我可以引用它，但系统说仅供参考。我应该基于内容添加引用。例如，如果提到Spring Boot特性，引用[^1]。 示例引用：[^1]: Spring Boot offers a fast way... 这描述了Spring Boot的优点，我可以融入回答中。 5. **生成相关问题**：在回答后，添加"相关问题"部分。 6. **格式**： - 行内数学表达式：如果有数学内容，用$...$，但这里可能不涉及数学，所以可能不需要。 - 独立公式：如果有，用$$...$$，但这里不适用。 - 中文回答。 回答大纲： - 介绍：Spring Boot 简化了HTTP请求处理，使用RestTemplate或WebClient发送POST请求。 - 步骤： 1. 添加依赖。 2. 创建RestTemplate bean或使用WebClient。 3. 发送POST请求。 - 代码示例。 - 解释。 - 相关问题。 代码示例使用RestTemplate，因为它是传统的，WebClient是响应式的。 添加引用：在提到Spring Boot特性时，添加[^1]。 最终回答结构： - 解释方法。 - 代码块（使用```java）。 - 相关问题。 生成相关问题： 1. 如何配置RestTemplate的超时设置？ 2. 在Spring Boot中使用WebClient有什么优势？ 3. 如何处理POST请求的响应？</think>### 在Spring Boot框架中发送POST请求的方法 在Spring Boot框架中，发送HTTP POST请求通常涉及作为客户端向外部服务发送数据。Spring Boot提供了多种工具来简化HTTP客户端操作，其中最常见的是使用`RestTemplate`（传统同步方式）或`WebClient`（响应式异步方式）。下面我将一步步解释如何实现，并提供代码示例。整个过程基于Spring Boot的自动配置特性，它能减少样板代码，让开发者更专注于业务逻辑[^1]。 #### 步骤1: 添加Spring Boot依赖 首先，确保你的项目包含Spring Web依赖。如果你使用Maven，在`pom.xml`中添加以下依赖： ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> ``` 这引入了`RestTemplate`和基本的HTTP支持。对于响应式编程（如使用`WebClient`），还需添加`spring-boot-starter-webflux`依赖。 #### 步骤2: 创建RestTemplate Bean 在Spring Boot应用中，通过配置类定义`RestTemplate` Bean。这样Spring会自动管理其生命周期和依赖注入。 ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @Configuration public class AppConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } } ``` #### 步骤3: 发送POST请求 使用`RestTemplate`的`postForObject`或`postForEntity`方法发送POST请求。以下是一个完整示例： - 定义一个简单的数据对象（如DTO）。 - 在服务类中注入`RestTemplate`并发送请求。 ```java // 定义DTO类（示例数据） public class User { private String name; private String email; // 构造方法、getter和setter省略（实际中需添加） public User(String name, String email) { this.name = name; this.email = email; } } // 服务类发送POST请求 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import org.springframework.web.client.RestTemplate; @Service public class ApiService { private final RestTemplate restTemplate; @Autowired public ApiService(RestTemplate restTemplate) { this.restTemplate = restTemplate; } public String sendPostRequest() { String url = "https://jsonplaceholder.typicode.com/users"; // 示例API端点 User user = new User("John Doe", "[email protected]"); // 请求体数据 // 发送POST请求，并获取响应 ResponseEntity<String> response = restTemplate.postForEntity(url, user, String.class); // 处理响应 if (response.getStatusCode().is2xxSuccessful()) { return "请求成功! 响应体: " + response.getBody(); } else { return "请求失败! 状态码: " + response.getStatusCode(); } } } ``` #### 关键点解释 - **URL**：指定目标API的地址（示例中使用了公开测试API）。 - **请求体**：`postForEntity`方法的第二个参数是请求体对象（如`User`实例），Spring会自动将其序列化为JSON（默认使用Jackson库）。 - **响应处理**：`postForEntity`返回`ResponseEntity`，包含状态码、响应头等。你可以使用`getBody()`获取响应内容。 - **异常处理**：建议添加`try-catch`块处理`RestClientException`（如网络错误）。 - **WebClient替代方案**：对于异步场景，使用`WebClient`（需`spring-boot-starter-webflux`依赖）。示例： ```java import org.springframework.web.reactive.function.client.WebClient; public String sendPostWithWebClient() { return WebClient.create() .post() .uri("https://jsonplaceholder.typicode.com/users") .bodyValue(new User("Jane Doe", "[email protected]")) .retrieve() .bodyToMono(String.class) .block(); // 阻塞获取结果（实际中可异步处理） } ``` `WebClient`更高效，支持非阻塞IO[^1]。 #### 注意事项 - **安全性**：生产环境中，使用HTTPS并配置连接池或超时设置。 - **测试**：通过MockRestServiceServer单元测试你的客户端代码。 - 通过Spring Boot的自动配置，这些步骤大大简化，开发者无需手动管理HTTP连接细节[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值