设计模式之观察者模式

1:概念
什么是观察者(Observer)模式呢?
观察者模式 : 定义了对象之间的一对多依赖,让多个观察者对象同时监听某一个主题对象,当者个对象改变状态时它的所有依赖者都会收到通知并且自动更新.

2:观察者模式类图:

3:代码演示

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

public abstract class  Subject {


    private List<Observer> observers = new ArrayList<Observer>();

    public void attach(Observer observer){
        observers.add(observer);
    }
    public void detach(Observer observer){
        observers.remove(observer);
    }

    public void notice(){
        for(Observer o : observers) {
            o.update();
        }
    }

}

public abstract class Observer {

    public abstract void update();

}

public class ConcreteSubject extends Subject {

    private String subjectState;

    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }

}


public class ConcreteObserver extends Observer {

    private String name;
    private String observateState;
    private ConcreteSubject subject;

    public ConcreteObserver(String name, ConcreteSubject subject) {
        super();
        this.name = name;
        this.subject = subject;
    }



    @Override
    public void update() {
      observateState = subject.getSubjectState();
      System.out.println(name+";"+observateState);

    }



    public ConcreteSubject getSubject() {
        return subject;
    }

4:实际应用
在实际开发中我们再设计的时候需要进行思考,我们学习设计模式实在进行开发的时候进行思考,是否有适合的设计模式,如果没有,我们应该考虑一下,是否符合设计模式的思想,面向对象的思想.
下面呢,我们进行简单模拟类似微信公众号的关注,以及消息推送.

/**
 * 微信公众号接口
 * @author wsylp
 *
 */
public interface WeChatOfficialAccount {

    /**
     * 关注微信公众号
     * @param wuser
     * @return 
     */
    void attention(WUser wuser);

    /**
     * 取消微信公众号
     * @param wuser
     * @return 
     */
    void Unfriended(WUser wuser);

    /**
     * 推送消息
     */
    public void pushMessage();
}


public class JavaThought implements WeChatOfficialAccount {


    private List<WUser> wuserList = new ArrayList<>();

    private Message message ;


    public JavaThought(Message message) {
        super();
        this.message = message;
    }

    @Override
    public void attention(WUser wuser) {
        wuserList.add(wuser);

    }

    @Override
    public void Unfriended(WUser wuser) {
        wuserList.remove(wuser);

    }

    @Override
    public void pushMessage() {

        for (int i = 0; i < wuserList.size(); i++) {
            wuserList.get(i).getMessage(message);
        }

    }

}


/**
 * 消息类
 * @author wsylp
 *
 */
public class Message {
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

}


/**
 * 微信用户
 * @author wsylp
 *
 */
public interface WUser {

    /**
     * 接收消息(微信公众号调用此方法)
     */
    void getMessage(Message message);

}

public class WUserA implements WUser {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void getMessage(Message message) {

        System.out.println(getName() + ":" + message.getTitle() + ":" + message.getContent());
    }

}


public class WUserB implements WUser {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void getMessage(Message message) {
        System.out.println(getName() + ":" +message.getTitle() + ":" + message.getContent());
    }
}

public class WUserC implements WUser {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void getMessage(Message message) {
        System.out.println(getName() + ":" + message.getTitle() + ":" + message.getContent());
    }
}

测试类

/**
 * 测试观察者模式
 * @author wsylp
 *
 */
public class TestObserver {

    public static void main(String[] args) {
        WUserA userA = new WUserA();
        userA.setName("WUserA");

        WUserB userB = new WUserB();
        userB.setName("userB");

        WUserC userC = new WUserC();
        userC.setName("WUserC");

        Message message = new Message();
        message.setTitle("java设计模式之观察者模式");
        message.setContent("定义了对象之间的一对多依赖,让多个观察者对象同时监听某一个主题对象,当者个对象改变状态时它的所有依赖者都会收到通知并且自动更新.");

        JavaThought thought = new JavaThought(message);

        thought.attention(userA);
        thought.attention(userB);
        thought.attention(userC);

        thought.pushMessage();

    }
}

总结:
什么时候使用观察者模式?
当一个对象的改变需要同时改变其他对象的时候,而且他不知道有多少个对象待改变时可以考虑使用观察者模式.

作用:观察者模式所做的工作就是在解除耦合,让耦合的双方不再依赖于具体.从而使的各自的变化不会影响到另一边的变化.