精华内容
参与话题
问答
  • Json寻址工具类

    万次阅读 2020-04-15 17:05:52
    抽空写了个根据地址寻址json内容中的某个值的工具类。 说明: 1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样 private static final String JSON_ARRAY_FORMAT...

    在项目使用中,经常使用json的反序列化获取某个值,如果某个值的路径比较深,除了编写工作量变大和风险扩大外,还有就是代码不够整洁。抽空写了个根据地址寻址json内容中的某个值的工具类。

    说明:

    1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样

         private static final String JSON_ARRAY_FORMAT = "(.)*(\\[(\\d)+])$";
    
     /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return Object 如果获取不到 返回null
         */
        public static <T> T getObjectGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            try {
                return gson.fromJson(value4Path, tClass);
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
        }
    
        /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return List 如果获取不到 返回null
         */
        public static <T> List<T> getListGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            if (!value4Path.isJsonArray()) {
                throw new IllegalArgumentException("parse format not match");
            }
            JsonArray asJsonArray = value4Path.getAsJsonArray();
            ArrayList<T> objects = new ArrayList<>(asJsonArray.size());
            try {
                for (JsonElement jsonElement : asJsonArray) {
                    objects.add(gson.fromJson(value4Path, tClass));
                }
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
            return objects;
        }
    
    
        private static JsonElement getValue4Path(String content, String path) {
            LOGGER.info("content={},path={}", content, path);
            if (StringUtils.isBlank(path)) {
                LOGGER.warn("path is blank");
                return null;
            }
            if (!isJSONStr(content)) {
                LOGGER.warn("content format not json");
                return null;
            }
            JsonParser parser = new JsonParser();
            JsonElement parse = parser.parse(content);
            String[] split = path.split("\\.");
            StringBuilder stringBuilder = new StringBuilder();
            for (String s : split) {
                try {
                    parse = parseJson(parse, s, stringBuilder);
                } catch (Exception e) {
                    LOGGER.warn("can't find value ,this path is {}", path);
                    return null;
                }
            }
            return parse;
        }
    
        private static JsonElement parseJson(JsonElement jsonElement, String childPath, StringBuilder sb) {
            if (jsonElement.isJsonNull()) {
                return null;
            }
            if (StringUtils.isBlank(childPath)) {
                return jsonElement;
            }
            sb.append(".").append(childPath);
            Matcher matcher = Pattern.compile(JSON_ARRAY_FORMAT).matcher(childPath);
            if (matcher.find()) {
                String group = matcher.group(1);
                if (null == group) {
                    group = matcher.group(0);
                }
                String s = group.replaceAll("\\[", "\\\\[");
                String[] split1 = childPath.split(s);
                String key = null;
                if (null == split1 || split1.length == 0) {
                    key = "";
                } else {
                    key = split1[0];
                }
                String index = group.substring(1, group.length() - 1);
                if (StringUtils.isBlank(key)) {
                    if (!jsonElement.isJsonArray()) {
                        LOGGER.warn("can't find value by this childPath,path={}", sb.substring(1));
                        return null;
                    }
                    JsonArray asJsonArray = jsonElement.getAsJsonArray();
                    JsonElement res = asJsonArray.get(Integer.valueOf(index));
                    return res;
                } else {
                    JsonObject asJsonObject = jsonElement.getAsJsonObject();
                    JsonElement res = asJsonObject.get(key);
                    return res;
                }
            } else {
                JsonObject asJsonObject = jsonElement.getAsJsonObject();
                JsonElement res = asJsonObject.get(childPath);
                return res;
            }
    
        }
    
        public static void main(String[] args) {
            String str12 = "{\"additionJson\":{\"needPush\":true},\"id\":123456,\"date\":\"2013-4-13 12: 36: 54\"}";
            Boolean objectGson4Path12 = getObjectGson4Path(str12, "additionJson.needPush", Boolean.class);
            System.out.println(objectGson4Path12);
        }
    

     

    展开全文
  • /** * @description:驼峰与下划线之间互转工具类 * @author:boob * @since:2020/2/9 */ public class CamelCaseUtil { private static final char SEPARATOR = '_'; public CamelC...
    package com.bood.common.utils;
    
    /**
     * <p>
     * 驼峰与下划线之间互转工具类
     * </p>
     * 
     * @author:bood
     * @date:2020/10/16
     */
    public class CamelCaseUtil {
    
        private static final char SEPARATOR = '_';
    
        private CamelCaseUtil() {
        }
    
        /**
         * <p>
         * 转下划线
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toUnderlineName(String s) {
            if (s == null) {
                return null;
            }
    
            StringBuilder sb = new StringBuilder();
            boolean upperCase = false;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                boolean nextUpperCase = true;
    
                if (i < (s.length() - 1)) {
                    nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
                }
    
                if ((i >= 0) && Character.isUpperCase(c)) {
                    if (!upperCase || !nextUpperCase) {
                        if (i > 0) sb.append(SEPARATOR);
                    }
                    upperCase = true;
                } else {
                    upperCase = false;
                }
    
                sb.append(Character.toLowerCase(c));
            }
            return sb.toString();
        }
    
        /**
         * <p>
         * 转驼峰
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toCamelCase(String s) {
            if (s == null) {
                return null;
            }
            s = s.toLowerCase();
            StringBuilder sb = new StringBuilder(s.length());
            boolean upperCase = false;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c == SEPARATOR) {
                    upperCase = true;
                } else if (upperCase) {
                    sb.append(Character.toUpperCase(c));
                    upperCase = false;
                } else {
                    sb.append(c);
                }
            }
            return sb.toString();
        }
    
        /**
         * <p>
         * 转大写驼峰
         * </p>
         *
         * @param s: 
         * @return:java.lang.String
         * @author:bood
         * @date:2020/10/16
         */
        public static String toCapitalizeCamelCase(String s) {
            if (s == null) {
                return null;
            }
            s = toCamelCase(s);
            return s.substring(0, 1).toUpperCase() + s.substring(1);
        }
    
    }
    

    在这里插入图片描述
    混〔IT〕的小学生 热爱编程,喜欢挑战新事物!

    展开全文
  • 超级鹰打码平台工具类

    万次阅读 2020-07-27 16:49:27
    import datetime import json import os import re import scrapy from ..items import ZhoushanDeveloperItem from ..settings import LOG_DIR from ..util import utils ...class ZhoushanKuangjiaSpider(utils....
    """
    超级鹰打码平台工具类
    http://www.chaojiying.com/
    """
    from hashlib import md5
    
    import requests
    
    
    class Chaojiying(object):
    
        def __init__(self, username, password, soft_id):
            self.username = username
            self.password = md5(password.encode('utf-8')).hexdigest()
            self.soft_id = soft_id
            self.base_params = {
                'user': self.username,
                'pass2': self.password,
                'softid': self.soft_id,
            }
            self.headers = {
                'Connection': 'Keep-Alive',
                'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0)',
            }
    
        def post_pic(self, im, codetype):
            """
            im: 图片字节
            codetype: 题目类型 参考 http://www.chaojiying.com/price.html
            """
            params = {
                'codetype': codetype,
            }
            params.update(self.base_params)
            files = {'userfile': ('ccc.jpg', im)}
            r = requests.post('http://upload.chaojiying.net/Upload/Processing.php', data=params, files=files,
                              headers=self.headers)
            return r.json()
    
        def report_error(self, im_id):
            """
            im_id:报错题目的图片ID
            """
            params = {
                'id': im_id,
            }
            params.update(self.base_params)
            r = requests.post('http://upload.chaojiying.net/Upload/ReportError.php', data=params, headers=self.headers)
            return r.json()
    
    
    if __name__ == '__main__':
        CHAOJIYING_USERNAME = 'xxx'  # 超级鹰用户名
        CHAOJIYING_PASSWORD = 'xxx'  # 超级鹰密码
        CHAOJIYING_SOFT_ID = xxx  # 超级鹰用户软件ID
        CHAOJIYING_KIND = xxx  # 验证码类型
    
        #  识别验证码
        chaojiying = Chaojiying(CHAOJIYING_USERNAME, CHAOJIYING_PASSWORD, CHAOJIYING_SOFT_ID)
        result = chaojiying.post_pic(open('images/four/1.png', 'rb'), CHAOJIYING_KIND)
        print('result:', result)
    

     

    展开全文
  • HttpClient工具类

    万次阅读 多人点赞 2019-09-25 22:23:57
    最近在工作中需要在后台调用短信接口,经过研究决定使用HttpClient,自己封装了一个HttpClient工具类,简单轻松的实现get,post,put和delete请求,希望分享给大家。 1. 什么是HttpClient HTTP 协议可能是现在 ...

    最近在工作中需要在后台调用短信接口,经过研究决定使用HttpClient,自己封装了一个HttpClient工具类,简单轻松的实现get,post,put和delete请求,希望分享给大家。

    1. 什么是HttpClient

    HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了,越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能,但是对于大部分应用程序来说,JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是Apache HttpComponents 下的子项目,用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包,并且它支持 HTTP 协议最新的版本和建议。

    2. 功能介绍

    • 实现了所有 HTTP 的方法(GET,POST,PUT,DELETE 等)
    • 支持自动转向
    • 支持 HTTPS 协议
    • 支持代理服务器等

    3. 版本比较

    注意本篇博客主要是基于 HttpClient4.5.5 版本的来讲解的,也是现在最新的版本,之所以要提供版本说明的是因为 HttpClient 3 版本和 HttpClient 4 版本差别还是很多大的,基本HttpClient里面的接口都变了,你把 HttpClient 3 版本的代码拿到 HttpClient 4 上面都运行不起来,会报错的。所以一定要注意 HtppClient 的版本问题。

    4. HttpClient不能做的事情

    HttpClient 不是浏览器,它是一个客户端 HTTP 协议传输类库。HttpClient 被用来发送和接受 HTTP 消息。HttpClient 不会处理 HTTP 消息的内容,不会进行 javascript 解析,不会关心 content type,如果没有明确设置,HttpClient 也不会对请求进行格式化、重定向 url,或者其他任何和 HTTP 消息传输相关的功能。

    5. HttpClient使用流程

    使用HttpClient发送请求、接收响应很简单,一般需要如下几步即可。

    1. 创建HttpClient对象。
    2. 创建请求方法的实例,并指定请求URL。如果需要发送GET请求,创建HttpGet对象;如果需要发送POST请求,创建HttpPost对象。
    3. 如果需要发送请求参数,可调用HttpGetsetParams方法来添加请求参数;对于HttpPost对象而言,可调用setEntity(HttpEntity entity)方法来设置请求参数。
    4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求,该方法返回一个HttpResponse对象。
    5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头;调用HttpResponse的getEntity()方法可获取HttpEntity对象,该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
    6. 释放连接。无论执行方法是否成功,都必须释放连接

    6. HttpClient工具类

    本项目采用spring-boot构建,话不多说,上代码

    优秀

    6.1 添加依赖

    <properties>
            <httpclient.version>4.5.5</httpclient.version>
    
            <java.version>1.8</java.version>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        </properties>
    
        <dependencies>
            <!-- springboot的web和test启动库 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
    
            <!-- apache httpclient组件 -->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
            </dependency>
    
        </dependencies>
    
        <build>
            <finalName>${project.artifactId}</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <!-- 跳过单元测试 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <configuration>
                        <skipTests>true</skipTests>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    

    6.2 编写spring-boot启动类

    /**
     * Description: springboot启动类
     * 
     * @author JourWon
     * @date Created on 2018年4月19日
     */
    @SpringBootApplication
    public class Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Application.class, args);
    	}
    
    }
    

    6.3 编写get和post请求测试controller

    /**
     * Description: get和post请求测试controller
     * 
     * @author JourWon
     * @date Created on 2018年4月19日
     */
    @RestController
    @RequestMapping("/hello")
    public class HelloWorldController {
    
    	@GetMapping("/get")
    	public String get() throws InterruptedException {
    		return "get无参请求成功";
    	}
    
    	@GetMapping("/getWithParam")
    	public String getWithParam(@RequestParam String message) {
    		return "get带参请求成功,参数message: " + message;
    	}
    
    	@PostMapping("/post")
    	public String post(@RequestHeader("User-Agent") String userAgent,
                @RequestHeader("Accept") String accept,
                @RequestHeader("Accept-Language") String acceptLanguage,
                @RequestHeader("Accept-Encoding") String acceptEncoding,
                @RequestHeader("Cookie") String cookie,
                @RequestHeader("Connection") String conn) {
    		// 打印请求头信息
    		System.out.println("Cookie = " + cookie);
    		System.out.println("Connection = " + conn);
    		System.out.println("Accept = " + accept);
    		System.out.println("Accept-Language = " + acceptLanguage);
    		System.out.println("Accept-Encoding = " + acceptEncoding);
    		System.out.println("User-Agent = " + userAgent);
    		
    		return "post无参请求成功";
    	}
    
    	@PostMapping("/postWithParam")
    	public String postWithParam(@RequestParam String code, @RequestParam String message) {
    		return "post带参请求成功,参数code: " + code + ",参数message: " + message;
    	}
    
    }
    

    6.4 创建httpClient响应结果对象

    /**
     * Description: 封装httpClient响应结果
     * 
     * @author JourWon
     * @date Created on 2018年4月19日
     */
    public class HttpClientResult implements Serializable {
    
    	/**
    	 * 响应状态码
    	 */
    	private int code;
    
    	/**
    	 * 响应数据
    	 */
    	private String content;
    
    }
    

    6.5 重点,编写httpclient工具类

    /**
     * Description: httpClient工具类
     * 
     * @author JourWon
     * @date Created on 2018年4月19日
     */
    public class HttpClientUtils {
    
    	// 编码格式。发送编码格式统一用UTF-8
    	private static final String ENCODING = "UTF-8";
    	
    	// 设置连接超时时间,单位毫秒。
    	private static final int CONNECT_TIMEOUT = 6000;
    	
    	// 请求获取数据的超时时间(即响应时间),单位毫秒。
    	private static final int SOCKET_TIMEOUT = 6000;
    
    	/**
    	 * 发送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
    	 */
    	public static HttpClientResult doGet(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
    		// 创建httpClient对象
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    
    		// 创建访问的地址
    		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, null);
    	}
    	
    	/**
    	 * 发送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);
    	}
    
    	/**
    	 * 发送post请求;带请求头和请求参数
    	 * 
    	 * @param url 请求地址
    	 * @param headers 请求头集合
    	 * @param params 请求参数集合
    	 * @return
    	 * @throws Exception
    	 */
    	public static HttpClientResult doPost(String url, Map<String, String> headers, Map<String, String> params) throws Exception {
    		// 创建httpClient对象
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    
    		// 创建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);
    		}
    	}
    
    	/**
    	 * 发送put请求;不带请求参数
    	 * 
    	 * @param url 请求地址
    	 * @param params 参数集合
    	 * @return
    	 * @throws Exception
    	 */
    	public static HttpClientResult doPut(String url) throws Exception {
    		return doPut(url);
    	}
    
    	/**
    	 * 发送put请求;带请求参数
    	 * 
    	 * @param url 请求地址
    	 * @param params 参数集合
    	 * @return
    	 * @throws Exception
    	 */
    	public static HttpClientResult doPut(String url, Map<String, String> params) throws Exception {
    		CloseableHttpClient httpClient = HttpClients.createDefault();
    		HttpPut httpPut = new HttpPut(url);
    		RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECT_TIMEOUT).setSocketTimeout(SOCKET_TIMEOUT).build();
    		httpPut.setConfig(requestConfig);
    		
    		packageParam(params, httpPut);
    
    		CloseableHttpResponse httpResponse = null;
    
    		try {
    			return getHttpClientResult(httpResponse, httpClient, httpPut);
    		} finally {
    			release(httpResponse, httpClient);
    		}
    	}
    
    	/**
    	 * 发送delete请求;不带请求参数
    	 * 
    	 * @param url 请求地址
    	 * @param params 参数集合
    	 * @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
    	 */
    	public static HttpClientResult getHttpClientResult(CloseableHttpResponse httpResponse,
    			CloseableHttpClient httpClient, HttpRequestBase httpMethod) throws Exception {
    		// 执行请求
    		httpResponse = httpClient.execute(httpMethod);
    
    		// 获取返回结果
    		if (httpResponse != null && httpResponse.getStatusLine() != null) {
    			String content = "";
    			if (httpResponse.getEntity() != null) {
    				content = EntityUtils.toString(httpResponse.getEntity(), ENCODING);
    			}
    			return new HttpClientResult(httpResponse.getStatusLine().getStatusCode(), content);
    		}
    		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();
    		}
    	}
    
    }
    

    6.6 启动spring-boot,测试get、post请求

    /**
     * Description: HttpClientUtils工具类测试
     * 
     * @author JourWon
     * @date Created on 2018年4月19日
     */
    public class HttpClientUtilsTest {
    
    	/**
    	 * Description: 测试get无参请求
    	 * 
    	 * @throws Exception
    	 */
    	@Test
    	public void testGet() throws Exception {
    		HttpClientResult result = HttpClientUtils.doGet("http://127.0.0.1:8080/hello/get");
    		System.out.println(result);
    	}
    
    	/**
    	 * Description: 测试get带参请求
    	 * 
    	 * @throws Exception
    	 */
    	@Test
    	public void testGetWithParam() throws Exception {
    		Map<String, String> params = new HashMap<String, String>();
    		params.put("message", "helloworld");
    		HttpClientResult result = HttpClientUtils.doGet("http://127.0.0.1:8080/hello/getWithParam", params);
    		System.out.println(result);
    	}
    
    	/**
    	 * Description: 测试post带请求头不带请求参数
    	 * 
    	 * @throws Exception
    	 */
    	@Test
    	public void testPost() throws Exception {
    		Map<String, String> headers = new HashMap<String, String>();
    		headers.put("Cookie", "123");
    		headers.put("Connection", "keep-alive");
    		headers.put("Accept", "application/json");
    		headers.put("Accept-Language", "zh-CN,zh;q=0.9");
    		headers.put("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36");
    		HttpClientResult result = HttpClientUtils.doPost("http://127.0.0.1:8080/hello/post", headers, null);
    		System.out.println(result);
    	}
    
    	/**
    	 * Description: 测试post带参请求
    	 * 
    	 * @throws Exception
    	 */
    	@Test
    	public void testPostWithParam() throws Exception {
    		Map<String, String> params = new HashMap<String, String>();
    		params.put("code", "0");
    		params.put("message", "helloworld");
    		HttpClientResult result = HttpClientUtils.doPost("http://127.0.0.1:8080/hello/postWithParam", params);
    		System.out.println(result);
    	}
    
    }
    

    完整代码下载链接

    展开全文
  • 很多时候都需要使用到缓存工具-(不过目前有很多专业的缓存工具,写这个东西仅仅是为了梳理缓存的逻辑) 首先定义一个存储工具使用的ConcurrentHashMap(支持并发) private volatile Map<String, CacheObject&...
  • CollectionUtils工具类

    万次阅读 2020-09-01 15:40:49
    这篇讲的CollectionUtils工具类是在apache下的 相关的maven <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version&...
  • 自动生成代码工具 数据库工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 数据库工具类 import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.PreparedStatement; i...
  • 自动生成代码工具 模板工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 模板工具类 import java.io.BufferedWriter; import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.util.ArrayList; i...
  • 自动生成代码工具 文件工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 文件工具类 import java.io.File; import java.util.List; import java.util.Map; import org.apache.commons.lang.StringUtils; import org.slf4j.Lo...
  • Java之——导出Excel通用工具类

    万次阅读 多人点赞 2018-03-22 21:11:15
    转载请注明出处:... ... 一、概述 相信大家在工作过程中,都会遇到这样一个需求,就是将相关的数据列表导出成excel,那么,有没有通用的导出方式呢,这里,...
  • 流量转换工具类需要的工具类

    千次阅读 2020-03-26 11:07:07
    用于double类型数据进行运算: ... import java.math.BigDecimal;... * 由于Java的简单类型不能够精确的对浮点数进行运算,这个工具类提供精 * 确的浮点数运算,包括加减乘除和四舍五入。 */ public ...
  • 自动生成代码工具 配置文件工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 配置文件工具类 import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import org.dom4j.Do...
  • 自动生成代码工具 字符串工具类

    万次阅读 2019-09-20 15:59:31
    自动生成代码工具 字符串工具类 import org.apache.commons.lang.StringUtils; import com.ijwt.exception.JavaTypeException; import com.ijwt.exception.MybatisTypeException; /** * @...
  • JAVA后端极光推送工具类实现

    万次阅读 2020-02-28 13:28:24
    官网文档地址: https://docs.jiguang.cn/ 1:导入maven jar包 <!-- 极光推送 --> <dependency> <groupId>cn.jpush.api</groupId> <artifactId>jpush-client<... ...
  • 引言 最近在解决问题时候发现,BeanUtils copyProperties 方法会将值为null的字段也进行复制, 这有时候会不能满足我们的需求,所以...*************************************下面工具类可以直接使用*************...
  • JWT工具类

    万次阅读 2018-03-30 14:12:41
    1.JWT 加密/解密工具类实现 import com.google.gson.Gson; import io.jsonwebtoken.Claims; import io.jsonwebtoken.JwtBuilder; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.Signature...
  • MultipartFileToFile工具类

    千次阅读 2020-03-31 12:40:15
    MultipartFileToFile工具类: bufferReader读取文件都会把文件下载到项目目录中,要注意删除。以下实现MultipartFile 转 File功能以及项目中文件删除。 package com.reachauto.vsp.portal.util; import org....
  • 丢弃掉那些BeanUtils工具类吧,MapStruct真香!!!

    万次阅读 热门讨论 2020-08-10 12:55:30
    》中,我曾经对几款属性拷贝的工具类进行了对比。 然后在评论区有些读者反馈说MapStruct才是真的香,于是我就抽时间了解了一下MapStruct。结果我发现,这真的是一个神仙框架,炒鸡香。 这一篇文章就来简单介绍下Map...
  • FtpClient工具类

    万次阅读 2019-07-03 21:00:02
    1、maven依赖 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>${commons.l...
  • 工具类中,通过@Value的形式,获取配置失败,但是同样的写法在Controller中却成功了,而且在这个工具类的单元测试文件中也能获取到配置。 尝试在这个工具类上加入@Controller注解,@Service注解,@Component注解...
  • 一、引言 json字符串现在是项目中很常用的了,尤其是在写接口返回数据一般都是json格式的。小编最近在看项目中,发现有多处地方用到了java对象转json,但是引用的jar包都是不统一的。 常见的有由alibaba提供的...

空空如也

1 2 3 4 5 ... 20
收藏数 213,762
精华内容 85,504
关键字:

工具类