Java--业务场景：敏感词过滤代码实现（Fastjson配置全局序列化 @JSONField注解的serializeUsing属性）

业务场景

• 在系统数据库中，可能存在一些用户名称，昵称，评论中有些词汇，出于保护隐私或是不符合规范等原因，不能直接展示在前端页面上，这样的敏感词需要用 * 号代替。

  实现步骤

1. 将系统需要替换的敏感词保存在数据库中，在项目启动后，获取敏感词库，保存到Redis缓存中。
2. 编写敏感词序列化类 SensitiveWordSerializer 。
3. 在需要敏感词过滤的实体类对应的字段上加上注解 @JSONField(serializeUsing = SensitiveWordSerializer.class)。
4. 编写FastJson配置类 设置fastjson的全局序列化和反序列化的特性，使用FastJsonHttpMessageConverter替换spring boot默认实现(MappingJackson2HttpMessageConverter)作为HttpMessageConverters的首选实现。

   具体代码如下

   需要的依赖坐标

   <!--  fastjson 依赖  -->
   <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
   </dependency>
   <!--  redis 依赖  -->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>

   创建敏感词数据库

• 建库语句

  DROP TABLE IF EXISTS `sys_sensitive_word`;
  CREATE TABLE `sys_sensitive_word` (
  `id` varchar(100) NOT NULL COMMENT 'id',
  `name` varchar(100) DEFAULT NULL COMMENT '敏感词文本',
  `gmt_create` datetime DEFAULT NULL,
  `gmt_modified` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='敏感词表';

• 插入敏感词数据
  
• 编写相关的敏感词实体类，service，mapper等代码

  @Data
  @TableName("sys_sensitive_word")
  public class SensitiveWord {
     @TableId(value = "id", type = IdType.ASSIGN_ID)
     private Integer id;
  
     @TableField("name")
     private String name;
  
     @ApiModelProperty(value = "创建时间")
     @TableField(fill = FieldFill.INSERT)
     private Date gmtCreate;
  
     @ApiModelProperty(value = "更新时间")
     @TableField(fill = FieldFill.INSERT_UPDATE)
     private Date gmtModified;
    }

  编写敏感词初始化类

• 敏感词初始化类，负责读出数据库中的敏感词表，封装数据结构加载将redis中

  /**
   * 敏感词库初始化并放入redis中
   */
  @Slf4j
  @Component
  public class SensitiveWordInit {
  
      public static final String SENSITIVE_WORD_KEY = "SENSITIVE_WORD_KEY";
      /**
       * 敏感词库
       */
      private HashMap sensitiveWordMap;
      @Autowired
      private SensitiveWordService sensitiveWordService;
  
      private RedisTemplate<String, Object> redisTemplate;
  
      @Autowired
      public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
          this.redisTemplate = redisTemplate;
      }
      /**
       * 初始化敏感词
       *
       * @return
       */
      public Map<String,Object> initKeyWord() {
          try {
              List<SensitiveWord> sensitiveWords = sensitiveWordService.selectAll();
              // 从敏感词集合对象中取出敏感词并封装到Set集合中
              Set<String> keyWordSet = new HashSet();
              for (SensitiveWord s : sensitiveWords) {
                  keyWordSet.add(s.getName().trim());
              }
              // 将敏感词库加入到HashMap中
              addSensitiveWordToHashMap(keyWordSet);
              RedisOperation redisOperation = new RedisOperation(this.redisTemplate);
              redisOperation.set(SENSITIVE_WORD_KEY,sensitiveWordMap);
          } catch (Exception e) {
              log.error("初始化敏感词失败");
          }
          return sensitiveWordMap;
      }
  
      public Map getSensitiveWordFromRedis()
      {
          RedisOperation redisOperation = new RedisOperation(this.redisTemplate);
          Map map = redisOperation.get(SENSITIVE_WORD_KEY);
          return map;
      }
  
      /**
       * 封装敏感词库
       *
       * @param keyWordSet
       */
      private void addSensitiveWordToHashMap(Set<String> keyWordSet) {
          // 初始化HashMap对象并控制容器的大小
          sensitiveWordMap = new HashMap<String,Object>(keyWordSet.size());
          // 敏感词
          String key = null;
          // 用来按照相应的格式保存敏感词库数据
          Map nowMap = null;
          // 用来辅助构建敏感词库
          Map<String, String> newWorMap ;
          // 使用一个迭代器来循环敏感词集合
          Iterator<String> iterator = keyWordSet.iterator();
          while (iterator.hasNext()) {
              key = iterator.next();
              // 等于敏感词库，HashMap对象在内存中占用的是同一个地址，所以此nowMap对象的变化，sensitiveWordMap对象也会跟着改变
              nowMap = sensitiveWordMap;
              for (int i = MagicNum.ZERO; i < key.length(); i++) {
                  // 截取敏感词当中的字，在敏感词库中字为HashMap对象的Key键值
                  char keyChar = key.charAt(i);
                  // 判断这个字是否存在于敏感词库中
                  Object wordMap = nowMap.get(keyChar);
                  if (wordMap != null) {
                      nowMap = (Map) wordMap;
                  } else {
                      newWorMap = new HashMap();
                      newWorMap.put("isEnd", "0");
                      nowMap.put(keyChar, newWorMap);
                      nowMap = newWorMap;
                  // 如果该字是当前敏感词的最后一个字，则标识为结尾字
                  if (i == key.length() - MagicNum.ONE) {
                      nowMap.put("isEnd", "1");
                  }
              }
          }
      }}}

• 附上上面涉及到的RedisOperation工具类

     /**
      * 主要把一些常用的redis操作使用redisTemplate包装为redis命令名的方式
      */
     public final class RedisOperation {
    
         private static final String UNCHECKED = "unchecked";
         private RedisTemplate<String, Object> redisTemplate;
         public RedisOperation(RedisTemplate<String, Object> redisTemplate) {
             this.redisTemplate = redisTemplate;
         }
    
         /**
          * 返回与键 key 相关联的值
          */
         @SuppressWarnings(UNCHECKED)
         public <V> V get(String key) {
             return (V) redisTemplate.opsForValue().get(key);
         }
    
        /**
         * 删除key
         */
         public Boolean del(String key) {
             return redisTemplate.delete(key);
         }
    
        /**
         * 批量删除
         */
         public Long del(Collection<String> keys) {
             return redisTemplate.delete(keys);
         }
    
        /**
         * 返回给定的一个或多个字符串键的值
         */
    
         public List<Object> mget(String... keys) {
             return redisTemplate.opsForValue().multiGet(Arrays.asList(keys));
         }
    
        /**
         * 将value对象序列化后的字符串 关联到key<br/>
         * 如果key已经持有其他值，SET就覆写旧值，无视类型。
         */
         public void set(String key, Object value) {
             redisTemplate.opsForValue().set(key, value);
         }
    
        /**
         * 同时为多个键设置值<br/>
         * 如果某个给定键已经存在，那么MSET将使用新值去覆盖旧值
         */
         public void mset(Map<String, Object> map) {
             redisTemplate.opsForValue().multiSet(map);
         }
    
        /**
         * 同时为多个键设置值<br/>
         * 如果键key已经存在，则MSETNX命令不做任何动作
         */
         public void msetnx(Map<String, Object> map) {
             redisTemplate.opsForValue().multiSetIfAbsent(map);
         }
    
        /**
         * 将键key的值设置为value对象的序列化字符串，并将键key的生存时间设置为timeout<br/>
         * 如果键key已经存在，那么将覆盖已有的值
         */
         public void setex(String key, Object value, long timeout, TimeUnit unit) {
             redisTemplate.opsForValue().set(key, value, timeout, unit);
         }
    
        /**
         * 只在键key不存在的情况下， 将键key的值设置为value<br/>
         * 若键key已经存在，则SETNX命令不做任何动作
         */
         public void setnx(String key, Object value) {
             redisTemplate.opsForValue().setIfAbsent(key, value);
         }
    
        /**
        * 只在键key不存在的情况下，将键key的值设置为value，且同时设置过期时间<br/>
        * 若键key已经存在，则SETNX命令不做任何动作。
          */
          public void setnx(String key, Object value, long timeout, TimeUnit unit) {
             redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
          }
    
        /**
        * 为键key储存的数字值加上一
          */
          public Long incr(String key) {
             return incr(key, 1);
          }
    
        /**
        * 为键key储存的数字值加上增量increment
          */
          public Long incr(String key, long increment) {
             return redisTemplate.opsForValue().increment(key, increment);
          }
    
        /**
        * 将键key储存的整数值减去减量decrement
          */
          public Long decr(String key, long decrement) {
             return redisTemplate.opsForValue().decrement(key, decrement);
          }
    
        /**
        * 为键key储存的数字减一
          */
          public Long decr(String key) {
             return decr(key, 1);
          }
    
        /**
        * HGET命令在默认情况下返回给定域的值<br/>
        * 如果给定域不存在于哈希表中，又或者给定的哈希表并不存在，那么命令返回 nil
          */
          @SuppressWarnings(UNCHECKED)
          public <V> V hget(String key, String field) {
             return (V) redisTemplate.opsForHash().get(key, field);
          }
    
        /**
        * 如果给定的域不存在于哈希表，那么返回一个nil值<br/>
        * 因为不存在的key被当作一个空哈希表来处理，所以对一个不存在的key进行HMGET操作将返回一个只带有 nil 值的表
          */
          public List<Object> hmget(String key, String... fields) {
             return redisTemplate.opsForHash().multiGet(key, new ArrayList<>(Arrays.asList(fields)));
          }
    
        /**
        * 返回哈希表 key 中，所有的域和值
          */
          public Map<Object, Object> hgetAll(String key) {
             return redisTemplate.opsForHash().entries(key);
          }
    
        /**
        * 如果给定的哈希表并不存在，那么一个新的哈希表将被创建并执行HSET操作<br/>
        * 如果域field已经存在于哈希表中， 那么它的旧值将被新值 value 覆盖。
          */
          public <V> void hset(String key, String field, V value) {
             redisTemplate.opsForHash().put(key, field, value);
          }
    
        /**
        * 同时将多个field-value(域-值)对设置到哈希表key中<br/>
        * 此命令会覆盖哈希表中已存在的域<br/>
        * 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。
          */
          public void hmset(String key, Map<String, ?> data) {
             redisTemplate.opsForHash().putAll(key, data);
          }
    
        /**
        * 检查给定field是否存在于哈希表hash当中
          */
          public Boolean hexists(String key, String field) {
             return redisTemplate.opsForHash().hasKey(key, field);
          }
    
        /**
        * 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略
          */
          public Long hdel(String key, Object... fields) {
             return redisTemplate.opsForHash().delete(key, fields);
          }
    
        /**
        * 将一个或多个值 value 插入到列表 key 的表尾(最右边)<br/>
        * 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作<br />
        * 当 key 存在但不是列表类型时，返回一个错误
          */
          public Long rpush(String key, Object... values) {
             return redisTemplate.opsForList().rightPushAll(key, values);
          }
    
        /**
         * 将一个或多个值 value 插入到列表 key 的表头<br />
         * 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作<br />
         * 当 key 存在但不是列表类型时，返回一个错误
         */
          public Long lpush(String key, Object... values) {
             return redisTemplate.opsForList().leftPushAll(key, values);
          }
    
        /**
         * 移除并返回列表 key 的头元素
          */
          @SuppressWarnings(UNCHECKED)
          public <V> V lpop(String key) {
             return (V) redisTemplate.opsForList().leftPop(key);
          }
    
        /**
         * 移除并返回列表 key 的尾元素
          */
          @SuppressWarnings(UNCHECKED)
          public <V> V rpop(String key) {
             return (V) redisTemplate.opsForList().rightPop(key);
          }
    
        /**
         * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
          */
          @SuppressWarnings(UNCHECKED)
          public <V> Long sadd(String key, V... members) {
             return redisTemplate.opsForSet().add(key, members);
          }
    
        /**
        * 判断 member 元素是否集合 key 的成员
          */
          public Boolean sismember(String key, Object member) {
             return redisTemplate.opsForSet().isMember(key, member);
          }
    
        /**
        * 返回集合中的一个随机元素
          */
          @SuppressWarnings(UNCHECKED)
          public <V> V srandmember(String key) {
             return (V) redisTemplate.opsForSet().randomMember(key);
          }
    
        /**
        * 返回集合中的随机元素。<p/>
        * 如果 count 为正数，且小于集合基数，那么命令返回一个包含 count 个元素的数组，数组中的元素各不相同。如果 count 大于等于集合基数，那么返回整个集合。<p/>
        * 如果 count 为负数，那么命令返回一个数组，数组中的元素可能会重复出现多次，而数组的长度为 count 的绝对值。
          */
    
        public List<Object> srandmembers(String key, long count) {
           return redisTemplate.opsForSet().randomMembers(key, count);
        }
    
        /**
        * 返回集合 key 中的所有成员。<br />
        * 不存在的 key 被视为空集合
          */
          public Set<Object> smembers(String key) {
             return redisTemplate.opsForSet().members(key);
          }
    
        /**
        * 返回集合key的基数(集合中元素的数量)
          */
          public Long scard(String key) {
             return redisTemplate.opsForSet().size(key);
          }
    
        /**
        * 移除集合key中的一个或多个member元素，不存在的member元素会被忽略。<br />
        * 当key不是集合类型，返回一个错误
          */
          public Long srem(String key, Object... values) {
             return redisTemplate.opsForSet().remove(key, values);
          }
    
        /**
        * 将一个元素及其score值加入到有序集key当中
          */
          public <V> Boolean zadd(String key, V value, double score) {
             return redisTemplate.opsForZSet().add(key, value, score);
          }
    
        /**
         * 返回有序集key中，成员member的score值
          */
          public Double zscore(String key, Object member) {
             return redisTemplate.opsForZSet().score(key, member);
          }
    
        /**
         * 为有序集key的成员member的score值加上增量increment
          */
          public Double zincrby(String key, Object member, double increment) {
              return redisTemplate.opsForZSet().incrementScore(key, member, increment);
          }
    
        /**
         * 返回有序集key中，指定区间内的成员
          */
          public Set<Object> zrange(String key, long start, long end) {
             return redisTemplate.opsForZSet().range(key, start, end);
          }
    
        /**
         * 返回有序集key中，指定区间内的成员。且带有score
          */
          public Set<ZSetOperations.TypedTuple<Object>> zrangewithscore(String key, long start, long end) {
             return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
          }
    
        /**
         * 返回有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。<br />
         * 有序集成员按score值递增(从小到大)次序排列
         */
          public Set<Object> zrangebyscore(String key, double min, double max) {
             return redisTemplate.opsForZSet().rangeByScore(key, min, max);
          }
    
        /**
         * 返回有序集key中，指定区间内的成员<br />
         * 成员的位置按score值递减(从大到小)来排列
         */
          public Set<Object> zrevrange(String key, long start, long end) {
             return redisTemplate.opsForZSet().reverseRange(key, start, end);
          }
    
        /**
         * 返回有序集key中，指定区间内的成员。且带有score
         */
          public Set<ZSetOperations.TypedTuple<Object>> zrevrangewithscores(String key, long start, long end) {
             return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
          }
    
        /**
         * 返回有序集key中，所有score值介于min和max之间(包括等于min或max)的成员。<br />
         * 有序集成员按score值递增(从大到小)次序排列
         */
          public Set<Object> zrevrangebyscore(String key, double min, double max) {
             return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
          }
    
        /**
         * 移除有序集key中，所有score值介于min和max之间(包括等于min或max)的成员
          */
          public Long zremrangebyscore(String key, double min, double max) {
             return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
          }
    
        /**
         * 移除有序集key中，指定排名(rank)区间内的所有成员。
          */
          public Long zremrangebyrank(String key, long start, long end) {
             return redisTemplate.opsForZSet().removeRange(key, start, end);
          }
    
        /**
         * 移除有序集key中的一个或多个成员，不存在的成员将被忽略
          */
          public Long zrem(String key, Object... values) {
             return redisTemplate.opsForZSet().remove(key, values);
          }
    
        /**
         * 获取元素value在有序集合中的位置排名
         */
          public Long zrank(String key, Object value) {
             return redisTemplate.opsForZSet().reverseRank(key, value);
          }
        /**
         * 当key存在且是有序集类型时，返回有序集的基数。当key不存在时，返回0
         */
          public Long zcard(String key) {
             return redisTemplate.opsForZSet().size(key);
          }
    
        /**
         * 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员的数量
         */
          public Long zcount(String key, double min, double max) {
             return redisTemplate.opsForZSet().count(key, min, max);
          }
    
    
        /**
         * 设置过期时间
         *
         * @param timeout 过期时间，单位毫秒
         */
        public Boolean expire(String key, long timeout) {
            return redisTemplate.expire(key, timeout, TimeUnit.MILLISECONDS);
        }
    
        /**
         * 获取key的存活时长，单位毫秒
         */
        public Long ttl(String key) {
            return redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
        }
    
        /**
         * 判断key是否存在
         */
        public Boolean exist(String key) {
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 获取底层redisTemplate
         */
        public RedisTemplate<String, Object> getRedisTemplate() {
            return redisTemplate;
        }
  }

  编写敏感词序列化类

• 敏感词序列化类

   /**
    * 敏感词过滤工具类
    * 使用方法    @JSONField(serializeUsing = SensitiveWordSerializer.class)
    */
    @Component
    public class SensitiveWordSerializer implements ObjectSerializer {
    
    /**
    * 敏感词库
      */
      private static Map<String,Object> sensitiveWordMap = null;
    
    private static SensitiveWordInit wordInit;
    
    @Autowired
    public void setRedisTemplate(SensitiveWordInit sensitiveWordInit) {
    SensitiveWordSerializer.wordInit = sensitiveWordInit;
    }
    @PostConstruct
    public void initSensitiveWord() {
        sensitiveWordMap = SensitiveWordSerializer.wordInit.initKeyWord();
    }
    
    /**
     * 获取敏感词内容
     *
     * @param txt
     * @param matchType
     * @return 敏感词内容
     */
    public  Set<String> getSensitiveWord(String txt, int matchType) {
        Set<String> sensitiveWordList = new HashSet();
        for (int i = MagicNum.ZERO; i < txt.length(); i++) {
            int length = checkSensitiveWord(txt, i, matchType);
            if (length > MagicNum.ZERO) {
                // 将检测出的敏感词保存到集合中
                sensitiveWordList.add(txt.substring(i, i + length));
                i = i + length - MagicNum.ONE;
            }
        }
        return sensitiveWordList;
    }
    /**
     * 替换敏感词
     *
     * @param txt
     * @param matchType
     * @param replaceChar
     * @return
     */
    public  String replaceSensitiveWord(String txt, int matchType, String replaceChar) {
        sensitiveWordMap = wordInit.getSensitiveWordFromRedis();
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt, matchType);
        Iterator<String> iterator = set.iterator();
        String word ;
        String replaceString ;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceString = getReplaceChars(replaceChar, word.length());
            resultTxt = resultTxt.replaceAll(word, replaceString);
        }
        return resultTxt;
    }
    
    /**
     * 替换敏感词内容
     *
     * @param replaceChar
     * @param length
     * @return
     */
    private  String getReplaceChars(String replaceChar, int length) {
        StringBuilder resultReplace = new StringBuilder(replaceChar);
        for (int i = MagicNum.ONE; i < length; i++) {
            resultReplace.append(replaceChar);
        }
    
        return resultReplace.toString();
    }
    
    /**
     * 检查敏感词数量
     *
     * @param txt
     * @param beginIndex
     * @param matchType
     * @return
     */
    public  int checkSensitiveWord(String txt, int beginIndex, int matchType) {
        boolean flag = false;
        // 记录敏感词数量
        int matchFlag = MagicNum.ZERO;
        String word ;
        Map<String,Object> nowMap = sensitiveWordMap;
        for (int i = beginIndex; i < txt.length(); i++) {
            word = String.valueOf(txt.charAt(i));
            // 判断该字是否存在于敏感词库中
            nowMap = (Map<String,Object>) nowMap.get(word);
            if (nowMap != null) {
                matchFlag++;
                // 判断是否是敏感词的结尾字，如果是结尾字则判断是否继续检测
                if ("1".equals(nowMap.get("isEnd"))) {
                    flag = true;
                    // 判断过滤类型，如果是小过滤则跳出循环，否则继续循环
                }
            } else {
                break;
            }
        }
        if (!flag) {
            matchFlag = 0;
        }
        return matchFlag;
    }
    
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        String value = replaceSensitiveWord((String) object, MagicNum.TWO, "*");
        serializer.write(value);
    }
  }

  在需要敏感词过滤的实体上加上注解

• 加上注解 @JSONField(serializeUsing = SensitiveWordSerializer.class)

   @Data
   @EqualsAndHashCode(callSuper = false)
   @Accessors(chain = true)
   @TableName("sys_user")
   @ApiModel(description = "用户实体类")
   public class UserDTO  {
    
       @TableId(value = "id", type = IdType.ASSIGN_ID)
       private String id;
       
       @TableField(value = "username")
       // username需要敏感词过滤
       @JSONField(serializeUsing = SensitiveWordSerializer.class)
       private String username;
       
       //......
  }

  Fastjson配置类

• 设置fastjson的全局序列化和反序列化的特性，使用FastJsonHttpMessageConverter替换spring boot默认实现(MappingJackson2HttpMessageConverter)作为HttpMessageConverters首选实现

  /**
   * Fastjson全局序列化配置
   *
   */
    @Configuration
    @Slf4j
    public class FastJsonConfig {
        private static final Map<SerializerFeature, String> SERIALIZER_FEATURES = new EnumMap<>(SerializerFeature.class);
        private static final Map<Feature, String> PARSER_FEATURES = new EnumMap<>(Feature.class);
  
        static {
            SERIALIZER_FEATURES.put(SerializerFeature.WriteMapNullValue, "WriteMapNullValue:输出值为null的字段");
            SERIALIZER_FEATURES.put(SerializerFeature.WriteDateUseDateFormat, "WriteDateUseDateFormat:根据全局日期格式格式化");
            SERIALIZER_FEATURES.put(SerializerFeature.WriteBigDecimalAsPlain, "WriteBigDecimalAsPlain:大数序列化为文本");
            SERIALIZER_FEATURES.put(SerializerFeature.DisableCircularReferenceDetect, "DisableCircularReferenceDetect:关闭循环引用发现");
            PARSER_FEATURES.put(Feature.AllowISO8601DateFormat, "AllowISO8601DateFormat:支持ISO8601格式的日期");
            PARSER_FEATURES.put(Feature.DisableCircularReferenceDetect, "DisableCircularReferenceDetect:关闭循环引用发现");
  
            log.debug("全局启用Fastjson下列序列化选项");
            for (Map.Entry<SerializerFeature, String> entry : SERIALIZER_FEATURES.entrySet()) {
                JSON.DEFAULT_GENERATE_FEATURE |= entry.getKey().getMask();
                log.debug(entry.getValue());
            }
            log.debug("全局启用Fastjson下列反序列化选项");
            for (Map.Entry<Feature, String> entry : PARSER_FEATURES.entrySet()) {
                JSON.DEFAULT_PARSER_FEATURE |= entry.getKey().getMask();
                log.debug(entry.getValue());
            }
       }
  
    @Bean
    public HttpMessageConverters fastJsonHttpMessageConverters() {
          log.debug("启用FastJsonHttpMessageConverter，将其添加至同类HttpMessageConverter之前");
           return new HttpMessageConverters(new FastJsonHttpMessageConverter());
       }
   }

  执行效果

• 数据库中有一条用户数据，用户昵称为”笨蛋芝麻馅笨蛋“，”笨蛋“是我们的敏感词，启动项目，调用分页查询的接口，返回的用户昵称敏感词部分被*号代替：
• 数据库情况
  
• 调用接口查找用户信息结果,发现用户昵称中的敏感词成功被*号所代替。