Hola a todos, ¿sigues programando bucles for?
¿Quién más no puede usar el patrón de observador?
Este artículo trae la teoría y el combate real del " Modo Observador " ~
¿Qué es el patrón del observador?
El patrón de observador define una dependencia de uno a muchos entre objetos, de modo que mientras cambia el estado de un objeto, todos los objetos relacionados de los que depende serán notificados y actualizados automáticamente.
En el modo de observador, el objeto que cambia se denomina objetivo de observación y el objeto al que se notifica la actualización se denomina observador . Un objetivo de observación corresponde a múltiples observadores. El observador es generalmente una colección de listas, que se puede agregar dinámicamente y eliminado según sea necesario Fácil de ampliar.
La ventaja de usar el patrón del observador es que existe una relación de acoplamiento débil abstracta entre el objetivo de observación y el observador, lo que reduce la relación de acoplamiento entre los dos.
modelo de publicación-suscripción
El modo observador también se denomina modo de publicación-suscripción (Publish/Subscribe) en muchos lugares. De hecho, se puede entender de esta manera, pero aún existen ligeras diferencias entre los dos.
El observador en el modo de observador está vinculado directamente al objetivo de observación, y el objetivo de observación necesita mantener un conjunto de listas de observadores. Los dos tienen una dependencia combinada basada en la interfaz. Por lo tanto, aunque el modo de observador está débilmente acoplado, es no No completamente desacoplado.
En el modelo de publicación-suscripción , no hay conexión entre el editor y el suscriptor. El editor publica un tema (Tema) a través de la parte intermedia, y el suscriptor se suscribe a un tema (Tema) a través de la parte intermedia (centro de programación), y el estado del editor Los cambios de la suscripción no se notificarán directamente a los suscriptores, sino que se notificarán a través del intermediario, o los suscriptores se extraerán del intermediario por sí mismos, por lo que el modelo de publicación-suscripción está completamente desacoplado.
Una imagen para entender su relación:
La diferencia entre el patrón de observador y el patrón de suscripción-publicación
Según las imágenes, hay diferencias entre los dos. Ambos se denominan modo de observador y no tienen nada de malo.
Rueda de modo de observador
Debido a que el modo de observador se usa ampliamente, el kit de herramientas JDK viene con el conjunto de plantillas de modo de observador de la versión 1. 0. Podemos implementar fácilmente el modo de observador de acuerdo con su plantilla, y no es necesario repetir la rueda.
Clase objetivo del observador:
java.util.Observable
Las dos variables más importantes son:
- cambiado : observe si el estado del objetivo ha cambiado, el valor predeterminado es: falso;
- obs : Lista de observadores (observadores), una colección de lista segura para subprocesos: Vector, el valor predeterminado es una colección vacía;
Los métodos importantes en él están todos relacionados con el estado del objetivo de observación y el observador. Está claro de un vistazo y no se presentará aquí.
Interfaz del observador:
java.util.Observable
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
* method.
*/
void update(Observable o, Object arg);
}
La interfaz del observador tiene solo un método de actualización, que se utiliza para notificar al observador que se actualice.
Modo observador en acción
Bien, sabiendo que JDK viene con estas dos cosas, ahora implementemos un escenario de aplicación de modo de observador simple, simulando el envío de artículos en la cuenta pública, el objetivo de observación soy yo, el webmaster, los observadores son todos ustedes y yo soy en el público No. La pila de tecnología Java envía un artículo, todos pueden recibir la notificación de actualización y leerla.
Nueva clase de objetivo de observación:
import lombok.Getter;
import java.util.Observable;
/**
* 观察目标：栈长
* 来源微信公众号：Java技术栈
*/
@Getter
public class JavaStackObservable extends Observable {
private String article;
/**
* 发表文章
* @param article
*/
public void publish(String article){
// 发表文章
this.article = article;
// 改变状态
this.setChanged();
// 通知所有观察者
this.notifyObservers();
}
}
La lógica del objetivo de observación es publicar el artículo primero, luego cambiar el estado del objetivo de observación y luego notificar a todos los observadores.
Centrémonos en el código fuente del método notificarObservers:
Primero adquiera el bloqueo de sincronización, determine si el estado se actualiza, si se actualizó, borre el estado del objetivo de observación, luego use el ciclo for para atravesar todos los observadores y llame al método de actualización del observador para notificar al observador que actualice .
Agregue una clase de observador:
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import java.util.Observable;
import java.util.Observer;
/**
* 观察者：读者粉丝
* 来源微信公众号：Java技术栈
*/
@RequiredArgsConstructor
public class ReaderObserver implements Observer {
@NonNull
private String name;
private String article;
@Override
public void update(Observable o, Object arg) {
// 更新文章
updateArticle(o);
}
private void updateArticle(Observable o) {
JavaStackObservable javaStackObservable = (JavaStackObservable) o;
this.article = javaStackObservable.getArticle();
System.out.printf("我是读者：%s，文章已更新为：%s\n", this.name, this.article);
}
}
La lógica del observador es obtener el objeto de instancia del objetivo del observador, luego actualizar la información del artículo del objeto objetivo del observador a su propia información del artículo y, finalmente, mostrar que el artículo de tal y tal ha sido actualizado.
El observador solo necesita implementar el método de actualización de la interfaz del observador, que se utiliza para observar el destino para la notificación de llamadas.
Todo el código fuente real de este tutorial se ha subido a este repositorio: https://github.com/javastacks/javastack
El diagrama de la estructura de la clase del objetivo de observación y del observador es el siguiente:
Nuevas clases de examen:
/**
* 观察者：读者粉丝
* 来源微信公众号：Java技术栈
*/
public class ObserverTest {
public static void main(String[] args) {
// 创建一个观察目标
JavaStackObservable javaStackObservable = new JavaStackObservable();
// 添加观察者
javaStackObservable.addObserver(new ReaderObserver("小明"));
javaStackObservable.addObserver(new ReaderObserver("小张"));
javaStackObservable.addObserver(new ReaderObserver("小爱"));
// 发表文章
javaStackObservable.publish("什么是观察者模式？");
}
}
No existe un requisito de secuencia para la creación de objetivos de observación y observadores. El punto clave es que antes de publicar artículos para notificar a los observadores, el objetivo de observación debe agregarse a la lista de observadores.
Resultado de salida:
A través de esta sencilla práctica de envío de artículos, todos deben tener una comprensión básica del patrón de observador. En el trabajo real, hay muchos escenarios que se pueden usar, y el patrón de observador se puede considerar para dependencias de uno a muchos.
Resumir
No es fácil Después de trabajar durante mucho tiempo uno tras otro, ¿has aprendido el modo observador?
La ventaja del patrón del observador es desacoplar el objetivo de observación y el observador, y la desventaja también es obvia.Se puede ver en el ejemplo anterior que si hay demasiados objetos de observador, puede causar pérdidas de memoria.
Además, desde la perspectiva del rendimiento, las actualizaciones de todos los observadores se ponen en cola en un bucle, por lo que las operaciones de actualización de los observadores se pueden considerar como subprocesos asíncronos (o se pueden usar grupos de subprocesos) para mejorar la eficiencia general.
Todo el código fuente real de este tutorial se ha subido a este repositorio:
https://github.com/javastacks/javastack