Java中Supplier和Consumer接口的使用超详细教程_Java

一、背景

1. 概述

java 8 引入的函数式接口（functional interface）为编程范式带来了革命性突破，其中 supplier 与 consumer 作为基础且高频使用的接口，在函数式编程模型中占据核心地位。理解二者的设计理念与应用场景，是提升代码质量、优化编程效率的关键环节。

函数式接口的引入使 java 具备了更灵活的抽象能力，supplier 与 consumer 分别封装了"数据供给"与"数据消费"的核心逻辑，为数据处理流程的解耦提供了标准化方案，极大增强了代码的可读性与可维护性。

2. 概念类比

从抽象设计角度，可将 supplier 与 consumer 类比为"数据处理流水线"的两个核心节点：

supplier 作为数据生产者，类似于工厂的原料输出端，无需外部输入即可生成指定类型的数据，其核心职责是"提供结果"，不依赖外部状态，也不关心数据的后续用途。
consumer 作为数据消费者，类似于流水线的加工环节，接收指定类型的输入数据并执行处理逻辑，其核心特征是"无返回值"，通过副作用（side-effect）完成状态变更或外部交互。

这种生产者-消费者模型在计算机科学中广泛存在，java 8 通过函数式接口将其标准化，使开发者能够以更简洁的方式表达数据流转逻辑。

二、supplier 接口

supplier 接口是一个无输入参数、有返回值的函数式接口，用于表示"供给型"操作。其设计理念是封装一个可延迟执行的计算逻辑，在需要时通过调用 get() 方法获取结果。

1. 接口定义

package java.util.function;
/**
 * 表示结果的供给者。
 * 每次调用时不要求返回新的或不同的结果。
 * 这是一个函数式接口，其函数方法为 {@link #get()}。
 *
 * @param <t> 此供给者提供的结果类型
 * @since 1.8
 */
@functionalinterface
public interface supplier<t> {
    /**
     * 获取结果。
     *
     * @return 结果
     */
    t get();
}

接口特性分析：

注解 @functionalinterface 表明其为函数式接口，仅包含一个抽象方法 get()
泛型参数 <t> 定义了返回结果的类型
方法 get() 无参数，返回类型为 <t>，无checked异常声明

2. 典型应用场景

场景一：延迟初始化

利用 supplier 的延迟执行特性，可实现对象的按需创建，优化资源占用：

public class lazyinitializationexample {
    // 存储已初始化的对象
    private heavyobject heavyobject;
    // 提供对象的supplier
    private final supplier<heavyobject> heavyobjectsupplier = () -> new heavyobject();
    // 延迟获取对象
    public heavyobject getheavyobject() {
        if (heavyobject == null) {
            // 仅在首次调用时初始化
            heavyobject = heavyobjectsupplier.get();
        }
        return heavyobject;
    }
    // 模拟重量级对象
    static class heavyobject {
        public heavyobject() {
            // 模拟耗时初始化过程
            system.out.println("heavyobject initialized");
        }
    }
}

场景二：随机数据生成

封装随机数生成逻辑，便于在流处理中复用：

import java.util.random;
import java.util.function.supplier;
import java.util.stream.stream;
public class randomdatagenerator {
    // 生成随机整数的supplier
    private static final supplier<integer> random_integer_supplier = 
        () -> new random().nextint(100);
    public static void main(string[] args) {
        // 生成包含5个随机数的流并打印
        stream.generate(random_integer_supplier)
              .limit(5)
              .foreach(system.out::println);
    }
}

场景三：策略化数据提供

通过不同的 supplier 实现，可动态切换数据来源：

import java.util.function.supplier;
public class dataprovider {
    // 可配置的数据源
    private supplier<string> datasupplier;
    // 构造函数注入数据源
    public dataprovider(supplier<string> datasupplier) {
        this.datasupplier = datasupplier;
    }
    // 获取数据
    public string fetchdata() {
        return datasupplier.get();
    }
    public static void main(string[] args) {
        // 数据库数据源
        supplier<string> dbsupplier = () -> "data from database";
        // 缓存数据源
        supplier<string> cachesupplier = () -> "data from cache";
        dataprovider provider = new dataprovider(dbsupplier);
        system.out.println(provider.fetchdata()); // 输出：data from database
        // 切换为缓存数据源
        provider = new dataprovider(cachesupplier);
        system.out.println(provider.fetchdata()); // 输出：data from cache
    }
}

三、consumer 接口

consumer 接口是一个单输入参数、无返回值的函数式接口，用于表示"消费型"操作。其核心职责是接收数据并执行处理逻辑，通常通过副作用完成状态变更。

1. 接口定义

package java.util.function;
import java.util.objects;
/**
 * 表示接受单个输入参数且不返回结果的操作。
 * 与其他大多数函数式接口不同，consumer 预期通过副作用操作。
 * 这是一个函数式接口，其函数方法为 {@link #accept(object)}。
 *
 * @param <t> 操作的输入类型
 * @since 1.8
 */
@functionalinterface
public interface consumer<t> {
    /**
     * 对给定的参数执行此操作。
     *
     * @param t 输入参数
     */
    void accept(t t);
    /**
     * 返回一个组合的 consumer，先执行此操作，然后执行 after 操作。
     * 如果执行任一操作抛出异常，它将被传递给组合操作的调用者。
     * 如果执行此操作抛出异常，则 after 操作将不执行。
     *
     * @param after 此操作之后执行的操作
     * @return 一个组合的 consumer，依次执行此操作和 after 操作
     * @throws nullpointerexception 如果 after 为 null
     */
    default consumer<t> andthen(consumer<? super t> after) {
        objects.requirenonnull(after);
        return (t t) -> { accept(t); after.accept(t); };
    }
}

接口特性分析：

抽象方法 accept(t t) 接收泛型 <t> 类型参数，返回值为 void
默认方法 andthen(consumer) 支持 consumer 的链式组合，实现操作序列
设计意图明确：通过副作用（如修改外部状态、io操作）完成数据处理

2. 典型应用场景

场景一：数据处理与输出

封装数据处理逻辑，实现打印、存储等操作：

import java.util.function.consumer;
public class dataprocessor {
    // 打印字符串的consumer
    private static final consumer<string> print_consumer = system.out::println;
    // 格式化并打印字符串的consumer
    private static final consumer<string> format_consumer = s -> 
        system.out.println("formatted: " + s.touppercase());
    public static void main(string[] args) {
        string data = "hello world";
        // 直接打印
        print_consumer.accept(data); // 输出：hello world
        // 格式化后打印
        format_consumer.accept(data); // 输出：formatted: hello world
        // 组合操作：先打印原始数据，再打印格式化数据
        print_consumer.andthen(format_consumer).accept(data);
        // 输出：
        // hello world
        // formatted: hello world
    }
}

场景二：集合元素批量处理

结合集合框架的 foreach 方法，实现元素的批量处理：

import java.util.arrays;
import java.util.list;
import java.util.function.consumer;
public class collectionprocessor {
    public static void main(string[] args) {
        list<integer> numbers = arrays.aslist(1, 2, 3, 4, 5);
        // 打印数字的consumer
        consumer<integer> printconsumer = n -> system.out.print(n + " ");
        // 计算平方并打印的consumer
        consumer<integer> squareconsumer = n -> system.out.print(n * n + " ");
        system.out.println("原始数字:");
        numbers.foreach(printconsumer); // 输出：1 2 3 4 5 
        system.out.println("\n平方值:");
        numbers.foreach(squareconsumer); // 输出：1 4 9 16 25 
    }
}

场景三：对象属性修改

通过 consumer 封装对象修改逻辑，实现灵活的状态更新：

import java.util.function.consumer;
public class usermanager {
    static class user {
        private string name;
        private int age;
        public user(string name, int age) {
            this.name = name;
            this.age = age;
        }
        public string getname() { return name; }
        public int getage() { return age; }
        public void setname(string name) { this.name = name; }
        public void setage(int age) { this.age = age; }
        @override
        public string tostring() {
            return "user{name='" + name + "', age=" + age + "}";
        }
    }
    public static void main(string[] args) {
        user user = new user("张三", 20);
        // 修改姓名的consumer
        consumer<user> nameupdater = u -> u.setname("李四");
        // 增加年龄的consumer
        consumer<user> ageupdater = u -> u.setage(u.getage() + 5);
        // 组合操作：先修改姓名，再增加年龄
        consumer<user> userupdater = nameupdater.andthen(ageupdater);
        userupdater.accept(user);
        system.out.println(user); // 输出：user{name='李四', age=25}
    }
}

四、supplier 与 consumer 的对比分析

维度	supplier	consumer
核心职责	提供数据（生产者）	处理数据（消费者）
方法签名	t get()	void accept(t t)
输入参数	无	1个（t类型）
返回值	t类型结果	无（void）
典型应用	延迟初始化、随机数生成、数据源提供	数据打印、属性修改、批量处理
设计意图	封装无参计算逻辑，强调结果产出	封装单参处理逻辑，强调副作用操作
组合能力	无默认组合方法	支持 andthen() 链式组合
线程安全性	通常无副作用，线程安全风险低	常涉及状态修改，需关注线程安全

五、与匿名内部类的对比

在 java 8 之前，类似功能需通过匿名内部类实现，函数式接口结合 lambda 表达式大幅简化了代码：

实现方式	supplier 实现示例	consumer 实现示例
匿名内部类	`java supplier<string> supplier = new supplier<string>() { @override public string get() { return "data"; } };`	`java consumer<string> consumer = new consumer<string>() { @override public void accept(string s) { system.out.println(s); } };`
lambda 表达式	`java supplier<string> supplier = () -> "data";`	`java consumer<string> consumer = s -> system.out.println(s);`
方法引用	`java supplier<localdate> supplier = localdate::now;`	`java consumer<string> consumer = system.out::println;`

优势对比：

代码量减少 60% 以上，逻辑表达更直接
消除模板代码，聚焦核心业务逻辑
支持函数组合，提升代码灵活性

六、在设计模式中的应用

1. 策略模式

supplier 与 consumer 可作为策略接口，简化策略模式实现：

import java.util.function.supplier;
// 订单价格计算策略
public class pricecalculator {
    // 基础价格供给策略
    private final supplier<double> basepricesupplier;
    // 折扣计算策略
    private final consumer<double> discountconsumer;
    public pricecalculator(supplier<double> basepricesupplier, 
                          consumer<double> discountconsumer) {
        this.basepricesupplier = basepricesupplier;
        this.discountconsumer = discountconsumer;
    }
    public void calculate() {
        double baseprice = basepricesupplier.get();
        discountconsumer.accept(baseprice);
    }
    public static void main(string[] args) {
        // 普通用户策略
        pricecalculator regularcalc = new pricecalculator(
            () -> 100.0,  // 基础价格100
            price -> system.out.println("普通价: " + price)
        );
        // vip用户策略
        pricecalculator vipcalc = new pricecalculator(
            () -> 100.0,  // 基础价格100
            price -> system.out.println("vip价: " + price * 0.8)  // 8折
        );
        regularcalc.calculate(); // 输出：普通价: 100.0
        vipcalc.calculate();     // 输出：vip价: 80.0
    }
}

2. 观察者模式

consumer 可作为事件处理器，简化观察者注册：

import java.util.arraylist;
import java.util.list;
import java.util.function.consumer;
// 事件发布者
public class eventpublisher<t> {
    private final list<consumer<t>> listeners = new arraylist<>();
    // 注册观察者（consumer作为事件处理器）
    public void register(consumer<t> listener) {
        listeners.add(listener);
    }
    // 发布事件
    public void publish(t event) {
        listeners.foreach(listener -> listener.accept(event));
    }
    public static void main(string[] args) {
        eventpublisher<string> publisher = new eventpublisher<>();
        // 注册日志记录处理器
        publisher.register(event -> system.out.println("log: " + event));
        // 注册告警处理器
        publisher.register(event -> {
            if (event.contains("error")) {
                system.out.println("alert: " + event);
            }
        });
        publisher.publish("system started");
        publisher.publish("error occurred");
    }
}

3. 适配器模式

通过函数式接口适配新旧api：

// 旧系统接口
public class legacyservice {
    public string fetchdata() {
        return "legacy data";
    }
}
// 适配为supplier接口
public class legacyadapter implements supplier<string> {
    private final legacyservice legacyservice;
    public legacyadapter(legacyservice legacyservice) {
        this.legacyservice = legacyservice;
    }
    @override
    public string get() {
        return legacyservice.fetchdata();
    }
}
// 新系统使用适配器
public class newsystem {
    public void process(supplier<string> datasupplier) {
        string data = datasupplier.get();
        system.out.println("processing: " + data);
    }
    public static void main(string[] args) {
        newsystem system = new newsystem();
        legacyservice legacyservice = new legacyservice();
        // 通过适配器使用旧系统
        system.process(new legacyadapter(legacyservice));
    }
}

七、实际业务场景应用

1. 电商系统中的应用

场景一：订单处理流程

import java.util.arrays;
import java.util.list;
import java.util.function.consumer;
import java.util.function.supplier;
// 订单实体
class order {
    private string orderid;
    private list<string> products;
    private double totalamount;
    // 构造器、getter、setter省略
}
// 订单服务
public class orderservice {
    // 生成订单号的supplier
    private static final supplier<string> order_id_supplier = 
        () -> "ord-" + system.currenttimemillis();
    // 订单验证consumer
    private static final consumer<order> validate_consumer = order -> {
        if (order.getproducts().isempty()) {
            throw new illegalargumentexception("订单商品不能为空");
        }
        if (order.gettotalamount() <= 0) {
            throw new illegalargumentexception("订单金额必须为正数");
        }
    };
    // 订单保存consumer
    private static final consumer<order> save_consumer = order -> {
        system.out.println("保存订单到数据库: " + order.getorderid());
        // 实际保存逻辑
    };
    // 发送通知consumer
    private static final consumer<order> notify_consumer = order -> {
        system.out.println("向用户发送订单通知: " + order.getorderid());
        // 实际通知逻辑
    };

到此这篇关于java的supplier和consumer接口的使用超详细教程的文章就介绍到这了,更多相关java supplier和consumer接口内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！