Interpretación del patrón de diseño del observador

El modo de observador es un modo con una tasa de uso muy alta y se usa comúnmente en sistemas GUI y sistemas de publicación de suscripción. Porque una función importante de este modelo es el desacoplamiento, desacoplamiento del observador y del observador, haciendo que la dependencia entre ellos sea aún menor, o incluso sin dependencia.

definición

Defina una relación de dependencia de uno a muchos entre objetos, de modo que cuando cada objeto cambie de estado, todos los objetos que dependen de él sean notificados y actualizados automáticamente.

Gráficos UML

• El tema
  abstracto Sujeto , es decir, el rol del Observable. El rol del tema abstracto almacena referencias a todos los objetos observadores en una colección. Cada tema puede tener cualquier número de observadores. El tema abstracto proporciona una interfaz. Agregar y eliminar objetos observadores
• 
  Sujeto específico de ConcreteSubject , este rol guarda el estado relevante en el objeto de observador específico, y cuando el estado interno del sujeto específico cambia, notificará a todos los observadores registrados. El rol de sujeto específico también se llama el rol de observador concreto (ConcreteObservable)
• El observador es un
  observador abstracto. Este rol es una clase abstracta de observadores. Define una interfaz de actualización para actualizarse cuando se le notifica de cambios en el tema.
• 
  Observador de hormigón ConcreteObserver . Este rol implementa la interfaz de actualización definida por el rol de observador abstracto para actualizar su propio estado cuando el estado del sujeto cambia.

Implementación de código en modo observador (Java)

Resumen observado

public abstract class Subject {

    // 定义一个观察者数组
    private Vector<Observer> obs = new Vector<>();

    // 增加一个观察者
    public void addObserver(Observer o) {
        this.obs.add(o);
    }

    // 删除一个观察者
    public void delObserver(Observer o) {
        this.obs.remove(o);
    }

    // 通知所有观察者
    public void notifyObservers() {
        for (Observer o : this.obs) {
            o.update();
        }
    }

    public abstract void doSomeThing();

}

Observador específico

public class ConcreteSubject extends Subject{
    
    

    @Override
    public void doSomeThing() {
        // TODO 被观察者 处理具体业务逻辑
        System.out.println("被观察者处理业务逻辑 ，并通知观察者");
        // 通知观察者 
        super.notifyObservers();
    }

}

Observador

public interface Observer {
    // 更新方法
    public void update();
}

Observador específico

public class ConcreteObserver implements Observer{
    
    
    @Override
    public void update() {
        // 观察者处理具体业务逻辑
        System.out.println("观察者接到信息，并处理");  
    }
}

Llamada en modo observador

public class ObserverPatterns {

    public static void main(String[] args) {
        ConcreteSubject observed = new ConcreteSubject();
        Observer observer=new ConcreteObserver();
        observed.addObserver(observer);
        observed.doSomeThing();
    }
}

Escena aplicable

1. Escenario de comportamiento asociado
2. Evento escena de salida de varios niveles.
3. Escenarios de intercambio de mensajes entre sistemas, como cola de mensajes y mecanismo de procesamiento de bus de eventos

para resumir

La función principal del patrón del observador es desacoplar el objeto, aislar completamente al observador de lo observado y confiar únicamente en las abstracciones Observer y Observable.

ventaja

• Existe un acoplamiento abstracto entre el observador y el observado para hacer frente a los cambios comerciales.
• Mejorar la flexibilidad y escalabilidad del sistema.

Desventaja

Al aplicar el modo de observador, debe considerar la eficiencia del desarrollo y los problemas de eficiencia operativa. El programa contiene un observador, múltiples observadores, desarrollo y depuración, etc., el contenido será más complicado y la notificación de mensajes en JAVA se ejecuta secuencialmente por predeterminado. Un observador está atascado, lo que afectará la eficiencia general de ejecución. En este caso, generalmente se usa el método asincrónico