设计模式入门--观察者模式

概念

当一个主题对象状态发生变化时，则会自动通知它的依赖对象进行一些逻辑的处理，这就是观察者模式。
直白点说，一个类依赖另外一个乃至多个类，这个类实例状态变化时，会调用它所依赖对象的接口，触发它依赖对象进行某些逻辑的处理。专门拿出来感觉很抽象，事实上这个设计模式，我们经常在代码中都会使用到。

角色

抽象主题：被观察者（Subject）。提供对观察者增删、通知等操作接口。
具体主题：具体被观察者。内部提供一个供观察者注册的容器，每个观察者可以有任意多个观察者。当主题对象发生某种变化，会把变化通知给容器中注册的观察者对象。
抽象观察者：Observer，是具体观察者的抽象类或接口，它定义了具体的逻辑处理方法，使得在得到主题更改通知时进行一些逻辑的处理。
具体观察者：抽象观察者的具体实现类。

抽象主题和抽象观察者的意义：利用java的多态性特征，降低具体类与具体类之间的耦合性。

具体代码

1、com.learn.observerpattern.way1（借大佬例子一用）

场景：假设微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了某个公众号，当这个公众号更新时就会通知这些订阅的微信用户

抽象主题

package com.learn.observerpattern.way1;

/**
 * 抽象被观察者（Subject）抽象主题对象
 * Created by chao.du on 2018/2/1.
 */
public interface ISubject {
    /**
     * 增加订阅者
     * @param observer
     */
    void addObserver(IObserver observer);
    /**
     * 删除订阅者
     * @param observer
     */
    void delObserver(IObserver observer);
    /**
     * 通知订阅者更新消息
     */
    void notifyObserver();

    /**
     * 更新状态
     */
    void updateState(String state);
}

具体主题

package com.learn.observerpattern.way1;

import java.util.ArrayList;
import java.util.List;

/**
 * 具体主题，被观察者具体实现类
 * Created by chao.du on 2018/2/1.
 */
public class WeixinSubject implements ISubject{

    private String state;
    private List<IObserver> observers=new ArrayList<IObserver>();

    public void addObserver(IObserver observer) {
        this.observers.add(observer);
    }

    public void delObserver(IObserver observer) {
        this.observers.remove(observer);
    }

    public void notifyObserver() {
        for (IObserver observer:observers){
            observer.update(this.state);
        }
    }

    public void updateState(String state) {
        this.state=state;
        this.notifyObserver();
    }
}

抽象观察

package com.learn.observerpattern.way1;

/**
 * 观察者接口
 * Created by chao.du on 2018/2/1.
 */
public interface IObserver {
    public void update(String message);
}

具体观察者

package com.learn.observerpattern.way1;

/**
 * 观察者接口具体观察实现者
 * Created by chao.du on 2018/2/1.
 */
public class WeixinUser implements IObserver {

    private String name;

    public WeixinUser(String name) {
        this.name = name;
    }

    public void update(String message) {
        System.out.println(this.name+"收到了一个通知--"+message);
    }
}

客户端

package com.learn.observerpattern.way1;

/**
 * 测试客户端
 * Created by chao.du on 2018/2/1.
 */
public class Client {

    public static void main(String[] args) {
        //创建微信订阅主题
        ISubject subject=new WeixinSubject();
        //给主题添加订阅者
        subject.addObserver(new WeixinUser("小明"));
        subject.addObserver(new WeixinUser("小花"));
        subject.addObserver(new WeixinUser("小美"));
        //主题更新，通知订阅者
        subject.updateState("XX微信公众号发布了一篇新文章《如何与dalao同归于尽》");
    }

}

测试结果
这里写图片描述

2、com.learn.observerpattern.way2

场景：资讯网站每天给注册用户推送新闻。抽象主题就是资讯网站，被观察者是注册用户。

抽象主题

package com.learn.observerpattern.way2;

/**
 * 抽象主题
 * Created by chao.du on 2018/2/1.
 */
public interface ISubject {

    /**
     * 注册/添加观察者
     * @param observer
     */
    void addObserver(IObserver observer);

    /**
     * 更新主题对象消息状态
     * @param isGood
     * @param message
     */
    void updateMessage(boolean isGood,String message);

    /**
     * 通知观察者
     * @param isGood
     */
    void notiryObserver(boolean isGood);

}

具体主题

package com.learn.observerpattern.way2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * 具体主题，具体被观察者
 * Created by chao.du on 2018/2/1.
 */
public class RealSubject implements ISubject {

    /**
     * 消息
     */
    private String message;

    /**
     * 观察者容器
     */
    private List<IObserver> observerList=new ArrayList<IObserver>();

    /**
     * 添加观察者
     * @param observer
     */
    public void addObserver(IObserver observer){
        this.observerList.add(observer);
    }

    /**
     * 更新主题对象消息，通知观察者
     * @param isGood
     * @param message
     */
    public void updateMessage(boolean isGood,String message) {
        this.message=message;
        this.notiryObserver(isGood);
    }

    /**
     * 通知对象，把Message消息对象发送给
     * @param isGood true好消息 false坏消息
     */
    public void notiryObserver(boolean isGood) {
        HashMap<String,Object> content=new HashMap<String, Object>();
        content.put("message",this.message);
        for (IObserver observer:observerList) {
            if(isGood){
                observer.getWeiXinInfo(new Message(Message.MessageType.GOOD,content));
            }else{
                observer.getWeiXinInfo(new Message(Message.MessageType.BAD,content));
            }
        }
    }
}

抽象观察者

package com.learn.observerpattern.way2;

/**
 * 抽象观察者
 * Created by chao.du on 2018/2/1.
 */
public interface IObserver {

    void getWeiXinInfo(Message message);
}

具体观察者1

package com.learn.observerpattern.way2;

/**
 * 具体观察者
 * Created by chao.du on 2018/2/1.
 */
public class RealObserver1 implements IObserver{

    private String name;

    public RealObserver1(String name, ISubject weiXinSubject) {
        this.name=name;
        weiXinSubject.addObserver(this);
    }

    public void getWeiXinInfo(Message message) {
        System.out.println(this.name+"收到一个"+message.getType().getInfoTip()+"----"+message.getContent().get("message"));
    }
}

具体观察者2

package com.learn.observerpattern.way2;


/**
 * 具体观察者
 * Created by chao.du on 2018/2/1.
 */
public class RealObserver2 implements IObserver{

    private String name;

    public RealObserver2(String name, ISubject weiXinSubject) {
        this.name=name;
        weiXinSubject.addObserver(this);
    }

    public void getWeiXinInfo(Message message) {
        System.out.println(this.name+"收到一个"+message.getType().getInfoTip()+"----"+message.getContent().get("message"));
    }
}

具体观察者3

package com.learn.observerpattern.way2;

/**
 * 具体观察者
 * Created by chao.du on 2018/2/1.
 */
public class RealObserver3 implements IObserver{

    private String name;

    public RealObserver3(String name, ISubject weiXinSubject) {
        this.name=name;
        weiXinSubject.addObserver(this);
    }

    public void getWeiXinInfo(Message message) {
        System.out.println(this.name+"收到一个"+message.getType().getInfoTip()+"----"+message.getContent().get("message"));
    }
}

通知消息实体

package com.learn.observerpattern.way2;

import java.util.Map;

/**
 * 通知消息实体封装
 * Created by chao.du on 2018/2/1.
 */
public class Message {

    private  MessageType type;

    private Map<String,Object> content;

    public Message(MessageType type, Map<String, Object> content) {
        this.type = type;
        this.content = content;
    }

    public MessageType getType() {
        return type;
    }

    public void setType(MessageType type) {
        this.type = type;
    }

    public Map<String, Object> getContent() {
        return content;
    }

    public void setContent(Map<String, Object> content) {
        this.content = content;
    }

    enum  MessageType{

        GOOD(true,"好消息"),BAD(false,"坏消息");

        private final boolean infoState;
        private final String infoTip;

        MessageType(boolean infoState,String infoTip){
            this.infoState=infoState;
            this.infoTip=infoTip;
        }

        public boolean getInfoState() {
            return infoState;
        }

        public String getInfoTip() {
            return infoTip;
        }
    }
}

客户端

package com.learn.observerpattern.way2;

/**
 * 客户端，测试
 * Created by chao.du on 2018/2/1.
 */
public class Client {
    public static void main(String[] args) {
        //创建主题
        ISubject subject=new RealSubject();
        //创建观察者，并放入主题集合
        new RealObserver1("农民",subject);
        new RealObserver2("教师",subject);
        new RealObserver3("工人",subject);
        //主题修改，通知观察者
        subject.updateMessage(true,"还有几天要放年假了！！！");
        System.out.println("----------------------------------");
        subject.updateMessage(false,"过完年房价要涨了！！！");
    }
}

测试结果
这里写图片描述

github代码

参考资料：
1、《设计模式（三）：观察者模式与发布/订阅模式区别》
2、《观察者模式》
3、《设计模式（五）观察者模式》

设计模式入门--观察者模式

概念

角色

具体代码

1、com.learn.observerpattern.way1（借大佬例子一用）

2、com.learn.observerpattern.way2

猜你喜欢