Java设计模式之责任链模式、过滤器模式及策略模式的结合应用

介绍： 前两篇介绍过责任链模式和策略模式及基本应用，其实在实际的开发应用中，往往不会只有一种设计模式，而是多种设计模式的组合。责任链模式、过滤器模式和策略模式都是常见的设计模式，它们分别用于解耦请求处理、处理请求的过滤和提供不同的处理策略。在某些情况下，我们可以将这三种模式相结合，以提供更灵活和可扩展的代码结构。本文将通过实例介绍如何在Java中将责任链模式、过滤器模式和策略模式相结合。

场景设想： 假设我们正在开发一个Web应用程序，需要处理用户发起的购买请求。在请求到达后，我们需要进行身份验证、日志记录和根据不同的用户等级（例如：普通用户、VIP用户、管理员）提供不同的优惠策略。我们将使用责任链模式处理这一系列的处理器，并使用过滤器模式在每个处理器中进行具体的请求处理，同时使用策略模式根据用户等级提供不同的优惠策略。

代码实现： 首先，我们定义一个请求对象Request：

public class Request {
    private String username;
    private double amount;

    public Request(String username, double amount) {
        this.username = username;
        this.amount = amount;
    }

    public String getUsername() {
        return username;
    }

    public double getAmount() {
        return amount;
    }
}

接下来，我们创建一个处理器接口：

public interface RequestHandler {
    void handle(Request request, RequestFilterChain filterChain);
}

然后，我们实现具体的处理器类，包括身份验证、日志记录和权限检查：

public class AuthenticationHandler implements RequestHandler {
    @Override
    public void handle(Request request, RequestFilterChain filterChain) {
        if (authenticate(request.getUsername())) {
            filterChain.doFilter(request);
        } else {
            System.out.println("Authentication failed for user: " + request.getUsername());
        }
    }

    private boolean authenticate(String username) {
        // 实现身份验证逻辑
        return username.equals("admin");
    }
}

public class LoggingHandler implements RequestHandler {
    @Override
    public void handle(Request request, RequestFilterChain filterChain) {
        System.out.println("Logging request data: " + request.getAmount());
        filterChain.doFilter(request);
    }
}

public class PermissionHandler implements RequestHandler {
    @Override
    public void handle(Request request, RequestFilterChain filterChain) {
        if (checkPermissions(request.getUsername())) {
            filterChain.doFilter(request);
        } else {
            System.out.println("Permission denied for user: " + request.getUsername());
        }
    }

    private boolean checkPermissions(String username) {
        // 实现权限检查逻辑
        return username.equals("admin");
    }
}

接下来，我们实现过滤器链：

public class RequestFilterChain {
    private List<RequestHandler> handlers = new ArrayList<>();
    private int index = 0;

    public void addHandler(RequestHandler handler) {
        handlers.add(handler);
    }

    public void doFilter(Request request) {
        if (index < handlers.size()) {
            RequestHandler currentHandler = handlers.get(index);
            index++;
            currentHandler.handle(request, this);
        }
    }
}

然后，我们定义一个优惠策略接口：

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

实现不同用户等级的优惠策略：

public class RegularUserDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double amount) {
        // 普通用户没有优惠
        return amount;
    }
}

public class VIPUserDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double amount) {
        // VIP用户有5%的优惠
        return amount * 0.95;
    }
}

public class AdminUserDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double amount) {
        // 管理员有10%的优惠
        return amount * 0.9;
    }
}

最后，我们在客户端代码中组装处理器链和策略，并处理请求：

public class Client {
    public static void main(String[] args) {
        // 创建处理器实例
        RequestHandler authenticationHandler = new AuthenticationHandler();
        RequestHandler loggingHandler = new LoggingHandler();
        RequestHandler permissionHandler = new PermissionHandler();

        // 设置处理器的链
        RequestFilterChain filterChain = new RequestFilterChain();
        filterChain.addHandler(authenticationHandler);
        filterChain.addHandler(loggingHandler);
        filterChain.addHandler(permissionHandler);

        // 定义优惠策略
        DiscountStrategy regularUserDiscount = new RegularUserDiscountStrategy();
        DiscountStrategy vipUserDiscount = new VIPUserDiscountStrategy();
        DiscountStrategy adminUserDiscount = new AdminUserDiscountStrategy();

        // 模拟请求
        Request request1 = new Request("admin", 100.0);
        Request request2 = new Request("user", 200.0);

        // 处理请求
        System.out.println("Processing request 1:");
        filterChain.doFilter(request1);
        applyDiscount(request1, adminUserDiscount);

        System.out.println("\nProcessing request 2:");
        filterChain.doFilter(request2);
        applyDiscount(request2, vipUserDiscount);
    }

    private static void applyDiscount(Request request, DiscountStrategy discountStrategy) {
        double discountedAmount = discountStrategy.applyDiscount(request.getAmount());
        System.out.println("Discounted amount for user " + request.getUsername() + ": " + discountedAmount);
    }
}

输出：

Logging request data: 100.0
Discounted amount for user admin: 90.0

Authentication failed for user: user

在上面的示例中，我们成功地将责任链模式、过滤器模式和策略模式相结合，实现了处理购买请求的链式调用和不同用户等级的优惠策略。首先，请求通过处理器链，逐一经过身份验证、日志记录和权限检查的处理器。如果任何一个环节失败，将立即返回失败信息，否则继续处理请求。随后，根据用户等级选择不同的优惠策略进行优惠。

结论： 责任链模式、过滤器模式和策略模式的结合应用能够有效地解耦请求的发送者和接收者，实现灵活的请求处理流程，并根据不同的情况提供不同的处理策略。这种组合在Web应用程序、购物网站等场景中都非常有用。通过合理地使用这三种模式，我们可以实现更加灵活、可维护和可扩展的代码结构。