El modo Observer (a veces llamado Modo Publish-Subscribe, modo de visión del modelo, modo de lista de origen o modo esclavo) es un tipo de modo de diseño de software. En este modo, un objeto objetivo gestiona todos los objetos observadores que dependen de él y emiten notificaciones activamente cuando su estado cambia. Esto generalmente se logra llamando a los métodos de cada observador. Este patrón generalmente se usa para implementar sistemas de procesamiento de eventos.
El modo observador separa perfectamente el observador del objeto observado. Por ejemplo, la interfaz de usuario se puede utilizar como observador, y los datos comerciales son el observador. La interfaz de usuario observa los cambios en los datos comerciales. Después de descubrir los cambios en los datos, se mostrará en la interfaz. Un principio del diseño orientado a objetos es que cada clase del sistema se centrará en una función, no en otros aspectos. Una persona hace solo una cosa y lo hace bien. El modo Observador dibuja límites claros entre los módulos, mejorando la capacidad de mantenimiento y la reutilización de la aplicación.
El patrón de diseño del observador define una dependencia de uno a muchos entre objetos para que cuando el estado de un objeto cambie, todos los objetos que dependen de él se notifican y se actualizan automáticamente.
Método de implementación:
Hay muchas formas de implementar el patrón de observador, y fundamentalmente, el patrón debe contener dos roles: el observador y el objeto que se observa. En el ejemplo de ahora, los datos comerciales son el objeto a observar y la interfaz de usuario es el observador. Existe una relación lógica entre el observador y el observador. Cuando el observador cambia, el observador observará dichos cambios y responderá en consecuencia. Si se utiliza dicho proceso de observación entre la interfaz de usuario y los datos comerciales, se puede garantizar que se dibuja el límite entre la interfaz y los datos. Suponiendo que las necesidades de la aplicación cambian, el rendimiento de la interfaz debe modificarse. Solo se necesita reconstruir una interfaz de usuario, y los datos comerciales no necesitan cambiar.
1. Observador
(Observador) se registra en el sujeto, y el objeto observado almacena el observador en un contenedor.
2. Ser observado
El objeto que se observa tiene algún cambio (como se muestra en SomeChange en la figura), y todos los observadores registrados se obtienen del contenedor y notifican al observador del cambio.
3. Revocar la observación
El observador le dice al observador que cancele la observación y elimina el observador del contenedor.
Cuando un observador se registra en el contenedor del observador, el observador no debe preguntar sobre el tipo específico del observador, sino que debe usar la interfaz del observador. Esta ventaja es: suponiendo que hay otros observadores en el programa, siempre que este observador también sea implementado por la misma interfaz. Una persona observada puede corresponder a múltiples observadores. Cuando la persona que se observa cambia, puede notificar a todos los observadores uno por uno. Basado en interfaces, no implementaciones específicas, esto proporciona una mayor flexibilidad para los programas.
Código de demostración:
Definir la clase abstracta de roles que se observará:
paquete test.edu.mainrole; import java.util.arrayList; Public Abstract Class Absrole {private ArrayList <Iobserver> list = new ArrayList <Iobserver> (); public void add (IOBServer Observer) {list.add (observador); } public void Delete (IOBServer Observer) {list.remove (observador); } public void noDifyObServers (String NewState) {for (IOBServer Observer: list) {observver.update (newState); }}} Subclase de rol observado:
paquete test.edu.mainrole; El rol de clase pública extiende la absrola {estado de cadena privada; public String getState () {return State; } cambio public void (string nupdate) {state = nupdate; this.nodifyObServers (estado); }} Defina la interfaz del observador:
paquete test.edu.mainrole; interfaz pública ioBServer {Update public void (String NewState); } Observadores específicos:
paquete test.edu.mainrole; clase pública ObserverBJ1 implementa ioBServer {private String observverState; @Override public void Update (string state) {observverState = state; System.out.println ("El estado del observador 1 es:" + observación); }} paquete test.edu.mainrole; clase pública ObserverBj2 implementa IOBServer {private String ObserverState; @Override public void Update (string state) {observverState = state; System.out.println ("El estado del observador 2 es:" + observación); }} Cliente de prueba:
paquete test.edu.mainrole; Cliente de clase pública { / ** * @param args * / public static void main (string [] args) {rol seno = new rol (); IOBSERVER Observer1 = new ObserverVeBJ1 (); IOBSERVER Observer2 = new ObserverVeBJ2 (); Sujeto.Add (observador1); Sujeto.add (observador2); Sujeto.change ("¡Actualización!"); }} Resultados de ejecución:
El estado del observador 1 es: ¡Actualización! El estado de Observer 2 es: ¡Actualización!
Lo anterior se trata de este artículo, y espero que te inspire a aprender.