El "Modo Observador" de los patrones de diseño escritos para mí.

definición

Cuando hay una relación de uno a varios entre objetos, el objeto dependiente cambia y todos los objetos que dependen de él deben ser notificados.

por ejemplo

Debido al impacto de la epidemia, las escuelas de todo el país han retrasado el inicio de la escuela. La escuela comunica la noticia del retraso en el inicio a los maestros y padres (independientemente de la situación que el maestro transmita a los padres), y la hora de inicio específica es la misma. En este ejemplo, la escuela tiene una relación de uno a varios con los maestros y los padres, y es necesario notificarles las notificaciones de la escuela. Utilice el modo de observador para ver el código.

• Primero defina a la persona observada:学校

Mantener una variedad de observadores, los maestros y los padres pueden registrarse a través del método registerObserver; las escuelas publican notificaciones a través del método publishNotice

import java.util.ArrayList;
import java.util.List;
import observer.consumer.Observer;

public class School {
    
    

    private String name;

    public School(String name) {
    
    
        this.name = name;
    }

    private List<Observer> observers = new ArrayList<>();

    public void registerObserver(Observer observer) {
    
    
        observers.add(observer);
    }

    public void publishNotice(String message) {
    
    
        System.out.println("I'm school: " + name + ", send message: " + message);
        observers.forEach(e -> e.update(message));
    }
}

• Definir la interfaz Observer

public interface Observer {
    
    
    void update(String message);
}

• Definir al observador: el maestro

public class Teacher implements Observer {
    
    
    private String name;

    public Teacher(String name) {
    
    
        this.name = name;
    }

    @Override
    public void update(String message) {
    
    
        System.out.println("I'm teacher: " + name + ", received message: " + message);
        // do something
    }
}

• Definir el observador: padres

public class Parent implements Observer {
    
    
    private String name;

    public Parent(String name) {
    
    
        this.name = name;
    }

    @Override
    public void update(String message) {
    
    
        System.out.println("I'm parent: " + name + ", received message: " + message);
        // do something
    }
}

• Finalmente, utilice el método principal para ejecutar el anuncio del inicio retrasado de la escuela.

public class Main {
    
    
    public static void main(String[] args) {
    
    
        Parent parent = new Parent("ZS");
        Teacher teacher = new Teacher("LS");

        School school = new School("CSU");
        school.registerObserver(parent);
        school.registerObserver(teacher);

        school.publishNotice("Delay the start of school");
    }
}

Pros y contras

• ventaja

  • Como puede ver en el ejemplo anterior, existe un acoplamiento abstracto entre el observador y lo observado. La clase School no llama directamente al método de actualización de Teacher & Parent, sino que es una programación orientada a la interfaz y llama al método de su interfaz Observer. La ventaja es que si desea agregar un nuevo observador, puede heredar directamente la clase Observer y registrarla en School.
  • Se ha establecido un conjunto de mecanismos de activación. Si la Escuela quiere enviar las puntuaciones de cada alumno, se puede reutilizar el mismo mecanismo, sin volver a implementarlo.

• Desventaja

  • Si hay demasiados observadores, llevará mucho tiempo ejecutar la notificación (atravesando una matriz grande), y los observadores innecesarios deben darse de baja a tiempo.
  • Si el observador y lo observado son cíclicamente dependientes, puede causar una llamada cíclica y hacer que el sistema se bloquee.
  • El observador no sabe cómo cambia el objeto observado, solo el cambio.