Java 中的策略设计模式

简介

策略设计模式（Strategic Design Pattern）是一种行为型设计模式，它在 Java 编程中有着广泛的应用。该模式定义了一系列算法，将每个算法都封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户，使得代码更加灵活、可维护和可扩展。

基础概念

策略设计模式包含以下几个关键角色： - 抽象策略（Strategy）：定义了一个公共接口，所有具体策略类都必须实现这个接口。这个接口声明了一系列方法，这些方法代表了不同的算法。 - 具体策略（Concrete Strategy）：实现了抽象策略接口中定义的方法，每个具体策略类都实现了一个特定的算法。 - 上下文（Context）：持有一个抽象策略类型的引用，通过这个引用调用具体策略类的方法。上下文将客户端与具体策略隔离开来，客户端只需要与上下文交互，而不需要关心具体的策略实现。

使用方法

示例代码

下面通过一个简单的示例来展示策略设计模式的使用方法。假设我们有一个计算不同形状面积的应用，形状包括矩形和圆形。

抽象策略接口

public interface ShapeAreaCalculator {
    double calculateArea();
}

具体策略类：矩形面积计算

public class RectangleAreaCalculator implements ShapeAreaCalculator {
    private double length;
    private double width;

    public RectangleAreaCalculator(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

具体策略类：圆形面积计算

public class CircleAreaCalculator implements ShapeAreaCalculator {
    private double radius;

    public CircleAreaCalculator(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

上下文类

public class ShapeContext {
    private ShapeAreaCalculator calculator;

    public ShapeContext(ShapeAreaCalculator calculator) {
        this.calculator = calculator;
    }

    public double calculateArea() {
        return calculator.calculateArea();
    }
}

客户端代码

public class Main {
    public static void main(String[] args) {
        // 计算矩形面积
        ShapeAreaCalculator rectangleCalculator = new RectangleAreaCalculator(5, 3);
        ShapeContext rectangleContext = new ShapeContext(rectangleCalculator);
        System.out.println("矩形面积: " + rectangleContext.calculateArea());

        // 计算圆形面积
        ShapeAreaCalculator circleCalculator = new CircleAreaCalculator(4);
        ShapeContext circleContext = new ShapeContext(circleCalculator);
        System.out.println("圆形面积: " + circleContext.calculateArea());
    }
}

代码解释

ShapeAreaCalculator 接口定义了计算面积的方法，是抽象策略。
RectangleAreaCalculator 和 CircleAreaCalculator 类实现了 ShapeAreaCalculator 接口，分别实现了矩形和圆形面积的计算，是具体策略。
ShapeContext 类持有一个 ShapeAreaCalculator 引用，并通过 calculateArea 方法调用具体策略的计算方法，是上下文。
在 Main 类中，客户端通过创建不同的具体策略对象，并将其传递给 ShapeContext，实现了不同形状面积的计算。

常见实践

排序算法的应用

在 Java 中的 Collections.sort 方法就运用了策略设计模式。Comparator 接口就是抽象策略，不同的比较器实现类（如 String.CASE_INSENSITIVE_ORDER）就是具体策略。Collections.sort 方法是上下文，它接受一个 List 和一个 Comparator，通过 Comparator 来定义排序规则。

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

public class SortingExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("banana");
        names.add("Apple");
        names.add("cherry");

        // 使用自然排序
        Collections.sort(names);
        System.out.println("自然排序: " + names);

        // 使用忽略大小写排序
        Comparator<String> caseInsensitiveComparator = String.CASE_INSENSITIVE_ORDER;
        Collections.sort(names, caseInsensitiveComparator);
        System.out.println("忽略大小写排序: " + names);
    }
}

数据压缩算法

假设有不同的数据压缩算法，如 Gzip 和 Zip。可以定义一个抽象的压缩策略接口，不同的压缩算法实现类作为具体策略，使用上下文类来调用压缩方法。

public interface CompressionStrategy {
    byte[] compress(byte[] data);
}

public class GzipCompressionStrategy implements CompressionStrategy {
    @Override
    public byte[] compress(byte[] data) {
        // Gzip 压缩逻辑
        return null;
    }
}

public class ZipCompressionStrategy implements CompressionStrategy {
    @Override
    public byte[] compress(byte[] data) {
        // Zip 压缩逻辑
        return null;
    }
}

public class CompressionContext {
    private CompressionStrategy strategy;

    public CompressionContext(CompressionStrategy strategy) {
        this.strategy = strategy;
    }

    public byte[] compressData(byte[] data) {
        return strategy.compress(data);
    }
}

最佳实践

单一职责原则

每个具体策略类应该只负责一个特定的算法，遵循单一职责原则。这样可以使代码更加清晰，易于维护和扩展。例如，在面积计算示例中，RectangleAreaCalculator 和 CircleAreaCalculator 分别只负责矩形和圆形面积的计算。

依赖注入

通过依赖注入将具体策略传递给上下文，使得上下文更加灵活。在构造函数或 setter 方法中注入策略对象，这样可以在运行时动态切换策略。

策略枚举

如果具体策略的数量有限且固定，可以使用枚举来定义策略。枚举可以提供类型安全，并且易于使用。例如：

public enum SortingStrategy implements Comparator<String> {
    NATURAL_ORDER {
        @Override
        public int compare(String s1, String s2) {
            return s1.compareTo(s2);
        }
    },
    CASE_INSENSITIVE_ORDER {
        @Override
        public int compare(String s1, String s2) {
            return s1.compareToIgnoreCase(s2);
        }
    }
}

策略工厂

使用策略工厂来创建具体策略对象，可以将策略的创建逻辑封装起来，提高代码的可维护性。例如：

public class ShapeAreaCalculatorFactory {
    public static ShapeAreaCalculator createCalculator(String shapeType, double... params) {
        if ("rectangle".equals(shapeType)) {
            return new RectangleAreaCalculator(params[0], params[1]);
        } else if ("circle".equals(shapeType)) {
            return new CircleAreaCalculator(params[0]);
        }
        return null;
    }
}

小结

策略设计模式在 Java 编程中提供了一种灵活的方式来处理算法的变化。通过将算法封装在具体策略类中，并使用上下文来调用这些策略，使得代码更加模块化、可维护和可扩展。在实际应用中，遵循最佳实践可以进一步提高代码的质量和性能。

参考资料

《Effective Java》 - Joshua Bloch
《Design Patterns - Elements of Reusable Object-Oriented Software》 - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides