设计模式之观察者模式（四）

一、UML类图

1、observer pattern

2、event aggregator pattern

二、实例说明

1、observer pattern

public interface MoodObserver {

    void change(Mood mood);
}
public class BoyFriend implements MoodObserver {

    @Override
    public void change(Mood mood) {
        switch (mood) {
            case HAPPY:
                System.out.println("boyfriend: i am safe temporary");
                break;
            case ANGRY:
                System.out.println("boyfriend: i am tragedy");
                break;
            default:
                break;
        }
    }
}

public class Purse implements MoodObserver {
    @Override
    public void change(Mood mood) {
        switch (mood) {
            case HAPPY:
                System.out.println("purse: i am full of money");
                break;
            case ANGRY:
                System.out.println("purse: i am empty now");
                break;
            default:
                break;
        }
    }
}

public class GirlFriend {

    private List<MoodObserver> observerList;

    public GirlFriend() {
        observerList = new ArrayList<>();
    }

    public void registerObserver(MoodObserver moodObserver) {
        observerList.add(moodObserver);
    }

    public void removeObserver(MoodObserver moodObserver) {
        observerList.remove(moodObserver);
    }

    public void notifyObserver(Mood mood) {
        for (MoodObserver moodObserver : observerList) {
            moodObserver.change(mood);
        }
    }

    public void moodChange(Mood mood) {
        notifyObserver(mood);
    }
}
public enum Mood {

    HAPPY,
    ANGRY;
}
public class App {

    public static void main(String[] args) {
        GirlFriend girlFriend = new GirlFriend();
        BoyFriend boyFriend = new BoyFriend();
        Purse purse = new Purse();
        girlFriend.registerObserver(boyFriend);
        girlFriend.registerObserver(purse);
        girlFriend.moodChange(Mood.HAPPY);
        girlFriend.removeObserver(purse);
        girlFriend.moodChange(Mood.ANGRY);
    }
}

2、event aggregator pattern

public abstract class EventEmitter {

    private List<MoodObserver> observerList;

    public EventEmitter() {
        observerList = new ArrayList<>();
    }

    public EventEmitter(MoodObserver moodObserver) {
        this();
        registerObserver(moodObserver);
    }

    public void registerObserver(MoodObserver moodObserver) {
        observerList.add(moodObserver);
    }

    protected void notifyObservers(Mood mood) {
        for (MoodObserver moodObserver : observerList) {
            moodObserver.change(mood);
        }
    }

    public void removeObserver(MoodObserver moodObserver) {
        observerList.remove(moodObserver);
    }

    public abstract void cause();

}

public class BadWork extends EventEmitter {

    public BadWork(MoodObserver moodObserver) {
        super(moodObserver);
    }

    @Override
    public void cause() {
        notifyObservers(Mood.ANGRY);
    }
}

public class GoodWork extends EventEmitter {

    public GoodWork(MoodObserver moodObserver) {
        super(moodObserver);
    }

    @Override
    public void cause() {
        notifyObservers(Mood.HAPPY);
    }
}

public class AggregatorGirlFriend extends EventEmitter implements MoodObserver{

    private List<MoodObserver> observerList;

    public AggregatorGirlFriend() {
        observerList = new ArrayList<>();
    }

    @Override
    public void cause() {
        //NOP
    }

    @Override
    public void change(Mood mood) {
        notifyObservers(mood);
    }
}

public class App {

    public static void main(String[] args) {
    	BoyFriend boyFriend = new BoyFriend();
        Purse purse = new Purse();
        AggregatorGirlFriend aggregatorGirlFriend = new AggregatorGirlFriend();
        aggregatorGirlFriend.registerObserver(boyFriend);
        aggregatorGirlFriend.registerObserver(purse);
        GoodWork goodWork = new GoodWork(aggregatorGirlFriend);
        goodWork.cause();
        aggregatorGirlFriend.removeObserver(purse);
        BadWork badWork = new BadWork(aggregatorGirlFriend);
        badWork.cause();
    }
}

三、观察者模式使用场景

1、观察者之间互相不需要知道，添加或者删除观察者不会对其他的观察者造成影响。
2、以粗粒度的角度来说，可以通过事件聚合器模式将所有的事件都传输到一个管道上，如所有的事件（badwork、goodwork）都聚合到AggregatorGirlFriend身上，但是一旦事件变化，会影响到所有的观察者。以细粒度角度的来说，每个观察者可以接收不同的事件，事件变化观察者之间互不影响。
3、观察者模式适用于许多观察者需要分享共同的数据。缺点是事件触发时的流程很难通过代码显示进行查看，bug很难查找。