设计模式-策略模式

策略模式（Strategy Pattern）

定义

策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互换。策略模式使得算法可以在不影响客户端的情况下发生变化。该模式的主要目的是让算法在运行时可以自由切换。

策略模式 | 菜鸟教程 (runoob.com)

策略模式的主要角色

抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

优点

• 遵循开闭原则：可以在不修改现有代码的情况下增加新策略。

• 消除多重条件语句：避免了使用大量的if-else或switch-case语句。

• 提高灵活性：可以在运行时切换算法。

缺点

• 增加类的数量：每个策略都需要一个新的类，增加了代码的复杂性。

• 客户端必须知道所有策略：客户端需要了解不同的策略，以便选择合适的策略。

应用场景

• 当需要使用不同的算法或行为来完成某个任务时。

• 当有多种相似的行为，只需要在不同情况下切换时。

• 当需要避免使用大量条件语句（如if-else或switch-case）时。

案例：策略模式 + 工厂方法模式

业务场景介绍

假设我们有一个业务需求，系统中有多个业务场景使用不同的策略，比如：

1. 登录策略：支持微信登录、邮箱登录、手机号码登录等。
2. 支付策略：支持支付宝、微信支付、银行卡支付等多种支付方式。
3. 解析Excel文件策略：不同的Excel版本使用不同的解析策略。
4. 优惠等级策略：不同用户享有不同的优惠等级，可能基于消费金额、用户等级等条件。

实现思路

• 策略模式：为每种业务场景定义一个策略接口，并提供不同的策略实现类。每个实现类封装一种具体的算法（例如不同的登录方式、支付方式等）。
• 工厂方法模式：提供一个工厂类，根据不同的业务需求选择和返回合适的策略对象。
• Spring容器管理：将策略类交由Spring容器管理，这样可以方便地通过依赖注入来获取策略对象。

示例：购物优惠系统

在购物优惠系统中，我们可以使用策略模式来实现不同的优惠策略。用户可以选择九折优惠策略或满减优惠策略，系统将根据选择的策略计算优惠后的价格。

代码实现

1. 定义策略接口：DiscountStrategy

interface DiscountStrategy {
    double getDiscountedPrice(double price);
}

1. 具体策略类：TenPercentOffStrategy 和 FullReductionStrategy

class TenPercentOffStrategy implements DiscountStrategy {
    @Override
    public double getDiscountedPrice(double price) {
        return price * 0.9;
    }
}

class FullReductionStrategy implements DiscountStrategy {
    @Override
    public double getDiscountedPrice(double price) {
        if (price >= 300) {
            return price - 40;
        } else if (price >= 200) {
            return price - 25;
        } else if (price >= 150) {
            return price - 15;
        } else if (price >= 100) {
            return price - 5;
        } else {
            return price;
        }
    }
}

1. 上下文类：ShoppingCart

class ShoppingCart {
    private DiscountStrategy discountStrategy;

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

    public double calculatePrice(double price) {
        return discountStrategy.getDiscountedPrice(price);
    }
}

完整代码

import java.util.Scanner;

// 抽象策略接口
interface DiscountStrategy {
    double getDiscountedPrice(double price);
}

// 九折优惠策略
class TenPercentOffStrategy implements DiscountStrategy {
    @Override
    public double getDiscountedPrice(double price) {
        return price * 0.9;
    }
}

// 满减优惠策略
class FullReductionStrategy implements DiscountStrategy {
    @Override
    public double getDiscountedPrice(double price) {
        if (price >= 300) {
            return price - 40;
        } else if (price >= 200) {
            return price - 25;
        } else if (price >= 150) {
            return price - 15;
        } else if (price >= 100) {
            return price - 5;
        } else {
            return price;
        }
    }
}

// 上下文类
class ShoppingCart {
    private DiscountStrategy discountStrategy;

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

    public double calculatePrice(double price) {
        return discountStrategy.getDiscountedPrice(price);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        ShoppingCart cart = new ShoppingCart();

        for (int i = 0; i < n; i++) {
            double price = sc.nextDouble();
            int strategyType = sc.nextInt();

            switch (strategyType) {
                case 1:
                    cart.setDiscountStrategy(new TenPercentOffStrategy());
                    break;
                case 2:
                    cart.setDiscountStrategy(new FullReductionStrategy());
                    break;
                default:
                    throw new IllegalArgumentException("Invalid discount strategy");
            }

            double finalPrice = cart.calculatePrice(price);
            System.out.printf("%.0f%n", finalPrice); // 保留整数部分输出
        }

        sc.close();
    }
}

策略模式在项目中的应用

在我的数据分析项目中，我使用策略模式实现了反向压力机制，防止。具体来说，通过实时监控服务器的CPU和内存使用率。

当资源使用低于70%时，系统使用同步策略来快速响应用户请求；当资源使用高于此阈值时，系统转而使用异步策略，将任务推送到消息队列中，避免即时处理导致的资源瓶颈。

实现思路

1. 定义策略接口：ProcessingStrategy

interface ChartGenerationStrategy {
    void processRequest(Request request);
}

1. 具体策略类：SyncProcessingStrategy 和 AsyncProcessingStrategy

class SynchronousStrategy implements ProcessingStrategy {
    @Override
    public void processRequest(Request request) {
        // 同步处理请求
    }
}

class AsynchronousStrategy implements ProcessingStrategy {
    @Override
    public void processRequest(Request request) {
        // 异步处理请求
    }
}

1. 上下文类：RequestProcessor

class RequestProcessor {
    private ProcessingStrategy processingStrategy;

    public void setProcessingStrategy(ProcessingStrategy processingStrategy) {
        this.processingStrategy = processingStrategy;
    }

    public void process(Request request) {
        processingStrategy.processRequest(request);
    }
}

1. 监控和切换策略：ServerMetricsUtil 和 Main

class ServerMetricsUtil {
    public static double getCpuUsage() {
        // 获取CPU使用率
    }

    public static double getMemoryUsage() {
        // 获取内存使用率
    }
}

public class Main {
    public static void main(String[] args) {
        RequestProcessor processor = new ChartGenerationStrategy();
        Request request = new Request();

        double cpuUsage = ServerMetricsUtil.getCpuUsage();
        double memoryUsage = ServerMetricsUtil.getMemoryUsage();

        if (cpuUsage > 70 || memoryUsage > 70) {
            processor.setProcessingStrategy(new AsynchronousStrategy());
        } else {
            processor.setProcessingStrategy(new SynchronousStrategy());
        }

        processor.process(request);
    }
}

总结

策略模式提供了一种灵活的方式来定义一系列算法，并使它们可以互换。通过在项目中使用策略模式，我们可以在运行时根据不同的条件选择不同的处理策略，增强系统的灵活性和可维护性。在本文中，我们通过购物优惠系统和反向压力机制两个实例，详细介绍了策略模式的定义、优缺点、应用场景以及具体实现。希望这篇博客能帮助你更好地理解和应用策略模式。