Facilita el modo de observador

Escrito en frente : Estoy "navegando hacia el mar", este apodo proviene de mi nombre y el nombre de mi novia. Me encanta la tecnología, el código abierto y la programación. 技术是开源的、知识是共享的.

Este blog es un pequeño resumen y registro de su aprendizaje. Si está interesado en Java y algoritmos , puede seguir mi desarrollo y estudiaremos juntos.

用知识改变命运，让我们的家人过上更好的生活.

1. Definición y componentes

1. Definición

观察者（Observer）模式También conocido como modo Publicar / Suscribir (Publicar / Suscribir). GOF define el patrón de observación de la siguiente manera:

Defina una relación de dependencia de uno a muchos entre los objetos. Cuando el estado de un objeto cambia, todos los objetos que dependen de él se notifican y actualizan automáticamente.

Un principio importante del diseño orientado a objetos: el principio de la responsabilidad individual. Cada objeto del sistema debe enfocarse en abstracciones discretas en el dominio del problema. Entonces, idealmente, un objeto solo hace una cosa. Esto trae muchos beneficios en el desarrollo: proporciona reutilización y mantenibilidad, y también es una buena base para la refactorización.

2. Componentes

观察者模式Consta de las siguientes partes :

1. 抽象目标角色(Sujeto): el personaje objetivo conoce a su observador, y cualquier número de observadores puede observar el mismo objetivo. También proporciona una interfaz para registrar y eliminar objetos de observador. Los roles de destino a menudo se implementan mediante clases o interfaces abstractas.
2. 抽象观察者角色(Observador): defina una interfaz de actualización para los objetos que necesitan ser notificados cuando el objetivo cambia. El rol de observador abstracto se realiza principalmente por clase o interfaz abstracta.
3. 具体目标角色(Asunto concreto): Almacene el estado relevante en cada objeto Observador concreto. Cuando su estado cambia, envía notificaciones a sus observadores.
4. 具体观察者角色(Observador concreto): Almacene el estado relevante, que debe ser consistente con el estado del objetivo. Implemente la interfaz de actualización de Observer para mantener su estado consistente con el estado del objetivo. Una referencia al objeto Asunto concreto también se puede mantener dentro de este rol.

观察者模式El diagrama de clase utilizado puede expresar claramente la relación.

En la clase abstracta de Asunto, se proporcionan las funciones mencionadas anteriormente, y hay un método de notificación: notificar.

También puede ver que entre Subject y ConcreteSubject, se puede decir que se usa el patrón de plantilla (este patrón es realmente simple y lo suficientemente común como para usarse accidentalmente).

De esta forma, cuando el estado del rol objetivo específico cambia, el método de notificación se llamará de acuerdo con la convención, en este método, el método de actualización correspondiente se llamará uno por uno de acuerdo con la lista de observadores registrados en el rol objetivo para ajustar el estado del observador.

De esta manera, el patrón de observador completa un proceso.

Segundo, implemente el modo observador

La clase MySubject es nuestro objeto principal. Observer1 y Observer2 son objetos que dependen de MySubject. Cuando MySubject cambia, Observer1 y Observer2 deben cambiar.

La clase AbstractSubject define la lista de objetos a monitorear, que pueden modificarse: agregar o eliminar objetos monitoreados, y cuando MySubject cambia, es responsable de notificar los objetos que existen en la lista.

Interfaz de observador :

public interface Observer {
    public void update();
}

Clase de implementación: Observer1

public class Observer1 implements Observer {
    @Override
    public void update() {
        System.out.println("observer1 接收到了!");
    }
}

Clase de implementación: Observer2

public class Observer2 implements Observer{
    @Override
    public void update() {
        System.out.println("observer2 接收到了!");
    }
}

Interfaz de sujeto

public interface Subject {

    /**
     * 增加观察者
     *
     * @param observer
     */
    public void add(Observer observer);

    /**
     * 删除观察者
     * @param observer
     */
    public void del(Observer observer);

    /**
     * 通知所有的观察者
     */
    public void notifyObservers();

    /**
     * 自身的操作
     */
    public void operation();
}

Clase de implementación del sujeto

public abstract class AbstractSubject implements Subject {
    private Vector<Observer> vector = new Vector<Observer>();

    @Override
    public void add(Observer observer) {
        vector.add(observer);
    }

    @Override
    public void del(Observer observer) {
        vector.remove(observer);
    }

    @Override
    public void notifyObservers() {
        Enumeration<Observer> enumo = vector.elements();
        while (enumo.hasMoreElements()) {
            enumo.nextElement().update();
        }
    }

    @Override
    public void operation() {

    }
}

Clase MySubject

public class MySubject extends AbstractSubject {
    @Override
    public void operation() {
        System.out.println("主对象的状态发生了改变!");
        notifyObservers();
    }
}

Clase de prueba:

public class Test {
    public static void main(String[] args) {
        Subject subject = new MySubject();
        subject.add(new Observer1());
        subject.add(new Observer2());
        subject.operation();
    }
}

Resultados de la prueba:

3. Resumen

1. 观察者模式 ¿Qué problema resolvió?

Los cambios de estado de un objeto se notifican a otros objetos, y se debe considerar la facilidad de uso y el bajo acoplamiento para garantizar un alto grado de colaboración.

2. ¿Cómo solucionarlo?

Usando tecnología orientada a objetos, esta dependencia puede debilitarse.

3. 观察者模式 Cuando se usa

Cuando el estado de un objeto (objeto de destino) cambia, todos los objetos dependientes (objetos de observación) serán notificados y emitidos.

4. 观察者模式 Ventajas y desventajas.

[Ventajas]

① El observador y el observador están acoplados de manera abstracta.
② Establecer un mecanismo de activación.

[Desventajas]

① Si un objeto observado tiene muchos observadores directos e indirectos, tomará mucho tiempo notificar a todos los observadores.
②Si existe una dependencia circular entre el observador y el objetivo de observación, el objetivo de observación activará una llamada circular entre ellos, lo que puede provocar el bloqueo del sistema.
③ No existe un mecanismo correspondiente para el modo de observador que permita al observador saber cómo ha cambiado el objeto objetivo observado, sino solo saber que el objetivo de observación ha cambiado.

5. 观察者模式 Escenarios de uso

Un modelo abstracto tiene dos aspectos, uno de los cuales depende del otro. Encapsular estos aspectos en objetos separados les permite ser cambiados y reutilizados independientemente.

El cambio de un objeto hará que el otro o más objetos también cambien, sin saber cuántos objetos cambiarán, lo que puede reducir el acoplamiento entre los objetos.

Un objeto debe notificar a otros objetos sin saber quiénes son estos objetos.

Debe crear una cadena de activación en el sistema. El comportamiento del objeto A afectará al objeto B. El comportamiento del objeto B afectará al objeto C ... Puede usar el modo de observador para crear un mecanismo de activación de cadena.

6. 观察者模式 Consideraciones

① Ya existe una clase de soporte para el patrón de observador en JAVA.
② Evitar referencias circulares.
③ Si se ejecuta en secuencia, un error del observador hará que el sistema se atasque, generalmente usando el modo asíncrono.

---

Debido al nivel limitado, inevitablemente habrá algunos errores en el blog. Si hay algún error, ¡te insto a que me lo hagas saber!