Java-观察者模式业务实战

Java-观察者模式业务实战

引言

观察者模式是一种常用的设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有的观察者对象，使它们能够自动更新自身。

在用户注册场景中，当一个用户完成注册后，通常会有多个操作需要执行，比如发送欢迎邮件、记录日志、更新数据库等。这个场景非常适合使用观察者模式，可以把这些操作看作是注册事件的观察者。这样后续维护或者需要新增业务点就可以做到非侵入式迭代。

实践

定义一个 Subject 接口和一个 Observer 接口。

// Subject 接口
public interface Subject {
    
    
  // 注册观察者
  void registerObserver(Observer o);
	// 移除观察者	
  void removeObserver(Observer o);
  // 通知
  void notifyObservers();
}

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

创建一个 UserRegistration 类，该类实现了 Subject 接口。

import java.util.ArrayList;

// UserRegistration 类
public class UserRegistration implements Subject {
    
    

    private ArrayList<Observer> observers;
    private String message;

    public UserRegistration() {
    
    
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
    
    
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
    
    
        int i = observers.indexOf(o);
        if (i >= 0) {
    
    
            observers.remove(i);
        }
    }

    @Override
    public void notifyObservers() {
    
    
        for (int i = 0; i < observers.size(); i++) {
    
    
            Observer observer = (Observer)observers.get(i);
            observer.update(message);
        }
    }

    public void setMessage(String message) {
    
    
        this.message = message;
        notifyObservers();
    }
}

接下来，创建三个具体的观察者类，分别是 SendEmail, LogRecord, UpdateDatabase，这三个类分别实现了 Observer 接口。

// SendEmail 类
public class SendEmail implements Observer {
    
    

    private Subject userRegistration;

    public SendEmail(Subject userRegistration) {
    
    
        this.userRegistration = userRegistration;
        userRegistration.registerObserver(this);
    }

    @Override
    public void update(String message) {
    
    
        System.out.println("Send Email: " + message);
    }
}

// LogRecord 类
public class LogRecord implements Observer {
    
    

    private Subject userRegistration;

    public LogRecord(Subject userRegistration) {
    
    
        this.userRegistration = userRegistration;
        userRegistration.registerObserver(this);
    }

    @Override
    public void update(String message) {
    
    
        System.out.println("Record Log: " + message);
    }
}

// UpdateDatabase 类
public class UpdateDatabase implements Observer {
    
    

    private Subject userRegistration;

    public UpdateDatabase(Subject userRegistration) {
    
    
        this.userRegistration = userRegistration;
        userRegistration.registerObserver(this);
    }

    @Override
    public void update(String message) {
    
    
        System.out.println("Update Database: " + message);
    }
}

测试代码

// Main 类
public class Main {
    
    

    public static void main(String[] args) {
    
    

        // 创建一个 UserRegistration 对象
        UserRegistration userRegistration = new UserRegistration();

        // 创建三个观察者对象
        SendEmail sendEmail = new SendEmail(userRegistration);
        LogRecord logRecord = new LogRecord(userRegistration);
        UpdateDatabase updateDatabase = new UpdateDatabase(userRegistration);

        // 模拟用户注册
        userRegistration.setMessage("A new user has registered.");

        // 移除一个观察者
        userRegistration.removeObserver(sendEmail);

        // 模拟另一个用户注册
        userRegistration.setMessage("Another user has registered.");
    }
}

输出

Send Email: A new user has registered.
Record Log: A new user has registered.
Update Database: A new user has registered.
Record Log: Another user has registered.
Update Database: Another user has registered.

可以看到，当一个用户注册后，会自动发送邮件、记录日志和更新数据库。当另一个用户注册后，由于 SendEmail 观察者已被移除，所以不会再发送邮件，但会继续记录日志和更新数据库。

总结

观察者模式是一种非常实用的设计模式，在用户注册场景中，可以帮助我们简化代码，提高代码的可扩展性。当需要增加、修改或移除某个操作时，只需要添加、修改或移除相应的观察者即可，无需修改其他代码。

实际应用中可能业务有所变更，但思想是不变的。