yObject类包含常见基础类型字段和子类SubObject，SubObject包含LocalDateTime、LocalDate字段，模拟从前端接收到json字符串，然后转为对象，再把对象转为字符串。

之前有粉丝问我类里面包含内部类如何反序列化，所以这个例子也为了给粉丝一个参考。

代码片段如下，需要整个代码的请到gitee下载，文章中的测试类路径：src/test/java/com/javalaoniu/tool/JacksonMapperTest.java

@Test
public void demoTest() {
    JacksonMapper instance=JacksonMapper.getInstance();
    JacksonMapper jacksonMapper=JacksonMapper.nonDefaultMapper();
    System.out.println(instance==jacksonMapper);

    String s="{\n" +
        "  \"serviceUuid\": \"9430be4f4cb244d79a5c0bf5e77136dc\",  \n" +
        "  \"secretId\": \"dsvb942f67c43cb475\",  \n" +
        "  \"nonceStr\": \"90907e\",  \n" +
        "  \"sign\": \"6071BF709864F21AB1B218F3122358B4\",   \n" +
        "  \"pageIndex\": 1, \n" +
        "  \"pageSize\": 100, \n" +
        "  \"customParams\": {\n" +
        "     \"startTime\": \"2019-11-19 14:42:47\",\n" +
        "     \"endDate\": \"2019-11-20\",\n" +
        "     \"itemCodes\": \"90000700100754196914440306,90000600100754196914440309,90000800100754196914440306," +
        "90000700100754196914440342\"\n" +
        "  }\n" +
        "}";
    MyObject myObject=JacksonMapper.fromJsonString(s, MyObject.class);
    logger.info(myObject.toString());
    String json=instance.toJson(myObject);
    logger.info(json);
}

实体类

/**
* 静态内部类，jackson解析内部类时需要static修饰，否则需要把类单独放到java文件中
*
* @JsonFormat 来自定义时间格式
* @JsonIgnore可以忽略某个 Java 对象中的属性，它将不参与 JSON 的序列化与反序列化
* @JsonGetter可以在对 Java 对象进行 JSON 序列化时自定义属性名称
* @JsonSetter可以在对 JSON 进行反序列化时设置 JSON 中的 key 与 Java 属性的映射关系
*/
static class MyObject {

    private String serviceUuid;

    private String secretId;

    private String nonceStr;

    private String sign;

    private Integer pageIndex;

    private Integer pageSize;

    private SubObject customParams;

      。。。。。get/set等代码

}

/**
* 静态内部类，jackson解析内部类时需要static修饰，否则需要把类单独放到java文件中
*
* @JsonSerialize 指定序列化使用的类
* @JsonDeserialize 指定反序列化使用的类
*/
static class SubObject {
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
    @JsonDeserialize(using=LocalDateTimeDeserializer.class)
    @JsonSerialize(using=LocalDateTimeSerializer.class)
    private LocalDateTime startTime;

    @JsonFormat(pattern="yyyy-MM-dd")
    @JsonDeserialize(using=LocalDateDeserializer.class)
    @JsonSerialize(using=LocalDateSerializer.class)
    private LocalDate endDate;

    private String itemCodes;

    。。。。。get/set等代码

}

jackson工具类

package com.javalaoniu.tool.utils;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.util.JSONPObject;
import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.TimeZone;

/** 
 * 简单封装Jackson，实现JSON String<->Java Object的Mapper. 
 * 封装不同的输出风格, 使用不同的builder函数创建实例. 
 */  
public class JacksonMapper extends ObjectMapper {
  
    private static final long serialVersionUID=1L;  
  
    private static Logger logger=LoggerFactory.getLogger(JacksonMapper.class);
  
    private static JacksonMapper mapper;
  
    private JacksonMapper() {
        this(Include.NON_EMPTY);  
    }

    private JacksonMapper(Include include) {
        // 设置输出时包含属性的风格  
        if (include !=null) {  
            this.setSerializationInclusion(include);  
        }  
        // 允许单引号、允许不带引号的字段名称  
        this.enableSimple();  
        // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性  
        this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 运行empty的属性
        this.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        // 空值处理为空串
        this.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>(){
            @Override  
            public void serialize(Object value, JsonGenerator jgen,  
                    SerializerProvider provider) throws IOException,
                    JsonProcessingException {  
                jgen.writeString("");  
            }  
        });

        //this.registerModule(new SimpleModule().addSerializer(new MyBigDecimalDesirializer()));

        // 进行HTML解码。  
        /*this.registerModule(new SimpleModule().addSerializer(String.class, new JsonSerializer<String>(){  
            @Override  
            public void serialize(String value, JsonGenerator jgen,  
                    SerializerProvider provider) throws IOException,  
                    JsonProcessingException {  
                jgen.writeString(StringEscapeUtils.unescapeHtml4(value));  
            }  
        }));  */
        // 设置时区  
        this.setTimeZone(TimeZone.getDefault());//getTimeZone("GMT+8:00")  
    }

    /**
     * 设定是否使用Enum的toString函数来读写Enum,
     * 为False时使用Enum的name()函数来 读写Enum, 默认为False.
     * 注意本函数一定要在Mapper创建后, 所有的读写动作之前调用.
     */
    public JacksonMapper enableEnumUseToString() {
        this.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        this.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
        return this;
    }

    /**
     * 支持使用Jaxb的Annotation，使得POJO上的annotation不用与Jackson耦合。
     * 默认会先查找jaxb的annotation，如果找不到再找jackson的。
     */
    public JacksonMapper enableJaxbAnnotation() {
        JaxbAnnotationModule module=new JaxbAnnotationModule();
        this.registerModule(module);
        return this;
    }

    /**
     * 允许单引号
     * 允许不带引号的字段名称
     */
    public JacksonMapper enableSimple() {
        this.configure(Feature.ALLOW_SINGLE_QUOTES, true);
        this.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        this.configure(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN,true);
        return this;
    }

    /**
     * 取出Mapper做进一步的设置或使用其他序列化API.
     */
    public ObjectMapper getMapper() {
        return this;
    }

    /** 
     * Object可以是POJO，也可以是Collection或数组。 
     * 如果对象为Null, 返回"null". 
     * 如果集合为空集合, 返回"[]". 
     */  
    public String toJson(Object object) {  
        try {  
            return this.writeValueAsString(object);  
        } catch (IOException e) {  
            logger.warn("write to json string error:" + object, e);  
            return null;  
        }  
    }  
  
    /** 
     * 反序列化POJO或简单Collection如List<String>. 
     *  
     * 如果JSON字符串为Null或"null"字符串, 返回Null. 
     * 如果JSON字符串为"[]", 返回空集合. 
     *  
     * 如需反序列化复杂Collection如List<MyBean>, 请使用fromJson(String,JavaType) 
     * @see #fromJson(String, JavaType) 
     */  
    public <T> T fromJson(String jsonString, Class<T> clazz) {  
        if (jsonString==null || jsonString.isEmpty()) {  
            return null;  
        }  
        try {  
            return this.readValue(jsonString, clazz);  
        } catch (IOException e) {  
            logger.warn("parse json string error:" + jsonString, e);  
            return null;  
        }  
    }  
  
    /** 
     * 反序列化复杂Collection如List<Bean>, 先使用函数createCollectionType构造类型,然后调用本函数. 
     * @see #createCollectionType(Class, Class...) 
     */  
    @SuppressWarnings("unchecked")  
    public <T> T fromJson(String jsonString, JavaType javaType) {  
        if (jsonString==null || jsonString.isEmpty()) {  
            return null;  
        }  
        try {  
            return (T) this.readValue(jsonString, javaType);  
        } catch (IOException e) {  
            logger.warn("parse json string error:" + jsonString, e);  
            return null;  
        }  
    }  
  
    /** 
     * 构造泛型的Collection Type如: 
     * ArrayList<MyBean>, 则调用constructCollectionType(ArrayList.class,MyBean.class) 
     * HashMap<String,MyBean>, 则调用(HashMap.class,String.class, MyBean.class) 
     */  
    public JavaType createCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {  
        return this.getTypeFactory().constructParametricType(collectionClass, elementClasses);  
    }  
  
    /** 
     * 当JSON里只含有Bean的部分属性时，更新一个已存在Bean，只覆盖该部分的属性. 
     */  
    @SuppressWarnings("unchecked")  
    public <T> T update(String jsonString, T object) {  
        try {  
            return (T) this.readerForUpdating(object).readValue(jsonString);  
        } catch (JsonProcessingException e) {  
            logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);  
        } catch (IOException e) {  
            logger.warn("update json string:" + jsonString + " to object:" + object + " error.", e);  
        }  
        return null;  
    }

    /** 
     * 输出JSONP格式数据. 
     */  
    public String toJsonP(String functionName, Object object) {  
        return toJson(new JSONPObject(functionName, object));  
    }

    /**
     * 创建只输出非Null且非Empty(如List.isEmpty)的属性到Json字符串的Mapper,建议在外部接口中使用.
     */
    public static JacksonMapper getInstance() {
        if (mapper==null){
            mapper=new JacksonMapper(Include.ALWAYS).enableSimple();
        }
        return mapper;
    }

    /**
     * 创建只输出初始值被改变的属性到Json字符串的Mapper, 最节约的存储方式，建议在内部接口中使用。
     */
    public static JacksonMapper nonDefaultMapper() {
        if (mapper==null){
            mapper=new JacksonMapper(Include.NON_DEFAULT);
        }
        return mapper;
    }


    /**
     * 封装这个方法便于直接类名调用
     * 对象转换为JSON字符串 
     * @param object 
     * @return 
     */  
    public static String toJsonString(Object object){
        return JacksonMapper.getInstance().toJson(object);
    }  
      
    /**
     * 封装这个方法便于直接类名调用
     * JSON字符串转换为对象 
     * @param jsonString 
     * @param clazz 
     * @return 
     */  
    public static <T> T fromJsonString(String jsonString, Class<T> clazz){
        return JacksonMapper.getInstance().fromJson(jsonString, clazz);
    }
}

maven依赖

背景

灵魂拷问1：还在为新项目工具类搬迁而烦恼？

灵魂拷问2：还在为项目中工具类维护而烦恼？

??简述

Hutool它是一个Java工具集类库，包含了很多静态方法的封装：流处理、时间日期处理、正则处理、加解密处理、文件处理、集合处理等，可以说是项目中几乎所有XxxxUtil的替代品，它可以使你更多的关注代码逻辑，优雅的写出高效代码，避免“复制粘贴，改改再战”。

”?组件

模块划分预览，可以根据需求对每个模块单独引入，也可以通过引入hutool-all方式引入所有模块。

??常用

??只列举部分方法，详细可查看源码学习！！！

1、核心工具集

1.1、日期时间工具-DateUtil

日期转换再常用不过了，字符串转日期格式、日期格式转指定字符串格式、获取当前系统日期、时间差

// 自定义日期格式转化
String dateStr="2017-03-01";
Date date=DateUtil.parse(dateStr, "yyyy-MM-dd");

1.2、农历日期-ChineseDate

提供了生肖、天干地支、传统节日等方法。

//通过公历构建
ChineseDate date=new ChineseDate(DateUtil.parseDate("2020-01-25"));
// 一月
date.getChineseMonth();
// 正月
date.getChineseMonthName();
// 初一
date.getChineseDay();
// 庚子
date.getCyclical();
// 生肖：鼠
date.getChineseZodiac();
// 传统节日（部分支持，逗号分隔）：春节
date.getFestivals();
// 庚子鼠年 正月初一
date.toString();

1.3、计时器工具-TimeInterval

计算方法或过程执行的时间，支持分组计时，方便对比时间

TimeInterval timer=DateUtil.timer();

//---------------------------------
//-------这是执行过程
//---------------------------------

timer.interval();//花费毫秒数
timer.intervalRestart();//返回花费时间，并重置开始时间
timer.intervalMinute();//花费分钟数

1.4、文件类型判断-FileTypeUtil

在文件上传时，有时候我们需要判断文件类型。但是又不能简单的通过扩展名来判断（防止恶意脚本等通过上传到服务器上），于是我们需要在服务端通过读取文件的首部几个二进制位来判断常用的文件类型。

File file=FileUtil.file("d:/test.jpg");
String type=FileTypeUtil.getType(file);
//输出 jpg则说明确实为jpg文件
Console.log(type);

1.5、符串工具-StrUtil

这个工具的用处类似于Apache Commons Lang中的StringUtil，字符串判空操作就不再累述，StrUtil只做增强：sub、removePrefix、removeSuffix

// 去掉字符串的后缀，例如去个文件名的扩展名。
String fileName=StrUtil.removeSuffix("pretty_girl.jpg", ".jpg")  //fileName -> pretty_girl

1.6、16进制工具-HexUtil

16进制一般针对无法显示的一些二进制进行显示，常用于： 1、图片的字符串表现形式 2、加密解密 3、编码转换

String str="我是一个字符串";

String hex=HexUtil.encodeHexStr(str, CharsetUtil.CHARSET_UTF_8);

//hex是：
//e68891e698afe4b880e4b8aae5ad97e7aca6e4b8b2

String decodedStr=HexUtil.decodeHexStr(hex);

//解码后与str相同

1.7、Escape工具-EscapeUtil

转义和反转义工具类Escape / Unescape。escape采用ISO Latin字符集对指定的字符串进行编码。所有的空格符、标点符号、特殊字符以及其他非ASCII字符都将被转化成%xx格式的字符编码(xx等于该字符在字符集表里面的编码的16进制数字)。此类中的方法对应Javascript中的escape()函数和unescape()函数。

1.8、URL工具-URLUtil

URL（Uniform Resource Locator）中文名为统一资源定位符，有时也被俗称为网页地址。表示为互联网上的资源，如网页或者FTP地址。在Java中，也可以使用URL表示Classpath中的资源（Resource）地址。

?URLUtil.normalize 标准化化URL链接。对于不带http://头的地址做简单补全。

String url="http://www.hutool.cn//aaa/bbb";
// 结果为：http://www.hutool.cn/aaa/bbb
String normalize=URLUtil.normalize(url);

url="http://www.hutool.cn//aaa/\\bbb?a=1&b=2";
// 结果为：http://www.hutool.cn/aaa/bbb?a=1&b=2
normalize=URLUtil.normalize(url);

?URLUtil.encode 封装URLEncoder.encode，将需要转换的内容（ASCII码形式之外的内容），用十六进制表示法转换出来，并在之前加上%开头。

String body="366466 - 副本.jpg";
// 结果为：366466%20-%20%E5%89%AF%E6%9C%AC.jpg
String encode=URLUtil.encode(body);

1.9、枚举工具-EnumUtil

枚举（enum）算一种“语法糖”，是指一个经过排序的、被打包成一个单一实体的项列表。一个枚举的实例可以使用枚举项列表中任意单一项的值。枚举在各个语言当中都有着广泛的应用，通常用来表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量。Java从JDK5开始，引入了对枚举的支持。

//定义枚举 
public enum TestEnum{ 

    TEST1("type1"), TEST2("type2"), TEST3("type3"); 
    
    private TestEnum(String type) { 
        this.type=type; 
    } 
    
    private String type; 
    
    public String getType() { 
        return this.type; 
    } 
}

// 获取枚举类中所有枚举对象的name列表
List<String> names=EnumUtil.getNames(TestEnum.class); //结果：[TEST1, TEST2, TEST3]

// 获得枚举类中各枚举对象下指定字段的值
List<Object> types=EnumUtil.getFieldValues(TestEnum.class, "type"); //结果：[type1, type2, type3]

1.10、数字工具-NumberUtil

数字工具针对数学运算做工具性封装

// 格式化为指定字符串
long c=299792458;//光速
String format=NumberUtil.decimalFormat(",###", c);//299,792,458

1.11、数组工具-ArrayUtil

数组工具类主要针对原始类型数组和泛型数组相关方案进行封装

// 数组判空
int[] a={}; 
int[] b=null; 
ArrayUtil.isEmpty(a); 
ArrayUtil.isEmpty(b);

1.12、随机工具-RandomUtil

RandomUtil主要针对JDK中Random对象做封装，严格来说，Java产生的随机数都是伪随机数，因此Hutool封装后产生的随机结果也是伪随机结果。不过这种随机结果对于大多数情况已经够用。

// 例如我们想产生一个[10, 100)的随机数，则：
int c=RandomUtil.randomInt(10, 100);

1.13、唯一ID工具-IdUtil

在分布式环境中，唯一ID生成应用十分广泛，生成方法也多种多样，Hutool针对一些常用生成策略做了简单封装。包括UUID、ObjectId（MongoDB）、Snowflake（Twitter）

// 生成的UUID是带-的字符串，类似于：a5c8a5e8-df2b-4706-bea4-08d0939410e3
String uuid=IdUtil.randomUUID();

// 生成的是不带-的字符串，类似于：b17f24ff026d40949c85a24f4f375d42
String simpleUUID=IdUtil.simpleUUID();

1.14、正则工具-ReUtil

在文本处理中，正则表达式几乎是全能的，但是Java的正则表达式有时候处理一些事情还是有些繁琐

// 给定字符串是否匹配给定正则
String content="ZZZaaabbbccc中文1234";
boolean isMatch=ReUtil.isMatch("\\w+[\u4E00-\u9FFF]+\\d+", content);
Assert.assertTrue(isMatch);

1.15、身份证工具-IdcardUtil

支持大陆15位、18位身份证，港澳台10位身份证

String ID_18="321083197812162119";
String ID_15="150102880730303";

//是否有效
boolean valid=IdcardUtil.isValidCard(ID_18);
boolean valid15=IdcardUtil.isValidCard(ID_15);

//转换
String convert15To18=IdcardUtil.convert15To18(ID_15);

//年龄
DateTime date=DateUtil.parse("2017-04-10");   
int age=IdcardUtil.getAgeByIdCard(ID_18, date);
int age2=IdcardUtil.getAgeByIdCard(ID_15, date);

//生日
String birth=IdcardUtil.getBirthByIdCard(ID_18);
String birth2=IdcardUtil.getBirthByIdCard(ID_15);


//省份
String province=IdcardUtil.getProvinceByIdCard(ID_18);
String province2=IdcardUtil.getProvinceByIdCard(ID_15);

1.16、信息脱敏工具-DesensitizedUtil

在数据处理或清洗中，可能涉及到很多隐私信息的脱敏工作，因此Hutool针对常用的信息封装了一些脱敏方法。

// 以身份证号码为例：5***************1X
DesensitizedUtil.idCardNum("51343620000320711X", 1, 2);

1.17、社会信用代码工具-CreditCodeUtil

法人和其他组织统一社会信用代码制度，相当于让法人和其他组织拥有了一个全国统一的“身份证号”，由一下五部分组成： 第一部分：登记管理部门代码1位 (数字或大写英文字母) 第二部分：机构类别代码1位 (数字或大写英文字母) 第三部分：登记管理机关行政区划码6位 (数字) 第四部分：主体标识码（组织机构代码）9位 (数字或大写英文字母) 第五部分：校验码1位 (数字或大写英文字母)

// 校验是否为社会信用代码
String testCreditCode="91310110666007217T";
// true
CreditCodeUtil.isCreditCode(testCreditCode);

1.18、字段验证器-Validator

验证给定字符串是否满足指定条件，一般用在表单字段验证里。

// 验证是否为邮箱
boolean isEmail=Validator.isEmail("loolly@gmail.com")

// 如无法满足需求，可通过该正则验证
Validator.isMactchRegex("需要验证字段的正则表达式", "被验证内容")

1.19、Bean工具-BeanUtil

Bean工具类主要是针对这些setXXX和getXXX方法进行操作，比如将Bean对象转为Map等等

// 使用Map填充bean
HashMap<String, Object> map=CollUtil.newHashMap();
map.put("name", "Joe");
map.put("age", 12);
map.put("openId", "DFDFSDFWERWER");

SubPerson person=BeanUtil.fillBeanWithMap(map, new SubPerson(), false);

1.20、集合工具-CollUtil

这个工具主要增加了对数组、集合类的操作。

// 将集合转换为字符串
String[] col=new String[]{"a","b","c","d","e"};
List<String> colList=CollUtil.newArrayList(col);

String str=CollUtil.join(colList, "#"); //str -> a#b#c#d#e

1.21、列表工具-ListUtil

List在集合中中使用最为频繁，因此新版本的Hutool中针对List单独封装了工具方法。

// 列表截取
final List<Integer> of=ListUtil.of(1, 2, 3, 4);

// [3, 4]
final List<Integer> sub=ListUtil.sub(of, 2, 4);

// 对子列表操作不影响原列表
sub.remove(0);

1.22、Unicode编码转换工具-UnicodeUtil

此工具主要针对类似于\u4e2d\u6587这类Unicode字符做一些特殊转换。

// 字符串转Unicode 第二个参数true表示跳过ASCII字符（只跳过可见字符）
String s=UnicodeUtil.toUnicode("aaa123中文", true); //结果aaa123\\u4e2d\\u6587

// Unicode转字符串
String res=UnicodeUtil.toString("aaa\\U4e2d\\u6587\\u111\\urtyu\\u0026"); //结果aaa中文\\u111\\urtyu&

1.23、Map工具-MapUtil

MapUtil是针对Map的一一列工具方法的封装，包括getXXX的快捷值转换方法。

// reverse Map的键和值互换
Map<String, String> map=MapUtil.newHashMap();
        map.put("a", "1");
        map.put("b", "2");
        map.put("c", "3");
        map.put("d", "4");

Map<String, String> map2=MapUtil.reverse(map);

结果为：

{
   "1": "a",
   "2": "b",
   "3": "c",
   "4": "d",
}

1.24、Base64编码解码

Base64编码是用64（2的6次方）个ASCII字符来表示256（2的8次方）个ASCII字符，也就是三位二进制数组经过编码后变为四位的ASCII字符显示，长度比原来增加1/3。

String a="伦家是一个非常长的字符串";
// 5Lym5a625piv5LiA5Liq6Z2e5bi46ZW/55qE5a2X56ym5Liy
String encode=Base64.encode(a);

// 还原为a
String decodeStr=Base64.decodeStr(encode);

1.25、数学相关-MathUtil

此工具是NumberUtil的一个补充，NumberUtil偏向于简单数学计算的封装，MathUtil偏向复杂数学计算。

1.26、图片工具-ImgUtil

针对awt中图片处理进行封装，这些封装包括：缩放、裁剪、转为黑白、加水印等操作。

// 图片类型转换png->jpg
ImgUtil.convert(FileUtil.file("e:/test2.png"), FileUtil.file("e:/test2Convert.jpg"));

// 彩色转黑白
ImgUtil.gray(FileUtil.file("d:/logo.png"), FileUtil.file("d:/result.png"));

// 添加文字水印
ImgUtil.pressText(
    FileUtil.file("e:/pic/face.jpg"),  
    FileUtil.file("e:/pic/test2_result.png"), 
    "版权所有", Color.WHITE, //文字 
    new Font("黑体", Font.BOLD, 100), //字体 
    0, //x坐标修正值。 默认在中间，偏移量相对于中间偏移 
    0, //y坐标修正值。 默认在中间，偏移量相对于中间偏移 
    0.8f//透明度：alpha 必须是范围 [0.0, 1.0] 之内（包含边界值）的一个浮点数字 
);

1.27、网络工具-NetUtil

在日常开发中，网络连接这块儿必不可少。日常用到的一些功能，隐藏掉部分IP地址、绝对相对路径的转换等等。

String ip="127.0.0.1";
long iplong=2130706433L;

// 根据long值获取ip v4地址
String ip=NetUtil.longToIpv4(iplong);


// 根据ip地址计算出long型的数据
long ip=NetUtil.ipv4ToLong(ip);

// 检测本地端口可用性
boolean result=NetUtil.isUsableLocalPort(6379);

// 是否为有效的端口
boolean result=NetUtil.isValidPort(6379);

// 隐藏掉IP地址
String result=NetUtil.hideIpPart(ip);

2、JSON

2.1、JSON工具-JSONUtil

针对JSONObject和JSONArray的静态快捷方法集合

// JSON字符串解析
String html="{\"name\":\"Something must have been changed since you leave\"}";
JSONObject jsonObject=JSONUtil.parseObj(html);
jsonObject.getStr("name");

// XML字符串转JSON
String s="<sfzh>123</sfzh><sfz>456</sfz><name>aa</name><gender>1</gender>"; 
JSONObject json=JSONUtil.parseFromXml(s); 
json.get("sfzh"); 
json.get("name");

// JSON转XML
final JSONObject put=JSONUtil.createObj().set("aaa", "你好").set("键2", "test"); 
// <aaa>你好</aaa><键2>test</键2> 
final String s=JSONUtil.toXmlStr(put);

// JSON转Bean
String json="{\"ADT\":[[{\"BookingCode\":[\"N\",\"N\"]}]]}"; 
Price price=JSONUtil.toBean(json, Price.class); 
price.getADT().get(0).get(0).getBookingCode().get(0);

3、加密解密

3.1、加密解密工具-SecureUtil

SecureUtil主要针对常用加密算法构建快捷方式，还有提供一些密钥生成的快捷工具方法。

// AES对称加解密
String content="test中文";

// 随机生成密钥
byte[] key=SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();

// 构建
AES aes=SecureUtil.aes(key);

// 加密
byte[] encrypt=aes.encrypt(content);
// 解密
byte[] decrypt=aes.decrypt(encrypt);

// 加密为16进制表示
String encryptHex=aes.encryptHex(content);
// 解密为字符串
String decryptStr=aes.decryptStr(encryptHex, CharsetUtil.CHARSET_UTF_8);

4、HTTP客户端

4.1、Http客户端工具类-HttpUtil

基于JDK的HttpUrlConnection封装完成，完整支持https、代理和文件上传、以及URL参数编解码等。

GET请求栗子：

// 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS
String result1=HttpUtil.get("https://www.baidu.com");

// 当无法识别页面编码的时候，可以自定义请求页面的编码
String result2=HttpUtil.get("https://www.baidu.com", CharsetUtil.CHARSET_UTF_8);

//可以单独传入http参数，这样参数会自动做URL编码，拼接在URL中
HashMap<String, Object> paramMap=new HashMap<>();
paramMap.put("city", "北京");

String result3=HttpUtil.get("https://www.baidu.com", paramMap);

POST请求栗子：

HashMap<String, Object> paramMap=new HashMap<>();
paramMap.put("city", "北京");

String result=HttpUtil.post("https://www.baidu.com", paramMap);

文件上传栗子：

HashMap<String, Object> paramMap=new HashMap<>();
//文件上传只需将参数中的键指定（默认file），值设为文件对象即可，对于使用者来说，文件上传与普通表单提交并无区别
paramMap.put("file", FileUtil.file("D:\\face.jpg"));

String result=HttpUtil.post("https://www.baidu.com", paramMap);

4.2、HTML工具类-HtmlUtil

如我们在使用爬虫爬取HTML页面后，需要对返回页面的HTML内容做一定处理，比如去掉指定标签（例如广告栏等）、去除JS、去掉样式等等，这些操作都可以使用HtmlUtil完成。

// 转义HTML特殊字符
String html="<html><body>123'123'</body></html>";
// 结果为：<html><body>123'123'</body></html>
String escape=HtmlUtil.escape(html);

// 还原被转义的HTML特殊字符
String escape="<html><body>123'123'</body></html>"; 
// 结果为：<html><body>123'123'</body></html> 
String unescape=HtmlUtil.unescape(escape);

// 清除指定HTML标签和被标签包围的内容
String str="pre<img src=\"xxx/dfdsfds/test.jpg\">";
// 结果为：pre 
String result=HtmlUtil.removeHtmlTag(str, "img");


// 清除所有HTML标签，但是保留标签内的内容 
String str="pre<div class=\"test_div\">\r\n\t\tdfdsfdsfdsf\r\n</div><div class=\"test_div\">BBBB</div>"; 
// 结果为：pre\r\n\t\tdfdsfdsfdsf\r\nBBBB 
String result=HtmlUtil.cleanHtmlTag(str);

// 清除指定HTML标签，不包括内容
String str="pre<div class=\"test_div\">abc</div>"; 
// 结果为：preabc 
String result=HtmlUtil.unwrapHtmlTag(str, "div");


// 过滤HTML文本,防止XSS攻击
String html="<alert></alert>"; 
// 结果为："" 
String filter=HtmlUtil.filter(html);

5、扩展工具集

5.1、拼音工具-PinyinUtil

引入拼音库（TinyPinyin、JPinyin、Pinyin4j）其中任意一个引擎，从而实现获取汉语拼音、拼音首字母

// 获取拼音："ni hao" 
String pinyin=PinyinUtil.getPinyin("你好", " "); 

// 获取拼音首字母："h, s, d, y, g"
String result=PinyinUtil.getFirstLetter("H是第一个", ", ");

5.2、Emoji工具-EmojiUtil

引入表情依赖，实现表情转义、表情转html、转义的别名转表情

<!-- 表情依赖 -->
<dependency>
    <groupId>com.vdurmont</groupId>
    <artifactId>emoji-java</artifactId>
    <version>4.0.0</version>
</dependency>

// 转义Emoji字符
String alias=EmojiUtil.toAlias("");//:smile:

// 将转义的别名转为Emoji字符
String emoji=EmojiUtil.toUnicode(":smile:");//

// 将字符串中的Unicode Emoji字符转换为HTML表现形式
String alias=EmojiUtil.toHtml("");//

5.3、二维码工具-QrCodeUtil

引入zxing库依赖（理论上你引入的版本应与此版本一致或比这个版本新），实现二维码的生成（二维码可附带logo图标）以及识别二维码

<!-- zxing库依赖 -->
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>3.3.3</version>
</dependency>

// 自定义参数生成指定url对应的二维码到文件
QrConfig config=new QrConfig(300, 300);
// 设置边距，既二维码和背景之间的边距
config.setMargin(3);
// 设置前景色，既二维码颜色（青色）
config.setForeColor(Color.CYAN.getRGB());
// 设置背景色（灰色）
config.setBackColor(Color.GRAY.getRGB());

// 生成二维码到文件，也可以到流
QrCodeUtil.generate("http://hutool.cn/", config, FileUtil.file("e:/qrcode.jpg"));


// 识别二维码（decode -> "http://hutool.cn/" ）
String decode=QrCodeUtil.decode(FileUtil.file("d:/qrcode.jpg"));

5.4、邮件工具-MailUtil

Hutool对所有第三方都是可选依赖，因此在使用MailUtil时需要自行引入第三方依赖。支持群发、带附件、自定义邮件服务器

<!-- java-mail依赖 -->
<!-- 说明 com.sun.mail是javax.mail升级后的版本，新版本包名做了变更。 -->
<dependency>
    <groupId>com.sun.mail</groupId>
    <artifactId>javax.mail</artifactId>
    <version>1.6.2</version>
</dependency>

// 发送普通文本邮件，最后一个参数可选是否添加多个附件
MailUtil.send("hutool@foxmail.com", "测试", "邮件来自Hutool测试", false);

// 发送HTML格式的邮件并附带附件，最后一个参数可选是否添加多个附件：
MailUtil.send("hutool@foxmail.com", "测试", "<h1>邮件来自Hutool测试</h1>", true, FileUtil.file("d:/aaa.xml"));

// 群发邮件，可选HTML或普通文本，可选多个附件：
ArrayList<String> tos=CollUtil.newArrayList( 
    "person1@bbb.com", 
    "person2@bbb.com", 
    "person3@bbb.com", 
    "person4@bbb.com"); 
MailUtil.send(tos, "测试", "邮件来自Hutool群发测试", false);

官方文档： https://www.hutool.cn/docs/#/

Github地址： https://github.com/dromara/hutool

Gitee地址： https://gitee.com/dromara/hutool

作者：京东零售 马宏伟

来源：京东云开发者社区 转载请注明来源

scape() 和 unescape() 是 JavaScript 中的两个函数，用于编码和解码字符串。

escape() 函数用于对字符串进行编码，将字符串中的特殊字符转换为十六进制转义序列。这些特殊字符包括非字母数字字符、保留字符和其他特殊字符。例如，空格字符会被转换为 %20。

示例:

var str="Hello, World!";
var encodedStr=escape(str);
console.log(encodedStr);  // 输出：Hello%2C%20World%21

在上述示例中，escape() 函数将字符串 "Hello, World!" 编码为 "Hello%2C%20World%21"。

unescape() 函数用于对字符串进行解码，将被 escape() 编码的字符串恢复为原始字符串。

示例:

var encodedStr="Hello%2C%20World%21";
var decodedStr=unescape(encodedStr);
console.log(decodedStr);  // 输出：Hello, World!

在上述示例中，unescape() 函数将编码后的字符串 "Hello%2C%20World%21" 解码为原始字符串 "Hello, World!"。

需要注意的是，escape() 和 unescape() 函数在 ECMAScript 3 中被标记为已弃用，并且不建议在新的 JavaScript 代码中使用。

推荐使用更安全和可靠的编码和解码函数，例如encodeURI()、encodeURIComponent()、decodeURI() 和 decodeURIComponent()。

使用这些新的函数会更好地处理特殊字符和 Unicode 字符。

例如，encodeURI() 和 encodeURIComponent() 在编码 URL 时通常更合适，而 decodeURI() 和 decodeURIComponent()在解码 URL 时更合适。