行为类——观察者模式

观察者模式

  • 定义:定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖它的对象都会得到通知并被自动更新。
  • UML类图:
    观察者模式
  • 综合分析:

    优点:

    1. 观察者与被观察者是抽象耦合关系,实现类可以动态拓展。
    2. 便于建立一套触发机制,把单一类的触发关系串联起来。

    缺点:

    1. 开发效率的考虑。把单体的机制分开,需考虑模式应用的价值。
    2. 运行效率的考虑。单线程效率慢,需考虑合理设置多线程。

    适用场景:

    1. 关联行为场景。关联行为是可拆分的,而不是组合关系。
    2. 多级触发场景。
    3. 跨系统的消息交换场景,如消息队列处理机制。

观察者模式实践

观察接口

    public interface IObserver {
         //条件触发后需要作出的处理
         public void update();
     }

抽象被观察类

    public abstract class Subject {
         //保证线程安全
         Vector observers = new Vector<>();
         
         public void addObserver(IObserver o) {
             observers.add(o);
         }
         
         public void removeObserver(IObserver o) {
             observers.remove(o);
         }
         
         public void notifyObservers() {
             for(IObserver observer : observers)
                 observer.update();
         }
     }

被观察实体类

    public class ConcreteSubject extends Subject {
         public void dosomething() {
             //TODO happen events
             super.notifyObservers();
         }
     }

观察实体类

    public class ConcreteObserver implements IObserver {
         @Override
         public void update() {
             System.out.println("happen change, handle info!");
         }
     }

客户端类

public class client {
    public static void main(String[] args) {
        IObserver observerA = new ConcreteObserver();
        ConcreteSubject subjectA = new ConcreteSubject();
        subjectA.addObserver(observerA);
        subjectA.dosomething();
    }
}

Java观察者模式实践

  • 类图UML:
    Java观察者实现

具体实现代码

public class OriginObserver {
    public interface Subject {
        public void dosomething();
    }
    
    public static class ConcreteSubject 
        extends Observable implements Subject {
        @Override
        public void dosomething() {
            //TODO happen events
            super.setChanged();
            super.notifyObservers("obj");
        }
    }
    
    public static class ConcreteObserver implements Observer {
        @Override
        public void update(Observable observable, Object o){
            System.out.println(observable.toString() + ", obj: " + o.toString());
        }
    }
    
    public static void main(String[] args) {
        ConcreteObserver observer = new ConcreteObserver();
        ConcreteSubject subject = new ConcreteSubject();
        subject.addObserver(observer);
        subject.dosomething();
    }
}

源代码

你可能感兴趣的:(行为类——观察者模式)