利用Java泛型和策略模式实现不同消息的处理器

要实现一个基于Java泛型的消息处理框架，使得未来添加新消息时只需添加对应的消息处理器，可以遵循以下步骤：

1. 定义消息接口

首先定义一个通用的消息接口，让所有消息类型实现这个接口。

public interface Message {
    // 可以定义一些通用的方法，如果需要
}

2. 定义消息处理器接口

接下来，定义一个通用的消息处理器接口，使用泛型来绑定消息类型。

public interface MessageHandler<T extends Message> {
    void handle(T message);
}

3. 实现具体的消息类型

实现具体的消息类型，每个类型都继承Message接口。

public class TextMessage implements Message {
    private String content;

    public TextMessage(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }
}

public class ImageMessage implements Message {
    private String imageUrl;

    public ImageMessage(String imageUrl) {
        this.imageUrl = imageUrl;
    }

    public String getImageUrl() {
        return imageUrl;
    }
}

4. 实现具体的消息处理器

为每个消息类型实现对应的处理器，实现MessageHandler接口。

public class TextMessageHandler implements MessageHandler<TextMessage> {
    @Override
    public void handle(TextMessage message) {
        System.out.println("Handling text message: " + message.getContent());
    }
}

public class ImageMessageHandler implements MessageHandler<ImageMessage> {
    @Override
    public void handle(ImageMessage message) {
        System.out.println("Handling image message: " + message.getImageUrl());
    }
}

5. 实现消息处理器的注册与调用机制

为了让框架能够根据消息类型找到对应的处理器，可以使用一个处理器的注册表，并通过反射或泛型机制来实现。

import java.util.HashMap;
import java.util.Map;

public class MessageProcessor {
    private Map<Class<? extends Message>, MessageHandler<? extends Message>> handlers = new HashMap<>();

    public <T extends Message> void registerHandler(Class<T> messageType, MessageHandler<T> handler) {
        handlers.put(messageType, handler);
    }

    public <T extends Message> void process(T message) {
        @SuppressWarnings("unchecked")
        MessageHandler<T> handler = (MessageHandler<T>) handlers.get(message.getClass());
        if (handler != null) {
            handler.handle(message);
        } else {
            throw new RuntimeException("No handler found for message type: " + message.getClass());
        }
    }
}

6. 使用框架

现在你可以注册消息处理器，并处理对应的消息。

public class Main {
    public static void main(String[] args) {
        MessageProcessor processor = new MessageProcessor();

        // 注册消息处理器, 实际应用中可以利用
        processor.registerHandler(TextMessage.class, new TextMessageHandler());
        processor.registerHandler(ImageMessage.class, new ImageMessageHandler());

        // 创建并处理消息
        TextMessage textMessage = new TextMessage("Hello, World!");
        processor.process(textMessage);

        ImageMessage imageMessage = new ImageMessage("http://example.com/image.png");
        processor.process(imageMessage);
    }
}

结果

当运行上述代码时，控制台会输出：

Handling text message: Hello, World!
Handling image message: http://example.com/image.png

通过这种方式，未来添加新的消息类型时，只需实现新的消息类和对应的处理器，并在处理器注册时将其注册即可。备注：这里我们为了展示方面采用手动注册的方式实现了消息和处理器的绑定，实际中我们可以通过反射机制或者依赖注入的方式来实现自动绑定。