精华内容
下载资源
问答
  • SpringBoot发送Http请求-RestTemplate

    万次阅读 多人点赞 2020-05-14 12:05:41
    SpringBoot发送Http请求 [提前声明] 文章由作者:张耀峰 结合自己生产中的使用经验整理,最终形成简单易懂的文章 写作不易,转载请注明,谢谢! 大数据代码案例地址: https://github.com/Mydreamandreality/sparkResearch...

    SpringBoot发送Http请求

    [提前声明]
    文章由作者:张耀峰 结合自己生产中的使用经验整理,最终形成简单易懂的文章
    写作不易,转载请注明,谢谢!
    大数据代码案例地址: https://github.com/Mydreamandreality/sparkResearch


    前言

    之前我写过一篇关于SpringBoot发送Http请求的文章、当时使用的是Apache,Http.client
    文章地址:图解springboot后端发送HttpGet和HttpPost请求
    但是使用这个工具发送请求很繁琐、代码看起来也很复杂、而且大部分都是冗余的代码、而Spring给我们提供了一个发送Http请求的工具、所以我觉得有必要安利一下

    RestTemplate

    首先看下spring官方对RestTemplate的解释

    在这里插入图片描述

    RestTemplate是Spring用于同步client端的核心类,简化了与http服务的通信,并满足RestFul原则,程序代码可以给它提供URL,并提取结果。默认情况下,RestTemplate默认依赖jdk的HTTP连接工具。当然你也可以 通过setRequestFactory属性切换到不同的HTTP源,比如Apache HttpComponents、Netty和OkHttp

    如何使用

    经过简单了解后、我们不多bb、直接上代码、通过代码来说话

    • 1、pom配置

    先声明下我的SpringBoot版本:<version>2.1.13.RELEASE</version>
    org.springframework.web中已经默认集成了RestTemplate

    引用apache的httclient (不是用RestTemplate吗?为什么又引用了apache的client、别急 稍后解释

            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>4.5.6</version>
            </dependency>
    
    • 2、RestTemplate配置

    在Spring的官方文档中可以了解到、RestTemplate 采用同步方式执行 HTTP 请求的类,底层使用 JDK 原生 HttpURLConnection API ,或者 HttpComponents等其他 HTTP 客户端请求类库。还有一处强调的就是 RestTemplate 提供模板化的方法让开发者能更简单地发送 HTTP 请求

    既然如此、那么我们底层依然使用apache的client给我们提供的http请求服务能力、上层的应用开发使用RestTemplate的模板

    ClientHttpRequestFactory 接口有4个实现类,分别是:

    • AbstractClientHttpRequestFactoryWrapper 用来装配其他request factory的抽象类。
    • CommonsClientHttpRequestFactory 允许用户配置带有认证和http连接池的httpclient,已废弃,推荐用HttpComponentsClientHttpRequestFactory。
    • HttpComponentsClientHttpRequestFactory 同2.
    • SimpleClientHttpRequestFactory 接口的一个简单实现,可配置proxy,connectTimeout,readTimeout等参数。

    我们使用的是HttpComponentsClientHttpRequestFactory来配置

    • 配置application.yml

    首先我们自定义一些配置参数、后面会用到

    http_pool:
      max_total: 200
      default_max_per_route: 100
      connect_timeout: 5000
      connection_request_timeout: 1000
      socket_timeout: 65000
      validate_after_inactivity: 2000
    
    • 新建ApplicationValues.java

    这个是读取配置中的参数方法

    import lombok.Getter;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    /**
     * @author 孤
     * @version v1.0
     * @Developers 张耀烽
     * @serviceProvider 四叶草安全(SeClover)
     * @description 获取Application配置数据
     * @date
     */
    @Getter
    @Component
    public class ApplicationValues {
    
        @Value("${http_pool.max_total}")
        private int maxTotal;
    
        @Value("${http_pool.default_max_per_route}")
        private int maxPerRoute;
    
        @Value("${http_pool.connect_timeout}")
        private int connTimeOut;
    
        @Value("${http_pool.connection_request_timeout}")
        private int connReqTimeOut;
    
        @Value("${http_pool.socket_timeout}")
        private int socketTimeout;
    
        @Value("${http_pool.validate_after_inactivity}")
        private int inactivity;
    }
    
    • 新建RestTemplateConfig.java

    这个是配置我们的底层http客户端(这里我们使用apache的client

    如何配置:

    Spring提供了HttpComponentsClientHttpRequestFactory可以通过该方法来配置我们的http客户端

    import com.clover.api.consts.ApplicationValues;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.config.Registry;
    import org.apache.http.config.RegistryBuilder;
    import org.apache.http.conn.socket.ConnectionSocketFactory;
    import org.apache.http.conn.socket.PlainConnectionSocketFactory;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.ClientHttpRequestFactory;
    import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    /**
     * @author 孤
     * @version v1.0
     * @Developers 张耀烽
     * @serviceProvider 四叶草安全(SeClover)
     * @description http工厂配置
     * @date
     */
    @Configuration
    public class RestTemplateConfig {
    
        @Autowired
        private ApplicationValues appValues;
    
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate(httpRequestFactory());
        }
    
        @Bean
        public ClientHttpRequestFactory httpRequestFactory() {
            return new HttpComponentsClientHttpRequestFactory(httpClient());
        }
    
        @Bean
        public HttpClient httpClient() {
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", SSLConnectionSocketFactory.getSocketFactory())
                    .build();
            PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
            connectionManager.setMaxTotal(appValues.getMaxTotal());
            connectionManager.setDefaultMaxPerRoute(appValues.getMaxPerRoute());
            connectionManager.setValidateAfterInactivity(appValues.getInactivity());
            RequestConfig requestConfig = RequestConfig.custom()
                    //服务器返回数据(response)的时间,超过抛出read timeout
                    .setSocketTimeout(appValues.getSocketTimeout())
                    //连接上服务器(握手成功)的时间,超出抛出connect timeout
                    .setConnectTimeout(appValues.getConnTimeOut())
                    //从连接池中获取连接的超时时间,超时间未拿到可用连接,会抛出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool
                    .setConnectionRequestTimeout(appValues.getConnReqTimeOut())
                    .build();
            return HttpClientBuilder.create()
                    .setDefaultRequestConfig(requestConfig)
                    .setConnectionManager(connectionManager)
                    .build();
        }
    }
    
    • 发送请求

    RestTemplate对于不同的请求方式提供了不同的函数、我把官方的图贴一下、下面我会把常用的跟大家说一下

    在这里插入图片描述

    发送Post请求、请求参数为json

    一般的post请求都是从body中传递json参数、比如是这样的

    {
        "name":"张耀烽",
        "sex":"男"
    }
    
    • 首先我们构造我们的json请求参数
    • 其次发送请求

    请求发送成功后、会返回 ResponseEntity对象、spring把response的所有结果集都封装在了这个对象中、我们可以按需使用、此处我只获取了请求成功后返回的body

        /**
         * 生成post请求的JSON请求参数
         * 请求示例:
         * {
         * "id":1,
         * "name":"张耀烽"
         * }
         *
         * @return
         */
        public HttpEntity<Map<String, String>> generatePostJson(Map<String, String> jsonMap) {
    
            //如果需要其它的请求头信息、都可以在这里追加
            HttpHeaders httpHeaders = new HttpHeaders();
    
            MediaType type = MediaType.parseMediaType("application/json;charset=UTF-8");
    
            httpHeaders.setContentType(type);
    
            HttpEntity<Map<String, String>> httpEntity = new HttpEntity<>(jsonMap, httpHeaders);
    
            return httpEntity;
        }
        
        
          /**
         * post请求、请求参数为json
         *
         * @return
         */
        public String sendPost() {
            String uri = "http://127.0.0.1:80";
    
            Map<String, String> jsonMap = new HashMap<>(6);
            jsonMap.put("name", "张耀烽");
            jsonMap.put("sex", "男");
    
            ResponseEntity<String> apiResponse = restTemplate.postForEntity
                    (
                            uri,
                            generatePostJson(jsonMap),
                            String.class
                    );
            return apiResponse.getBody();
        }
    

    发送get请求、请求参数为uri参数

    get的请求我们一般都是通过uri的方式来进行传参,比如:

    http://127.0.0.1:80/?name=张耀烽&sex=男

    • 首先构造我们的get请求参数
    • 发送get请求、获取结果
     /**
         * 生成get参数请求url
         * 示例:https://0.0.0.0:80/api?u=u&o=o
         * 示例:https://0.0.0.0:80/api
         *
         * @param protocol 请求协议 示例: http 或者 https
         * @param uri      请求的uri 示例: 0.0.0.0:80
         * @param params   请求参数
         * @return
         */
        public String generateRequestParameters(String protocol, String uri, Map<String, String> params) {
            StringBuilder sb = new StringBuilder(protocol).append("://").append(uri);
            if (ToolUtil.isNotEmpty(params)) {
                sb.append("?");
                for (Map.Entry map : params.entrySet()) {
                    sb.append(map.getKey())
                            .append("=")
                            .append(map.getValue())
                            .append("&");
                }
                uri = sb.substring(0, sb.length() - 1);
                return uri;
            }
            return sb.toString();
        }
    
        /**
         * get请求、请求参数为?拼接形式的
         * <p>
         * 最终请求的URI如下:
         * <p>
         * http://127.0.0.1:80/?name=张耀烽&sex=男
         *
         * @return
         */
        public String sendGet() {
            Map<String, String> uriMap = new HashMap<>(6);
            uriMap.put("name", "张耀烽");
            uriMap.put("sex", "男");
    
            ResponseEntity responseEntity = restTemplate.getForEntity
                    (
                            generateRequestParameters("http", "127.0.0.1:80", uriMap),
                            String.class
                    );
            return (String) responseEntity.getBody();
        }
    

    总结

    到此我们两种常用的请求就已经掌握了、其它的方法你们需要用的时候去看就可以了、都是一些重载的方法、大同小异。

    完整代码:

    import com.clover.api.utils.tools.ToolUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpEntity;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.MediaType;
    import org.springframework.http.ResponseEntity;
    import org.springframework.stereotype.Component;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author 孤
     * @version v1.0
     * @Developers 张耀烽
     * @serviceProvider 四叶草安全(SeClover)
     * @description 请简易描述定义
     * @date 2020/5/14
     */
    @Component
    public class RestMock<k, v> {
    
        @Autowired
        private RestTemplate restTemplate;
    
        /**
         * 生成post请求的JSON请求参数
         * 请求示例:
         * {
         * "id":1,
         * "name":"张耀烽"
         * }
         *
         * @return
         */
        public HttpEntity<Map<String, String>> generatePostJson(Map<String, String> jsonMap) {
    
            //如果需要其它的请求头信息、都可以在这里追加
            HttpHeaders httpHeaders = new HttpHeaders();
    
            MediaType type = MediaType.parseMediaType("application/json;charset=UTF-8");
    
            httpHeaders.setContentType(type);
    
            HttpEntity<Map<String, String>> httpEntity = new HttpEntity<>(jsonMap, httpHeaders);
    
            return httpEntity;
        }
    
    
        /**
         * 生成get参数请求url
         * 示例:https://0.0.0.0:80/api?u=u&o=o
         * 示例:https://0.0.0.0:80/api
         *
         * @param protocol 请求协议 示例: http 或者 https
         * @param uri      请求的uri 示例: 0.0.0.0:80
         * @param params   请求参数
         * @return
         */
        public String generateRequestParameters(String protocol, String uri, Map<String, String> params) {
            StringBuilder sb = new StringBuilder(protocol).append("://").append(uri);
            if (ToolUtil.isNotEmpty(params)) {
                sb.append("?");
                for (Map.Entry map : params.entrySet()) {
                    sb.append(map.getKey())
                            .append("=")
                            .append(map.getValue())
                            .append("&");
                }
                uri = sb.substring(0, sb.length() - 1);
                return uri;
            }
            return sb.toString();
        }
    
        /**
         * get请求、请求参数为?拼接形式的
         * <p>
         * 最终请求的URI如下:
         * <p>
         * http://127.0.0.1:80/?name=张耀烽&sex=男
         *
         * @return
         */
        public String sendGet() {
            Map<String, String> uriMap = new HashMap<>(6);
            uriMap.put("name", "张耀烽");
            uriMap.put("sex", "男");
    
            ResponseEntity responseEntity = restTemplate.getForEntity
                    (
                            generateRequestParameters("http", "127.0.0.1:80", uriMap),
                            String.class
                    );
            return (String) responseEntity.getBody();
        }
    
        /**
         * post请求、请求参数为json
         *
         * @return
         */
        public String sendPost() {
            String uri = "http://127.0.0.1:80";
    
            Map<String, String> jsonMap = new HashMap<>(6);
            jsonMap.put("name", "张耀烽");
            jsonMap.put("sex", "男");
    
            ResponseEntity<String> apiResponse = restTemplate.postForEntity
                    (
                            uri,
                            generatePostJson(jsonMap),
                            String.class
                    );
            return apiResponse.getBody();
        }
    
    }
    
    

    更多完整代码可以去参考我的个人开源项目easy_boot、项目地址easy_boot开源项目

    展开全文
  • Java工具类--通过HttpClient发送http请求

    万次阅读 多人点赞 2015-11-27 15:17:34
    在写网络程序的时候,经常会有从网址获取数据的需求,上一篇解析JSON就需要从百度获取天气数据,本文介绍一种模拟发送http请求的工具–HttpClient。HttpClient的介绍 The most essential function of HttpClient is...

    在写网络程序的时候,经常会有从网址获取数据的需求,上一篇解析JSON就需要从百度获取天气数据,本文介绍一种Java发送http请求的工具–HttpClient。

    HttpClient的介绍

    The most essential function of HttpClient is to execute HTTP methods. Execution of an HTTP method involves one or several HTTP request / HTTP response exchanges, usually handled internally by HttpClient. The user is expected to provide a request object to execute and HttpClient is expected to transmit the request to the target server return a corresponding response object, or throw an exception if execution was unsuccessful.

    HttpClient最基本的功能就是执行http方法,执行http方法包括了一次或者几次HTTP请求和相应的变化,通常也是通过HttpClient来处理的。只要用户提供一个request的对象,HttpClient就会将用户的请求发送到目标服务器上,并且返回一个respone对象,如果没有执行成功将抛出一个异常。

    通过文档的介绍我们可以知道,发送HTTP请求一般可以分为以下步骤

    1. 取得HttpClient对象
    2. 封装http请求
    3. 执行http请求
    4. 处理结果

    其中可以发送的请求类型有GET, HEAD, POST, PUT, DELETE, TRACE 和 OPTIONS

    HttpClient supports out of the box all HTTP methods defined in the HTTP/1.1 specification: GET, HEAD, POST, PUT, DELETE, TRACE and OPTIONS.

    官方文档中的示例

    //1.获得一个httpclient对象
    CloseableHttpClient httpclient = HttpClients.createDefault();
    //2.生成一个get请求
    HttpGet httpget = new HttpGet("http://localhost/");
    //3.执行get请求并返回结果
    CloseableHttpResponse response = httpclient.execute(httpget);
    try {
        //4.处理结果
    } finally {
        response.close();
    }
    

    介绍一下最常用的HttpGet和HttpPost。
    RESTful提倡,通过HTTP请求对应的POST、GET、PUT、DELETE来完成对应的CRUD操作。
    所以本文介绍一下通过GET获取数据和POST提交数据的实现方法。

    ##发送HttpGet
    先介绍发送HttpGet请求

    	/**
    	 * 发送HttpGet请求
    	 * @param url
    	 * @return
    	 */
    	public static String sendGet(String url) {
    		//1.获得一个httpclient对象
    		CloseableHttpClient httpclient = HttpClients.createDefault();
    		//2.生成一个get请求
    		HttpGet httpget = new HttpGet(url);
    		CloseableHttpResponse response = null;
    		try {
    			//3.执行get请求并返回结果
    			response = httpclient.execute(httpget);
    		} catch (IOException e1) {
    			e1.printStackTrace();
    		}
    		String result = null;
    		try {
    			//4.处理结果,这里将结果返回为字符串
    			HttpEntity entity = response.getEntity();
    			if (entity != null) {
    				result = EntityUtils.toString(entity);
    			}
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				response.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return result;
    	}
    

    ##发送HttpPost
    发送HttpPost的方法和发送HttpGet很类似,只是将请求类型给位HttpPost即可。
    代码如下

    	/**
    	 * 发送不带参数的HttpPost请求
    	 * @param url
    	 * @return
    	 */
    	public static String sendPost(String url) {
    		//1.获得一个httpclient对象
    		CloseableHttpClient httpclient = HttpClients.createDefault();
    		//2.生成一个post请求
    		HttpPost httppost = new HttpPost(url);
    		CloseableHttpResponse response = null;
    		try {
    			//3.执行get请求并返回结果
    			response = httpclient.execute(httppost);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		//4.处理结果,这里将结果返回为字符串
    		HttpEntity entity = response.getEntity();
    		String result = null;
    		try {
    			result = EntityUtils.toString(entity);
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    

    带参数的HttpPost

    发送带参数的HttpPost

    Many applications need to simulate the process of submitting an HTML form, for instance, in order to log in to a web application or submit input data. HttpClient provides the entity class UrlEncodedFormEntity to facilitate the process.

    HttpClient通过UrlEncodedFormEntity,来提交带参数的请求

    将需要提交的参数放在map里
    代码如下

    	/**
    	 * 发送HttpPost请求,参数为map
    	 * @param url
    	 * @param map
    	 * @return
    	 */
    	public static String sendPost(String url, Map<String, String> map) {
    		CloseableHttpClient httpclient = HttpClients.createDefault();
    		List<NameValuePair> formparams = new ArrayList<NameValuePair>();
    		for (Map.Entry<String, String> entry : map.entrySet()) {
    			//给参数赋值
    			formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    		}
    		UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
    		HttpPost httppost = new HttpPost(url);
    		httppost.setEntity(entity);
    		CloseableHttpResponse response = null;
    		try {
    			response = httpclient.execute(httppost);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		HttpEntity entity1 = response.getEntity();
    		String result = null;
    		try {
    			result = EntityUtils.toString(entity1);
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    

    完整代码

    完成代码如下,用到的jar包有httpclient-4.5.1.jar,httpcore-4.4.3.jar,依赖的jar有commons-logging-1.2.jar
    注意是Apache HttpClient,不是commons-httpclient

    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import org.apache.http.Consts;
    import org.apache.http.HttpEntity;
    import org.apache.http.NameValuePair;
    import org.apache.http.ParseException;
    import org.apache.http.client.entity.UrlEncodedFormEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicNameValuePair;
    import org.apache.http.util.EntityUtils;
    /**
     * @author GWCheng
     *
     */
    public class HttpUtil {
    
    	private static final CloseableHttpClient httpclient = HttpClients.createDefault();
    
    	/**
    	 * 发送HttpGet请求
    	 * @param url
    	 * @return
    	 */
    	public static String sendGet(String url) {
    
    		HttpGet httpget = new HttpGet(url);
    		CloseableHttpResponse response = null;
    		try {
    			response = httpclient.execute(httpget);
    		} catch (IOException e1) {
    			e1.printStackTrace();
    		}
    		String result = null;
    		try {
    			HttpEntity entity = response.getEntity();
    			if (entity != null) {
    				result = EntityUtils.toString(entity);
    			}
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				response.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		return result;
    	}
    
    	/**
    	 * 发送HttpPost请求,参数为map
    	 * @param url
    	 * @param map
    	 * @return
    	 */
    	public static String sendPost(String url, Map<String, String> map) {
    		List<NameValuePair> formparams = new ArrayList<NameValuePair>();
    		for (Map.Entry<String, String> entry : map.entrySet()) {
    			formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    		}
    		UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, Consts.UTF_8);
    		HttpPost httppost = new HttpPost(url);
    		httppost.setEntity(entity);
    		CloseableHttpResponse response = null;
    		try {
    			response = httpclient.execute(httppost);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		HttpEntity entity1 = response.getEntity();
    		String result = null;
    		try {
    			result = EntityUtils.toString(entity1);
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    
    	/**
    	 * 发送不带参数的HttpPost请求
    	 * @param url
    	 * @return
    	 */
    	public static String sendPost(String url) {
    		HttpPost httppost = new HttpPost(url);
    		CloseableHttpResponse response = null;
    		try {
    			response = httpclient.execute(httppost);
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		HttpEntity entity = response.getEntity();
    		String result = null;
    		try {
    			result = EntityUtils.toString(entity);
    		} catch (ParseException | IOException e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    
    }
    

    测试用例

    服务器端代码

    @Controller
    @RequestMapping("/test")
    // /test/**
    public class TestController {
    	// /test/view post 提交数据,模拟表单
    	@RequestMapping(value = "/view", method = RequestMethod.POST)
    	public void viewTest(PrintWriter out, HttpServletResponse response, @RequestParam("param1") String param1,
    			@RequestParam("param2") String param2) {
    		response.setContentType("application/json;charset=UTF-8");
    		Gson gson = new GsonBuilder().create();
    		Map<String, Object> map = new HashMap<String, Object>();
    		map.put("param1", param1);
    		map.put("param2", param2);
    		System.out.println(gson.toJson(map));
    		out.print(gson.toJson(map));
    	}
    	
    	// /test/view?param1=aaa&param2=bbb get 
    		@RequestMapping(value = "/view", method = RequestMethod.GET)
    		public void viewTest3(PrintWriter out, HttpServletResponse response, @RequestParam("param1") String param1,
    				@RequestParam("param2") String param2) {
    			response.setContentType("application/json;charset=UTF-8");
    			Gson gson = new GsonBuilder().create();
    			Map<String, Object> map = new HashMap<String, Object>();
    			map.put("param1", param1);
    			map.put("param2", param2);
    			System.out.println(gson.toJson(map));
    			out.print(gson.toJson(map));
    		}
    
    	// /test/view2/{courseId}
    	@RequestMapping(value = "/view2/{param}", method = RequestMethod.GET)
    	public void viewTest1(PrintWriter out, HttpServletResponse response, @PathVariable("param") String param) {
    		response.setContentType("application/json;charset=UTF-8");
    		Gson gson = new GsonBuilder().create();
    		Map<String, Object> map = new HashMap<String, Object>();
    		map.put("param", param);
    		out.print(gson.toJson(map));
    	}
    
    	// /test/view3
    	@RequestMapping(value = "/view3", method = RequestMethod.POST)
    	public void viewTest2(PrintWriter out, HttpServletResponse response) {
    		response.setContentType("application/json;charset=UTF-8");
    		Gson gson = new GsonBuilder().create();
    		Map<String, Object> map = new HashMap<String, Object>();
    		map.put("status", "success");
    		out.print(gson.toJson(map));
    	}
    
    }
    

    测试代码

    public class HttpClientTest {
    
    	@Test
    	public void testGet() {
    		//百度天气的api
    		//String url1 = "http://api.map.baidu.com/telematics/v3/weather?location=%E5%8C%97%E4%BA%AC&output=json&ak=W69oaDTCfuGwzNwmtVvgWfGH";
    		String url1 = "http://localhost:8080/wechat/test/view2/你好世界";
    		String result1 = HttpUtil.sendGet(url1);
    		System.out.println(result1);
    		//输出{"param":"你好世界"}
    	}
    	@Test
    	public void testPost() throws UnsupportedEncodingException{
    		String url = "http://localhost:8080/wechat/test/view";
    		Map<String,String> map = new HashMap<String,String>();
    		map.put("param1", "你好世界");
    		map.put("param2", "哈哈");
    		String result = HttpUtil.sendPost(url, map);
    		System.out.println(result);
    		//输出结果{"param1":"你好世界","param2":"哈哈"}
    
    	}
    	
    	@Test
    	public void testPost1() throws UnsupportedEncodingException{
    		String url = "http://localhost:8080/wechat/test/view3";
    		String result = HttpUtil.sendPost(url);
    		System.out.println(result);
    		//输出结果{"status":"success"}
    
    	}
    
    }
    

    建议通过HttpGet获取信息,HttpPost提交信息,而HttpGet获取信息时需要提交的参数一般会在url中体现,或者以?传参,或者在url中传参,所以就没写HttpGet带参数的。也希望大家能遵循Http的设计原则,通过HttpGet, HttpPost, HttpPut, HttpDelete,来实现获取数据,提交数据,修改数据,和删除数据的方法。

    2018年10月25修改

    依赖

            <!--apache工具类-->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.1</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-collections4</artifactId>
                <version>4.1</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.2</version>
                <scope>provided</scope>
            </dependency>
            <!--httpclient-->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>4.5.6</version>
            </dependency>
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpmime</artifactId>
                <version>4.5.6</version>
            </dependency>
            <!--log-->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.10</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>1.1.2</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.1.2</version>
            </dependency>
            <!--MultipartFile-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>2.0.6.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.0.6.RELEASE</version>
            </dependency>
    

    最近优化了一下这个方法,具体程序如下

    package com.cgw.util;
    
    import com.alibaba.fastjson.JSONObject;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections4.CollectionUtils;
    import org.apache.commons.collections4.MapUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.http.Consts;
    import org.apache.http.Header;
    import org.apache.http.HttpEntity;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.config.ConnectionConfig;
    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.MultipartEntityBuilder;
    import org.apache.http.entity.mime.content.StringBody;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.message.BasicHeader;
    import org.apache.http.util.EntityUtils;
    import org.springframework.mock.web.MockMultipartFile;
    import org.springframework.web.multipart.MultipartFile;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.nio.charset.Charset;
    import java.nio.charset.CodingErrorAction;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.nio.file.Paths;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Http工具类
     *
     * @author 程高伟
     */
    @Slf4j
    public class HttpUtil {
    
        private static final String USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36";
    
        // 超时设置
        private static final RequestConfig requestConfig = RequestConfig.custom()
                .setConnectTimeout(5000)
                .setConnectionRequestTimeout(5000)
                .setSocketTimeout(10000)
                .build();
    
        // 编码设置
        private static final ConnectionConfig connectionConfig = ConnectionConfig.custom()
                .setMalformedInputAction(CodingErrorAction.IGNORE)
                .setUnmappableInputAction(CodingErrorAction.IGNORE)
                .setCharset(Consts.UTF_8)
                .build();
    
        private static HttpClientBuilder getBuilder() {
            List<Header> headers = new ArrayList<>();
            Header header = new BasicHeader("User-Agent", USER_AGENT);
            headers.add(header);
            return HttpClients.custom().setDefaultConnectionConfig(connectionConfig).setDefaultHeaders(headers).setDefaultRequestConfig(requestConfig);
        }
    
        /**
         * 发送HttpGet请求
         *
         * @param url 请求地址
         * @return
         */
        public static String sendGet(String url) throws IOException {
            String result;
            HttpGet httpGet = new HttpGet(url);
            try (CloseableHttpClient httpclient = getBuilder().build();
                 CloseableHttpResponse response = httpclient.execute(httpGet)) {
                HttpEntity httpEntity = response.getEntity();
                result = EntityUtils.toString(httpEntity);
            }
            return result;
        }
    
        /**
         * 发送HttpPost请求,参数为json字符串
         *
         * @param url     请求地址
         * @param jsonStr json字符串
         * @return
         */
        public static String sendPost(String url, String jsonStr) throws IOException {
            String result;
    
            // 设置entity
            StringEntity stringEntity = new StringEntity(jsonStr, Consts.UTF_8);
            stringEntity.setContentType("application/json");
    
            HttpPost httpPost = new HttpPost(url);
            httpPost.setEntity(stringEntity);
    
            try (CloseableHttpClient httpclient = getBuilder().build(); CloseableHttpResponse httpResponse = httpclient.execute(httpPost);) {
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity);
            }
            return result;
        }
    
        /**
         * 发送HttpPost请求,提交表单,支持文件上传
         *
         * @param url    请求地址
         * @param params 表单参数
         * @param files  上传文件
         * @return
         */
        public static String sendPost(String url, Map<String, Object> params, List<MultipartFile> files) throws IOException {
            String result;
            // 设置entity
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setCharset(Charset.forName("UTF-8"));
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
            if (CollectionUtils.isNotEmpty(files)) { // 文件表单参数
                for (MultipartFile file : files) {
                    Path path = Paths.get(file.getOriginalFilename());
                    String contentType = Files.probeContentType(path);
                    if (StringUtils.isEmpty(contentType)) {
                        contentType = "application/octet-stream";
                    }
                    builder.addBinaryBody(file.getName(), file.getInputStream(), ContentType.create(contentType), file.getOriginalFilename());
                }
            }
            if (MapUtils.isNotEmpty(params)) { // 普通表单参数
                params.forEach((k, v) -> {
                    StringBody stringBody = new StringBody(v.toString(), ContentType.create("text/plain", "UTF-8"));
                    builder.addPart(k, stringBody);
                });
            }
    
            HttpPost httpPost = new HttpPost(url);
            httpPost.setEntity(builder.build());
    
            try (CloseableHttpClient httpclient = getBuilder().build();
                 CloseableHttpResponse httpResponse = httpclient.execute(httpPost)) {
                HttpEntity httpEntity = httpResponse.getEntity();
                result = EntityUtils.toString(httpEntity);
            }
            return result;
        }
    
        // MultipartFile里面的name就是表单的name,文件名是originalFilename
        private static MultipartFile fileToMultipartFile(File file, String name) throws IOException {
            log.info("File转MultipartFile:文件路径:{}", file.getAbsolutePath());
            FileInputStream inputStream = new FileInputStream(file);
            Path path = Paths.get(file.getAbsolutePath());
            String contentType = Files.probeContentType(path);
            if (StringUtils.isEmpty(contentType)) {
                contentType = "application/octet-stream";
            }
            MultipartFile multipartFile = new MockMultipartFile(
                    name,
                    file.getName(),
                    contentType,
                    inputStream);
            log.info("File转MultipartFile:转换后的文件信息:[name:{}, originalFilename:{} ,contentType:{}]",
                    multipartFile.getName(),
                    multipartFile.getOriginalFilename(),
                    multipartFile.getContentType());
            return multipartFile;
        }
    
        public static void main(String[] args) throws IOException {
            String url = "http://127.0.0.1:8080/file/uploadSingle";
            Map<String, Object> params = new HashMap<>();
            params.put("userId", 123);
            params.put("username", "张三");
            List<MultipartFile> files = new ArrayList<>();
            MultipartFile file = fileToMultipartFile(new File("d:\\file\\中文.jpg"), "file");
            files.add(file);
            System.out.println(sendPost(url, params, files));
        }
    
    }
    

    参考文献

    HttpClient Tutorial

    展开全文
  • lua 发送http请求

    万次阅读 2019-08-03 11:43:44
    lua发送http请求,luajit默认没有http.lua库,需要下载并存放到luajit对应目录。 一、下载http.lua和http_headers.lua库 参考:https://www.zixuephp.net/article-448.html bash location=/testscript{ ...

      lua发送http请求,luajit默认没有http.lua库,需要下载并存放到luajit对应目录。

    一、下载http.lua和http_headers.lua库

    参考:https://www.zixuephp.net/article-448.html

    bash

    1. location = /testscript{
    2.     default_type text/plain;
    3.     content_by_lua_file html/luafile/test.lua;
    4. }
    
     

    bash

    1. vim test.lua
    2. local zhttp = require "resty.http"

            1.运行后查看nginx错误日志,会提示没有http.lua文件:

     

            2.下载http.lua和http_headers.lua库

                下载页面:https://github.com/pintsized/lua-resty-http

                直接下载:http_headers.lua-http.lua.rar

                下载好后放入对应目录,这里的目录是:

    
     

    bash

    1. [root@zixuephp resty]# pwd
    2. /usr/local/LuaJIT/share/luajit-2.0.5/resty
    3. git clone https://github.com/pintsized/lua-resty-http.git

     

     

        重启nginx。

    二、lua发送http请求代码

        1.get请求

    
     

    bash

    1. local zhttp = require "resty.http"
    2. local function http_post_client(url, timeout)
    3.         local httpc = zhttp.new()
    4.  
    5.         timeout = timeout or 30000
    6.         httpc:set_timeout(timeout)
    7.  
    8.         local res, err_ = httpc:request_uri(url, {
    9.                 method = "GET",
    10.                 headers = {
    11.                     ["Content-Type"] = "application/x-www-form-urlencoded",
    12.                 }
    13.         })
    14.         httpc:set_keepalive(5000, 100)
    15.         --httpc:close()
    16.         return res, err_
    17. end

        2.post请求

    
     

    bash

    1. local zhttp = require "resty.http"
    2. local function http_post_client(url,body,timeout)
    3.         local httpc = zhttp.new()
    4.  
    5.         timeout = timeout or 30000
    6.         httpc:set_timeout(timeout)
    7.  
    8.         local res, err_ = httpc:request_uri(url, {
    9.                 method = "POST",
    10.                 body = body,
    11.                 headers = {
    12.                     ["Content-Type"] = "application/x-www-form-urlencoded",
    13.                 }
    14.         })
    15.         httpc:set_keepalive(5000, 100)
    16.          httpc:close()
    17.         if not res then 
    18.             return nil, err_ 
    19.          else if res.status == 200 then 
    20.              return res.body, err_ 
    21.          else 
    22.              return nil, err_ end 
    23.          end
    24.  
    25. end
    
     

    bash

    1. --get
    2. local resp, err = http_post_client("http://zixuephp.net/index.html?name=test",3000)
    3. --post
    4. local body = {"name" = "test"}
    5. local resp, err = http_post_client("http://zixuephp.net/index.html?name=test",body,3000)
    展开全文
  • 通过idea发送HTTP请求

    万次阅读 2020-07-28 15:07:09
    通过idea发送HTTP请求 我们测试自己写的接口时候经常会用到postman等工具构造请求,来检验接口是否正确,postman很方便,但是idea也自带了这种功能 打开后是这样子: 这里能看到返回结果: 也可以这种形式,点击...

    通过idea发送HTTP请求

    我们测试自己写的接口时候经常会用到postman等工具构造请求,来检验接口是否正确,postman很方便,但是idea也自带了这种功能
    

    在这里插入图片描述
    打开后是这样子:
    在这里插入图片描述

    这里能看到返回结果:在这里插入图片描述
    也可以这种形式,点击这里
    在这里插入图片描述
    成为这种形式:
    在这里插入图片描述
    通过这个我们能很方便的测试相关的接口,不需要再打开postman等测试工具。
    欢迎大家指出问题,共同进步。

    展开全文
  • Golang发送HTTP请求

    千次阅读 2020-07-01 20:37:45
    Golang发送HTTP请求 import ( "bytes" "encoding/json" "errors" "io" "io/ioutil" "net/http" "github.com/golang/glog" ) // AuthResp 授权码返回结构 type AuthResp struct { Token string `json:...
  • Android 发送http请求

    千次阅读 2019-04-15 10:42:35
    发送http请求是比较好耗时的操作,所以要把他们放在线程里面(我是这么理解的) 现在android版本越来越高,都在用HttpURLConnection这种方式发送链接(舍弃了原来的HtypClient) 发送请求大致分为如下几步 1.创建一...
  • RestTemplate发送HTTP请求

    万次阅读 2017-12-27 10:42:59
    Spring 中的 RestTemplate 可以很方便的发送HTTP请求,来看看如何使用 RestTemplate 发送 GET 请求RestAPI - 通过@RequestParam接收参数的GET接口@RequestMapping(value = "accounts/filter", method = Request...
  • go 发送http请求

    千次阅读 2019-04-23 21:56:22
    写了一下go发送http请求常用的几种方法 package main import ( "net/http" "io/ioutil" "fmt" "strings" "net/url" "bytes" "encoding/json" ) func main() { urls := "http://www.baidu.com/" var data ...
  • httpclient发送http请求

    千次阅读 2019-02-13 09:42:20
    Java发送Http请求 1、方法一,通过apache的httpclient import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.http.HttpEntity; import ...
  • C#发送http请求代码

    千次阅读 2019-07-31 10:49:41
    C#发送http请求代码 public string HttpGet(string Url, string postDataStr) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url + (postDataStr == "" ? "" : "?") + postDataStr);...
  • 微信小程序如何发送 http 请求

    千次阅读 2019-02-09 14:52:34
    为什么要使用云函数发送 http 请求 小程序 云函数 5 个可信域名 不受限制 需要备案 无需备案 在一些特殊情境, 比如域名没有备案或域名 5 个以上就需要使用云函数发送 HTTP 请求了. 如何使用云函数发送...
  • JAVA发送HTTP请求方式总结

    万次阅读 多人点赞 2018-05-30 14:40:21
    java 发送HTTP请求方式总结 源代码:http://github.com/lovewenyo/HttpDemo 1. HttpURLConnection 使用JDK原生提供的net,无需其他jar包; HttpURLConnection是URLConnection的子类,提供更多的方法,...
  • 说说在 Android 中如何发送 HTTP 请求

    万次阅读 2018-06-09 11:18:12
    客户端会向服务器发出一条 HTTP...可以使用 HttpURLConnection(官方推荐) 来发送 HTTP 请求。 布局文件: &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;LinearLayout x...
  • java发送http请求的两种方式:HTTPClient和CloseableHttpClient 下面分别介绍使用HTTPClient和CloseableHTTPClient进行Get和Post请求的方式。 HttpClient 使用commons-httpclient.jar,maven依赖如下: &lt;...
  • JAVA后台发送http请求

    千次阅读 2019-01-19 15:26:21
    JAVA后台发送http请求 代码: @RequestMapping("/check") @ResponseBody public Map check(Integer cashRecordId,Integer status,Integer clientId) { Map map = new HashMap&lt;&gt;(); ...
  • Java发送Http请求的一般步骤

    千次阅读 2019-04-29 14:51:41
    Java发送Http请求的一般步骤 最近在使用百度地图和百度AI的开发API,经常需要发送http请求,在这里记录一下java发送Http请求的步骤。希望对大家有用。 了解Http报文结构 首先介绍Http协议的结构。请求报文和响应...
  • Java 实现发送Http请求

    千次阅读 2016-08-12 15:59:23
    最近需要一个短信业务的接口,发送http请求来发送短信,因为网上给的代码混乱不统一,自己实现了一个,以便自己以后自己使用java发送http请求。import org.apache.commons.httpclient.Header; import org.apache....
  • IOS 发送HTTP请求报错

    千次阅读 2017-08-16 12:47:08
    iOS 发送HTTP请求报错: App Transport Security has blocked a cleartext HTTP (http://) resource load since it is insecure. Temporary exceptions can be configured via your app’s Info.plist file.
  • linux下使用shell发送http请求

    万次阅读 2017-11-23 10:29:42
    本文主要介绍如何在linux下使用shell发送http请求。一、curl1. get请求curl命令默认下就是使用get方式发送http请求。curl www.baidu.com2. post请求使用-d参数,形式如下:curl -d "param1=value1¶m2=value2" ...
  • Qt之HTTP——发送HTTP请求

    千次阅读 2018-08-20 20:35:00
    在使用Qt发送HTTP请求中一般使用的链接都是http://前缀,而有的服务器支持 https://前缀的链接,而Qt本身是支持https的,但是https访问需要用到SSL认证,而QT默认是不支持SSL认证,所以在Qt中使用https需要进行SSL...
  • Qt发送HTTP请求

    千次阅读 2013-07-23 14:26:25
    最近在搞QT跟服务器交互的东西,自然少不了发送和接受HTTP请求。 ... HTTP请求在QT中相应的类为QNetworkRequest,HTTP响应相应的类为QNetworkReply,下面是一个管理的发送HTTP请求并读取响应的例子: //Test
  • Java代码发送Http请求

    千次阅读 2017-10-17 23:40:21
    最近在项目中药使用Java代码来发送Http请求,在查找资料的过程中收货颇多,故记此文,以备后看。这里我将报文头,报文体等信息都存储在Map里面传到方法里面来。使用GET方式向URL发送请求 /** * 获取接口返回的结果...
  • linux 使用shell发送http请求

    千次阅读 2019-08-06 16:50:03
    curl命令默认下就是使用get方式发送http请求。 curl www.baidu.com 2. post请求 curl -X POST www.baidu.com 使用-d带参数请求参数,形式如下: curl -X POST <url> -d <data> //curl -X 请求...
  • 封装js发送http请求

    万次阅读 2017-04-15 15:46:39
    封装js发送http请求var http = function () { this.xhr = new XMLHttpRequest(); };http.prototype.setTimeout = function (timeout) { this.xhr.timeout = timeout; };http.prototype.request = function (url, ...
  • oracle发送http请求

    万次阅读 2016-08-04 09:06:22
    使用oracle发送http请求,实现的思路是:在某张表上配置触发器,该触发器调用存储过程,使用存储过程执行http请求的发送。 需要注意的几点是: 1、http post请求,在发送的时候,跟数据库的字符集有关,在处理不当的...
  • shell发送Http请求

    千次阅读 2014-07-02 10:17:43
    3. shell发送http请求    curl -d parm1=1¶m2=zzq¶m3=123 http://www.iteye.com
  • nodejs使用request发送http请求

    千次阅读 2019-04-26 16:53:55
    在nodejs的开发中,有时需要后台去调用其他服务器的接口,这个时候,就需要发送HTTP请求了。有一个简单的工具可以用,Simplified HTTP request client,可以比较方便的模拟请求。 安装 npm install --save request ...
  • Android中对服务器发送http请求

    千次阅读 2017-11-14 19:15:35
    当我们需要和服务器进行交互的时候,需要对远程服务器发送请求,接下来我会概述一下android中okhttp的用法public class HttpUtil {//发送Http请求类,每次发送Http请求调用该方法 /* * 通过okhttp3发送请求(用来...
  • 用perl发送http请求

    千次阅读 2017-02-21 17:07:10
    工作中经常用到脚本发送http请求,但是用脚本发送和用浏览器发送差别很到,当你用脚本调用一些接口时可能没有权限,此时需要获取到调用接口的权限,一般情况下就是。请求的时候需要带着一个cookie值或者一个token值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,372
精华内容 24,948
关键字:

发送http请求