设计模式——策略模式

策略模式

- [1. 引言](#1. 引言)
- [2. 什么是策略模式?](#2. 什么是策略模式?)
- [3. 策略模式的结构](#3. 策略模式的结构)
- [4. 策略模式的实现](#4. 策略模式的实现)
- [5. 策略模式的优点](#5. 策略模式的优点)
- [6. 策略模式的缺点](#6. 策略模式的缺点)
- [7. 策略模式的应用场景](#7. 策略模式的应用场景)
- [8. 策略模式与其他模式的关系](#8. 策略模式与其他模式的关系)
- [9. Java标准库中的策略模式](#9. Java标准库中的策略模式)
- - [1. java.util.Comparator](#1. java.util.Comparator)
  - 示例：
  - [2. java.util.concurrent.ThreadPoolExecutor](#2. java.util.concurrent.ThreadPoolExecutor)
  - 示例：
  - [3. javax.servlet.http.HttpServlet](#3. javax.servlet.http.HttpServlet)
  - 示例：
  - [4. java.io.InputStream](#4. java.io.InputStream)
  - 示例：
  - [5. javax.swing.LayoutManager](#5. javax.swing.LayoutManager)
  - 示例：
- [10. 总结](#10. 总结)

1. 引言

在软件开发中,我们经常需要实现一些算法或策略,而这些算法可能会随着需求的变化而改变。策略模式就是为了应对这种情况而生的,它提供了一种灵活且可扩展的方式来管理和切换不同的算法。

2. 什么是策略模式?

策略模式(Strategy Pattern)是一种行为型设计模式,它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化独立于使用算法的客户端。

3. 策略模式的结构

策略模式主要包含以下三个角色:

Context(上下文): 持有一个Strategy的引用
Strategy(抽象策略类): 定义了一个公共接口,各种不同的算法以不同的方式实现这个接口
ConcreteStrategy(具体策略类): 实现了Strategy接口的具体算法

4. 策略模式的实现

一个电商系统,需要根据不同的会员等级提供不同的折扣策略。

首先,定义一个折扣策略接口:

java 复制代码

public interface DiscountStrategy {
    double applyDiscount(double price);
}

然后,实现几个具体的折扣策略:

java 复制代码

// 普通会员折扣
public class RegularDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.95; // 5%折扣
    }
}

// 黄金会员折扣
public class GoldDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.9; // 10%折扣
    }
}

// 白金会员折扣
public class PlatinumDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.85; // 15%折扣
    }
}

接下来,创建一个上下文类来使用这些策略:

java 复制代码

public class ShoppingCart {
    private DiscountStrategy discountStrategy;

    public void setDiscountStrategy(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double checkout(double price) {
        if (discountStrategy == null) {
            return price;
        }
        return discountStrategy.applyDiscount(price);
    }
}

最后,可以在客户端代码中使用这个购物车ShoppingCart :

java 复制代码

public class Client {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        
        // 普通会员购物
        cart.setDiscountStrategy(new RegularDiscountStrategy());
        System.out.println("Regular member's price: " + cart.checkout(100));

        // 黄金会员购物
        cart.setDiscountStrategy(new GoldDiscountStrategy());
        System.out.println("Gold member's price: " + cart.checkout(100));

        // 白金会员购物
        cart.setDiscountStrategy(new PlatinumDiscountStrategy());
        System.out.println("Platinum member's price: " + cart.checkout(100));
    }
}

5. 策略模式的优点

算法可以自由切换: 只要实现了策略接口,就可以自由地在不同策略间切换。
避免使用多重条件判断: 如果不使用策略模式,可能需要使用多重条件语句来选择不同的算法。
扩展性良好: 在不修改原有系统的基础上,可以灵活地增加新的算法。
策略类之间可以自由替换: 由于所有策略类都实现同一个接口,所以它们之间可以自由替换。

6. 策略模式的缺点

客户端必须知道所有的策略类,并自行决定使用哪一个策略类。
策略模式将造成产生很多策略类,可能会增加系统的复杂度。
每一个策略都是一个单独的类,复用性较低。

7. 策略模式的应用场景

当一个系统需要动态地在几种算法中选择一种时。
当一个对象有很多的行为,如果不用模式,这些行为就只好使用多重条件选择语句来实现。
不希望客户端知道复杂的、与算法相关的数据结构,在具体策略类中封装算法和相关的数据结构,提高算法的保密性与安全性。

8. 策略模式与其他模式的关系

工厂模式: 工厂模式可以用来创建策略对象,与策略模式配合使用。
状态模式: 策略模式和状态模式的结构几乎完全一样,但它们的意图不同。
命令模式: 命令模式可以使用策略模式来参数化命令对象。

9. Java标准库中的策略模式

Java标准库中有很多使用策略模式的例子。

1. java.util.Comparator

Comparator接口是Java中最常见的策略模式实现之一。它允许我们定义对象的自定义排序策略。

示例：

java 复制代码

import java.util.*;

public class ComparatorExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Charlie");

        // 使用自然顺序（字母顺序）
        Collections.sort(names);
        System.out.println("Natural order: " + names);

        // 使用自定义比较器（按长度排序）
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });
        System.out.println("Sorted by length: " + names);

        // 使用Lambda表达式（按长度降序排序）
        Collections.sort(names, (s1, s2) -> s2.length() - s1.length());
        System.out.println("Sorted by length (descending): " + names);
    }
}

在这个例子中，Comparator就是策略接口，不同的排序方法是具体的策略实现。

2. java.util.concurrent.ThreadPoolExecutor

ThreadPoolExecutor类使用策略模式来决定如何处理新提交的任务，特别是当线程池已满时。

示例：

java 复制代码

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 使用CallerRunsPolicy
        ThreadPoolExecutor executorWithCallerRuns = new ThreadPoolExecutor(
            2, 2, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(2),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 使用DiscardPolicy
        ThreadPoolExecutor executorWithDiscard = new ThreadPoolExecutor(
            2, 2, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(2),
            new ThreadPoolExecutor.DiscardPolicy());

        // 提交任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executorWithCallerRuns.execute(() -> {
                System.out.println("Task " + taskId + " executed by " + 
                                   Thread.currentThread().getName());
            });
        }

        executorWithCallerRuns.shutdown();
        executorWithDiscard.shutdown();
    }
}

这里，RejectedExecutionHandler接口是策略接口，CallerRunsPolicy和DiscardPolicy是具体的策略实现。

3. javax.servlet.http.HttpServlet

虽然不是严格意义上的策略模式，HttpServlet类使用了类似策略模式的方法来处理不同类型的HTTP请求。

示例：

java 复制代码

import javax.servlet.http.*;
import java.io.IOException;

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws IOException {
        response.getWriter().println("GET request handled");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws IOException {
        response.getWriter().println("POST request handled");
    }

    // 其他HTTP方法...
}

在这个例子中，不同的HTTP方法（GET、POST等）可以看作是不同的策略。

4. java.io.InputStream

InputStream类及其子类使用了策略模式来实现不同的读取策略。

示例：

java 复制代码

import java.io.*;

public class InputStreamExample {
    public static void main(String[] args) throws IOException {
        // 文件输入流策略
        try (InputStream fileIn = new FileInputStream("example.txt")) {
            int data = fileIn.read();
            while(data != -1) {
                System.out.print((char) data);
                data = fileIn.read();
            }
        }

        // 字节数组输入流策略
        byte[] bytes = "Hello, World!".getBytes();
        try (InputStream byteArrayIn = new ByteArrayInputStream(bytes)) {
            int data = byteArrayIn.read();
            while(data != -1) {
                System.out.print((char) data);
                data = byteArrayIn.read();
            }
        }
    }
}

这里，InputStream是抽象策略，FileInputStream和ByteArrayInputStream是具体策略。

5. javax.swing.LayoutManager

Swing库中的LayoutManager接口使用策略模式来定义不同的布局策略。

示例：

java 复制代码

import javax.swing.*;
import java.awt.*;

public class LayoutExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Layout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 使用FlowLayout策略
        JPanel flowPanel = new JPanel(new FlowLayout());
        flowPanel.add(new JButton("Button 1"));
        flowPanel.add(new JButton("Button 2"));

        // 使用BorderLayout策略
        JPanel borderPanel = new JPanel(new BorderLayout());
        borderPanel.add(new JButton("North"), BorderLayout.NORTH);
        borderPanel.add(new JButton("South"), BorderLayout.SOUTH);

        frame.add(flowPanel, BorderLayout.NORTH);
        frame.add(borderPanel, BorderLayout.CENTER);

        frame.pack();
        frame.setVisible(true);
    }
}

在这个例子中，LayoutManager是策略接口，FlowLayout和BorderLayout是具体的布局策略。

10. 总结

策略模式是一种非常实用的设计模式,它提供了管理算法族、分离算法实现和算法使用的有效方法。通过策略模式,可以在不修改原有系统的情况下,灵活地增加新的算法或行为。在实际开发中,应该根据具体情况来判断是否使用策略模式,以达到代码复用、增强扩展性和维护性的目的。