设计模式--观察者模式

1. 概述

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

2. 解决的问题

　　将一个系统分割成一个一些类相互协作的类有一个不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。观察者就是解决这类的耦合关系的。

3. 模式中的角色

　　3.1 抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

　　3.2 具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。

　　3.3 抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。

　　3.4 具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。

4. 模式解读

　　4.1 观察者模式的代码

 /// <summary>
    /// 抽象主题类
    /// </summary>
    public abstract class Subject
    {
        private IList<Observer> observers = new List<Observer>();

        /// <summary>
        /// 增加观察者
        /// </summary>
        /// <param name="observer"></param>
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        /// <summary>
        /// 移除观察者
        /// </summary>
        /// <param name="observer"></param>
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        /// <summary>
        /// 向观察者（们）发出通知
        /// </summary>
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }

    /// <summary>
    /// 抽象观察者类，为所有具体观察者定义一个接口，在得到通知时更新自己
    /// </summary>
    public abstract class Observer
    {
        public abstract void Update();
    }

    /// <summary>
    /// 具体观察者或具体通知者，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。
    /// </summary>
    public class ConcreteSubject : Subject
    {
        private string subjectState;

        /// <summary>
        /// 具体观察者的状态
        /// </summary>
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }

    /// <summary>
    /// 具体观察者，实现抽象观察者角色所要求的更新接口，已是本身状态与主题状态相协调
    /// </summary>
    public class ConcreteObserver : Observer
    {
        private string observerState;
        private string name;
        private ConcreteSubject subject;

        /// <summary>
        /// 具体观察者用一个具体主题来实现
        /// </summary>
        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }

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

        /// <summary>
        /// 实现抽象观察者中的更新操作
        /// </summary>
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("The observer's state of {0} is {1}", name, observerState);
        }
    }

　　4.2 客户端代码

公司的一个需求，具体是，我的一个类变化了,我需要了解到这个类的变化，并且得到他的id，和模块名称（在本demo中没有体现）,那么就用到了观察者模式！

首先，我们的业务类有一个顶层的接口，所有的业务类都实现了这个接口

package com.sun.Observer;

import java.io.Serializable;

public interface Entity<PK extends Serializable> extends Serializable {

    void setId(PK id);

    PK getId();
}

 定义一个具体的业务类，方便测试

package com.sun.Observer;

public class Student implements Entity<String> {

    private static final long serialVersionUID = 1L;
    private String id;
    private String name;
    private Integer age;

    @Override
    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

 定义一个观察者

package com.sun.Observer;

import java.util.Observable;
import java.util.Observer;

public class TstObServer implements Observer{
    
    @Override
    public void update(Observable observ, java.lang.Object o) {
        EntityEventBlock eeb = (EntityEventBlock) observ;
        System.out.println("捕获业务对象变动数 = "+ eeb.getChangeEvents().size());
        for (EntityChangeEvent event : eeb.getChangeEvents()) {
            System.out.println("entityCls:[" + event.getEntityCls() + "]"
                    + ",id:[" + event.getId() + "]"
                    + ",变动类型:[" + (event.getType() == EntityChangeEvent.TYPE_ADD ? "新增" :
                            event.getType() == EntityChangeEvent.TYPE_UPDATE ? "更新" :
                            event.getType() == EntityChangeEvent.TYPE_DELETE ? "删除" : "") + "]");
        }
    }

}

 监听实体变化的辅助类

package com.sun.Observer;

import java.io.Serializable;

import org.apache.commons.lang3.StringUtils;

public class EntityChangeEvent {
    public static final int TYPE_ADD = 1;
    public static final int TYPE_UPDATE = 2;
    public static final int TYPE_DELETE = 3;

    private Class<?> entityCls;
    private Serializable id;
    private int type;

    public EntityChangeEvent(Class<?> entityCls, Serializable id, int type) {
        this.id = id;
        this.type = type;
        this.entityCls = entityCls;
    }

    public Class<?> getEntityCls() {
        return entityCls;
    }

    public Serializable getId() {
        return id;
    }

    public String getIdStr() {
        return id != null ? id.toString() : null;
    }

    public void setId(Serializable id) {
        this.id = id;
    }

    public int getType() {
        return type;
    }

    @Override
    public boolean equals(Object obj) {
        if (!EntityChangeEvent.class.isInstance(obj)) {
            return false;
        }
        EntityChangeEvent otherObj = (EntityChangeEvent) obj;
        return (StringUtils.equals(getIdStr(), otherObj.getIdStr()));
    }

    @Override
    public int hashCode() {
        if (id != null) {
            return id.hashCode();
        }
        return super.hashCode();
    }

}

通知主题

package com.sun.Observer;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

public class EntityEventBlock extends Observable {
    private List<EntityChangeEvent> changeEvents = new ArrayList<EntityChangeEvent>();

    public void setObservers(List<Observer> observers) {//这里可以注入进来observer
        for (Observer observer : observers) {
            this.addObserver(observer);
        }
    }

    public static synchronized EntityEventBlock instance() {
        EntityEventBlock eventBlock = new EntityEventBlock();// from httpSession
        return eventBlock;
    }

    public void makeDelEvent(Class entityCls, Serializable id) {
        makeChangeEvent(entityCls, id, EntityChangeEvent.TYPE_DELETE);
    }

    public void makeAddEvent(Class entityCls, Serializable id) {
        makeChangeEvent(entityCls, id, EntityChangeEvent.TYPE_ADD);
    }

    public void makeUpdateEvent(Class entityCls, Serializable id) {
        makeChangeEvent(entityCls, id, EntityChangeEvent.TYPE_UPDATE);
    }

    private void makeChangeEvent(Class entityCls, Serializable id, int changeType) {
        EntityChangeEvent e = new EntityChangeEvent(entityCls, id, changeType);
        if (changeEvents.contains(e)) {
            changeEvents.remove(e);
        }
        changeEvents.add(e);
        this.setChanged();
        this.notifyObservers(); 
    }

    public List<EntityChangeEvent> getChangeEvents() {
        return changeEvents;
    }

    public void setChangeEvents(List<EntityChangeEvent> changeEvents) {
        this.changeEvents = changeEvents;
    }
}

 测试

package com.sun.Observer;

import java.util.Observer;
import java.util.UUID;


public class ObserverDemo {
    private static EntityEventBlock e = EntityEventBlock.instance();
    static {
        Observer o = new TstObServer();
        e.addObserver(o);
    }
    
    public static void main(String[] args) {
        
        Student s1 = new Student();
        s1.setId(UUID.randomUUID().toString());
        add(s1);
        Student s2 = new Student();
        s2.setId(UUID.randomUUID().toString());
        add(s2);

    }

    static void update(Entity entity) {
        e.makeUpdateEvent(entity.getClass(), entity.getId());

    }

    static void add(Entity entity) {
        e.makeAddEvent(entity.getClass(), entity.getId());
    }

    static void delete(Entity entity) {
        e.makeDelEvent(entity.getClass(), entity.getId());
    }
}