java和Spring中观察者模式的应用详解

我来详细讲解一下“java和Spring中观察者模式的应用详解”的完整攻略。

什么是观察者模式？

观察者模式（Observer Pattern）是一种行为型设计模式，也叫做发布-订阅模式（Publish/Subscribe），用于定义对象之间的一种一对多的依赖关系。当一个对象的状态改变时，所有依赖于它的对象都会收到通知并自动更新。观察者模式的核心思想就是解耦，将观察者和被观察者分离开来，使系统能够更好地应对变化。

java中观察者模式的应用

在java中，观察者模式 应用广泛，比如AWT/Swing中的事件处理机制、JMS中的消息监听器模式、Java事件处理器、Servlet中的监听器、Spring框架中的事件驱动模型等等。

下面来看一个简单的java代码示例。

示例1：

public interface Observer {  
    public void update(Object obj);  
}  

public interface Subject {  
    public void attach(Observer observer);  
    public void detach(Observer observer);  
    public void notifyObservers();  
}  

public class ConcreteSubject implements Subject {  
    private List<Observer> observerList = new ArrayList<Observer>();  
    private Object obj;  

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

    @Override  
    public void detach(Observer observer) {  
        observerList.remove(observer);  
    }  

    @Override  
    public void notifyObservers() {  
        for (Observer observer : observerList) {  
            observer.update(obj);  
        }  
    }  

    public void setObj(Object obj) {  
        this.obj = obj;  
        notifyObservers();  
    }  
}  

public class ConcreteObserver implements Observer {  
    @Override  
    public void update(Object obj) {  
        System.out.println("Object has been updated: " + obj.toString());  
    }  
}  

//test 
public class Main {  
    public static void main(String[] args) {  
        ConcreteSubject subject = new ConcreteSubject();  
        Observer observer = new ConcreteObserver();  
        subject.attach(observer);  
        subject.setObj("Hello World!");  
    }  
} 

解释：

• Subject 接口定义了观察者所需要的接口，包括 attach()、detach()、notifyObservers() 方法。
• ConcreteSubject 类是具体主题角色，继承了 Subject 接口并重写其中的方法。
• Observer 接口定义了观察者所需要的接口，包括 update() 方法。
• ConcreteObserver 类是具体观察者角色，继承了 Observer 接口并重写其中的方法。
• 在 Main 类中，我们创建了 ConcreteSubject 和 ConcreteObserver 对象，并将 observer 对象添加到 subject 对象上，然后改变 subject 的状态，就会自动通知 observer。

Spring中观察者模式的应用

Spring框架在其事件驱动模型中实现了观察者模式。在Spring中，事件（Event）就是被观察者，而监听器（Listener）就是观察者。Spring 为事件和监听器之间的通信提供了 ApplicationEventPublisher 和 ApplicationListener 两个接口，具体实现类为 ApplicationContext 和 AbstractApplicationEventMulticaster。

下面看一个简单的Spring代码示例。

示例2：

@Component
public class MyEventPublisher {
    @Autowired
    private ApplicationContext applicationContext;

    public void publishEvent(MyEvent event) {
        applicationContext.publishEvent(event);
    }
}

@Component
public class MyEventListener {

    @EventListener
    public void handleEvent(MyEvent event) {
        System.out.println("Receive event: " + event.getMessage());
    }
}

public class MyEvent extends ApplicationEvent {
    private String message;

    public MyEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

//test
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.scan("com.example");
        context.refresh();

        MyEventPublisher eventPublisher = context.getBean(MyEventPublisher.class);
        eventPublisher.publishEvent(new MyEvent(this, "Hello World!"));

        context.close();
    }
}

解释：

• MyEventPublisher 类是事件的发布者，通过 ApplicationContext 接口的 publishEvent() 方法发布事件。
• MyEventListener 类是事件的监听器，使用 @EventListener 注解标记在 handleEvent() 方法上，当 MyEvent 事件发布时，handleEvent() 方法会被自动调用。
• MyEvent 类是 MyEventPublisher 所要发布的事件，继承了 ApplicationEvent 类。
• 在 Main 类中，我们创建了 AnnotationConfigApplicationContext 对象，并扫描 com.example 包，然后创建 MyEventPublisher 对象，发布 MyEvent 事件。此时，MyEventListener 的 handleEvent() 方法会被自动调用，输出 "Receive event: Hello World!"。

这就是java和Spring中观察者模式的应用详解。观察者模式是一种非常常用的设计模式，可以帮助我们实现对象之间松耦合的关系，使系统更加灵活、扩展性更强。