多结构JSON（仅event字段通用）转Java对象的优雅实现方案

嘿，这个场景我太熟了！手动判断event字段不仅容易出错，还会让代码越来越臃肿——推荐你用Jackson的多态类型处理来解决，完美适配你的需求，代码还特别整洁。

1. 定义基类，配置多态规则 #

首先创建一个抽象基类，包含所有JSON都有的event字段，并用Jackson注解指定多态解析规则：

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.EXISTING_PROPERTY,
    property = "event"
)
@JsonSubTypes({
    @JsonSubTypes.Type(value = ConversationStartedEvent.class, name = "conversation_started"),
    @JsonSubTypes.Type(value = MessageEvent.class, name = "message")
    // 后续新增event类型，直接在这里加一行配置即可
})
public abstract class BaseEvent {
    private String event;

    public String getEvent() {
        return event;
    }

    public void setEvent(String event) {
        this.event = event;
    }
}

注解说明：

• @JsonTypeInfo：告诉Jackson用event字段的值来区分不同的子类
• @JsonSubTypes：建立event值和对应Java类的映射关系

2. 定义各个具体事件类 #

针对每个event类型，创建继承自基类的具体类，只需要包含该事件特有的字段：

示例1：处理conversation_started事件的类 #

public class ConversationStartedEvent extends BaseEvent {
    private String context;
    private User user;
    private boolean subscribed;

    // getter、setter、构造器按需生成
    public static class User {
        private String id;
        private String name;
        private String avatar;
        private String country;
        private String language;
        private int api_version;

        // getter、setter按需生成
    }
}

示例2：处理message事件的类 #

public class MessageEvent extends BaseEvent {
    private Message message;

    // getter、setter、构造器按需生成
    public static class Message {
        private String type;
        private String text;
        private Location location;

        // getter、setter按需生成
        public static class Location {
            private double lat;
            private double lon;

            // getter、setter按需生成
        }
    }
}

3. 反序列化JSON到对应Java对象 #

用Jackson的ObjectMapper直接反序列化，它会自动根据event字段的值匹配到对应的子类：

import com.fasterxml.jackson.databind.ObjectMapper;

public class EventProcessor {
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) throws Exception {
        // 处理conversation_started类型的JSON
        String conversationJson = "{ \"event\":\"conversation_started\", \"context\":\"context information\", \"user\":{ \"id\":\"01234567890A=\", \"name\":\"John McClane\", \"avatar\":\"http://avatar.example.com\", \"country\":\"UK\", \"language\":\"en\", \"api_version\":1 }, \"subscribed\":false }";
        
        BaseEvent convEvent = objectMapper.readValue(conversationJson, BaseEvent.class);
        if (convEvent instanceof ConversationStartedEvent) {
            ConversationStartedEvent event = (ConversationStartedEvent) convEvent;
            System.out.println("触发对话开始事件，用户：" + event.getUser().getName());
        }

        // 处理message类型的JSON
        String messageJson = "{ \"event\":\"message\", \"message\":{ \"type\":\"text\", \"text\":\"a message to the service\", \"location\":{ \"lat\":12.34, \"lon\":12.34 } } }";
        
        BaseEvent msgEvent = objectMapper.readValue(messageJson, BaseEvent.class);
        if (msgEvent instanceof MessageEvent) {
            MessageEvent event = (MessageEvent) msgEvent;
            System.out.println("收到消息：" + event.getMessage().getText());
        }
    }
}

额外优化：避免instanceof判断（可选） #

如果不想用instanceof，可以用访问者模式让代码更优雅：

1. 在基类新增抽象方法：

public abstract class BaseEvent {
    // 原有字段和方法
    public abstract void accept(EventVisitor visitor);
}

2. 定义访问者接口：

public interface EventVisitor {
    void visit(ConversationStartedEvent event);
    void visit(MessageEvent event);
    // 新增event类型时，在这里加对应方法
}

3. 在具体类实现accept方法：

public class ConversationStartedEvent extends BaseEvent {
    // 原有字段和方法
    @Override
    public void accept(EventVisitor visitor) {
        visitor.visit(this);
    }
}

4. 编写事件处理器：

public class EventHandler implements EventVisitor {
    @Override
    public void visit(ConversationStartedEvent event) {
        // 处理对话开始事件的逻辑
    }

    @Override
    public void visit(MessageEvent event) {
        // 处理消息事件的逻辑
    }
}

使用时直接传入处理器即可：

BaseEvent event = objectMapper.readValue(json, BaseEvent.class);
event.accept(new EventHandler());

这种方式新增event类型时，只需要新增子类和访问者方法，完全不用修改现有处理逻辑，非常符合开闭原则。

内容的提问来源于stack exchange，提问作者Mykhailo Bormashenko