轻松把玩HttpClient之封装HttpClient工具类(三)，插件式配置Header

上篇文章介绍了插件式配置HttpClient，本文将介绍插件式配置Header。

为什么要配置header在前面已经提到了，还里再简单说一下，要使用HttpClient模拟请求，去访问各种接口或者网站资源，都有可能有各种限制，比如说java客户端模拟访问csdn博客，就必须设置User-Agent，否则就报错了。还有各种其他情况，必须的设置一些特定的Header，才能请求成功，或者才能不出问题。

好了就说这么多，本次还是采用构造者模式的级联调用方式，来完成该工具类。在该工具类中，为所有常用的Http Request Header都提供了设置方法。具体参数参考的链接是HTTP Header 详解。

不再多废话了，看具体代码吧：

package com.tgb.ccl.http.common;

import java.util.HashMap;
import java.util.Map;

import org.apache.http.Consts;
import org.apache.http.Header;
import org.apache.http.message.BasicHeader;

/**
 * 创建HttpReqHead
 *
 * @author arron
 * @date 2015年11月9日 上午10:37:23
 * @version 1.0
 */
public class HttpHeader {

	private HttpHeader() {};

	public static HttpHeader custom() {
		return new HttpHeader();
	}

	//记录head头信息
	private Map<String, Header> headerMaps = new HashMap<String, Header>();

	/**
	 * 指定客户端能够接收的内容类型
	 * 例如：Accept: text/plain, text/html
	 *
	 * @param accept
	 */
	public HttpHeader accept(String accept) {
		headerMaps.put(HttpReqHead.ACCEPT,
				new BasicHeader(HttpReqHead.ACCEPT, accept));
		return this;
	}

	/**
	 * 浏览器可以接受的字符编码集
	 * 例如：Accept-Charset: iso-8859-5
	 *
	 * @param acceptCharset
	 */
	public HttpHeader acceptCharset(String acceptCharset) {
		headerMaps.put(HttpReqHead.ACCEPT_CHARSET,
				new BasicHeader(HttpReqHead.ACCEPT_CHARSET, acceptCharset));
		return this;
	}

	/**
	 * 指定浏览器可以支持的web服务器返回内容压缩编码类型
	 * 例如：Accept-Encoding: compress, gzip
	 *
	 * @param acceptEncoding
	 */
	public HttpHeader acceptEncoding(String acceptEncoding) {
		headerMaps.put(HttpReqHead.ACCEPT_ENCODING,
				new BasicHeader(HttpReqHead.ACCEPT_ENCODING, acceptEncoding));
		return this;
	}

	/**
	 * 浏览器可接受的语言
	 * 例如：Accept-Language: en,zh
	 *
	 * @param acceptLanguage
	 */
	public HttpHeader acceptLanguage(String acceptLanguage) {
		headerMaps.put(HttpReqHead.ACCEPT_LANGUAGE,
				new BasicHeader(HttpReqHead.ACCEPT_LANGUAGE, acceptLanguage));
		return this;
	}

	/**
	 * 可以请求网页实体的一个或者多个子范围字段
	 * 例如：Accept-Ranges: bytes
	 *
	 * @param acceptRanges
	 */
	public HttpHeader acceptRanges(String acceptRanges) {
		headerMaps.put(HttpReqHead.ACCEPT_RANGES,
				new BasicHeader(HttpReqHead.ACCEPT_RANGES, acceptRanges));
		return this;
	}

	/**
	 * HTTP授权的授权证书
	 * 例如：Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
	 *
	 * @param authorization
	 */
	public HttpHeader authorization(String authorization) {
		headerMaps.put(HttpReqHead.AUTHORIZATION,
				new BasicHeader(HttpReqHead.AUTHORIZATION, authorization));
		return this;
	}

	/**
	 * 指定请求和响应遵循的缓存机制
	 * 例如：Cache-Control: no-cache
	 *
	 * @param cacheControl
	 */
	public HttpHeader cacheControl(String cacheControl) {
		headerMaps.put(HttpReqHead.CACHE_CONTROL,
				new BasicHeader(HttpReqHead.CACHE_CONTROL, cacheControl));
		return this;
	}

	/**
	 * 表示是否需要持久连接（HTTP 1.1默认进行持久连接）
	 * 例如：Connection: close 短链接； Connection: keep-alive 长连接
	 *
	 * @param connection
	 * @return
	 */
	public HttpHeader connection(String connection) {
		headerMaps.put(HttpReqHead.CONNECTION,
				new BasicHeader(HttpReqHead.CONNECTION, connection));
		return this;
	}

	/**
	 * HTTP请求发送时，会把保存在该请求域名下的所有cookie值一起发送给web服务器
	 * 例如：Cookie: $Version=1; Skin=new;
	 *
	 * @param cookie
	 */
	public HttpHeader cookie(String cookie) {
		headerMaps.put(HttpReqHead.COOKIE,
				new BasicHeader(HttpReqHead.COOKIE, cookie));
		return this;
	}

	/**
	 * 请求内容长度
	 * 例如：Content-Length: 348
	 *
	 * @param contentLength
	 */
	public HttpHeader contentLength(String contentLength) {
		headerMaps.put(HttpReqHead.CONTENT_LENGTH,
				new BasicHeader(HttpReqHead.CONTENT_LENGTH, contentLength));
		return this;
	}

	/**
	 * 请求的与实体对应的MIME信息
	 * 例如：Content-Type: application/x-www-form-urlencoded
	 *
	 * @param contentType
	 */
	public HttpHeader contentType(String contentType) {
		headerMaps.put(HttpReqHead.CONTENT_TYPE,
				new BasicHeader(HttpReqHead.CONTENT_TYPE, contentType));
		return this;
	}

	/**
	 * 请求发送的日期和时间
	 * 例如：Date: Tue, 15 Nov 2010 08:12:31 GMT
	 *
	 * @param date
	 * @return
	 */
	public HttpHeader date(String date) {
		headerMaps.put(HttpReqHead.DATE,
				new BasicHeader(HttpReqHead.DATE, date));
		return this;
	}

	/**
	 * 请求的特定的服务器行为
	 * 例如：Expect: 100-continue
	 *
	 * @param expect
	 */
	public HttpHeader expect(String expect) {
		headerMaps.put(HttpReqHead.EXPECT,
				new BasicHeader(HttpReqHead.EXPECT, expect));
		return this;
	}

	/**
	 * 发出请求的用户的Email
	 * 例如：From: [email protected]
	 *
	 * @param from
	 */
	public HttpHeader from(String from) {
		headerMaps.put(HttpReqHead.FROM,
				new BasicHeader(HttpReqHead.FROM, from));
		return this;
	}

	/**
	 * 指定请求的服务器的域名和端口号
	 * 例如：Host: blog.csdn.net
	 *
	 * @param host
	 * @return
	 */
	public HttpHeader host(String host) {
		headerMaps.put(HttpReqHead.HOST,
				new BasicHeader(HttpReqHead.HOST, host));
		return this;
	}

	/**
	 * 只有请求内容与实体相匹配才有效
	 * 例如：If-Match: “737060cd8c284d8af7ad3082f209582d”
	 *
	 * @param ifMatch
	 * @return
	 */
	public HttpHeader ifMatch(String ifMatch) {
		headerMaps.put(HttpReqHead.IF_MATCH,
				new BasicHeader(HttpReqHead.IF_MATCH, ifMatch));
		return this;
	}

	/**
	 * 如果请求的部分在指定时间之后被修改则请求成功，未被修改则返回304代码
	 * 例如：If-Modified-Since: Sat, 29 Oct 2010 19:43:31 GMT
	 *
	 * @param ifModifiedSince
	 * @return
	 */
	public HttpHeader ifModifiedSince(String ifModifiedSince) {
		headerMaps.put(HttpReqHead.IF_MODIFIED_SINCE,
				new BasicHeader(HttpReqHead.IF_MODIFIED_SINCE, ifModifiedSince));
		return this;
	}

	/**
	 * 如果内容未改变返回304代码，参数为服务器先前发送的Etag，与服务器回应的Etag比较判断是否改变
	 * 例如：If-None-Match: “737060cd8c284d8af7ad3082f209582d”
	 *
	 * @param ifNoneMatch
	 * @return
	 */
	public HttpHeader ifNoneMatch(String ifNoneMatch) {
		headerMaps.put(HttpReqHead.IF_NONE_MATCH,
				new BasicHeader(HttpReqHead.IF_NONE_MATCH, ifNoneMatch));
		return this;
	}

	/**
	 * 如果实体未改变，服务器发送客户端丢失的部分，否则发送整个实体。参数也为Etag
	 * 例如：If-Range: “737060cd8c284d8af7ad3082f209582d”
	 *
	 * @param ifRange
	 * @return
	 */
	public HttpHeader ifRange(String ifRange) {
		headerMaps.put(HttpReqHead.IF_RANGE,
				new BasicHeader(HttpReqHead.IF_RANGE, ifRange));
		return this;
	}

	/**
	 * 只在实体在指定时间之后未被修改才请求成功
	 * 例如：If-Unmodified-Since: Sat, 29 Oct 2010 19:43:31 GMT
	 *
	 * @param ifUnmodifiedSince
	 * @return
	 */
	public HttpHeader ifUnmodifiedSince(String ifUnmodifiedSince) {
		headerMaps.put(HttpReqHead.IF_UNMODIFIED_SINCE,
				new BasicHeader(HttpReqHead.IF_UNMODIFIED_SINCE, ifUnmodifiedSince));
		return this;
	}

	/**
	 * 限制信息通过代理和网关传送的时间
	 * 例如：Max-Forwards: 10
	 *
	 * @param maxForwards
	 * @return
	 */
	public HttpHeader maxForwards(String maxForwards) {
		headerMaps.put(HttpReqHead.MAX_FORWARDS,
				new BasicHeader(HttpReqHead.MAX_FORWARDS, maxForwards));
		return this;
	}

	/**
	 * 用来包含实现特定的指令
	 * 例如：Pragma: no-cache
	 *
	 * @param pragma
	 * @return
	 */
	public HttpHeader pragma(String pragma) {
		headerMaps.put(HttpReqHead.PRAGMA,
				new BasicHeader(HttpReqHead.PRAGMA, pragma));
		return this;
	}

	/**
	 * 连接到代理的授权证书
	 * 例如：Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
	 *
	 * @param proxyAuthorization
	 */
	public HttpHeader proxyAuthorization(String proxyAuthorization) {
		headerMaps.put(HttpReqHead.PROXY_AUTHORIZATION,
				new BasicHeader(HttpReqHead.PROXY_AUTHORIZATION, proxyAuthorization));
		return this;
	}

	/**
	 * 只请求实体的一部分，指定范围
	 * 例如：Range: bytes=500-999
	 *
	 * @param range
	 */
	public HttpHeader range(String range) {
		headerMaps.put(HttpReqHead.RANGE,
				new BasicHeader(HttpReqHead.RANGE, range));
		return this;
	}

	/**
	 * 先前网页的地址，当前请求网页紧随其后,即来路
	 * 例如：Referer: http://www.zcmhi.com/archives/71.html
	 *
	 * @param referer
	 */
	public HttpHeader referer(String referer) {
		headerMaps.put(HttpReqHead.REFERER,
				new BasicHeader(HttpReqHead.REFERER, referer));
		return this;
	}

	/**
	 * 客户端愿意接受的传输编码，并通知服务器接受接受尾加头信息
	 * 例如：TE: trailers,deflate;q=0.5
	 *
	 * @param te
	 */
	public HttpHeader te(String te) {
		headerMaps.put(HttpReqHead.TE,
				new BasicHeader(HttpReqHead.TE, te));
		return this;
	}

	/**
	 * 向服务器指定某种传输协议以便服务器进行转换（如果支持）
	 * 例如：Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11
	 *
	 * @param upgrade
	 */
	public HttpHeader upgrade(String upgrade) {
		headerMaps.put(HttpReqHead.UPGRADE,
				new BasicHeader(HttpReqHead.UPGRADE, upgrade));
		return this;
	}

	/**
	 * User-Agent的内容包含发出请求的用户信息
	 *
	 * @param userAgent
	 * @return
	 */
	public HttpHeader userAgent(String userAgent) {
		headerMaps.put(HttpReqHead.USER_AGENT,
				new BasicHeader(HttpReqHead.USER_AGENT, userAgent));
		return this;
	}

	/**
	 * 关于消息实体的警告信息
	 * 例如：Warn: 199 Miscellaneous warning
	 *
	 * @param warning
	 * @return
	 */
	public HttpHeader warning(String warning) {
		headerMaps.put(HttpReqHead.WARNING,
				new BasicHeader(HttpReqHead.WARNING, warning));
		return this;
	}

	/**
	 * 通知中间网关或代理服务器地址，通信协议
	 * 例如：Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1)
	 *
	 * @param via
	 * @return
	 */
	public HttpHeader via(String via) {
		headerMaps.put(HttpReqHead.VIA,
				new BasicHeader(HttpReqHead.VIA, via));
		return this;
	}

	/**
	 * 设置此HTTP连接的持续时间（超时时间）
	 * 例如：Keep-Alive: 300
	 *
	 * @param keepAlive
	 * @return
	 */
	public HttpHeader keepAlive(String keepAlive) {
		headerMaps.put(HttpReqHead.KEEP_ALIVE,
				new BasicHeader(HttpReqHead.KEEP_ALIVE, keepAlive));
		return this;
	}

	public String accept() {
		return get(HttpReqHead.ACCEPT);
	}

	public String acceptCharset() {
		return get(HttpReqHead.ACCEPT_CHARSET);
	}

	public String acceptEncoding() {
		return get(HttpReqHead.ACCEPT_ENCODING);
	}

	public String acceptLanguage() {
		return get(HttpReqHead.ACCEPT_LANGUAGE);
	}

	public String acceptRanges() {
		return get(HttpReqHead.ACCEPT_RANGES);
	}

	public String authorization() {
		return get(HttpReqHead.AUTHORIZATION);
	}

	public String cacheControl() {
		return get(HttpReqHead.CACHE_CONTROL);
	}

	public String connection() {
		return get(HttpReqHead.CONNECTION);
	}

	public String cookie() {
		return get(HttpReqHead.COOKIE);
	}

	public String contentLength() {
		return get(HttpReqHead.CONTENT_LENGTH);
	}

	public String contentType() {
		return get(HttpReqHead.CONTENT_TYPE);
	}

	public String date() {
		return get(HttpReqHead.DATE);
	}

	public String expect() {
		return get(HttpReqHead.EXPECT);
	}

	public String from() {
		return get(HttpReqHead.FROM);
	}

	public String host() {
		return get(HttpReqHead.HOST);
	}

	public String ifMatch() {
		return get(HttpReqHead.IF_MATCH);
	}

	public String ifModifiedSince() {
		return get(HttpReqHead.IF_MODIFIED_SINCE);
	}

	public String ifNoneMatch() {
		return get(HttpReqHead.IF_NONE_MATCH);
	}

	public String ifRange() {
		return get(HttpReqHead.IF_RANGE);
	}

	public String ifUnmodifiedSince() {
		return get(HttpReqHead.IF_UNMODIFIED_SINCE);
	}

	public String maxForwards() {
		return get(HttpReqHead.MAX_FORWARDS);
	}

	public String pragma() {
		return get(HttpReqHead.PRAGMA);
	}

	public String proxyAuthorization() {
		return get(HttpReqHead.PROXY_AUTHORIZATION);
	}

	public String referer() {
		return get(HttpReqHead.REFERER);
	}

	public String te() {
		return get(HttpReqHead.TE);
	}

	public String upgrade() {
		return get(HttpReqHead.UPGRADE);
	}

	public String userAgent() {
		return get(HttpReqHead.USER_AGENT);
	}

	public String via() {
		return get(HttpReqHead.VIA);
	}

	public String warning() {
		return get(HttpReqHead.WARNING);
	}

	public String keepAlive() {
		return get(HttpReqHead.KEEP_ALIVE);
	}

	/**
	 * 获取head信息
	 *
	 * @return
	 */
	private String get(String headName) {
		if (headerMaps.containsKey(headName)) {
			return headerMaps.get(headName).getValue();
		}
		return null;
	}

	/**
	 * 返回header头信息
	 *
	 * @return
	 */
	public Header[] build() {
		Header[] headers = new Header[headerMaps.size()];
		int i = 0;
		for (Header header : headerMaps.values()) {
			headers[i] = header;
			i++;
		}
		headerMaps.clear();
		headerMaps = null;
		return headers;
	}

	/**
	 * Http头信息
	 *
	 * @author arron
	 * @date 2015年11月9日 上午11:29:04
	 * @version 1.0
	 */
	private static class HttpReqHead {
		public static final String ACCEPT = "Accept";
		public static final String ACCEPT_CHARSET = "Accept-Charset";
		public static final String ACCEPT_ENCODING = "Accept-Encoding";
		public static final String ACCEPT_LANGUAGE = "Accept-Language";
		public static final String ACCEPT_RANGES = "Accept-Ranges";
		public static final String AUTHORIZATION = "Authorization";
		public static final String CACHE_CONTROL = "Cache-Control";
		public static final String CONNECTION = "Connection";
		public static final String COOKIE = "Cookie";
		public static final String CONTENT_LENGTH = "Content-Length";
		public static final String CONTENT_TYPE = "Content-Type";
		public static final String DATE= "Date";
		public static final String EXPECT = "Expect";
		public static final String FROM = "From";
		public static final String HOST = "Host";
		public static final String IF_MATCH = "If-Match ";
		public static final String IF_MODIFIED_SINCE = "If-Modified-Since";
		public static final String IF_NONE_MATCH = "If-None-Match";
		public static final String IF_RANGE = "If-Range";
		public static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
		public static final String KEEP_ALIVE = "Keep-Alive";
		public static final String MAX_FORWARDS = "Max-Forwards";
		public static final String PRAGMA = "Pragma";
		public static final String PROXY_AUTHORIZATION = "Proxy-Authorization";
		public static final String RANGE = "Range";
		public static final String REFERER = "Referer";
		public static final String TE = "TE";
		public static final String UPGRADE = "Upgrade";
		public static final String USER_AGENT = "User-Agent";
		public static final String VIA = "Via";
		public static final String WARNING = "Warning";
	}

	/**
	 * 常用头信息配置
	 *
	 * @author arron
	 * @date 2015年11月18日 下午5:30:00
	 * @version 1.0
	 */
	public static class Headers{
		public static final String APP_FORM_URLENCODED="application/x-www-form-urlencoded";
		public static final String TEXT_PLAIN="text/plain";
		public static final String TEXT_HTML="text/html";
		public static final String TEXT_XML="text/xml";
		public static final String TEXT_JSON="text/json";
		public static final String CONTENT_CHARSET_ISO_8859_1 = Consts.ISO_8859_1.name();
		public static final String CONTENT_CHARSET_UTF8 = Consts.UTF_8.name();
		public static final String DEF_PROTOCOL_CHARSET = Consts.ASCII.name();
		public static final String CONN_CLOSE = "close";
		public static final String KEEP_ALIVE = "keep-alive";
		public static final String EXPECT_CONTINUE = "100-continue";
	}
}

调用方式：

	//设置header信息
	Header[] headers=HttpHeader.custom().keepAlive("false").connection("close").contentType(Headers.APP_FORM_URLENCODED).build();

就是这么简单。到此该工具类就完成了。下一篇将分享该工具类以及单次调用测试和多线程调用测试。

版权声明：本文为博主原创文章，未经博主允许不得转载。如需转载请声明：【转自 http://blog.csdn.net/xiaoxian8023 】

时间： 2024-11-12 01:53:05

轻松把玩HttpClient之封装HttpClient工具类(三)，插件式配置Header的相关文章

轻松把玩HttpClient之封装HttpClient工具类(二)，插件式配置HttpClient对象

上一篇文章中,简单分享一下封装HttpClient工具类的思路及部分代码,本文将分享如何实现插件式配置HttpClient对象. 如果你看过我前面的几篇关于HttpClient的文章或者官网示例,应该都知道HttpClient对象在创建时,都可以设置各种参数,但是却没有简单的进行封装,比如对我来说比较重要的3个:代理.ssl(包含绕过证书验证和自定义证书验证).超时.还需要自己写.所以这里我就简单封装了一下,顺便还封装了一个连接池的配置. 其实说是插件式配置,那是高大上的说法,说白了,就是采用了

DAO设计模式实现数据库的增删改查（进一步封装JDBC工具类）

一.DAO模式简介 DAO即Data Access Object,数据访问接口.数据访问:故名思义就是与数据库打交道.夹在业务逻辑与数据库资源中间. DAO模式实际上是两个模式的组合,即Data Accessor (数据访问者)模式和 Active Domain Object(领域对象)模式.Data Accessor 模式实现了数据访问和业务逻辑的分离:Active Domain Object 模式实现了业务数据的对象化封装. 需要注意的是,DAO设计模式是Java EE中的设计模式,而非Ja

MySQL数据库学习笔记（十）----JDBC事务处理、封装JDBC工具类

首先需要回顾一下上一篇文章中的内容:MySQL数据库学习笔记(九)----JDBC的PreparedStatement接口重构增删改查 一.JDBC事务处理: 我们已经知道,事务的概念即:所有的操作要么同时成功,要么同时失败.在MySQL中提供了Commit.Rollback命令进行事务的提交与回滚.实际上在JDBC中也存在事务处理,如果要想进行事务处理的话,则必须按照以下的步骤完成. JDBC中事务处理的步骤: 1.要取消掉JDBC的自动提交:void setAutoCommit(boolea

封装JDBC工具类

JDBC连接数据库基本的步骤是固定的,这样就可以考虑封装一个工具类来简化数据库操作. 封装时用到了Java中的properties配置文件,是以一种键值对的形式存在的,可以把连接数据库要动态的信息保存到里面,这样比较直观,不容易出错,而且容易维护. 把配置文件放到src下就可以,如果要放到包下面就配置文件的相对路径就必须从包名开始. Demo : db.properties mysqlDriver=com.mysql.jdbc.Driver mysqlURL=jdbc:mysql://local

导入导出封装的工具类 （一） 利用POI封装

对于导入导出各个项目中几乎都会用到,记得在高校平台中封装过导入导出这部分今天看了看是利用JXL封装的而经理说让我用POI写写导出,这两个导入导出框架是目前比较流程和常用的框架,有必要都了解一下. 写了写代码觉得导入导出这一块底层都是一样的,几乎所有的框架和别的牛人也好都是底层利用POI或JXL实现,比的是谁对这部分封装的好而且每个项目中对导入导出具体的细节是不同的,因此,有必要了解了解怎么样操作POI,学学使用它的API做导入导出也许第一步你封装的没有别人那么好,你也会收获很多了解他们封装的思路

JAVA中封装JSONUtils工具类及使用

在JAVA中用json-lib-2.3-jdk15.jar包中提供了JSONObject和JSONArray基类,用于JSON的序列化和反序列化的操作.但是我们更习惯将其进一步封装,达到更好的重用. 封装后的JSON工具类JSONUtils.java代码如下: JSONUtils代码,点击展开 import java.util.ArrayList;import java.util.Collection;import java.util.HashMap;import java.util.Itera

MySQL数据库学习笔记（十一）----DAO设计模式实现数据库的增删改查（进一步封装JDBC工具类）

[声明] 欢迎转载,但请保留文章原始出处→_→ 生命壹号:http://www.cnblogs.com/smyhvae/ 文章来源:http://www.cnblogs.com/smyhvae/p/4059514.html 联系方式:[email protected] [正文] 一.DAO模式简介 DAO即Data Access Object,数据访问接口.数据访问:故名思义就是与数据库打交道.夹在业务逻辑与数据库资源中间. DAO模式实际上是两个模式的组合,即Data Accessor (数据

Spring 工具类 ConfigurationClassParser 分析得到配置类

https://blog.csdn.net/andy_zhang2007/article/details/78549773 Spring 工具类 ConfigurationClassParser 分析得到配置类原创安迪源文 最后发布于2017-11-16 12:19:50 阅读数 4296 收藏展开简介Spring的工具类ConfigurationClassParser用于分析@Configuration注解的配置类,产生一组ConfigurationClass对象.它的分析过程会接受一组种子配

Android Studio快速创建常用工具类的插件Utils

现如今Android开发,开发工具Android Studio已成为主流,而为Android Studio打造的插件也越来越多,今天为大家介绍一个快速创建常用工具类的插件Utils.其实Android中有关工具类的库有很多,但我们开发中一般只会用到某个库的一个或几个类,所以这时候Utils就有了很大的优势了,它直接创建自己所需要的工具类,而且每个工具类是相互解耦的.下面,我们就来一起看看它的集成及使用. 首先,我们看一下集成方式 下载jar包导入1.下载最新jar包Utils.jar-v1.32