Guava黑魔法:在日志脱敏场景下的奇遇

使用log4j2实现日志数据脱敏 立即下载

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

ef8e05c53d4cf7d24bc6e863c63d8dc6.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:juejin.cn/post/
7274626136328257588


❝

「Guava」 之于「Javaer」 ,如同「Excel」 之于「办公达人」 。

都非常好用,但实际上大部分人只用到了其「1%不到」 的功能。

❞

日志脱敏到底是个啥

「敏感信息脱敏」 实际上是隶属于「安全领域」 的一个子领域,而「日志脱敏」 又是「敏感信息脱敏」 的一个子领域。

好了,打住,不闲聊这些有的没的,直接开整:到底什么是日志脱敏?

未脱敏之前

如下有一个关于个人信息的类

public class Person {
   private Long id;
   private String name;
   private String phone;
   private String account;
   // setter and gettr ...
}

在日志脱敏之前,我们一般会这样直接打印日志

log.info("个人信息:{}",JsonUtils.toJSONString(person));

然后打印完之后,日志大概是这样

个人信息:{"id":1,"name":"张无忌","phone":"17709141590","account":"14669037943256249"}

那如果是这种敏感信息打印到日志中的话,安全问题是非常大的。研发人员或者其他可以访问这些敏感日志的人就可能会故意或者不小心泄露用户的个人信息,甚至干些啥坏事。

0474717e76ae15231719cc1ed7b40149.jpeg
坏事

脱敏后

那日志脱敏最后要达到什么效果呢?

如下:需要把敏感字段中的一部分字符使用特殊符号替换掉(这里我们用*来做特殊符号)

个人信息:{"id":1,"name":"**忌","phone":"177******90","account":"146*********49"}

所以,很自然的,我们就写了个「脱敏组件」 ,在每一个字段上用「注解」 来标识每一个字段是什么类型的敏感字段,需要怎么脱敏。

比如,对于上面的个人信息,在打印日志的时候需要研发人员做两件事:

  1. 「使用脱敏组件提供的注解来标识敏感字段」

public class Person {
   // id是非敏感字段,不需要脱敏
   private Long id;
   
   @Sensitive(type = SensitiveType.Name)
   private String name;
   
   @Sensitive(type = SensitiveType.Phone)
   private String phone;
   
   @Sensitive(type = SensitiveType.Account)
   private String account;
   // setter and gettr ...
}
  1. 「使用脱敏组件先脱敏,再打印日志」

如下,先使用脱敏组件提供的工具类脱敏个人信息,然后再打印日志

log.info("个人信息:{}", DataMask.toJSONString(person));

具体的使用和实现原理可以参考:

唯品会脱敏说明:https://github.sheincorp.cn/vipshop/vjtools/blob/master/vjkit/docs/data_masking.md。

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

日志脱敏遇到了什么问题

到这,还只是一般脱敏组件提供的功能范畴。也就是说,到这你基本上都可以在github上搜索到一些现成的解决方案。

d2b1193476ad9b63ddb4e85ac45b5a12.jpeg
一般般

但是到了企业里面,就不是说到这就已经结束了。

到了企业里面,你得满足客户(也就是研发人员)奇奇怪怪(也许只是一开始「你觉得」 是奇奇怪怪,但是实际上很合理)的需求。

比如,我们就有研发人员提出:「需要按照Map中的Key来配置脱敏规则」

啥意思呢?简单来说,如果我有一个Map类型的数据,如下

Map<String,Object> personMap = new HashMap<>();  
personMap.put("name","张无忌");  
personMap.put("phone","17709141590");  
personMap.put("account","14669037943256249");  
personMap.put("id",1L);

那么在配置文件中指定好对应的key的脱敏规则后就可以把Map中的敏感数据也脱敏。

大概配置文件如下:

#指定Map中的key为name,name,account的value的脱敏规则分别是Name,Account,Phone
Name=name
Account=account
Phone=phone

那先不管需求是否合理吧,反正客户就是上帝,满足再说。

然后,我们就开始实现了。

基本思路:「复制Map」 ,然后遍历复制后的Map,找到Key有对应脱敏规则的value,按照脱敏规则脱敏,最后使用Json框架序列化脱敏后的Map。

public class DataMask{
  // other method...
 /**
  * 将需要脱敏的字段先进行脱敏操作,最后转成json格式
  * @param object 需要序列化的对象
  * @return 脱敏后的json格式
  */
 public static String toJSONString(Object object) {
  if (object == null) {
   return null;
  }
  try {

   // 脱敏map类型
   if (object instanceof Map) {
        return return maskMap(object);
   }

   // 其他类型
   return JsonUtil.toJSONString(object);
  } catch (Exception e) {
   return String.valueOf(object);
  }
 }
        
        private static String maskMap(Object object) {
  Map map = (Map) object;
  MaskJsonStr maskJsonStr = new MaskJsonStr();
  // 复制Map
  HashMap<String, Object> mapClone = new HashMap<>();
  mapClone.putAll(map);
  Map mask = maskJsonStr.maskMapValue(mapClone);
  return JsonUtil.getObjectMapper().writeValueAsString(mask);
 }
}

public class MaskJsonStr{
  // other method...
    public Map<String, Object> maskMapValue(Map<String, Object> map) {
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            Object val = entry.getValue();
            if (val instanceof Map) {
                maskMapValue((Map<String, Object>) val);
            } else if (val instanceof Collection) {
                Collection collVal = maskCollection(entry.getKey(), val);
                map.put(entry.getKey(), collVal);
            } else {
                // 根据key从脱敏规则中获取脱敏规则,然后脱敏
                Object maskVal = maskString(entry.getKey(), val);
                if (maskVal != null) {
                    map.put(entry.getKey(), maskVal);
                } else {
                    map.put(entry.getKey(), val);
                }
            }
        }

        return map;
    }
}

可以说,「在整体思路上,没啥毛病」 ,但是往往「魔鬼就在细节中」 。

5f8dc286a1b1a3bde0d089ecea95c825.jpeg
细节

看到这,也许有些大神,直接从代码中已经看出问题了。不急,我们还是悠着点来,给你10分钟思量一下先。

0e520da491a4cdcc8a3ca4b978af3714.jpeg

❝

「1」 分钟

❞

❝

「2」 分钟

❞

❝

「n」 分钟

❞

f9ae5b87dda503a9c0f8d271cb177ceb.jpeg

好的,我知道的,你肯定是不会思考的。

我们直接看问题。有使用我们这个组件的研发人员找过说:我c a o,你们把我的业务对象「Map中的值修改掉了」 。

我们本来想直接回怼:你们是不是姿势不对,不会用啊。但是本着严(zhi)谨(qian)的(bei)原(da)则(nian)(guo),还是问了句,你在本地复现了吗?

结果,还真被打脸了。人家既有截图,又给我们发了可复现的代码。真是打脸打到家了。

06dae693fb33101d75bd1870f80aae87.gif
打脸

那到底是啥问题呢?按道理,我们肯定是测试过的,正常情况下不会有问题。那到底是什么场景下有问题呢?

我们发现:「有嵌套类型的Map的时候就会有问题」

测试程序如下:

@Test  
public void testToJSONString() {  
    Map<String,Object> personMap = new HashMap<>();  
    personMap.put("name","张无忌");  
    personMap.put("phone","17709141590");  
    personMap.put("account","14669037943256249");  
    personMap.put("id",1L);  

    Map<String,Object> innerMap = new HashMap();  
    innerMap.put("name","张无忌的女儿");  
    innerMap.put("phone","18809141567");  
    innerMap.put("account","17869037943255678");  
    innerMap.put("id",2L);  
    personMap.put("daughter",innerMap);  

    System.out.println("脱敏后:"+DataMask.toJSONString(personMap));  
    System.out.println("脱敏后的原始Map对象:"+personMap);
}

输出结果如下:

脱敏后:{"name":"**忌","id":1,"phone":"177*****590","daughter":{"phone":"188*****567","name":"****女儿","id":2,"account":"1***************8"},"account":"1***************9"}
脱敏后的原始Map对象:{phone=17709141590, name=张无忌, id=1, daughter={phone=188*****567, name=****女儿, id=2, account=1***************8}, account=14669037943256249}

我们发现,脱敏时是成功的,但是却「把原始对象中的内嵌innerMap对象中的值修改了」 。

985943da8f86a96150e724da1b438534.jpeg
震惊

❝

要知道,作为脱敏组件,你可以有点小bug,你也可以原始简单粗暴,「甚至你都可以脱敏失败」 (本该脱敏的却没有脱敏),但是你「千万不能修改业务中使用的对象」 啊。

❞

❝

虽然问题很大,但是我们还是要沉着应对问题,仔细分析问题。做到泰山崩于前而色不变,才是打工人的正确处事方式。不然只会「越急越慌,越慌越不冷静,最后买1送3」 (修1个bug,新引入3个bug)

❞

简单debug,加上看源代码,其实这个问题还是比较容易发现的,主要问题就是在「复制Map对象的姿势不对」

❝

如下,我们是使用这样的方式来复制Map的。本来是想做「深度clone」 的,但是这种事做不到深度clone的。对于有内嵌的对象的时候只能做到「浅clone」 。

❞

// 复制Map
HashMap<String, Object> mapClone = new HashMap<>();
mapClone.putAll(map);

所以,只有一层关系的简单Map是可以脱敏成功的,且不会改变原来的Map。但是对于有嵌套的Map对象时,就会修改嵌套Map对象中的值了。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

问题的原因是啥,如何解决,思路是啥

❝

从上面的分析中就可以得出其根本原因:没有正确地深度clone Map对象

❞

那很自然地,我们的解决思路就是找到一种合适的「深度 clone Map对象」 的方式就OK了。

然后我就问ChatGPT了,ChatGPT的回答有下面几个方法

  1. 「使用序列化和反序列化」 :通过将对象序列化为字节流,然后再将字节流反序列化为新的对象,可以实现深度克隆。需要注意被克隆的对象及其引用类型成员变量都需要实现Serializable接口。

  2. 「使用第三方库」 :除了上述两种方式,还可以使用一些第三方库,例如Apache Commons的SerializationUtils类、Google的Gson库等,它们提供了更简洁的方法来实现深度克隆。

  3. 「使用JSON序列化和反序列化」 :将对象转换为JSON字符串,然后再将JSON字符串转换为新的对象。需要使用JSON库,如Jackson、Gson等。

  4. 「使用Apache Commons的BeanUtils类」 :BeanUtils提供了一个cloneBean()方法,可以对JavaBean进行深度克隆。需要注意,被克隆的对象及其引用类型成员变量都需要实现Serializable接口。

  5. 「最佳实践是根据需求和具体情况灵活应用」 ,或者采用第三方库实现对象克隆,如 Apache Commons BeanUtils、Spring BeanUtils 等。

上面几个方式基本上可以分为3类:

  1. 「序列化和反序列化」 :JDK自带的序列化(需要实现Serializable接口);利用Gson,FastJson,Jackson等JSON序列化工具序列化后再反序列化;其他序列化框架序(如Hessain等)列化反序列化

  2. 「利用第三方库」 :第三方库直接clone对象。但都有一定的限定条件

  3. 「视情况而定」 :基本上没有一种通用的方法,可以适配是有的深度clone场景。所以ChatGPT提出了这一种不是办法的办法

根据上面的一番探索,发现还得自己敲代码造轮子。

c3a0211d3222b0b13dab73567bb234b6.jpeg
敲代码

❝

那其实你仔细分析后发现:我们确实不需要通用的深度clone对象的能力。我们只需要把Map类型深度clone好就行,对于其他自定义DTO,我们是不需要深度clone的。

❞

然后就是卡卡一顿猛敲,如下:常规递归操作

public class MapUtil {  
    private MapUtil() {  

    }  

    public static <K, V> Map<K, V> clone(Map<K, V> map) {  
        if (map == null || map.isEmpty()) {  
            return map;  
        }  
        Map cloneMap = new HashMap();  
        for (Map.Entry<K, V> entry : map.entrySet()) {  
            final V value = entry.getValue();  
            final K key = entry.getKey();  
            if (value instanceof Map) {  
                Map mapValue = (Map) value;  
                cloneMap.put(key, clone(mapValue));  
            } else if (value instanceof Collection) {  
                Collection collectionValue = (Collection) value;  
                cloneMap.put(key, clone(collectionValue));  
            } else {  
                cloneMap.put(key, value);  
            }  
        }  
        return cloneMap;  
    }  

    public static <E> Collection<E> clone(Collection<E> collection) {  
        if (collection == null || collection.isEmpty()) {  
            return collection;  
        }  
        Collection clonedCollection;  
        try {  
            // 有一定的风险会反射调用失败  
            clonedCollection = collection.getClass().newInstance();  
        } catch (InstantiationException | IllegalAccessException e) {  
            // simply deal with reflect exception  
            throw new RuntimeException(e);  
        }  

        for (E e : collection) {  
            if (e instanceof Collection) {  
                Collection collectionE = (Collection) e;  
                clonedCollection.add(clone(collectionE));  
            } else if (e instanceof Map) {  
                Map mapE = (Map) e;  
                clonedCollection.add(clone(mapE));  
            } else {  
                clonedCollection.add(e);  
            }  
        }  
        return clonedCollection;  
    }  
}

然后,又是一波Junit操作,嘎嘎绿灯,收拾完事。

0ce9c2e83e4e74b23e910fe31456d84b.jpeg
行

貌似,到这我们就可以下班了。

791f6003415d41bd36282be84e516c8b.jpeg
下班

但是,等等,这篇文章貌似,好像,的确,应该缺点啥吧?

这尼玛不是讲的是Guava吗,到这为止,貌似跟Guava毛关系没有啊!!!

989cbbbeaa306bc5a589a06708cddc2d.jpeg
扯淡

那我们继续,容你再思考一下,到现在为止,我们的深度clone方案有什么问题。

好的,我懂的。咱看到这,图的就是一个乐,你让我思考,这不是强人所难吗

❝

思考,思考是不可能存在的。

❞

06d208c7383da9fa83024c979649b28e.jpeg
我懂

❝

那咱们就直接看问题:就是啥都好,问题就是「性能比较差!!!」

❞

如果你是一个老司机,你可能看到上面的代码就已经感觉到了,性能是相对比较低的。

❝

基本上,Map层级越深,字段越多,内嵌的集合对象元素越多,性能越差!!!

❞

至于差到什么程度,其实是可以通过 微基准测试框架「JMH」 来实际测试一下就知道了。这里我就不测试了。

❝

那我们还有什么办法来解决这个性能问题吗?

❞

如果我们还是集中于深度clone对象上做文章,去找寻性能更高的深度clone框架或者是类库的话,那么其实这个问题就已经「走偏」 了。

我们再来回顾一下我们之前的问题:

❝

我们需要对Map对象按照key来脱敏,所以我们选择了深度clone Map,然后对Map遍历按照key脱敏后序列化。

❞

❝

那其实我们最终要解决的问题是:Map对象序列化后的字符串得是按照key的脱敏规则脱敏后的字符串。

❞

所以,其实我们除了深度clone这一条路外,还有另外两条路:

  • 1.「自定义Map类型的序列化器」 :在序列化Map的时候,如果有脱敏规则则应用脱敏规则来序列化Map

  • 2.「转换Map为脱敏后的Map」 :自定义Map对象,将脱敏规则作为转换函数来把普通的Map转换为脱敏的Map

对于第一种方式,要看你使用的Json框架是否支持(一般Map类型用的都是内置的Map序列化器,不一定可以自定义)。

那第二种方式,到底应该如何玩呢. 如下:

// 脱敏转换函数
public interface MaskFunction<K, V, E> {
    /**
     * @param k key
     * @param v value
     * @return 根据key和value得到脱敏(如果有需要的话)后的值
     */
    E mask(K k, V v);
}
// 自定义MaskMap对象,经过MaskFunction函数,将普通Map转换为脱敏后的Map
public class MaskMap extends HashMap {

    private MaskFunction maskFunction;

    public MaskMap(MaskFunction maskFunction) {
        this.maskFunction = maskFunction;
    }

    @Override
    public Object get(Object key) {
        Object value = super.get(key);
        if (value == null) {
            return null;
        }
        return maskFunction.mask(key, value);
    }
    // other function to  override ...
}

如上,Map不再是「clone」 的玩法,而是「转换」 的玩法,所以,这种操作是非常「轻量级」 的。

但是这种玩法也有缺点:比较麻烦,需要override好多方法(不然就需要熟读Map序列化器来找到最小化需要override的方法,并且不太靠谱),并且全部都要是「转换」 的玩法。

终于,终于,终于,这个时候该轮到我们「Guava」 登场了。

c0b944177ffa8f52d3238ee60ed0e931.jpeg
轮到我了

Guava登场

用过Guava的人都知道,Guava中很多好用的方法,但是我们平常用的多的也就是那几个。所以这个时候你说需要转换Map,那我们是不是可以去Guava中看看有没有现成的方案,没准有惊喜!!!

1868335ba24ca8051bb1e40fb87047a8.jpeg
惊喜

一看就是惊喜:

30d194a03c185d767e33bee3e83eec21.jpeg
Maps#transformEntries(Map<K,V1>, Maps.EntryTransformer<? super K,? super V1,V2>)

❝

Returns a view of a map whose values are derived from the original map's entries. In contrast to transformValues, this method's entry-transformation logic may depend on the key as well as the value. All other properties of the transformed map, such as iteration order, are left intact.

❞

❝

返回一个Map的试图,其中它的值是从原来map中entry派生出来的。相较于transformValues方法,这个基于entry的转换逻辑是既依赖于key又依赖于value。变换后的映射的所有其他属性(例如迭代顺序)均保持不变

❞

这不正是我们上面需要实现的 MaskMap吗!!!

除此之外,我们还需要支持,对集合类型的脱敏「转换」 ,再去看一下呢,又是惊喜!!!

7f67626f1f5e7eabf84f5d99dadfe334.jpeg

到这,基本上,我们已经在Gauva中找到了我们所需要的全部元素了。下面就是简单集合脱敏规则使用下就好了

public class MaskEntryTransformer implements Maps.EntryTransformer<Object, Object, Object> {
    private static final Maps.EntryTransformer<Object, Object, Object> MASK_ENTRY_TRANSFORMER = new MaskEntryTransformer();

    private MaskEntryTransformer() {

    }

    public static Maps.EntryTransformer<Object, Object, Object> getInstance() {
        return MASK_ENTRY_TRANSFORMER;
    }

    @Override
    public Object transformEntry(Object objectKey, Object value) {
        if (value == null) {
            return null;
        }
        if (value instanceof Map) {
            Map valueMap = (Map) value;
            return Maps.transformEntries(valueMap, this);
        }
        final Maps.EntryTransformer<Object, Object, Object> thisFinalMaskEntryTransformer = this;
        if (value instanceof Collection) {
            Collection valueCollection = (Collection) value;
            if (valueCollection.isEmpty()) {
                return valueCollection;
            }
            return Collections2.transform(valueCollection, new Function<Object, Object>() {
                @Override
                public Object apply(Object input) {
                    if (input == null) {
                        return null;
                    }
                    if (input instanceof Map) {
                        Map inputValueMap = (Map) input;
                        return Maps.transformEntries(inputValueMap, thisFinalMaskEntryTransformer);
                    }
                    if (input instanceof Collection) {
                        Collection inputValueCollection = (Collection) input;
                        return Collections2.transform(inputValueCollection, this);
                    }
                    if (!(objectKey instanceof String)) {
                        return input;
                    }
                    final String key = (String) objectKey;
                    return transformPrimitiveType(key, input);
                }
            });
        }
        if (!(objectKey instanceof String)) {
            return value;
        }
        final String key = (String) objectKey;
        return transformPrimitiveType(key, value);
    }

    /**
     * 按照脱敏规则脱敏基本数据类型
     *
     * @param key
     * @param value
     * @return
     */
    private Object transformPrimitiveType(final String key, final Object value) {
        // ...
    }
}

那脱敏的地方只要转换一下Map就可以了,如下:

public class DataMask {
    /**
     * 将需要脱敏的字段先进行脱敏操作,最后转成json格式
     * @param object 需要序列化的对象
     * @return 脱敏后的json格式
     */
    public static String toJSONString(Object object) {
        if (object == null) {
                return null;
        }
        try {
                if (object instanceof Map) {
                        Map maskMap = Maps.transformEntries((Map) object, MaskEntryTransformer.getInstance());
                        return JsonUtil.toJSONString(maskMap);
                }

                return JsonUtil.toJSONString(object, jsonFilter);
        } catch (Exception e) {
                return object.toString();
        }
    }
}

一点疑问

我们调用了transformEntries方法,是可以根据key(可以找到脱敏规则)和value(可以判断类型)来转换的。但是Map中的有些API实际上可能只有value(比如values())或者只有key(比如get()方法)的,那这种EntryTransformer是如何生效的?

❝

你是不是有那么一点好奇呢?

❞

我们就不去想了,直接看代码:

  • 对于get()方,只有key参数:

但是比较容易通过key拿到对应的value,然后把key和value传给转换函数就可以了

public V2 get(Object key) {  
    V1 value = fromMap.get(key);  
    return (value != null || fromMap.containsKey(key))  
    ? transformer.transformEntry((K) key, value)  
    : null;  
}

❝

这里的实现其实有一个细节,不知道大家注意没有。

就是这一个判断:(value != null || fromMap.containsKey(key)) ,我们上面实现的时候直接没有考虑到值为null的情况(但value为null,但是有对应的key的时候还是应该要调用转换函数的)

❞

  • 对于values()方,只返回值

public Collection<V2> values() {  
    return new Values<K, V2>(this);  
}

也是一样,返回一个转换后的 Collection,其中Collection中的值也是经过 transformer转换的。

而对于迭代器也是一样的,都有对应的实现类把转换逻辑放进去了。

Guava闲聊

Guava的Veiw思想

其实上面的这种 Veiw的基本思想,在Guava中有非常多的场景应用的,如

  • com.google.common.base.Splitter#split

  • com.google.common.collect.Lists#partition

  • com.google.common.collect.Sets#difference

  • ...other

❝

这种 Veiw的基本思想,其实就是「懒加载」 的思想:「在调用的时候不实际做转换,而是在实际使用的时候会做转换」

❞

比如:com.google.common.base.Splitter#split在调用的时候实际上并不是立刻马上去分隔字符串,而是返回一个Iterable的View对象。只是在实际迭代这个Iterable的View对象时才会实际去切分字符串。

在比如com.google.common.collect.Sets#difference在调用的时候并不会立刻马上去做两个集合的差操作,而是返回一个 SetView的View对象,只有在实际使用这个View对象的API的时候才会真正做差操作。

❝

注意点:这种思想大部分场景下,会是性能友好型的,但是也有例外。我们要分清楚场景。

比如,分割字符串的方法com.google.common.base.Splitter#split,如果调用完之后不做任何操作,或者只会遍历一次(大部分场景都是只遍历一次),那么这其实就是最好的方法。但是如果调用完之后,还需要遍历很多次,那么这种场景下,性能可能不是最好的。

❞

❝

所以,对于我们来讲,如果Guava工具包中没有我们需要的View的方法,那么我们可以自己按照这个思想来造一个。如果已经有了,要区分场景使用.

❞

简单聊一下Guava API的兼容性

升级过Guava版本的同学可能深有体会,升级Guava是一件比较头疼的事情。因为「Gauva API的兼容性是做得很差」 的。(当然这里主要还是因为大部分同学没有认真阅读官方的文档导致的)

因为,官网首页就直接提醒了Guava API的兼容性原则:

bdc0690b6a4578165141c2ea9f3dbb78.jpeg

具体请参考:Guava官网https://guava.dev/。

这对于我们做基础组件的同学来讲,是一件尤其需要注意的事情。因为一旦使用了前后不兼容的API,那么使用组件的应用很可能因为API不兼容,导致无法运行的问题。

❝

所以对于做组件的同学,对于Guava的使用一定要慎重:能不用就不用,必须要用的话一定不能使用以@Beta注解标注的方法或者类。

❞

总结

Gauva确实是一个保藏库,当你要造轮子的时候不妨先看看Gauva中有没有现成的轮子。每看一次,也许就多一次惊喜。

这一次是Map对象脱敏场景遇上了Guava的 Maps#transformEntries(Map<K,V1>, .Maps.EntryTransformer<? super K,? super V1,V2>) ,那么你又有什么场景偶遇了Guava呢?,可以在评论区聊一下。


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

ddfeb28aad411988f52543de16e12615.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

72f2d211be1c10b69e6110d808822400.png

53418a7d057fa2245e737ad8a1cecd3e.pngc48c159ac7a406a1c4d2549b7e4d0be1.png6d36fa4d9ddf4d73d8607ba24c527849.png0e747ef22429465e738eaf7d8ed5a7f3.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
ArcGIS坐标系实战:从北京54到CGCS2000的完整转换指南(附常见报错解决方案) 本文详细解析了ArcGIS中从北京54到CGCS2000坐标系的完整转换流程,涵盖核心原理、分步操作指南及常见报错解决方案。重点介绍了高斯投影分带规则、地理变换方法选择以及性能优化技巧,帮助GIS工程师确保空间数据的精确转换与高效处理。 阅读详情

相关推荐

PX4固件下VTOL固定翼的3种起飞方式对比:手抛vs弹射vs跑道

本文深度解析PX4固件下VTOL固定翼的三种起飞方式:手抛、弹射与跑道起飞,对比其技术差异与适用场景。通过详细的参数配置和工程实践指南,帮助开发者优化起飞性能,提升无人机在不同环境下的适应性和可靠性。文章特别针对PX4飞控系统的最新特性进行了技术探讨。

weixin_30296405的博客 89

Guava 骚操作,10分钟搞定日志脱敏需求!

Guava之于Javaer,如同Excel之于办公达人。都非常好用,但实际上大部分人只用到了其1%不到的功能。1日志脱敏到底是个啥敏感信息脱敏实际上是隶属于安全领域的一个子领域,而日志脱敏又是敏感信息脱敏的一个子领域。好了,打住,不闲聊这些有的没的,直接开整:到底什么是日志脱敏?1.1 未脱敏之前如下有一个关于个人信息的类publicclassPerson{ privateLong...

Java知音 844

Xtract or Ucfyber的最条理的整理入门级教程

XTRACT可以对任意截面进行全过程截面分析。工程中常用来分析各种截面(如异形柱、组合截面等)的非线性特征点及承载力校核。 xtract主要思路也是根据各种材料本构关系,基于平截面假定,用fiber划分截面进行全过程非线性分析。......

→★佐佑思维★← 8406

开源工具导航—— Apache Commons与Guava全览

guava与apache common概览

D的博客 2643

WRF-BEM相关参数说明

本参数适用于WRF-BEM模拟武汉市气候。

m0_60013472的博客 1896

RAD Studio 12安装全攻略:从下载到破解InterBase的完整流程(附KeyPatch使用技巧)

本文提供RAD Studio 12的完整安装指南,包括系统要求、安装步骤及InterBase数据库的高效配置方法。详细介绍了如何使用KeyPatch工具进行许可证处理,并分享了IDE优化和开发技巧,帮助开发者快速上手这一强大的跨平台开发工具。

q6r7s8t9的博客 956

Guava骚操作,10分钟搞定日志脱敏需求!

????这是一个或许对你有用的社群????一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料:《项目实战(视频)》:从书中学,往事中“练”《互联网高频面试题》:面朝简历学习,春暖花开《架构 x 系统设计》:摧枯拉朽,掌控面试高频场景题《精进 Java 学习指南》:系统学习,互联网主流技术栈《必读 Java 源码专栏》:知其然,知其所以然????这是一个或许...

weixin_44421461的博客 315

在 ABAP 环境中构建自定义健康监控指标:面向 SAP Cloud ALM 与 SAP Focused Run 的完整实践

本文介绍了在ABAP环境中开发自定义健康监控指标的方法。主要内容包括:1)标准监控指标的不足,如无法反映业务应用层面的问题;2)自定义监控架构,通过metric provider定义指标,由采集作业周期性获取数据并存储;3)核心实现技术,包括IF_GSM_API_PROVIDER接口和三个关键方法;4)指标从ABAP推送到SAP Cloud ALM/Focused Run的完整流程;5)开发实践步骤,从业务分析到具体实现。该方案可帮助团队监控业务关键指标,提升系统运维能力。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 266

Guava如何搞定日志脱敏需求!

Guava是一个由Google开发的Java库,提供了丰富的工具类和函数,用于简化Java开发过程。它包含了许多实用的功能,其中包括字符串处理、集合操作、缓存管理等。在日志处理方面,Guava提供了一些有用的类和方法,可以方便地进行日志脱敏操作。Guava是由Google开发的一个开源Java库,旨在提供高效、可靠和简洁的Java编程解决方案。它包含了许多实用的工具类和函数,涵盖了多个领域,例如集合操作、字符串处理、并发编程、缓存管理、函数式编程等。

牛肉胡辣汤 569

使用 MATLAB/Simulink + Simscape Electrical + SimPowerSystems + Stateflow,构建一个多能互补微电网系统的动态响应仿真模型

本文详细介绍了使用MATLAB/Simulink构建多能互补微电网动态响应仿真模型的方法。文章从系统架构设计入手,包含光伏、风电、柴油发电机、锂电池储能等多种组件,重点讲解了建模过程、控制策略(下垂控制、PLL、SOC管理)和模式切换逻辑(Stateflow)。通过四种典型场景(负荷突增、光伏出力骤降、并网/孤岛切换、电动机启动)的仿真分析,验证了微电网在动态响应中的关键性能指标,并提出了高可靠性设计建议。该模型为微电网的稳定性分析和优化设计提供了有效工具,特别强调了储能系统在快速功率支撑中的重要作用。

amy_mhd的博客 161

【网络与爬虫 49】突破WAF防线:Web应用防火墙绕过实战攻略

本文深入探讨Web应用防火墙(WAF)的工作原理与绕过技术,从基础的编码变换到高级的协议层攻击,通过实战案例和代码演示,帮助安全研究者和渗透测试人员理解现代WAF防护机制并掌握合规的绕过方法。内容涵盖SQL注入、XSS、文件上传等攻击向量的WAF绕过技术,适合网络安全从业者和爬虫开发者学习参考。

熵数实验室 1849

3 步完成 Spring Boot 的日志脱敏

大家好,我是宝哥!在我们书写代码的时候,会书写许多日志代码,但是有些敏感数据是需要进行安全脱敏处理的。对于日志脱敏的方式有很多,常见的有①使用conversionRule标签,继承MessageConverter②书写一个脱敏工具类,在打印日志的时候对特定特字段进行脱敏返回。两种方式各有优缺点:第一种方式需要修改代码,不符合开闭原则。第二种方式,需要在日志方法的参数进行脱敏,对原生日志有入侵行为。...

程序员闪充宝 1581

AES-128-CMAC:背景、汽车应用、CAPL 实现与开源工具验证

本文详解车载诊断中AES-128-CMAC算法的原理与应用,涵盖其在UDS安全访问、刷写鉴权、SecOC认证及密钥派生中的核心作用。结合真实汽车电子场景,提供纯CAPL实现代码与测试脚本,并通过pycryptodome进行逐字节验证,确保算法正确性。全程基于CANoe实测数据,可直接用于HIL环境复现,助力开发者高效落地汽车网络安全方案。

蚂蚁小兵 122

日志脱敏更加优雅性能更好,远超正则。支持 logback+log4j2 插件

序号方法参数结果说明1desCopy()目标对象深度拷贝脱敏对象适应性更强2desJson()目标对象脱敏对象 json性能较好3目标对象集合深度拷贝脱敏对象集合4目标对象集合脱敏对象 json 集合通过注解,指定每一个字段的脱敏策略。数据准备bean.setUsername("张三");bean.setAddress("中国上海市浦东新区外滩18号");bean.setMaskAll("可恶啊我会被全部掩盖");

3731

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

基于springboot、logback的日志脱敏组件

在涉及敏感数据的⽇志记录环境中,数据保护和个⼈隐私⽆疑是⾄关重要的领域。确保敏感数据不被泄露,脱敏处理成为必不可少的⼀步。数据脱敏是⼀种技术⼿段,其将敏感信息转换为不可识别或不可逆转的形式,以便在保护⽤户隐私和数据安全的同时,不影响其原有的⽤途。Logback是⼀个深受欢迎的Java⽇志框架,⼴泛应⽤于各类应⽤程序的⽇志记录中。它的强⼤之处在于提供了丰富的配置选项和灵活性,让开发⼈员能够完全掌控⽇志的输出格式和输出⽬标。

燃木刀法 1732

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

高性能日志脱敏组件:已支持 log4j2 和 logback 插件

日志脱敏是常见的安全需求。普通的基于工具类方法的方式,对代码的入侵性太强,编写起来又特别麻烦。提供基于注解的方式,并且内置了常见的脱敏方式,便于开发。同时支持 logback 和 log4j2 等常见的日志脱敏插件。

929

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Apache Commons 和 Guava 两个第三方的开源工具库的使用

通过 Apache Commons 和 Guava 两个第三方的开源工具库,可以减少循环、ifelse 的代码。写出的代码更有健壮性并且可以在新人面前装一波。Apache Commons 和 Guava 有许许多多的工具类,这里只列出了小小的部分,可以在官网例子中查看到各种用法。

初念初恋的博客 2936

java日志脱敏

在开发中,我们经常会处理一些敏感数据,比如:身份证号、手机号、银行卡、邮箱等等。为了保护用户的数据安全,我们需要对这些数据进行脱敏处理。JAVA提供了一些工具,可以让我们更加便捷的去处理。@Retention(RetentionPolicy.RUNTIME):运行时生效。@Target(ElementType.FIELD):可用在字段上。@JacksonAnnotationsInside:此注解可以点进去看一下是一个元注解,主要是用户打包其他注解一起使用。

qq_39239864的博客 3305

这个开源组件太强了,仅需三步完成 SpringBoot 日志脱敏

点击关注公众号,实用技术文章及时了解前言在我们书写代码的时候,会书写许多日志代码,但是有些敏感数据是需要进行安全脱敏处理的。对于日志脱敏的方式有很多,常见的有①使用conversionRule标签,继承MessageConverter②书写一个脱敏工具类,在打印日志的时候对特定特字段进行脱敏返回。两种方式各有优缺点:第一种方式需要修改代码,不符合开闭原则。第二种方式,需要...

Java知音 1113

logback - 自定义日志脱敏组件,一种不错的脱敏方案

击上方关注 “终端研发部”设为“星标”,和你一起掌握更多数据库知识前言在我们写代码的时候,会书写许多日志代码,但是有些敏感数据是需要进行安全脱敏处理的。对于日志脱敏的方式有很多,常见的有:①使用conversionRule标签,继承MessageConverter②书写一个脱敏工具类,在打印日志的时候对特定特字段进行脱敏返回。两种方式各有优缺点:第一种方式需要修改代码,不符合开闭原则。第二种方式,...

这个时代,作为程序员可能要学习小程序 1425

【数据脱敏】身份证,手机号,密码数据脱敏hutool

在项目开发过程中,例如:身份证号码,电话号码,地址,邮箱号码这类敏感信息,希望不被别人看到。这时如果时前端做了脱敏操作,人们可以通过F12调试看到请求返回信息,仍能看到。所以需要后台开发做数据脱敏操作

舒克日记的博客 3037

日志、java日志管理--logback、日志脱敏处理

引用参考: 【splunk】 --Splunk—云计算&大数据时代的超级日志分析和监控利器 [url]https://blog.youkuaiyun.com/enweitech/article/details/51330610[/url] 【log4j】 --Log4j日志在java项目中的使用(附工程源码) [url]https://blog.youkuaiyun.com/wushiwude/artic...

编程日常记录与总结 https://franciswmf.iteye.com 2875

Java实战:实现日志脱敏

本文将深入探讨Java中日志脱敏的实现原理与最佳实践,并通过具体示例指导开发者在实际项目中实现安全的日志输出。

oandy0的博客 2932

如何利用日志打印时把敏感信息脱敏

日志脱敏如何利用日志打印时把敏感信息脱敏 如何利用日志打印时把敏感信息脱敏 这里利用的是map类型,如果想用其他类型可以转成别的类型 public static Map excludeLogInfo(Map<String, String> maps){ try { Map<String, String> tempMaps = new HashMap<String, String>(); if (null =

qq_44856609的博客 2032

大厂也在用的6种数据脱敏方案,醍醐灌顶!

网易严选java一面 基本只问了Java相关的内容 近期做的项目有遇到什么困难吗,怎么解决的; HashMap详细介绍一下,怎么计算下标值的,时间复杂度是多少,最坏的时间复杂度是多少,在扩容的时候时间复杂度是O(n)的,你有什么方式去优化这个时间复杂度吗; ConcurrentHashMap的底层实现原理,怎么查找的的,如何保证查找时的线程安全性; 多线程介绍一下,如果一个方法被synchronized修饰了,你有什么方法可以去掉这个关键字,保证线程安全并且可以提升效率吗; 线程池介绍一

m0_57431076的博客 410
上一篇: 30K Star,最全面的PDF处理开源项目,你也可以拥有一个本地的PDF处理大全
下一篇: 万字长文解析谷歌日历的数据库是怎么设计的
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值