Java策略模式的应用案例

策略模式概述

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，将每个算法都封装起来，并且使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。在Java中，策略模式通过接口和实现类来实现，这样可以将不同的行为封装到不同的类中，使得代码更加灵活、可维护和可扩展。

策略模式的结构

1. 抽象策略（Strategy）：定义了一个公共接口，各种具体的策略类实现这个接口。这个接口规定了具体策略类必须实现的方法。
2. 具体策略（Concrete Strategy）：实现了抽象策略接口的具体类，每个具体策略类实现了不同的算法或行为。
3. 环境（Context）：持有一个抽象策略类的引用，提供给客户端调用的方法。在运行时，环境类可以根据需要切换具体的策略对象。

策略模式在Java中的实现步骤

1. 定义抽象策略接口：创建一个接口，定义需要实现的方法。这个方法就是不同策略需要实现的核心算法。
2. 创建具体策略类：实现抽象策略接口，每个具体策略类实现不同的算法。
3. 创建环境类：在环境类中持有抽象策略接口的引用，并提供一个方法，在该方法中调用策略接口的方法。
4. 客户端使用：在客户端代码中，创建环境类的对象，并根据需要传入不同的具体策略类对象。

示例场景：电商平台的促销策略

假设我们正在开发一个电商平台，平台有不同的促销策略，如满减、打折、赠品等。我们可以使用策略模式来实现这些促销策略。

定义抽象策略接口

首先，定义一个促销策略的抽象接口 PromotionStrategy。

public interface PromotionStrategy {
    void doPromotion();
}

这个接口只有一个方法 doPromotion，具体的促销策略类需要实现这个方法来执行相应的促销活动。

创建具体策略类

1. 满减策略

public class ManjianPromotionStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("满200减50");
    }
}

2. 打折策略

public class DiscountPromotionStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("打8折");
    }
}

3. 赠品策略

public class FreeGiftPromotionStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("满300送精美礼品");
    }
}

创建环境类

创建一个 PromotionActivity 类作为环境类，它持有 PromotionStrategy 的引用。

public class PromotionActivity {
    private PromotionStrategy promotionStrategy;

    public PromotionActivity(PromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }

    public void executePromotion() {
        promotionStrategy.doPromotion();
    }
}

客户端使用

在客户端代码中，我们可以根据不同的促销活动选择不同的促销策略。

public class Client {
    public static void main(String[] args) {
        // 选择满减策略
        PromotionActivity activity1 = new PromotionActivity(new ManjianPromotionStrategy());
        activity1.executePromotion();

        // 选择打折策略
        PromotionActivity activity2 = new PromotionActivity(new DiscountPromotionStrategy());
        activity2.executePromotion();

        // 选择赠品策略
        PromotionActivity activity3 = new PromotionActivity(new FreeGiftPromotionStrategy());
        activity3.executePromotion();
    }
}

在上述代码中，通过创建不同的 PromotionActivity 对象，并传入不同的具体策略类对象，实现了不同的促销策略。这样，如果需要新增或修改促销策略，只需要新增或修改具体的策略类，而不需要修改 PromotionActivity 类和客户端代码，提高了代码的可维护性和可扩展性。

策略模式在Java集合框架中的应用

在Java集合框架中，策略模式也有广泛的应用。例如，Collections 类中的 sort 方法，它可以对列表进行排序。sort 方法有两种重载形式，一种是使用元素的自然顺序进行排序（元素需要实现 Comparable 接口），另一种是可以传入一个 Comparator 对象，使用自定义的比较策略进行排序。

1. 定义比较策略接口 Comparator

public interface Comparator<T> {
    int compare(T o1, T o2);
}

Comparator 接口定义了一个 compare 方法，用于比较两个对象的大小。

2. 使用 Comparator 进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ComparatorExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 18));
        students.add(new Student("Charlie", 22));

        // 使用自定义比较策略按年龄升序排序
        Comparator<Student> ageComparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        };
        Collections.sort(students, ageComparator);
        System.out.println("按年龄升序排序: " + students);

        // 使用自定义比较策略按姓名长度降序排序
        Comparator<Student> nameLengthComparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getName().length() - o1.getName().length();
            }
        };
        Collections.sort(students, nameLengthComparator);
        System.out.println("按姓名长度降序排序: " + students);
    }
}

在上述代码中，通过实现 Comparator 接口，定义了不同的比较策略，然后将这些策略传递给 Collections.sort 方法，实现了对 Student 列表的不同排序方式。这体现了策略模式的灵活性，不同的排序策略可以相互替换，而不影响 Collections.sort 方法的实现。

策略模式与其他设计模式的关系

1. 与工厂模式结合：可以使用工厂模式来创建具体的策略对象。例如，在电商促销策略的例子中，可以创建一个 PromotionStrategyFactory 类，根据不同的条件创建不同的促销策略对象。这样可以将策略对象的创建和使用分离，使得客户端代码更加简洁。

public class PromotionStrategyFactory {
    public static PromotionStrategy getPromotionStrategy(String promotionType) {
        if ("manjian".equals(promotionType)) {
            return new ManjianPromotionStrategy();
        } else if ("discount".equals(promotionType)) {
            return new DiscountPromotionStrategy();
        } else if ("freegift".equals(promotionType)) {
            return new FreeGiftPromotionStrategy();
        }
        return null;
    }
}

客户端代码可以这样使用：

public class ClientWithFactory {
    public static void main(String[] args) {
        String promotionType = "manjian";
        PromotionStrategy strategy = PromotionStrategyFactory.getPromotionStrategy(promotionType);
        PromotionActivity activity = new PromotionActivity(strategy);
        activity.executePromotion();
    }
}

2. 与状态模式的比较：策略模式和状态模式在结构上非常相似，都有一个上下文类持有一个抽象类的引用，并且通过该引用调用具体实现类的方法。但是它们的意图不同。策略模式侧重于算法的可替换性，客户端可以根据需要选择不同的算法；而状态模式侧重于对象状态的变化，对象根据自身状态的改变而改变行为。例如，一个电梯类，在不同的状态（如运行、停止、维修等）下有不同的行为，这适合用状态模式；而如果是计算不同图形面积的算法，有矩形、圆形等不同的计算方法，这适合用策略模式。

策略模式的优点

1. 提高代码的可维护性：当需要新增或修改一个策略时，只需要新增或修改具体的策略类，不需要修改环境类和客户端代码。例如，在电商促销策略中，如果要新增一种促销策略，只需要创建一个新的具体策略类并实现 PromotionStrategy 接口，而不需要修改 PromotionActivity 类和客户端代码。
2. 提高代码的可扩展性：可以方便地添加新的策略，满足不断变化的需求。例如，电商平台后续可能会推出限时抢购、团购等促销策略，只需要创建相应的具体策略类即可。
3. 实现算法的复用：不同的客户端可以复用相同的策略类。例如，在多个电商活动中都可能用到满减策略，只需要创建一个 ManjianPromotionStrategy 类，不同的活动都可以使用它。

策略模式的缺点

1. 客户端需要了解具体策略：客户端需要知道有哪些具体策略可供选择，并根据需要选择合适的策略。这可能增加客户端代码的复杂性。例如，在电商促销策略的客户端代码中，需要知道 ManjianPromotionStrategy、DiscountPromotionStrategy 等具体策略类，并根据活动需求选择合适的策略。
2. 策略类数量增多：如果有很多不同的策略，会导致策略类的数量增多，增加代码的管理难度。例如，电商平台有非常多的促销策略，如阶梯满减、组合打折等，会创建大量的具体策略类。

策略模式在实际项目中的应用场景

1. 游戏开发：在游戏中，不同的角色可能有不同的攻击方式、移动方式等。可以使用策略模式来实现这些不同的行为。例如，战士角色可能有近战攻击策略，法师角色可能有远程魔法攻击策略。

public interface AttackStrategy {
    void attack();
}

public class MeleeAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("使用近战武器攻击");
    }
}

public class MagicAttackStrategy implements AttackStrategy {
    @Override
    public void attack() {
        System.out.println("释放魔法攻击");
    }
}

public class Character {
    private AttackStrategy attackStrategy;

    public Character(AttackStrategy attackStrategy) {
        this.attackStrategy = attackStrategy;
    }

    public void performAttack() {
        attackStrategy.attack();
    }
}

客户端代码：

public class GameClient {
    public static void main(String[] args) {
        // 创建战士角色
        Character warrior = new Character(new MeleeAttackStrategy());
        warrior.performAttack();

        // 创建法师角色
        Character mage = new Character(new MagicAttackStrategy());
        mage.performAttack();
    }
}

2. 数据加密：在数据传输或存储过程中，可能需要使用不同的加密算法，如AES、RSA等。可以使用策略模式来实现不同的加密策略。

public interface EncryptionStrategy {
    String encrypt(String data);
}

public class AESEncryptionStrategy implements EncryptionStrategy {
    @Override
    public String encrypt(String data) {
        // 实际的AES加密逻辑
        return "AES加密后的: " + data;
    }
}

public class RSAEncryptionStrategy implements EncryptionStrategy {
    @Override
    public String encrypt(String data) {
        // 实际的RSA加密逻辑
        return "RSA加密后的: " + data;
    }
}

public class DataSender {
    private EncryptionStrategy encryptionStrategy;

    public DataSender(EncryptionStrategy encryptionStrategy) {
        this.encryptionStrategy = encryptionStrategy;
    }

    public void sendData(String data) {
        String encryptedData = encryptionStrategy.encrypt(data);
        System.out.println("发送加密后的数据: " + encryptedData);
    }
}

客户端代码：

public class EncryptionClient {
    public static void main(String[] args) {
        // 使用AES加密策略发送数据
        DataSender sender1 = new DataSender(new AESEncryptionStrategy());
        sender1.sendData("重要信息");

        // 使用RSA加密策略发送数据
        DataSender sender2 = new DataSender(new RSAEncryptionStrategy());
        sender2.sendData("敏感数据");
    }
}

3. 报表生成：在企业应用中，可能需要生成不同格式的报表，如PDF、Excel、HTML等。可以使用策略模式来实现不同的报表生成策略。

public interface ReportGeneratorStrategy {
    void generateReport();
}

public class PDFReportGeneratorStrategy implements ReportGeneratorStrategy {
    @Override
    public void generateReport() {
        System.out.println("生成PDF格式报表");
    }
}

public class ExcelReportGeneratorStrategy implements ReportGeneratorStrategy {
    @Override
    public void generateReport() {
        System.out.println("生成Excel格式报表");
    }
}

public class HTMLReportGeneratorStrategy implements ReportGeneratorStrategy {
    @Override
    public void generateReport() {
        System.out.println("生成HTML格式报表");
    }
}

public class ReportGenerator {
    private ReportGeneratorStrategy reportGeneratorStrategy;

    public ReportGenerator(ReportGeneratorStrategy reportGeneratorStrategy) {
        this.reportGeneratorStrategy = reportGeneratorStrategy;
    }

    public void generate() {
        reportGeneratorStrategy.generateReport();
    }
}

客户端代码：

public class ReportClient {
    public static void main(String[] args) {
        // 生成PDF报表
        ReportGenerator pdfGenerator = new ReportGenerator(new PDFReportGeneratorStrategy());
        pdfGenerator.generate();

        // 生成Excel报表
        ReportGenerator excelGenerator = new ReportGenerator(new ExcelReportGeneratorStrategy());
        excelGenerator.generate();

        // 生成HTML报表
        ReportGenerator htmlGenerator = new ReportGenerator(new HTMLReportGeneratorStrategy());
        htmlGenerator.generate();
    }
}

通过以上丰富的示例和详细的讲解，相信你对Java中策略模式的应用有了更深入的理解。策略模式在实际开发中有着广泛的应用，能够有效地提高代码的灵活性、可维护性和可扩展性。在面对需要根据不同情况选择不同算法或行为的场景时，不妨考虑使用策略模式来优化代码。