使用BiConsumer接口重构具有相同操作但不同输入类型的方法_技术教程

本文探讨了如何使用java的`biconsumer`接口重构具有相同业务逻辑但操作不同类型对象（如`map`和`genericrecord`）的方法。通过创建一个通用的`add`方法接受`biconsumer`，并结合方法引用，可以有效消除代码重复。进一步，可以定义重载的便利方法，以保持原有的调用风格，从而提升代码的模块化和可维护性。

在软件开发中，我们经常会遇到这样的场景：多个方法执行着几乎相同的操作，但它们所处理的数据结构类型不同。这种代码重复不仅增加了维护成本，也使得代码难以扩展。

遇到的问题

考虑以下两个Java方法，它们都执行“将键值对放入某个容器”的操作，但容器的类型分别是Map和GenericRecord：

public void method1(Map map, String key, String value){
  map.put(key, value);
}

public void method2(GenericRecord recordMap, String key, String value){
  recordMap.put(key, value);
}

这两个方法的核心逻辑都是调用传入对象的put(key, value)方法。由于Map和GenericRecord并非通过共同的接口或抽象类来定义put方法（至少在它们的直接继承关系中没有），直接通过多态性来重构会比较困难。

解决方案：利用 BiConsumer 接口进行重构

Java 8引入的函数式接口为解决这类问题提供了优雅的方案。BiConsumer是一个函数式接口，它接受两个输入参数，但不返回任何结果。这非常适合我们这里的put操作，因为它接受一个键和一个值，并且不返回任何内容。

我们可以创建一个通用的静态方法，该方法接受一个BiConsumer实例以及要操作的键和值：

import java.util.function.BiConsumer;

public class RefactorUtil {

    /**
     * 通用的添加方法，接受一个BiConsumer来执行键值对的放置操作。
     *
     * @param consumer 接受两个参数（键和值）且不返回结果的函数式接口。
     * @param key 要放置的键。
     * @param value 要放置的值。
     * @param  键的类型。
     * @param  值的类型。
     */
    public static  void add(BiConsumer consumer, K key, V value) {
        consumer.accept(key, value);
    }
}

现在，我们可以使用方法引用来调用这个通用的add方法。map::put和recordMap::put都是有效的BiConsumer实例，它们分别代表了Map和GenericRecord的put方法：

import java.util.HashMap;
import java.util.Map;

// 假设 GenericRecord 是一个自定义类，也包含 put 方法
class GenericRecord {
    private Map data = new HashMap<>();
    public void put(K key, V value) {
        data.put(key, value);
        System.out.println("GenericRecord: put " + key + " -> " + value);
    }
    public V get(K key) { return data.get(key); }
}

public class Application {
    public static void main(String[] args) {
        Map myMap = new HashMap<>();
        GenericRecord myRecord = new GenericRecord<>();

        // 使用通用的 add 方法和方法引用
        RefactorUtil.add(myMap::put, "name", "Alice");
        RefactorUtil.add(myRecord::put, "id", "123");

        System.out.println("Map content: " + myMap); // 输出: Map content: {name=Alice}
        System.out.println("Record content: " + myRecord.get("id")); // 输出: Record content: 123
    }
}

通过这种方式，我们成功地将核心的put逻辑抽象到一个通用的add方法中，消除了method1和method2中的重复代码。

进一步优化：提供重载的便利方法

虽然直接使用RefactorUtil.add(map::put, key, value)是有效的，但如果希望保持与原始方法类似的调用风格，或者为了提高API的易用性，我们可以提供一些重载的便利方法。这些方法将直接接受具体的容器类型（如Map或GenericRecord），并在内部调用通用的add方法：

import java.util.Map;
import java.util.function.BiConsumer;

public class RefactorUtil {

    // ... (上面定义的通用 add 方法保持不变) ...
    public static  void add(BiConsumer consumer, K key, V value) {
        consumer.accept(key, value);
    }

    /**
     * 为Map类型提供的便利添加方法。
     *
     * @param map 要操作的Map。
     * @param key 键。
     * @param value 值。
     * @param  键的类型。
     * @param  值的类型。
     */
    public static  void add(Map map, K key, V value) {
        add(map::put, key, value); // 内部调用通用的add方法
    }

    /**
     * 为GenericRecord类型提供的便利添加方法。
     *
     * @param record 要操作的GenericRecord。
     * @param key 键。
     * @param value 值。
     * @param  键的类型。
     * @param  值的类型。
     */
    public static  void add(GenericRecord record, K key, V value) {
        add(record::put, key, value); // 内部调用通用的add方法
    }
}

现在，我们可以在应用代码中以更简洁、更直观的方式调用这些方法，就像调用原始的method1和method2一样：

// ... (Application 类和 GenericRecord 类定义不变) ...

public class Application {
    public static void main(String[] args) {
        Map myMap = new HashMap<>();
        GenericRecord myRecord = new GenericRecord<>();

        // 使用重载的便利方法
        RefactorUtil.add(myMap, "name", "Alice");
        RefactorUtil.add(myRecord, "id", "123");

        System.out.println("Map content: " + myMap);
        System.out.println("Record content: " + myRecord.get("id"));
    }
}