Java两大工具库：Commons和Guava（6）

朴灿烈づ我的快乐病毒、 2023-09-24 17:03 34阅读 0赞

![format_png][]

您好，我是湘王，这是我的掘金小站，欢迎您来，欢迎您再来～

--------------------

除了操作集合、限流和缓存，Guava还有另一个隐秘的功能：事件总线EventBus机制——是发布-订阅模式的实现，不需要显式地注册回调——比观察者模式更灵活。

EventBus是在单体架构内实现松耦合的一种很好的手段，通过它可以实现与业务逻辑无关的事件监听和消费。Guava提供的事件总线EventBus分为两种：

1、同步事件EventBus，主要用于单线程环境；

2、异步事件AsyncEventBus，主要用于多线程环境。

可以稍稍回顾一下观察者模式。

在支付系统的设计模式中，当完成交易后，需要给用户发送通知时就使用到了观察者模式，怎么做的呢？

1、定义账户观察者接口及其子接口支付观察者和积分观察者；

2、支付抽象类实现这两个子接口，具体支付类阿里支付、微信支付和余额支付，也都分别实现这两个子接口；

3、在账户类中加入观察者接口列表，并增加注册、删除和调用观察者接口的方法；

4、在支付时将各类支付方式注册到账户的观察者列表中；

5、在交易完成后，就可以调用账户的调用观察者接口的方法，实现回调。

![format_png 1][]

观察者模式的实现稍嫌麻烦。

既然用观察者模式实现比较麻烦，那不妨换个思路，用Guava EventBus来实现，而且无需继承任何接口。调用、发送回调通知同样也很简单，用EventBus把支付回调再来实现一遍。

先定义观察者：

/**
     * 支付宝观察者
     *
     * @author 湘王
     */
    public class AliPayObserver {
        // 标记当前订阅者是线程安全的，支持并发接收消息
        @AllowConcurrentEvents
        @Subscribe
        public void pay(Account account) {
            if (account.getName().equalsIgnoreCase("ALI")) {
                System.out.println("支付宝 >>>>>> 已付款");
                System.out.println(account.getMessage());
            }
        }
    }
    复制代码

/**
     * 微信支付观察者
     *
     * @author 湘王
     */
    public class WeixinObserver {
        // 标记当前订阅者是线程安全的，支持并发接收消息
        @AllowConcurrentEvents
        @Subscribe
        public void pay(Account account) {
            if (account.getName().equalsIgnoreCase("WEIXIN")) {
                System.out.println("微信 >>>>>> 已付款");
                System.out.println(account.getMessage());
            }
        }
    }
    复制代码

/**
     * 余额支付观察者
     *
     * @author 湘王
     */
    public class YuePayObserver {
        // 标记当前订阅者是线程安全的，支持并发接收消息
        @AllowConcurrentEvents
        @Subscribe
        public void pay(Account account) {
            if (account.getName().equalsIgnoreCase("YUE")) {
                System.out.println("余额 >>>>>> 已付款");
                System.out.println(account.getMessage());
            }
        }
    }
    复制代码

然后定义账户类：

/**
     * 账户
     *
     * @author 湘王
     */
    public class Account {
        private String name;
        private double amount;
        private Date date;
    
        public Account(String name, double amount, Date date) {
            this.name = name;
            this.amount = amount;
            this.date = date;
        }
    
        public String getName() {
            return name;
        }
    
        public String getMessage() {
            StringBuilder sb = new StringBuilder();
            sb.append("账户：").append(this.name).append(", ");
            sb.append("金额：").append(amount).append(", ");
            sb.append("日期：").append(date);
            return sb.toString();
        }
    }
    复制代码

最后实现事件总线：

/**
     * 事件总线
     *
     * @author 湘王
     */
    public class EventBusTest {
        // 回调通知
        public static void notifyObserver() {
            EventBus bus = new EventBus();
            AliPayObserver ali = new AliPayObserver();
            WeixinObserver weixin = new WeixinObserver();
            YuePayObserver yue = new YuePayObserver();
            bus.register(ali);
            bus.register(weixin);
            bus.register(yue);
    
            Account account1 = new Account("ALI", 1.6, new Date());
            bus.post(account1);
            Account account2 = new Account("WEIXIN", 2.2, new Date());
            bus.post(account2);
            Account account3 = new Account("YUE", 3, new Date());
            bus.post(account3);
        }
    
        public static void main(String[] args) throws InterruptedException {
            notifyObserver();
        }
    }
    复制代码

运行main方法，可以看到，尽管没有显式声明观察者接口，但通过一个@Subscribe注解，就完成了方法回调。这就是EventBus比观察者模式要灵活强大的地方。

如果还不满足，那就再来一个例子。创建观察者接口和具体观察者：

/**
     * 做家务的接口
     *
     * @author 湘王
     */
    public interface HouseWork {
        public void dry();
    }
    复制代码

/**
     * 女主人（具体做家务的人）
     *
     * @author 湘王
     */
    public class Woman implements HouseWork {
        @Override
        public void dry() {
            System.out.println("可以晾衣服了");
        }
    }
    复制代码

创建Subject：

/**
     * 洗衣机（Subject类）
     *
     * @author 湘王
     */
    public class WashingMachine {
        private Vector<HouseWork> vector = new Vector<>();
    
        public void register(HouseWork work) {
            vector.add(work);
        }
    
        public void unregister(HouseWork work) {
            vector.remove(work);
        }
    
        public void notifyObserver() {
            for (HouseWork work : vector) {
                work.dry();
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            // 洗衣机
            WashingMachine machine = new WashingMachine();
            // 女主人
            Woman woman = new Woman();
            // 洗衣机让女主人成为自己的观察者
            machine.register(woman);
            System.out.println("将衣服放到洗衣机。。。");
            System.out.println("买菜、遛娃中。。。");
            Thread.sleep(3000);
            // 通知观察者（女主人），衣服洗完了
            machine.notifyObserver();
        }
    }
    复制代码

用EventBus把刚才家庭妇女做家务的例子再来做一遍（现在换成家庭妇男）：

/**
     * 具体观察者
     *
     * @author 湘王
     */
    public class Man {
        @Subscribe
        public void dry(Sheet sheet) {
            System.out.println("可以晾 " + sheet.getName() + " 床单了");
        }
    }
    复制代码

/**
     * 事件总线
     *
     * @author 湘王
     */
    public class EventBusTest {
        // 回调通知
        public static void notifyObserver() {
            EventBus bus = new EventBus();
            Man man = new Man();
            bus.register(man);
            bus.post(new Sheet("富安娜"));
        }
    
        public static void main(String[] args) {
            notifyObserver();
        }
    }
    复制代码

/**
     * 床单实体类
     *
     * @author 湘王
     */
    public class Sheet {
        private String name;
    
        public Sheet(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    复制代码

运行main方法，可以看到和之前一样的效果。事件总线的一个缺点是，回调接口必须有参数——这并不友好。

[format_png]: https://img-blog.csdnimg.cn/img_convert/59b1508374efbc9797eb6d893abd4bb1.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/2ad315bda3cccd74ecd1a8f7382e039b.webp?x-oss-process=image/format,png