设计模式——观察者模式（三）Google Guava EventBus

Google Guava 事件总线 

传统上，Java的进程内事件分发都是通过发布者和订阅者之间的显式注册实现的。设计EventBus就是为了取代这种显示注册方式，使组件间有了更好的解耦。EventBus不是通用型的发布-订阅实现，不适用于进程间通信。

 EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现。对于事件监听和发布订阅模式，EventBus非常优雅使用起来也非常的简单,这个可不是吹的是真的非常的简单。

依赖

         <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>20.0</version>
        </dependency>

 EventBus的使用

package org.demo.spring.event.eventbus;

import com.google.common.eventbus.AsyncEventBus;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.SubscriberExceptionContext;
import com.google.common.eventbus.SubscriberExceptionHandler;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Method;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 事件总线工厂
 * 
 */
@Slf4j
public class EventBusFactory {

    // 同步事件总线
    private volatile static EventBus eventBus;
    // 异步事件总线
    private volatile static AsyncEventBus asyncEventBus;

    private static ThreadPoolExecutor threadPoolExecutor;

    /**
     * 默认使用异步事件总线
     * @return
     */
    public static EventBus getEventBus() {
        return  getEventBus(true);
    }

    /**
     *  可以采用静态内部类实现单例
     */
    public static EventBus getEventBus(boolean async) {
        if (async) {
            if (asyncEventBus == null) {
                synchronized (AsyncEventBus.class) {
                    // 双重检查，避免并发访问创建多个对象问题
                    if (asyncEventBus == null) {
                        asyncEventBus = new AsyncEventBus(getEventBusThreadPool());
                    }
                }
            }

            return asyncEventBus;
        } else {
            if (eventBus == null) {
                synchronized (EventBus.class) {
                    // 双重检查，避免并发访问创建多个对象问题
                    if (eventBus == null) {
                        eventBus = new EventBus(DefaultExceptionHandler.INSTANCE);
                    }
                }
            }
            return eventBus;
        }
    }


    private static ThreadPoolExecutor getEventBusThreadPool() {
        if (threadPoolExecutor == null) {
            // 当队列满时，任务直接丢弃，避免出错
            threadPoolExecutor = new ThreadPoolExecutor(20,
                    120,
                    60,
                    TimeUnit.SECONDS,
                    new LinkedBlockingDeque<>(100000),
                    new NamedThreadFactory("EventBus_BlockThreadPool"),
                    new ThreadPoolExecutor.DiscardPolicy());
        }
        return threadPoolExecutor;
    }

    /**
     * 默认异常处理者
     * 
     */
    static class DefaultExceptionHandler implements SubscriberExceptionHandler {

        public static final DefaultExceptionHandler INSTANCE  = new DefaultExceptionHandler();
        // 是否有错
        private ThreadLocal<Boolean>                errorFlag = new ThreadLocal<Boolean>() {

                                                                  @Override
                                                                  protected Boolean initialValue() {
                                                                      return false;
                                                                  }
                                                              };

        @Override
        public void handleException(Throwable exception, SubscriberExceptionContext context) {
            if (!errorFlag.get()) {
                errorFlag.set(true);
            }
            Logger logger = logger(context);
            logger.error(message(context), exception);
        }

        public boolean hasError() {
            return errorFlag.get();
        }

        public void clearErrorFlag() {
            errorFlag.remove();
        }

        private static Logger logger(SubscriberExceptionContext context) {
            return LoggerFactory.getLogger(DefaultExceptionHandler.class);
        }

        private static String message(SubscriberExceptionContext context) {
            Method method = context.getSubscriberMethod();
            return "Exception thrown by subscriber method " + method.getName() + '('
                   + method.getParameterTypes()[0].getName() + ')' + " on subscriber " + context.getSubscriber()
                   + " when dispatching event: " + context.getEvent();
        }
    }

    /**
     * 返回并执行删除
     * @return true 表示有错误，false表示没有错误
     */
    public static boolean getAndRemoveErrorFlag() {
        try {
           return DefaultExceptionHandler.INSTANCE.hasError();
        } finally {
            DefaultExceptionHandler.INSTANCE.clearErrorFlag();
        }
    }
}

package org.demo.spring.event.eventbus;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 复制来源 org.apache.dubbo.common.utils -NamedThreadFactory
 */
public class NamedThreadFactory implements ThreadFactory {
    protected static final AtomicInteger POOL_SEQ = new AtomicInteger(1);
    protected final AtomicInteger mThreadNum;
    protected final String mPrefix;
    protected final boolean mDaemon;
    protected final ThreadGroup mGroup;

    public NamedThreadFactory() {
        this("pool-" + POOL_SEQ.getAndIncrement(), false);
    }

    public NamedThreadFactory(String prefix) {
        this(prefix, false);
    }

    public NamedThreadFactory(String prefix, boolean daemon) {
        this.mThreadNum = new AtomicInteger(1);
        this.mPrefix = prefix + "-thread-";
        this.mDaemon = daemon;
        SecurityManager s = System.getSecurityManager();
        this.mGroup = s == null ? Thread.currentThread().getThreadGroup() : s.getThreadGroup();
    }

    public Thread newThread(Runnable runnable) {
        String name = this.mPrefix + this.mThreadNum.getAndIncrement();
        Thread ret = new Thread(this.mGroup, runnable, name, 0L);
        ret.setDaemon(this.mDaemon);
        return ret;
    }

    public ThreadGroup getThreadGroup() {
        return this.mGroup;
    }
}

/**
 * 事件
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class IEvent implements Serializable {
    private static final long serialVersionUID = -8819029849121087074L;

    private Map map;

}

/**
 * 事件监听器
 */
@Component
@Slf4j
public class IEventListener {

    @PostConstruct
    private void init() {
        // 注册事件监听器
        EventBusFactory.getEventBus().register(this);
    }

    @Subscribe
    @AllowConcurrentEvents
    public final void listen(IEvent iEvent) {
        log.info("接受订阅消息:{}", iEvent);
    }


}

测试：

/**
 * 事件发布测试
 *  由于是自己搭建的springboot项目，启动非常快，有时测试就直接用定时任务，不写单侧了
 */
@Component
public class TestJob {

    @Scheduled(cron = "*/5 * * * * ?")
    public void cronJob() {
        IEvent iEvent = new IEvent();
        Map map = new HashMap<String, Object>() {
            {
                put("a", "123");
                put("b", "456");
            }
        };
        iEvent.setMap(map);
        EventBusFactory.getEventBus().post(iEvent);

    }

}

参考：

Google Guava EventBus

Google Guava]-事件总线