Java方法重构：利用BiConsumer和方法重载优化相似逻辑_技术教程

本文探讨了如何通过java的函数式接口`biconsumer`和方法重载来重构具有相似操作但输入类型不同的方法。通过抽象出核心操作，并提供便捷的重载方法，可以有效减少代码重复，提高代码的可维护性和灵活性，同时保持api的易用性。

在软件开发中，我们经常会遇到这样的场景：多个方法执行着几乎相同的逻辑，但它们操作的数据结构类型不同。这通常会导致代码重复，降低可维护性。例如，以下两个方法都执行了“放置”操作，但分别作用于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方法，但由于参数类型不同，直接的泛型重构可能会遇到困难。本文将介绍如何利用Java 8引入的函数式接口BiConsumer结合方法重载来优雅地解决这一问题。

1. 利用 BiConsumer 抽象核心操作

BiConsumer 是一个函数式接口，它接受两个输入参数，但不返回任何结果。这非常适合抽象那些接受两个参数并执行某个动作（如put操作）的逻辑。我们可以定义一个通用的辅助方法，该方法接受一个BiConsumer实例以及两个参数，然后调用BiConsumer的accept方法来执行实际操作。

首先，定义一个泛型辅助方法 add：

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

// 假设 GenericRecord 是一个自定义接口或类，也提供了put方法
// public interface GenericRecord {
//     void put(K key, V value);
// }

public class RefactorExample {

    /**
     * 通用的添加方法，利用 BiConsumer 抽象 put 逻辑。
     *
     * @param consumer 接收两个参数并执行操作的 BiConsumer 实例（例如 map::put）。
     * @param key      要添加的键。
     * @param value    要添加的值。
     * @param       键的类型。
     * @param       值的类型。
     */
    static  void add(BiConsumer consumer, K key, V value) {
        consumer.accept(key, value);
    }

    // ... 后续代码
}

现在，我们可以使用方法引用（::）将Map或GenericRecord的put方法作为BiConsumer实例传递给这个add方法。

public class RefactorExample {
    // ... (上面的 add 方法)

    public static void main(String[] args) {
        Map myMap = new java.util.HashMap<>();
        // 假设 GenericRecord 存在并已实例化
        // GenericRecord myRecord = new SomeGenericRecordImpl<>();

        String key1 = "name";
        String value1 = "Alice";
        String key2 = "age";
        String value2 = "30";

        // 调用通用 add 方法
        add(myMap::put, key1, value1);
        System.out.println("Map after add: " + myMap); // 输出: {name=Alice}

        // 如果 GenericRecord 存在，可以这样调用
        // add(myRecord::put, key2, value2);
        // System.out.println("Record after add: " + myRecord);
    }
}

通过这种方式，我们成功地将核心的put逻辑抽象到了一个通用的add方法中，避免了在method1和method2中重复编写map.put(key, value)。

2. 提供重载的便利方法

尽管使用add(map::put, key, value)已经很简洁，但在某些情况下，我们可能希望保持与原始方法调用模式相似的API，或者为特定的数据结构提供更直观的入口。这时，可以定义一系列重载的便利方法，它们内部调用我们之前创建的通用add方法。

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

// 假设 GenericRecord 接口或类
interface GenericRecord {
    void put(K key, V value);
}

public class RefactorExample {

    // 通用的添加方法，利用 BiConsumer 抽象 put 逻辑
    static  void add(BiConsumer consumer, K key, V value) {
        consumer.accept(key, value);
    }

    /**
     * 为 Map 提供的重载便利方法。
     *
     * @param map   要操作的 Map 实例。
     * @param key   键。
     * @param value 值。
     * @param    键的类型。
     * @param    值的类型。
     */
    static  void add(Map map, K key, V value) {
        add(map::put, key, value);
    }

    /**
     * 为 GenericRecord 提供的重载便利方法。
     *
     * @param record 要操作的 GenericRecord 实例。
     * @param key    键。
     * @param value  值。
     * @param     键的类型。
     * @param     值的类型。
     */
    static  void add(GenericRecord record, K key, V value) {
        add(record::put, key, value);
    }

    public static void main(String[] args) {
        Map myMap = new java.util.HashMap<>();
        GenericRecord myRecord = new GenericRecord() {
            private Map internalMap = new java.util.HashMap<>();
            @Override
            public void put(String key, String value) {
                internalMap.put(key, value);
            }
            @Override
            public String toString() {
                return internalMap.toString();
            }
        };

        // 使用重载方法，调用方式与原始方法相似
        add(myMap, "city", "New York");
        System.out.println("Map after add: " + myMap); // 输出: {city=New York}

        add(myRecord, "country", "USA");
        System.out.println("Record after add: " + myRecord); // 输出: {country=USA}
    }
}

现在，我们可以像原始方法那样直接调用add(myMap, key, value)或add(myRecord, key, value)，而底层的实际逻辑都由通用的BiConsumer驱动的add方法处理。这在保持API清晰性和易用性的同时，最大化地减少了代码重复。