怎样制作图片网站,什么推广平台好,怎么看小企业网站建设,做一个网站做少多少钱Jackson 是一个流行的 Java JSON 处理库#xff0c;它提供了将 Java 对象与 JSON 数据相互转换的功能。Jackson 的主要功能包括#xff1a;
序列化#xff1a;将 Java 对象转换为 JSON 字符串。反序列化#xff1a;将 JSON 字符串转换为 Java 对象。
Jackson 提供了以下几…Jackson 是一个流行的 Java JSON 处理库它提供了将 Java 对象与 JSON 数据相互转换的功能。Jackson 的主要功能包括
序列化将 Java 对象转换为 JSON 字符串。反序列化将 JSON 字符串转换为 Java 对象。
Jackson 提供了以下几个核心组件
jackson-core核心库提供 JSON 的解析和生成。jackson-databind数据绑定库负责将 JSON 数据绑定到 Java 对象。jackson-annotations包含用于 JSON 处理的注解如 JsonProperty、JsonIgnore 等。
基本使用
在使用 Jackson 之前你需要在 pom.xml 中添加 Jackson 的依赖
dependencies!-- Jackson 核心库 --dependencygroupIdcom.fasterxml.jackson.core/groupIdartifactIdjackson-core/artifactIdversion2.13.3/version/dependency!-- Jackson 数据绑定库 --dependencygroupIdcom.fasterxml.jackson.core/groupIdartifactIdjackson-databind/artifactIdversion2.13.3/version/dependency!-- Jackson 注解库 --dependencygroupIdcom.fasterxml.jackson.core/groupIdartifactIdjackson-annotations/artifactIdversion2.13.3/version/dependency
/dependencies序列化示例
import com.fasterxml.jackson.databind.ObjectMapper;public class Example {public static void main(String[] args) throws Exception {ObjectMapper objectMapper new ObjectMapper();// 创建一个示例对象User user new User();user.setName(John);user.setAge(30);// 将对象转换为 JSON 字符串String json objectMapper.writeValueAsString(user);System.out.println(json); // 输出: {name:John,age:30}}
}class User {private String name;private int age;// Getter 和 Setter
}反序列化示例
import com.fasterxml.jackson.databind.ObjectMapper;public class Example {public static void main(String[] args) throws Exception {ObjectMapper objectMapper new ObjectMapper();// JSON 字符串String json {\name\:\John\,\age\:30};// 将 JSON 字符串转换为 Java 对象User user objectMapper.readValue(json, User.class);System.out.println(user.getName()); // 输出: John}
}class User {private String name;private int age;// Getter 和 Setter
}实现自定义注解
如果你需要自定义序列化或反序列化逻辑你可以创建自定义注解和序列化器。以下是详细步骤
1. 定义自定义注解
创建一个自定义注解用于标记需要特殊处理的字段。例如我们可以创建一个 Sensitive 注解用于标记需要脱敏处理的字段。
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;Retention(RetentionPolicy.RUNTIME)
Target(ElementType.FIELD)
JsonSerialize(using SensitiveJsonSerializer.class) // 指定自定义序列化器
public interface Sensitive {SensitiveStrategy strategy(); // 指定脱敏策略
}理解 SensitiveJsonSerializer 类的代码时可以将其分为几个部分来讲解。这个类实现了 JsonSerializer用于自定义序列化过程特别是处理带有 Sensitive 注解的字段。下面详细解释代码的每个部分
1. JsonSerializerString
SensitiveJsonSerializer 类继承自 Jackson 的 JsonSerializerString。这是一个泛型类用于自定义如何将 String 类型的对象序列化为 JSON。
2. serialize 方法
serialize 方法是 JsonSerializer 类的抽象方法必须实现。它的作用是定义如何将 Java 对象在这个例子中是 String转换为 JSON 字符串。 2. 定义脱敏策略
创建一个枚举 SensitiveStrategy定义不同的脱敏策略。
import java.util.function.Function;public enum SensitiveStrategy {USERNAME(s - s.replaceAll((\\S)\\S(\\S*), $1*$2)),ID_CARD(s - s.replaceAll((\\d{4})\\d{10}(\\w{4}), $1****$2)),PHONE(s - s.replaceAll((\\d{3})\\d{4}(\\d{4}), $1****$2)),ADDRESS(s - s.replaceAll((\\S{3})\\S{2}(\\S*)\\S{2}, $1****$2****));private final FunctionString, String desensitizer;SensitiveStrategy(FunctionString, String desensitizer) {this.desensitizer desensitizer;}public FunctionString, String desensitizer() {return desensitizer;}
}理解 strategy.desensitizer().apply(value) 是如何工作的我们需要详细了解 FunctionString, String 这个接口以及 SensitiveStrategy 枚举类是如何定义和使用这个接口的。
Function 接口
Function 是 Java 8 引入的一个函数式接口它位于 java.util.function 包中。这个接口定义了一个方法 apply用于将一个输入值转换成一个输出值
FunctionalInterface
public interface FunctionT, R {R apply(T t);
}T 是输入类型R 是输出类型apply 方法接受一个 T 类型的参数并返回一个 R 类型的结果
SensitiveStrategy 枚举
在 SensitiveStrategy 枚举中每个枚举实例都被赋予了一个 FunctionString, String 类型的对象。这个对象用于定义字符串脱敏的具体实现。
public enum SensitiveStrategy {USERNAME(s - s.replaceAll((\\S)\\S(\\S*), $1*$2)),ID_CARD(s - s.replaceAll((\\d{4})\\d{10}(\\w{4}), $1****$2)),PHONE(s - s.replaceAll((\\d{3})\\d{4}(\\d{4}), $1****$2)),ADDRESS(s - s.replaceAll((\\S{3})\\S{2}(\\S*)\\S{2}, $1****$2****));private final FunctionString, String desensitizer;SensitiveStrategy(FunctionString, String desensitizer) {this.desensitizer desensitizer;}public FunctionString, String desensitizer() {return desensitizer;}
}每个枚举实例都使用一个 FunctionString, String 对象来定义如何进行字符串替换
USERNAME 实例的 Function 对象s - s.replaceAll((\\S)\\S(\\S*), $1*$2) 这个函数会将用户名的第二个字符替换为 *ID_CARD 实例的 Function 对象s - s.replaceAll((\\d{4})\\d{10}(\\w{4}), $1****$2) 这个函数会将身份证号码的中间部分替换为 ****其他实例类似。
这些 Function 对象都实现了 apply 方法用于对输入的字符串进行处理。
调用 desensitizer.apply(value)
当你调用 strategy.desensitizer().apply(value) 时实际上执行了以下步骤
strategy.desensitizer() 返回 FunctionString, String 类型的 desensitizer 对象。desensitizer.apply(value) 调用 Function 对象的 apply 方法对输入的 value 进行处理并返回处理后的结果。 总结
在序列化过程中调用 strategy.desensitizer().apply(value) 对字符串进行脱敏处理。将处理后的字符串写入 JsonGenerator 以生成最终的 JSON 输出。
3. 实现自定义序列化器
创建一个自定义的 JsonSerializer 类用于处理带有 Sensitive 注解的字段。
public class SensitiveJsonSerializer extends JsonSerializerString implements ContextualSerializer {private SensitiveStrategy strategy;Overridepublic void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {gen.writeString(strategy.desensitizer().apply(value));}/*** 获取属性上的注解属性*/Overridepublic JsonSerializer? createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {Sensitive annotation property.getAnnotation(Sensitive.class);System.out.println(annotation);if (Objects.nonNull(annotation) Objects.equals(String.class, property.getType().getRawClass())) {this.strategy annotation.strategy();return this;}return prov.findValueSerializer(property.getType(), property);}
}
这段代码是一个自定义的 Jackson 序列化器它实现了 JsonSerializerString 和 ContextualSerializer 接口用于在序列化过程中对特定类型的字段进行脱敏处理。让我们逐行解释代码的含义和作用。
SensitiveJsonSerializer 继承了 JsonSerializerString表示这是一个自定义的序列化器专门用于序列化 String 类型的字段。它还实现了 ContextualSerializer 接口这使得序列化器能够访问字段的上下文如注解并根据上下文进行调整。strategy 是一个 SensitiveStrategy 类型的字段用于存储从注解中提取的脱敏策略。 serialize 方法
serialize 方法用于序列化对象。value 是需要序列化的字段值。gen 是 JsonGenerator用于将序列化的内容写入输出。serializers 是 SerializerProvider提供了其他序列化器。在方法内部使用脱敏策略 (strategy.desensitizer()) 对字段值 (value) 进行脱敏处理并将处理后的值写入输出 (gen.writeString)。
createContextual 方法
createContextual 方法用于在序列化过程中根据上下文即字段的注解配置序列化器。prov 是 SerializerProvider提供了其他序列化器。property 是 BeanProperty表示当前正在序列化的字段。
方法内部首先获取字段上的 Sensitive 注解如果有
Sensitive annotation property.getAnnotation(Sensitive.class);然后检查注解是否存在且字段类型是否为 String。
if (Objects.nonNull(annotation) Objects.equals(String.class, property.getType().getRawClass())) {this.strategy annotation.strategy();return this;
}如果注解存在并且字段类型是 String则从注解中提取脱敏策略 (annotation.strategy()) 并赋值给 this.strategy。返回当前的序列化器 (return this;)。如果没有注解或字段类型不是 String则使用默认的序列化器 (prov.findValueSerializer(property.getType(), property))。
4. 使用自定义注解
在你的类中使用 Sensitive 注解来标记需要脱敏处理的字段。
Data
AllArgsConstructor
NoArgsConstructor
public class Person {/*** 真实姓名*/Sensitive(strategy SensitiveStrategy.USERNAME)private String realName;/*** 地址*/Sensitive(strategy SensitiveStrategy.ADDRESS)private String address;/*** 电话号码*/Sensitive(strategy SensitiveStrategy.PHONE)private String phoneNumber;/*** 身份证号码*/Sensitive(strategy SensitiveStrategy.ID_CARD)private String idCard;}
5.测试
RestController
public class TestController {GetMapping(/test)public Person test(){Person user new Person();user.setRealName(xxxx);user.setPhoneNumber( 15242554546);user.setAddress(天津市河西区....);user.setIdCard(111111111111111);return user;}
}
