Observer模式：“八卦”的公众号

我们都很熟悉微信的公众号了，所以我们用一个专门发八卦新闻的微信公众号作为需求例子

需求故事

• 1. 作为UserA，我希望GossipNewsPublisher可以register我，然后send “Gossip News 1”消息给我，这样UserA就可以read消息"Gossip News 1".
• 2. 作为UserB，我希望GossipNewsPublisher可以register我，然后send “Gossip News 2”消息给我，这个UserB可以 watch 消息"Gossip News 2"同时UserA也可以read消息"Gossip News 2"
• 3. 作为已经注册的UserA，我希望GossipNewsPublisher可以remove我，这样如果GossipNewsPublisher send “Gossip News 3”消息，UserA 将会read消息"Gossip News 2", 但是UserB将会watch消息"Gossip News 3"

Story1

Story1 Test Case

@Test
    public void testSendGrossipNews(){
        GossipPublisher gossipPublisher = new Gossippublisher();
        UserA userA = new UserA();

        //Story 1
        gossipPublisher.register(userA);
        gossipPublisher.send("Gossip News 1");
        assertEquals("Gossip News 1", userA.read());
    }

Story1 Implementation

由于这时候只有一个订阅者，那么只考虑简单的实现方式

public class GossipPublisher {
    private UserA registeredUser;
    public void register(UserA userA) {
        registeredUser= userA;
    }
    public void send(String news) {
        registeredUser.update(news);
    }
}

public class UserA {
    private String recivedNews = "";
    public String read() {
        return recivedNews;
    }
    public void update(String news) {
        recivedNews = news;
    }
}

运行测试，测试顺利通过

Story2

Story2 Test Case

@Test
    public void testSendGrossipNews(){
        GossipPublisher gossipPublisher = new GossipPublisher();
        UserA userA = new UserA();
        //Story 1
        gossipPublisher.register(userA);
        gossipPublisher.send("Gossip News 1");
        assertEquals("Gossip News 1", userA.read());

        //Story 2
        UserB userB = new UserB();
        gossipPublisher.register(userB);
        gossipPublisher.send("Gossip News 2");
        assertEquals("Gossip News 2",userB.watch());
        assertEquals("Gossip News 2",userA.read());

    }

Story2 Implementation

由于Story2就可以直接进化到Observer模式了，而java本身已经自带了Observer的相关接口，所以就直接使用Observer和Observable来实现了：

public class GossipPublisher extends Observable {
    public void register(Observer observer) {
        super.addObserver(observer);
    }
    public void send(String news) {
        super.setChanged();
        super.notifyObservers(news);
    }
}

public class UserA implements Observer{
    private String readNews = "";
    public String read() {
        return readNews;
    }
    @Override
    public void update(Observable o, Object arg) {
        readNews = String.valueOf(arg);
    }
}

public class UserB implements Observer {
    private String watchedNews = "";
    public String watch() {
        return watchedNews;
    }
    @Override
    public void update(Observable o, Object arg) {
        watchedNews=String.valueOf(arg);
    }
}

从上面的简单代码看到Observer本质其实就是把UserA和UserB的共同行为update抽象成一个接口，然后再把GossipPublisher中针对Observer接口的操作进行抽取放在Observable中，这样通过让八卦公众号发布者继承Observable，让用户实现Observer接口，就可以很轻松的解决这种消息订阅和消息分发的问题了。

Story 3 Test Case

public class GossipPublisherTest {
    public static final String GOSSIP_NEWS_1 = "Gossip News 1";
    public static final String GOSSIP_NEWS_2 = "Gossip News 2";
    public static final String GOSSIP_NEWS_3 = "Gossip News 3";
    @Test
    public void testSendGrossipNews() {
        GossipPublisher gossipPublisher = new GossipPublisher();
        UserA userA = new UserA();
        //Story 1
        gossipPublisher.register(userA);
        gossipPublisher.send(GOSSIP_NEWS_1);
        assertEquals(GOSSIP_NEWS_1, userA.read());
        //Story 2
        UserB userB = new UserB();
        gossipPublisher.register(userB);
        gossipPublisher.send(GOSSIP_NEWS_2);
        assertEquals(GOSSIP_NEWS_2, userB.watch());
        assertEquals(GOSSIP_NEWS_2, userA.read());
        //Story 3
        gossipPublisher.unregister(userA);
        gossipPublisher.send(GOSSIP_NEWS_3);
        assertEquals(GOSSIP_NEWS_2, userA.read());
        assertEquals(GOSSIP_NEWS_3, userB.watch());
    }
}

Story 3 Implementation

由于story3主要是要测试一下注销的功能，所以依然使用Observable里面的deletObserver功能来实现，顺利通过测试。

public class GossipPublisher extends Observable {
    public void register(Observer observer) {
        super.addObserver(observer);
    }
    public void send(String news) {
        super.setChanged();
        super.notifyObservers(news);
    }
    public void unregister(UserA userA) {
        super.deleteObserver(userA);
    }
}

和坚思辨

Observer模式所解决的问题其实在日常的开发中很常见，因为它的本质是解决发送消息通知的问题。

• 比如在UI界面上对一个组件进行操作以后，其他几个组件要发生相应的改变
• 比如在完成一个数据库的持久化以后，需要通知其他的缓存模块进行同步

因此只要是遇到这种1对多的消息传输问题，尤其是多还是可变的时候，就应该立刻想到应该使用Observer模式了