Java 设计者模式以及与Spring关系(五) 策略和观察者模式

// 策略接口
interface SortingStrategy {
    void sort(int[] array);
}

// 具体策略类：冒泡排序
class BubbleSortStrategy implements SortingStrategy {
    public void sort(int[] array) {
        System.out.println("Sorting using bubble sort");
        // 这里可以添加冒泡排序的实现
    }
}

// 具体策略类：选择排序
class SelectionSortStrategy implements SortingStrategy {
    public void sort(int[] array) {
        System.out.println("Sorting using selection sort");
        // 这里可以添加选择排序的实现
    }
}

// 上下文类
class SortedArray {
    private SortingStrategy strategy;

    public SortedArray(SortingStrategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(SortingStrategy strategy) {
        this.strategy = strategy;
    }

    public void sortArray(int[] array) {
        strategy.sort(array);
    }
}

// 测试类
public class StrategyPatternDemo {
    public static void main(String[] args) {
        int[] array = { 1, 5, 3, 2, 4 };

        SortedArray context = new SortedArray(new BubbleSortStrategy());
        context.sortArray(array);

        context.setStrategy(new SelectionSortStrategy());
        context.sortArray(array);
    }
}

spring中应用

策略模式在 Spring 中也很常见，例如资源管理和权限验证等多种不同实现可以互换使用。

观察者模式（Observer）

观察者模式是一种行为型设计模式，它定义了对象间的一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这种模式通常用于实现分布式事件处理系统，其中一个对象的状态发生改变会自动通知所有依赖于它的对象。

示例

import java.util.ArrayList;
import java.util.List;

// 主题接口
interface Subject {
    void attach(Observer o);
    void detach(Observer o);
    void notifyUpdate(Message m);
}

// 观察者接口
interface Observer {
    void update(Message m);
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer o) {
        observers.add(o);
    }

    public void detach(Observer o) {
        observers.remove(o);
    }

    public void notifyUpdate(Message m) {
        for(Observer o: observers) {
            o.update(m);
        }
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    public void update(Message m) {
        System.out.println("Received message: " + m.getMessageContent());
    }
}

// 消息类
class Message {
    private String messageContent;

    public Message(String m) {
        this.messageContent = m;
    }

    public String getMessageContent() {
        return messageContent;
    }
}

// 测试类
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();

        subject.attach(observer1);
        subject.attach(observer2);

        subject.notifyUpdate(new Message("First Message"));  // Both observers will receive the update

        subject.detach(observer1);

        subject.notifyUpdate(new Message("Second Message")); // Only the second observer will receive the update
    }
}

在这个示例中，ConcreteSubject 是一个具体的主题，它维护一个观察者列表并通知它们状态的变化。ConcreteObserver 是一个具体的观察者，定义了当接收到主题通知时如何响应。Message 类代表了一个消息或状态的更新。