设计模式-策略模式

策略模式（Strategy Pattern）

定义

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

优点

遵循开闭原则：可以在不修改现有代码的情况下增加新策略。
消除多重条件语句：避免了使用大量的if-else或switch-case语句。
提高灵活性：可以在运行时切换算法。

缺点

增加类的数量：每个策略都需要一个新的类，增加了代码的复杂性。
客户端必须知道所有策略：客户端需要了解不同的策略，以便选择合适的策略。

应用场景

当需要使用不同的算法或行为来完成某个任务时。
当有多种相似的行为，只需要在不同情况下切换时。
当需要避免使用大量条件语句（如if-else或switch-case）时。

示例：购物优惠系统

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

代码实现

定义策略接口 ：DiscountStrategy

java 复制代码

interface DiscountStrategy {
    double getDiscountedPrice(double price);
}

具体策略类 ：TenPercentOffStrategy 和 FullReductionStrategy

java 复制代码

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;
        }
    }
}

上下文类 ：ShoppingCart

java 复制代码

class ShoppingCart {
    private DiscountStrategy discountStrategy;

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

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

完整代码

java 复制代码

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

实现思路

定义策略接口 ：ProcessingStrategy

java 复制代码

interface ChartGenerationStrategy {
    void processRequest(Request request);
}

具体策略类 ：SyncProcessingStrategy 和 AsyncProcessingStrategy

java 复制代码

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

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

上下文类 ：RequestProcessor

java 复制代码

class RequestProcessor {
    private ProcessingStrategy processingStrategy;

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

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

监控和切换策略 ：ServerMetricsUtil 和 Main

java 复制代码

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);
    }
}

总结

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