一个高性能事件分发器

当我们项目业务类型较多，又要满足高并发要求，自己编写一个事件分发器太麻烦，这是我们可以使用disruptor框架，此框架很好的解决了高并发分发问题；

disruptor是什么

Disruptor它是一个开源的并发框架，并获得2011 Duke’s 程序框架创新奖，能够在无锁的情况下实现网络的Queue并发操作。
Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，它能够以很低的延迟产生大量交易。这个系统是建立在JVM平台上，其核心是一个业务逻辑处理器，它能够在一个线程里每秒处理6百万订单。业务逻辑处理器完全是运行在内存中，使用事件源驱动方式。业务逻辑处理器的核心是Disruptor。

就是一个实现了订阅发布的队列，无锁。它能在一秒内处理6百万个订单（转发），观察者模式。

术语

RingBuffer:

被看作Disruptor最主要的组件，然而从3.0开始RingBuffer仅仅负责存储和更新在Disruptor中流通的数据。对一些特殊的使用场景能够被用户(使用其他数据结构)完全替代。

Sequence:

Disruptor使用Sequence来表示一个特殊组件处理的序号。和Disruptor一样，每个消费者(EventProcessor)都维持着一个Sequence。大部分的并发代码依赖这些Sequence值的运转，因此Sequence支持多种当前为AtomicLong类的特性。

Sequencer:

这是Disruptor真正的核心。实现了这个接口的两种生产者（单生产者和多生产者）均实现了所有的并发算法，为了在生产者和消费者之间进行准确快速的数据传递。

SequenceBarrier:

由Sequencer生成，并且包含了已经发布的Sequence的引用，这些的Sequence源于Sequencer和一些独立的消费者的Sequence。它包含了决定是否有供消费者来消费的Event的逻辑。

 

启动disruptor

 @Bean
    public EventDispatcherProducer startEventDispatcher() {
        Disruptor<EventDispatcher> disruptor = new Disruptor<>(
                new EventDispatcherFactory(),
                524288,
                Executors.defaultThreadFactory()
        );
        disruptor.handleEventsWith(new LoginDataHandler());
        disruptor.handleEventsWith(new UserinfoDataHandler());
        disruptor.handleEventsWith(new SendMessageDataHandler());
        disruptor.handleEventsWith(new ReceiveMessageDataHandler());
        disruptor.setDefaultExceptionHandler(new EventDispatcherExceptionHandler());
        disruptor.start();
        EventDispatcherProducer eventDispatcherProducer = new EventDispatcherProducer(disruptor.getRingBuffer());
        return eventDispatcherProducer;
    }

 

EventDispatcher

public class EventDispatcher<T> {
    T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

　

EventDispatcherExceptionHandler

public class EventDispatcherExceptionHandler implements ExceptionHandler<EventDispatcher> {

    public Logger logger = LoggerFactory.getLogger(EventDispatcherExceptionHandler.class);

    @Override
    public void handleEventException(Throwable ex, long sequence, EventDispatcher event) {
        logger.error("{} : {}. {} ", event, event, ex);
    }

    @Override
    public void handleOnStartException(Throwable ex) {
        logger.error("Exception during onStart(){}", ex);
    }

    @Override
    public void handleOnShutdownException(Throwable ex) {
        logger.error("Exception during onShutdown(){}", ex);
    }

}

　　

EventDispatcherFactory

public class EventDispatcherFactory implements EventFactory<EventDispatcher> {
    @Override
    public EventDispatcher newInstance() {
        return new EventDispatcher();
    }
}

　　

EventDispatcherProducer

public class EventDispatcherProducer {
    private final EventTranslatorOneArg<EventDispatcher, Event> TRANSLATOR =
            (event, sequence, requestDto) -> event.setData(requestDto);
    private final RingBuffer<EventDispatcher> ringBuffer;

    public EventDispatcherProducer(RingBuffer<EventDispatcher> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    public void onData(Event requestDto) {
        ringBuffer.publishEvent(TRANSLATOR, requestDto);
    }
}

　　

业务核心处理

public class LoginDataHandler implements EventHandler<EventDispatcher> {

    public Logger logger = LoggerFactory.getLogger(LoginDataHandler.class);

    @Override
    public void onEvent(EventDispatcher eventDispatcher, long sequence, boolean endOfBatch) throws Exception {
        try {
            Event event = (Event) eventDispatcher.getData();
            if (event instanceof LoginDataEvent) {
              
            }
        } catch (Exception e) {
            logger.error("UserinfoDataHandler e{}", e);
        }
    }

}