当前位置：首页 > news >正文

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

news 来源：原创 2025/6/13 21:55:47

设计模式为解决常见软件问题提供了经典方案，但在现代编程语言中，部分模式可通过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
    }
}