本文探讨了如何使用java的`biconsumer`接口重构具有相同业务逻辑但操作不同类型对象（如`map`和`genericrecord`）的方法。通过创建一个通用的`add`方法接受`biconsumer`，并结合方法引用，可以有效消除代码重复。进一步，可以定义重载的便利方法，以保持原有的调用风格，从而提升代码的模块化和可维护性。
在软件开发中，我们经常会遇到这样的场景：多个方法执行着几乎相同的操作，但它们所处理的数据结构类型不同。这种代码重复不仅增加了维护成本，也使得代码难以扩展。
遇到的问题
考虑以下两个Java方法，它们都执行“将键值对放入某个容器”的操作，但容器的类型分别是Map和GenericRecord：
public void method1(Map<String,String> 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<T, U>是一个函数式接口，它接受两个输入参数，但不返回任何结果。这非常适合我们这里的put操作，因为它接受一个键和一个值，并且不返回任何内容。
我们可以创建一个通用的静态方法，该方法接受一个BiConsumer实例以及要操作的键和值：
import java.util.function.BiConsumer;
public class RefactorUtil {
/**
* 通用的添加方法，接受一个BiConsumer来执行键值对的放置操作。
*
* @param consumer 接受两个参数（键和值）且不返回结果的函数式接口。
* @param key 要放置的键。
* @param value 要放置的值。
* @param <K> 键的类型。
* @param <V> 值的类型。
*/
public static <K, V> void add(BiConsumer<K, V> consumer, K key, V value) {
consumer.accept(key, value);
}
}现在，我们可以使用方法引用来调用这个通用的add方法。map::put和recordMap::put都是有效的BiConsumer实例，它们分别代表了Map和GenericRecord的put方法：
在 Java 中初始化和管理阿里云 SDK客户端。包括单例模式、线程安全、endpoint 与 region 配置、VPC 终端节点、同步与异步等。
import java.util.HashMap;
import java.util.Map;
// 假设 GenericRecord 是一个自定义类，也包含 put 方法
class GenericRecord<K, V> {
private Map<K, V> 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<String, String> myMap = new HashMap<>();
GenericRecord<String, String> 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 <K, V> void add(BiConsumer<K, V> consumer, K key, V value) {
consumer.accept(key, value);
}
/**
* 为Map类型提供的便利添加方法。
*
* @param map 要操作的Map。
* @param key 键。
* @param value 值。
* @param <K> 键的类型。
* @param <V> 值的类型。
*/
public static <K, V> void add(Map<K, V> map, K key, V value) {
add(map::put, key, value); // 内部调用通用的add方法
}
/**
* 为GenericRecord类型提供的便利添加方法。
*
* @param record 要操作的GenericRecord。
* @param key 键。
* @param value 值。
* @param <K> 键的类型。
* @param <V> 值的类型。
*/
public static <K, V> void add(GenericRecord<K, V> 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<String, String> myMap = new HashMap<>();
GenericRecord<String, String> 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"));
}
}总结
通过上述重构，我们实现了以下目标：
- 消除代码重复：将核心的put操作逻辑集中到一个地方。
- 提高代码可读性与可维护性：代码结构更清晰，易于理解和修改。
- 增强灵活性：如果未来有更多类似put操作的容器类型，只需为它们添加相应的重载便利方法，而无需修改核心逻辑。
- 遵循DRY原则：Don't Repeat Yourself（不要重复自己）。
这种模式特别适用于当你有多个类或接口，它们都提供了语义相同但方法签名略有差异（或不共享共同接口）的操作时。通过BiConsumer（或其他函数式接口如Consumer、Function等），我们可以将这些操作抽象出来，实现更高级别的代码复用。
