自定义@JsonUnwrapped注解实现任意命名风格 ​

public class Test {
    @FieldDefaults(level = AccessLevel.PRIVATE)
    @Data
    static class Bean {
        @JsonUnwrapped




    
(prefix = "user")
        Name name;
        int age;
    @Data
    @FieldDefaults(level = AccessLevel.PRIVATE)
    @Accessors(chain = true)
    static class Name {
        String firstName;
        String lastName;
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        Bean bean = new Bean();
        bean.setName(new Name().setFirstName("张").setLastName("三"));
        bean.setAge(1);
        String json = objectMapper.writeValueAsString(bean);
        // 序列化输出
        System.out.println(json);
        // 反序列化输出
        System.out.println(objectMapper.readValue(json, Bean.class));
}

// com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector
public class JacksonAnnotationIntrospector extends AnnotationIntrospector implements java.io.Serializable{
    @Override
    public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member)
        // 找一下存不存在JsonUnwrapped注解
        JsonUnwrapped ann = _findAnnotation(member, JsonUnwrapped.class);
        // if not enabled, just means annotation is not enabled; not necessarily
        // that unwrapping should not be done (relevant when using chained introspectors)
        // 注解不存在或者未启用 返回null 即不做unwrap
        if (ann == null || !ann.enabled()) {
            return null;
        String prefix = ann.prefix();
        String suffix = ann.suffix();
        // 拿到前缀和后缀 构造名称转换器
        return NameTransformer.simpleTransformer(prefix, suffix);
// com.fasterxml.jackson.databind.util.NameTransformer
public abstract class NameTransformer {
    public static NameTransformer 




    
simpleTransformer(final String prefix, final String suffix) {
        // 前缀、后缀是否存在
        boolean hasPrefix = (prefix != null) && !prefix.isEmpty();
        boolean hasSuffix = (suffix != null) && !suffix.isEmpty();
        // 根据前缀、后缀是否存在构造不同的名称转换器
        // 序列化的时候会调用transform生成展开的属性名称
        // 反序列化的时候调用reverse方法将展开的属性名称还原为原属性名称
        if (hasPrefix) {
            if (hasSuffix) {
                return new NameTransformer() {
                    @Override
                    public String transform(String name) {
                        // 这里可以看到 前缀、属性名、后缀是直接拼起来的 并未做命名策略处理
                        return prefix + name + suffix;
                    @Override
                    public String reverse(String transformed) {
                        if (transformed.startsWith(prefix)) {
                            String str = transformed.substring(prefix.length());
                            if (str.endsWith(suffix)) {
                                return str.substring(0, str.length() - suffix.length());
                        return null;
                    @Override
                    public String toString() {
                        return "[PreAndSuffixTransformer('" + prefix + "','" + suffix + "')]";
            return new NameTransformer() {
                @Override
                public String transform(String name) {
                    return prefix + name;
                @Override
                public String reverse(String transformed) {
                    if (transformed.startsWith(prefix)) {
                        return transformed.substring(prefix.length());
                    return null;
                @Override
                public String toString() {
                    return "[PrefixTransformer('" + prefix + "')]";
        if (hasSuffix) {
            return new NameTransformer() {
                @Override
                public String transform(String name) {
                    return name + suffix;
                @Override
                public String reverse(String transformed) {
                    if (transformed.endsWith(suffix)) {
                        return transformed.substring(0, transformed.length() - suffix.length());
                    return null;
                @Override
                public String toString() {
                    return "[SuffixTransformer('" + suffix + "')]";
        return NOP;
}

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
public @interface EnhancedJsonUnwrapped {
     * 展开前缀
     * @return 前缀
    String prefix() default "";
     * 展开属性后缀
     * @return 后缀
    String suffix() default "";




    

     * 命名策略 默认为驼峰
     * @return {@link Class}
    Class<? extends PropertyNamingStrategies.NamingBase> strategy() default PropertyNamingStrategies.LowerCamelCaseStrategy.class;
}

@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class EnhancedUnwrappedNameTransformer extends NameTransformer {
    String prefix;
    String suffix;
     * 命名策略
    PropertyNamingStrategies.NamingBase strategy;
    public EnhancedUnwrappedNameTransformer(String prefix, String suffix,
                                            Class<? extends PropertyNamingStrategies.NamingBase> klass) {
        this.prefix = prefix;
        this.suffix = suffix;
        this.strategy = ClassUtil.createInstance(klass, true);
    @Override
    public String transform(String name) {
        StringBuilder sb = new StringBuilder(name);
        // 存在前缀
        if (StringUtils.isNotEmpty(this.prefix)) {
            // 只要存在前缀 则将当前name第一个字母变大写 保证前缀+name为小写驼峰
            sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
            // 开始位置插入前缀
            sb.insert(0, prefix);
        // 存在后缀 
        if (StringUtils.isNotEmpty(suffix)) {
            // 将后缀转为小写驼峰
            sb.append(Character.toUpperCase(suffix.charAt(0))).append(suffix.substring(1));
        return this.strategy.translate(sb.toString());
    @Override
    public String reverse(String transformed) {
        // jackson reverse方法并没有使用 序列化的时候 直接使用transform方法
        // 反序列化的时候 会先把属性名按照transform结果先rename一次
        // 参考 https://github.com/FasterXML/jackson-databind/blob/2.16/src/main/java/com/fasterxml/jackson/databind/deser/impl/UnwrappedPropertyHandler.java#L33-L51
        // 原样返回
        return transformed;
}

public class EnhancedJacksonAnnotationIntrospector extends JacksonAnnotationIntrospector {
    @Override
    public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member) {
        EnhancedJsonUnwrapped annotation = super._findAnnotation(member, EnhancedJsonUnwrapped.class);
        // 没有EnhancedJsonUnwrapped注解 按照JsonUnwrapped注解规则处理
        if (Objects.isNull(annotation)) {
            return super.findUnwrappingNameTransformer(member);
        // 返回增强的unwrap命名转换
        return new EnhancedUnwrappedNameTransformer(annotation.prefix(), annotation.suffix(), annotation.strategy());
}

// 设置注解内省为我们自定义的 最好在全局实例上设置
objectMapper.setAnnotationIntrospector(new EnhancedJacksonAnnotationIntrospector());

public class Test {
    @FieldDefaults(level = AccessLevel.PRIVATE)
    @Data
    static class Bean {
        // 默认命名风格就是小写驼峰
        @EnhancedJsonUnwrapped(prefix = "user")
        Name name;
        int age;
    @Data
    @FieldDefaults(level = AccessLevel.PRIVATE)
    @Accessors(chain = true)
    static class Name {
        String firstName;
        String lastName;
    public static void main(String[] args) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setAnnotationIntrospector(new EnhancedJacksonAnnotationIntrospector());
        Bean bean = new Bean();
        bean.setName(new Name().setFirstName("张").setLastName("三"));
        bean.setAge(1);
        String json = objectMapper.writeValueAsString(bean);
        // 序列化输出
        System.out.println(json);
        // 反序列化输出
        System.out.println(objectMapper.readValue(json, Bean.class));
}

@FieldDefaults(level = AccessLevel.PRIVATE)
@Data
static class Bean {
    // 指定unwrap命名风格
    @EnhancedJsonUnwrapped(prefix = "user", strategy = PropertyNamingStrategies.LowerDotCaseStrategy.class)
    Name name;
    int age;