从APP消息推送所理解的观察者模式

#1、什么是观察者模式？

　　观察者模式=（出版者+订阅者）模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

　　例如：你有一个新闻APP，你订阅了《程序员》模块，当这个模块有新的文章更新时，你能在第一时间获取更新。当你厌倦了这个模块的内容时，取消订阅就行了。简单点理解就是：注册--->接收消息--->取消--->不在通知。

#2、具体如何使用？

　　*2.1场景描述：目前需要开发一款新闻应用，用户订阅某个模块后，系统会主动给他发送这个模块的消息，用户取消订阅后，不在向该用户推送这个模块的消息。

　　*2.2设计类图如下：

　　

　　*2.3类图描述

　　　抽象出版者（NewsService）：抽象观察者模式的出版中心，注册订阅用户，存储订阅用户，删除订阅用户，新闻推送，可以类比为最基本的用户增删改查。

　　　具体出版者（NewsServiceImpl）:出版中心的具体实现，为所有订阅的用户发送通知。

　　　抽象订阅者（UserService）：抽象订阅者需要的新闻信息，展示方式。

　　   具体订阅者（UserOne）:抽象订阅者的具体实现，自定义新闻的展示方式。　　　

#3、项目具体实现细节

　　 *3.1项目结构

　　*3.2具体代码

 public interface NewsService {
     void registerNews(UserService userService);
     void setNewsInfo(NewsBean newsBean);
     void notifyNews();
     void cancleNews(UserService userService);

     void setState();
     boolean getState();
 }

　　

 public interface UserService {
     void updateNews(NewsBean newsBean);
     void displayNews();
 }

 public class NewServiceImpl implements NewsService {
     private boolean state = false;
     private NewsBean newsBean;
     private List<UserService> userServiceList = null;

     private List<UserService> getUserServiceList(){
         if(userServiceList ==null){
             userServiceList = new ArrayList<>();
         }
         return userServiceList;
     }

     /**
      * 初始化
      */
     public NewServiceImpl(){
         getUserServiceList();
     }

     @Override
     public void registerNews(UserService userService) {
         userServiceList.add(userService);
     }

     @Override
     public void cancleNews(UserService userService) {
         userServiceList.remove(userService);
     }

     /**
      * 通知所有订阅用户
      */
     @Override
     public void notifyNews() {
         for (UserService userService : userServiceList) {
             userService.updateNews(newsBean);
         }
     }

     /**
      * 设置新闻信息
      * @param newsBean
      */
     @Override
     public void setNewsInfo(NewsBean newsBean){
         this.newsBean = newsBean;
         notifyNews();
     }

     @Override
     public void setState() {
         state = true;
     }

     @Override
     public boolean getState() {
         return this.state;
     }
 }

 public class UserOne implements UserService{
     private NewsService newsService;
     private NewsBean newsBean;
     /**
      * 订阅新闻
      * @param newsService
      */
     public UserOne(NewsService newsService){
         this.newsService = newsService;
         newsService.registerNews(this);
     }
     @Override
     public void updateNews(NewsBean newsBean) {
         this.newsBean = newsBean;
         displayNews();
     }

     @Override
     public void displayNews() {
         System.out.println(newsBean);
     }
 }

 public class UserTwo implements UserService{
     private NewsService newsService;
     private NewsBean newsBean;
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

     /**
      * 订阅新闻
      * @param newsService
      */
     public UserTwo(NewsService newsService){
         this.newsService = newsService;
         newsService.registerNews(this);
     }
     @Override
     public void updateNews(NewsBean newsBean) {
         this.newsBean = newsBean;
         displayNews();
     }

     @Override
     public void displayNews() {
         System.out.println("\n>>>高级用户推送信息："+"\n"+newsBean.getNewsTitle()+"\t"
                 +sdf.format(newsBean.getNewsDate())+"\n"+newsBean.getNewsContent());
     }
 }

　　

 public class NewsSystem {

     public static void main(String[] args) {
         NewsService newsService = new NewServiceImpl();
         // 用户类型一
         UserOne userOne = new UserOne(newsService);
         // 用户类型二
         UserTwo userTwo = new UserTwo(newsService);
         // 新闻推送
         newsService.setNewsInfo(new NewsBean("天道酬勤","习大大说：“天上不会掉馅饼，" +
                 "努力奋斗才能梦想成真。”",new Date()));
         // 用户类型一 取消订阅
         newsService.cancleNews(userOne);
         // 又一次新闻推送
         newsService.setNewsInfo(new NewsBean("观察者模式","观察者模式=（出版者+订阅者）" +
                 "模式",new Date()));
     }
 }

　　*3.3运行结果

　　

#4、模式总结

　   *4.1优点

　　　　出版者和订阅者之间用松耦合的方式结合，订阅者不必关心出版者如何给自己推送消息；

　　　　在对象之间定义一对多的依赖关系，对订阅者统一进行推送消息。

　　*4.2适用场景

　　　　当一个对象改变公共对象时，他不知道在其他什么地方用到这个公共对象。

转载请标明地址：http://www.cnblogs.com/huaxingtianxia/p/6266913.html