精华内容
下载资源
问答
  • 观察者模式应用广泛,尤其是在一些网络社交应用的推送功能中的应用更是...java本身内置了观察者模式的接口(java.util下),但在更为复杂的环境中,我们往往要自定义接口,以满足多样的需求。同时,一个观察者,有时...

    观察者模式应用广泛,尤其是在一些网络社交应用的推送功能中的应用更是十分广泛;因为这种模式对于此类应用具有先天优势,它能很方便的进行广播;

    使用场景主要有:1.一种对象的操作依赖于另一方面的变化

    2.更改一个对象是连带需要更改其一些他对象

    一句话来说就是广播模型。

    java本身内置了观察者模式的接口(java.util下),但在更为复杂的环境中,我们往往要自定义接口,以满足多样的需求。

    同时,一个观察者,有时需要观察多个对象,当然,这个是要根据问题具体情况;

    以下的demo是个一个观察者观察两个对象--天气,商品,同时通过标记来区别对待观察者

    public interface WeatherSubject

    {

    public static final int QING = 4;

    public static final int YU = 1;

    public static final int QING2YU = 2;

    public static final int FENG = 3;

    public static final int ERROR = 0;

    public void attach(WeatherObserver observer);

    public void detach(WeatherObserver observer);

    public void notifyWeatherObserver();

    }

    public interface WeatherObserver

    {

    public void updateWeather(WeatherSubject subject);

    public boolean isInWeatherFlags(int f);

    }

    public interface ShopSubject

    {

    public static final int ERROR=0;

    public static final int FOOD=1;

    public static final int TOOL=2;

    public static final int BED=3;

    public void attach(ShopObserver observer);

    public void detach(ShopObserver observer);

    public void notifyShopObserver();

    }

    public interface ShopObserver

    {

    public void updateShop(ShopSubject subject);

    public boolean isInShopFlags(int f);

    }

    public class ChinaWeatherSubject implements WeatherSubject

    {

    List observers = new ArrayList();

    String weatherContent;

    int flag = ERROR;

    private String calculateWeather()

    {

    Random random = new Random();

    switch(random.nextInt(5))

    {

    case 1:

    flag = QING;

    return "今天,天气晴好";

    case 2:

    flag = YU;

    return "今天,狂风暴雨";

    case 3:

    flag = QING2YU;

    return "雨夹雪转晴";

    case 4:

    flag = FENG;

    return "今天下午,6级大风";

    }

    flag = ERROR;

    return "获取天气失败";

    }

    public String getWeatherContent() {

    return weatherContent;

    }

    public void setWeatherContent() {

    this.weatherContent = calculateWeather();

    notifyWeatherObserver();

    }

    public void attach(WeatherObserver observer) {

    observers.add(observer);

    }

    public void detach(WeatherObserver observer) {

    observers.remove(observer);

    }

    public void notifyWeatherObserver() {

    for(WeatherObserver o : observers)

    {

    if(o.isInWeatherFlags(flag)) o.updateWeather(this);

    }

    }

    }

    public class TianMaoShopSubject implements ShopSubject

    {

    List observers = new ArrayList();

    String shopContent;

    int flag = ERROR;

    private String calculateShop()

    {

    Random random = new Random();

    switch(random.nextInt(4))

    {

    case 1:

    flag = BED;

    return "床上用品";

    case 2:

    flag = FOOD;

    return "食物";

    case 3:

    flag = TOOL;

    return "日用工具";

    }

    flag = ERROR;

    return "获取商品失败";

    }

    public void attach(ShopObserver observer) {

    observers.add(observer);

    }

    public void detach(ShopObserver observer) {

    observers.remove(observer);

    }

    public void notifyShopObserver() {

    for(ShopObserver o : observers)

    {

    if(o.isInShopFlags(flag)) o.updateShop(this);

    }

    }

    public String getShopContent() {

    return shopContent;

    }

    public void setShopContent() {

    this.shopContent = calculateShop();

    notifyShopObserver();

    }

    }

    public class AppObserver implements WeatherObserver,ShopObserver

    {

    String username;

    List weatherFlags = new ArrayList();

    List shopFlags = new ArrayList();

    public AppObserver(String uname,int[] wFlag,int[] sFlag) {

    username = uname;

    setWeatherFlags(wFlag);

    setShopFlags(sFlag);

    }

    public void setWeatherFlags(int[] wFlag)

    {

    for(int i=0;i

    {

    weatherFlags.add(wFlag[i]);

    }

    }

    public void setShopFlags(int[] sFlag)

    {

    for(int i=0;i

    {

    shopFlags.add(sFlag[i]);

    }

    }

    public boolean isInWeatherFlags(int f) {

    return weatherFlags.contains(f);

    }

    public boolean isInShopFlags(int f) {

    return shopFlags.contains(f);

    }

    public void updateWeather(WeatherSubject subject) {

    System.out.println(username+"收到天气消息 ; 天气情况是:"+((ChinaWeatherSubject)subject).getWeatherContent());

    }

    public void updateShop(ShopSubject subject) {

    System.out.println(username+"收到商店消息 ; 货物情况是:"+((TianMaoShopSubject)subject).getShopContent());

    }

    }

    public class ObserverTest {

    public static void main(String[] args) {

    ChinaWeatherSubject subject = new ChinaWeatherSubject();

    TianMaoShopSubject subject0 = new TianMaoShopSubject();

    AppObserver o1 = new AppObserver("凌风",new int[]{

    WeatherSubject.FENG,

    },new int[]{

    ShopSubject.BED,

    });

    AppObserver o2 = new AppObserver("雪情",new int[]{

    WeatherSubject.QING2YU,

    },new int[]{

    ShopSubject.FOOD,

    });

    AppObserver o3 = new AppObserver("莎莎",new int[]{

    WeatherSubject.YU,

    WeatherSubject.QING2YU,

    WeatherSubject.QING,

    WeatherSubject.FENG,

    },new int[]{

    ShopSubject.BED,

    ShopSubject.FOOD,

    ShopSubject.TOOL,

    });

    subject.attach(o1);

    subject.attach(o2);

    subject.attach(o3);

    subject0.attach(o1);

    subject0.attach(o2);

    subject0.attach(o3);

    subject.setWeatherContent();

    subject0.setShopContent();

    }

    }

    运行效果:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    展开全文
  •  观察者模式广播机制,是消息订阅和推送的核心设计。观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式,通俗来讲在对象之间定义了多...

    一、观察者模式定义 

      观察者模式是广播机制,是消息订阅和推送的核心设计。观察者模式是对象的行为模式,又叫发布-订阅(Publish/Subscribe)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式,通俗来讲在对象之间定义了多对一的订阅,让多个观察者对象同时监听某一个主题对象,当主题对象改变状态时,主题对象的所有订阅者对象都会收到通知并自动更新。

    二、四中角色

    • 抽象被观察者角色:也就是一个抽象主题(Subject),它把所有对观察者对象的引用保存在一个集合中,每个主题都可以有任意数量的观察者对象。抽象主题提供一个接口,可以增加和删除观察者角色以及发布消息,一般用一个抽象类或者接口来定义。
    • 具体被观察者角色:也就是一个具体的主题对象,当主题的内部状态改变时,会向所有在该主题注册过的观察者发出通知。
    • 抽象观察者角色:为所有的具体观察者定义一个接口,在得到主题通知时更新自己。
    • 具体观察者角色:实现抽象观察者角色的更新接口。

    三、场景举例

    有一个微信公众号服务,不定时发布一些消息,关注公众号的用户就可以收到推送消息,取消关注的就收不到推送消息。

    四、观察者(发布-订阅)模式具体实现过程

    1、定义一个抽象被观察者(抽象主题)接口

    /***
     * 抽象被观察者(抽象主题)接口
     * 声明了添加、删除、通知观察者方法
     */
    public interface ISubject {
    
        public void registerObserver(IObserver o);
        public void removeObserver(IObserver o);
        public void notifyObserver();
    }

    2、定义一个抽象观察者接口

    /***
     * 抽象观察者
     * 定义了一个update()方法,当被观察者(抽象主题)调用notifyObservers()方法时,观察者的update()方法会被触发。
     */
    public interface IObserver {
       public void update(String message);
    }

    3、定义具体被观察者对象,实现抽象被观察者接口

    /**
     * 被观察者对象,也就是微信公众号服务
     * 实现了ISubject接口,对ISubject接口的三个方法进行了具体实现
     *
    public class WechatServer implements ISubject {
    
        //注意到这个List集合的泛型参数为IObserver接口,设计原则:面向接口编程而不是面向实现编程
        private List<IObserver> list;
        private String message;
        
        public WechatServer() {
           list = new ArrayList<IObserver>();
        }
        
        @Override
        public void registerObserver(IObserver o) {
           list.add(o);
        }
    
        @Override
        public void removeObserver(IObserver o) {
          if(!list.isEmpty()){
            list.remove(o);
          }   
        }
    
        @Override
        public void notifyObserver() {
           for(int i = 0; i < list.size(); i++) {
             IObserver oserver = list.get(i);
               oserver.update(message);
           }
        }
    
        public void sendInfomation(String s) {
            this.message = s;
            System.out.println("微信服务更新消息: " + s);
            //消息更新,通知所有观察者
            notifyObserver();
        }
    }

    4、定义具体观察者,微信公众号的具体观察者即为用户User

    public class User implements IObserver {
    
        private String name;
        private String message;
        
        public User(String name) {
            this.name = name;
        }
        
        @Override
        public void update(String message) {
           this.message = message;
           read();
        }
    
        public void read() {
            System.out.println(name + " 收到推送消息: " + message);
        }
    }

    5、编写测试类测试

    首先公众号服务(主题对象)注册三个用户,张三、李四、王五。公众号发布了一条消息"微信安卓版本功能升级!",三个用户都收到了消息。接着用户张三取消订阅该公众号,这时公众号又推送了一条消息,此时用户张三已经收不到消息,其他用户可以正常能收到微信公众号推送的消息。

    public class Test {
    
    	public static void main(String[] args) {
            WechatServer server = new WechatServer();
            IObserver userZhang = new User("ZhangSan");
            IObserver userLi = new User("LiSi");
            IObserver userWang = new User("WangWu");
            server.registerObserver(userZhang);
            server.registerObserver(userLi);
            server.registerObserver(userWang);
            server.sendInfomation("微信安卓版本功能升级!");
            
            System.out.println("----------------------------------------------");
            server.removeObserver(userZhang);
            System.out.println("用户张三取消订阅");
            server.sendInfomation("微信IOS版本功能升级!");
    	}
    }

    控制台测试结果打印:

    可以看到,这个模式是松偶合的,尤其在消息订阅设计中非常实用。改变主题或观察者中的一方,另一方不会受到影响。

    欢迎交流,如有问题,扫码关注公众号,联系笔者

    展开全文
  • 观察者模式广播机制,消息订阅和推送的核心设计。开发中常见的场景: 1.手机中消息推送 2.后台群发信息观察者模式例子(自己实现) 首先是定义观察者接口并使用三个子类实现/** * 观察者接口 * * @author ...

    什么叫观察者模式:
    观察者模式是广播机制,消息订阅和推送的核心设计。

    开发中常见的场景:
    1.手机中消息推送
    2.后台群发信息

    观察者模式例子(自己实现)
    首先是定义观察者接口并使用三个子类实现

    /**
     * 观察者接口
     * 
     * @author liuxg
     * @date 2016年5月27日 下午10:15:30
     */
    public interface IObserver {
    
        public void process();
    
    }
    
    class Observer1 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer1执行动作");
    
        }
    
    }
    class Observer2 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer2执行动作");
    
        }
    
    }
    class Observer3 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer3执行动作");
    
        }
    
    }

    再定义主题,观察者若想获得消息,必须先注册

    /**
     * 
     * @author liuxg
     * @date 2016年5月27日 下午10:12:18
     */
    public class Subject {
    
        List<IObserver> list = new ArrayList<IObserver>();
    
    
        /***
         * 注册观察者
         * @param observer
         */
        public void registerObserver(IObserver observer){
            list.add(observer);
        }
    
    
        /**
         * 广播消息
         */
        public void send(){ 
            for (IObserver observer : list) {
                observer.process();
            }
        }
    
    }

    客户端这样子,我们这样子使用

    public class Client01 {
    
        public static void main(String[] args) {
            IObserver observer1 = new Observer1();
            IObserver observer2 = new Observer2();
            IObserver observer3 = new Observer3();
    
            Subject subject = new Subject();
            subject.registerObserver(observer1);
            subject.registerObserver(observer2);
            subject.registerObserver(observer3);
    
            subject.send();
    
        }
    
    }

    接下来我们利用jdk的api来实现观察者模式
    观察者模式例子(jdk api)

    /**
     * 实现观察者
     * @author liuxg
     * @date 2016年5月28日 下午7:11:43
     */
    public class MyObserver implements Observer {
    
        @Override
        public void update(Observable o, Object arg) {
            int state = ((ConcreteSubject)o).getState();
    
            System.out.println("state = " + state);
    
    
        }
    
    }

    接下来我们来实现主题信息

    
    /**
     * 继承jdk的Observable来实现主题信息
     * @author liuxg
     * @date 2016年5月28日 下午7:10:52
     */
    public class ConcreteSubject extends Observable{
    
        private int state ;
    
        public void set(int state) { //状态切换,广播信息
            this.state = state;
    
            setChanged();
            notifyObservers();
    
        }
    
        public int getState() {
            return state;
        }
    
        public void setState(int state) {
            this.state = state;
        }
    }
    

    客户端测试,可以这样子

    public class Client02 {
    
        public static void main(String[] args) {
            ConcreteSubject obj = new ConcreteSubject();
    
            MyObserver observer = new MyObserver();
            obj.addObserver(observer);
    
            obj.set(123);
    
        }
    
    }
    
    展开全文
  • public final class NotificationReceiver extends BroadcastReceiver { private static final String LOGTAG = LogUtil .makeLogTag(NotificationReceiver.class); private final static Object syncLoc
    public final class NotificationReceiver extends BroadcastReceiver {
    
    	private static final String LOGTAG = LogUtil
    			.makeLogTag(NotificationReceiver.class);
    	
        private final static Object syncLock = new Object();  
    	private static NotificationReceiver notificationReceiver;
    
    	private NotificationReceiver() {
    	}
    	
    	public static NotificationReceiver getInstance(){
    		// synchronized同步块处括号中的锁定对象采用的是一个无关的Object类实例。
    		// 将它作为锁而不是通常synchronized所用的this,其原因是getInstance方法是一个静态方法,
    		// 在它的内部不能使用未静态的或者未实例化的类对象(避免空指针异常)。
    		// 同时也没有直接使用instance作为锁定的对象,是因为加锁之时,instance可能还没实例化(同样是为了避免空指针异常)。
    		if (notificationReceiver == null) {
    			synchronized (syncLock) {
    				if(notificationReceiver == null)
    					notificationReceiver = new NotificationReceiver();
    			}
    		}
    		return notificationReceiver;
    	}
    }


    单例类中不建议将getInstance方法修饰为synchronized方法,其原因是一旦这样做了,这种做法会在每次调用getInstance方法时,都需要加锁,相比效率更低。

    展开全文
  • 文章目录概述适用场景优点缺点演示 概述 ◆ 定义:定义了对象之间的一对多依赖,让多个观察者对象同时监听某...◆ 观察者模式支持广播通信 缺点 ◆ 观察者之间有过多的细节依赖、提高时间消耗及程序复杂度 ◆ 使用要...
  • 所谓的观察者模式其实就像广播那样,一个广播站在广播,其余的收音机在接受,收音机接收到的内容随着广播站的内容变化而变化,这就是所有的观察者模式, 其中广播站相当于目标对象,而收音机就是传说中的观察者,...
  • 目录一、观察者模式的定义与类型二、观察者模式的适用场景三、观察者模式的优点四、观察者模式的缺点五、观察者模式示例 ...观察者模式支持广播通信 四、观察者模式的缺点 观察者之间有过多的细节依
  • 本设计模式资料源于慕课网,讲师:Geely 《Java设计模式精讲 Debug方式+内存分析》,本人作为自己手打整理作为学习的归纳总结。 一,模式介绍 1,定义和类型 定义:定义了对象之间的一对多依赖,让多个观察者对象...
  • JAVA设计模式之观察者模式概念:观察者模式(observer), 主要用于1:N的通知。当一个对象(目标对象Subject或Objservable,消息发布)的状态变化时,它需要及时通知一系列对象(观察者对象,Observer,消息订阅)...
  • Java设计模式

    2016-04-18 16:16:00
    1. 观察者设计模式: 意图:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。 主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和...
  • java模式之观察者模式

    2016-01-09 17:20:20
     最典型的观察者模式应用的是Java的Swing时间监听事件,每个listener注册到事件处理的Handler中,当事件源发生的时候,将遍历(广播)消息到所有的Listener中执行相应的方法,如actionPerform()中;  下面简单...
  • java8 rt.jar源码Flink 广播状态示例 这是一个正在进行的工作。 班级 类Dataserver将侦听端口 7777 上的连接,并将每秒两次向任何连接的套接字发送一个随机数 1-6。 类StateServer将侦听端口 7778 上的连接并允许在...
  • 使用java原生api写的一个用于接收udp广播消息的服务端程序,简单应用了生产者消费者模式
  • 观察者设计模式适合解决多种对象跟踪一个对象数据变化的程序结构问题,有一个称作是“主题”的对象 和若干个称作“观察者”的对象。举个现实生活中的例子:网络游戏中,你可以看到别人在地图上移动,此时就将 那个...
  • 其实就是发布订阅模式,发布者发布信息,订阅者获取信息,订阅了就能收到信息,没订阅就收不到信息。有点类似于收听广播,你收听了就会被通知到,反之则不能。 主要解决的问题:一个对象状态改变给其他对象通知的...
  • 观察者模式 Observe 当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。...何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。 如何解
  • 观察者模式(Observer Pattern)是对象出现依赖关系(一对多)时使用的,比如,当一个对象...何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。 优点:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407
精华内容 162
热门标签
关键字:

java广播模式

java 订阅