网上关于 Reactor 的文章很多,不过全是和 NIO 直接相关,本文只阐述 Reactor 设计的思想,同时给出范例代码实现。

Reactor 的设计思想是通过 Reactor 去感知到不同的事件,然后根据不同的事件去派发不同的处理器处理事件,下面的代码思路是通过 Reactor 对 Integer 和 String 这两种类型的资源做不同的处理,下面看代码。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
// 先看一下最终效果,Reactor 对不同的事件做不同的处理
public class Main {
    public static void main(String[] args) {
        Reactor.dispatch(
            Event.IntegerResource, DefaultResource.createResource(1)
        ); // Integer resource: [1]
        Reactor.dispatch(
            Event.StringResource, DefaultResource.createResource("String")
        ); // String resource: [String]
    }
}

// 定义事件类型
public enum Event {
    /** Integer 类型的资源事件 */
    IntegerResource,
    /** String 类型的资源事件 */
    StringResource
}

// 处理器接口
public interface Handler {
    /**
     * 处理资源
     * @param resource 需要被处理的资源
     */
    void handle(Resource resource);
}

// Integer 处理器
public class IntegerHandler implements Handler {

    private static final IntegerHandler self = new IntegerHandler();

    public static IntegerHandler getInstance() {
        return self;
    }

    @Override
    public void handle(Resource resource) {
        System.out.println(String.format("Integer resource: [%s]", resource.getResource()));
    }
}

// String 处理器
public class StringHandler implements Handler {

    private static final StringHandler self = new StringHandler();

    public static StringHandler getInstance() {
        return self;
    }

    @Override
    public void handle(Resource resource) {
        System.out.println(String.format("String resource: [%s]", resource.getResource()));
    }
}

// 资源接口
public interface Resource<T> {

    /** 获取资源 */
    T getResource();
}

// 默认资源实现类
public class DefaultResource<T> implements Resource<T> {

    private T resource;

    public DefaultResource(T resource) {
        this.resource = resource;
    }

    @Override
    public T getResource() {
        return resource;
    }

    public static <T> DefaultResource createResource(T resource) {
        return new DefaultResource(resource);
    }
}

// Reactor 类
public class Reactor {
    /** 存放事件和处理器的映射 */
    private static final Map<Event, Handler> eventToHandlerMap = new ConcurrentHashMap<>();

    static {
        // 注册事件处理器
        eventToHandlerMap.put(Event.IntegerResource, IntegerHandler.getInstance());
        eventToHandlerMap.put(Event.StringResource, StringHandler.getInstance());
    }

    /**
     * 根据不同的事件将资源分发给不同的处理器处理
     *
     * @param event    事件
     * @param resource 资源
     */
    public static <T> void dispatch(Event event, Resource<T> resource) {
        Handler handler = eventToHandlerMap.get(event);
        handler.handle(resource);
    }

}