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

A乐神

已于 2024-01-22 18:40:28 修改

阅读量691

点赞数 14

分类专栏： java 文章标签： java spring 策略模式

于 2024-01-22 18:40:01 首次发布

本文链接：https://blog.csdn.net/weixin_43895362/article/details/135753830

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

简介:

23设计者模式以及重点模式

策略模式（Strategy Pattern）

简介:

本文是个系列一次会出两个设计者模式作用，如果有关联就三个，除此外还会讲解在spring中作用。

23设计者模式以及重点模式

我们都知道设计者模式有3类23种设计模式，标红是特别重要的设计者模式建议都会，而且熟读于心，标蓝是指其次重要建议也要明白。

（1）创建型模式：单例模式、抽象工厂模式、构建者模式、工厂模式、原型模式。

（2）结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

（3）行为型模式：访问者模式、模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式。

策略模式（Strategy Pattern）

策略模式允许在运行时选择最适合的算法或行为。它定义了一系列算法，并将每个算法封装到具有共同接口的独立的类中。这种模式允许算法的互换使用，使得算法可以独立于使用它们的客户端变化。

说白了可以根据你的参数选择要走的具体实现类

示例

// 策略接口
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 类代表了一个消息或状态的更新。