Springboot-发送HTTP请求两种方式

最新推荐文章于 2024-08-27 11:40:42 发布
最新推荐文章于 2024-08-27 11:40:42 发布
阅读量8k 收藏 13
点赞数 5
分类专栏： 项目案例 文章标签： http restful spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jlonghou/article/details/121010194
版权
  • 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 241
首先，你需要在你的 Spring Boot 项目中添加 Axis2 的依赖。使用 SOAP 协议的 WebService 接口发送短信可以通过 Axis2 来实现。通过上述改进，我们增强了 SmsService 类的异常处理逻辑，提高了程序的健壮性和可用性。服务 URL: 请替换 SERVICE_URL 为你的 SOAP 服务的实际 URL。主要分为两类：使用第三方短信服务提供商的 API 和直接使用运营商提供的网关。直接使用运营商网关: 可能需要更多的集成工作，但可以更好地控制发送过程。
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
最新发布
ACGkaka的博客
09-22 1700
SpringBoot实战（三十）发送HTTP/HTTPS请求的五种实现方式【下篇】（Okhttp3、RestTemplate、Hutool）
Spring Boot发送http请求
a983677218的博客
08-27 529
有些网站会做反爬机制，所以在创建URL的时候，加上这句 connection.setRequestProperty("User-Agent","Mozilla/4.0 compatible;因为项目要调用第三方网站接口获取信息（类似python爬虫），所以在后端项目中需要前端axios一样去构建请求获取信息。下面用简单的获取IP地址为例。
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
ACGkaka的博客
07-04 1659
SpringBoot实战（二十九）发送HTTP/HTTPS请求的五种实现方式【上篇】（HttpURLConnection、HttpClient）
SpringBoot使用RestTemplate发送http请求（实操版）
weixin_47316183的博客
08-03 1万+
RestTmplate是Spring框架提供的 ，可用于在应用中调用 rest 服务，它简化了与 http 服务的通信方式，统一了RESTful的标准，封装了 http 链接， 我们只需要传入url及返回值类型即可。相较于之前常用的 HttpClient，RestTemplate 是一种更优雅的调用 RESTful 服务的方式。怎么样，是不是特别的方便和简单~
SpringBoot发送http请求
LifeBackwards的专栏
05-26 2342
此外，需要定义一个RestTemplate配置类。HttpUtils工具类如下。
Springboot整合RestTemplate发送http请求
程序三两行
10-17 7826
目录 一 概述 二 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 - 网络请求模版类RestTemplate使用详解
鱼的博客
08-16 1883
SpringBoot - 网络请求模版类RestTemplate使用详解 一、基本介绍 1，什么是 RestTemplate? （1）RestTemplate 是 Spring 提供的用于访问 Rest 服务的客户端，RestTemplate 提供了多种可以便捷访问远程 Http 服务的方法，能够大大提高客户端的编写效率。 RestTemplate 是 Spring 3 中引入的同步阻塞式 HTTP 客户端。根据 Spring 官方文档介绍，在将来的版本中它可能会被弃用，因为他们已在 Spring 5 中引
spring boot中使用http请求的示例代码
08-28
本篇文章主要介绍了spring boot中 使用http请求的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot-fastdfs.zip
08-29
SpringBoot则是一个简化Spring应用开发的框架，它提供了快速构建、配置和运行应用程序的方式。 【描述】描述中提到，此项目实现了前端使用Vue.js和Element-UI来创建上传页面的功能。Vue.js是目前非常流行的前端...
Springboot发送http请求
wzluestc的博客
12-01 3436
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请求(RestTemplate详解)
BASK2312的博客
12-27 7561
是Spring提供的用于访问Rest服务的客户端，提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。我之前的HTTP开发是用apache的HttpClient开发，代码复杂，还得操心资源回收等。代码很复杂，冗余代码多，稍微截个图，这是我封装好的一个post请求工具：本教程将带领大家实现Spring生态内RestTemplate的Get请求和Post请求还有的实践和核心方法源码的分析，看完你就会用优雅的方式来发HTTP请求。
SpringBoot发送HTTP请求
Kiyonobu的博客
06-23 1084
使用的HTTP是Spring自带的工具RestTemplate org.springframework.web.client.RestTemplate 启动类添加Bean @Bean public RestTemplate getrestTemplate() { return new RestTemplate(); } Service层自动注入 @Autowired RestTemplate restTemplate; 发送GET请求 注意：发送GET请求时，请求地址需要使用{}占位符，不然另一个项
Springboot使用Feign客户端发送HTTP请求，代替​RestTemplate​远程调用
Xmi2599的博客
06-12 3125
在 Spring Boot 中，可以使用 Feign 来创建 HTTP 客户端，通过简单的注解方式即可实现服务间的远程调用。Feign是一种声明式、模板化的HTTP客户端，在往常的 HTTP 调用中，一直都是使用的官方提供的来进行远程调用，该调用方式将组装代码冗余到正常业务代码中，不够优雅，因此，可以考虑用Feign来替代。
Spring Boot快速入门（二）：http请求
LieRabbit的博客
01-14 781
一、准备   postman：一个接口测试工具 创建一个新工程 选择web 不会的请看Spring Boot快速入门（一）：Hello Spring Boot   二、开始   新建java类RequestCtrl 1.添加一个all方法，使用@RequestMapping注解，可以处理所有的http请求       @RestController//这是一个控制...
vue+mapboxgl 运行轨迹循环
xm_w_xm的博客
12-11 1865
最终的样子 + mapboxgl 官网的例子 ：https://docs.mapbox.com/mapbox-gl-js/example/animate-a-line/ turf.js 官网：http://turfjs.org/ requestAnimationFrame 详解 我觉得写的很好：https://www.jianshu.com/p/fa5512dfb4f5 一、实现思路 1、绘制线 2、绘制一个点，将线的第一个点赋值给点 3、将geometry中线的每个节点值 ...
springboot发送http请求的api
07-14
在Spring Boot中，可以使用`RestTemplate`和`WebClient`来发送HTTP请求。这两种方式在Spring Boot中的用法与在Spring中基本相同。 1. `RestTemplate`：可以通过在应用程序中注入`RestTemplate`来使用它。Spring Boot会自动配置`RestTemplate`的实例，可以直接使用。以下是一个示例： ```java @RestController public class MyController { private final RestTemplate restTemplate; public MyController(RestTemplate restTemplate) { this.restTemplate = restTemplate; } @GetMapping("/example") public String example() { String url = "http://example.com/api/resource"; ResponseEntity<String> response = restTemplate.getForEntity(url, String.class); String responseBody = response.getBody(); return responseBody; } } ``` 2. `WebClient`：可以通过在应用程序中注入`WebClient.Builder`来创建`WebClient`实例，并使用它发送HTTP请求。以下是一个示例： ```java @RestController public class MyController { private final WebClient.Builder webClientBuilder; public MyController(WebClient.Builder webClientBuilder) { this.webClientBuilder = webClientBuilder; } @GetMapping("/example") public Mono<String> example() { String url = "http://example.com/api/resource"; return webClientBuilder.build().get() .uri(url) .retrieve() .bodyToMono(String.class); } } ``` 需要注意的是，Spring Boot会自动配置`RestTemplate`和`WebClient`的实例，因此无需任何额外的配置。在使用`RestTemplate`时，可以直接注入它，并使用它的方法发送HTTP请求。在使用`WebClient`时，需要通过`WebClient.Builder`创建`WebClient`实例，并使用链式调用的方式来构建和发送请求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值