Java 8 代码重构实战之四 Lambda表达式重构工厂模式与责任链模式

设计模式为解决常见软件问题提供了经典方案，但在现代编程语言中，部分模式可通过Lambda表达式进一步简化。本文以工厂模式和责任链模式为例，探讨如何用Lambda表达式减少冗余代码，提升灵活性与可读性。

1. 工厂模式（Factory Pattern）

传统实现：
工厂模式通过工厂类封装对象创建逻辑，客户端无需直接依赖具体类。通常需要定义接口、多个实现类和一个工厂类。

// 产品接口
interface DatabaseConnection {
    void connect();
}

// 具体产品实现
class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connected to MySQL");
    }
}

class PostgreSQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connected to PostgreSQL");
    }
}

// 工厂类
class ConnectionFactory {
    public DatabaseConnection createConnection(String type) {
        switch (type) {
            case "MySQL": return new MySQLConnection();
            case "PostgreSQL": return new PostgreSQLConnection();
            default: throw new IllegalArgumentException("Invalid type");
        }
    }
}

Lambda重构：
利用Supplier函数式接口和Map存储创建逻辑，避免冗长的条件判断和工厂类。

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

public class Main {
    private static final Map<String, Supplier<DatabaseConnection>> CONNECTION_FACTORY = new HashMap<>();
    
    static {
        CONNECTION_FACTORY.put("MySQL", MySQLConnection::new);
        CONNECTION_FACTORY.put("PostgreSQL", PostgreSQLConnection::new);
    }

    public static DatabaseConnection createConnection(String type) {
        Supplier<DatabaseConnection> supplier = CONNECTION_FACTORY.get(type);
        if (supplier == null) {
            throw new IllegalArgumentException("Invalid type");
        }
        return supplier.get();
    }

    public static void main(String[] args) {
        DatabaseConnection conn = createConnection("MySQL");
        conn.connect(); // 输出：Connected to MySQL
    }
}

优势：

• 消除工厂类：通过Map直接管理创建逻辑，扩展时只需添加新条目。
• 动态注册：支持运行时动态添加或修改产品类型。
• 代码简洁：避免switch-case或if-else分支判断。

2. 责任链模式（Chain of Responsibility Pattern）

传统实现：
责任链模式将多个处理器对象链接成链，请求沿链传递直至被处理。需定义处理器接口和多个实现类。

interface Handler {
    void handleRequest(String request);
    void setNext(Handler next);
}

abstract class AbstractHandler implements Handler {
    private Handler next;

    @Override
    public void setNext(Handler next) {
        this.next = next;
    }

    protected void passToNext(String request) {
        if (next != null) {
            next.handleRequest(request);
        }
    }
}

// 具体处理器
class AuthenticationHandler extends AbstractHandler {
    @Override
    public void handleRequest(String request) {
        if (request.contains("Auth")) {
            System.out.println("Authenticated");
        } else {
            passToNext(request);
        }
    }
}

class LoggingHandler extends AbstractHandler {
    @Override
    public void handleRequest(String request) {
        System.out.println("Logging request: " + request);
        passToNext(request);
    }
}

Lambda重构：
将处理逻辑封装为函数，通过函数组合构建责任链。

import java.util.function.UnaryOperator;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        // 定义处理函数
        UnaryOperator<String> authentication = request ->
            request.contains("Auth") ? "Authenticated" : request;

        UnaryOperator<String> logging = request -> {
            System.out.println("Logging: " + request);
            return request;
        };

        // 构建责任链
        UnaryOperator<String> chain = Stream.of(logging, authentication)
            .reduce(UnaryOperator.identity(), UnaryOperator::andThen);

        // 处理请求
        String result = chain.apply("Request with Auth");
        System.out.println(result); // 输出：Authenticated
    }
}

优势：

• 零冗余类：处理逻辑直接由Lambda或方法引用实现。
• 灵活组合：通过函数式组合（如andThen）动态构建链。
• 代码轻量：避免复杂的类继承和链式调用管理。

总结

通过Lambda表达式重构传统设计模式，可显著降低代码复杂度：

• 工厂模式：
  用Map存储Supplier函数，实现动态对象创建，消除工厂类。
• 责任链模式：
  将处理逻辑封装为函数，通过组合构建链，减少类层次结构。

适用场景：

• 工厂模式：对象创建逻辑简单，无需复杂初始化。
• 责任链模式：处理步骤独立且无复杂状态依赖。

注意事项：

• 逻辑复杂度：若处理逻辑涉及状态管理或复杂流程，仍需传统实现。
• 可读性：过度使用Lambda可能导致代码难以维护，需权衡简洁性与清晰性。

Lambda并非完全替代设计模式，而是提供了一种更轻量的实现选择。合理结合二者，可让代码既简洁又富有表现力。