Vavr 工具实用指南：Java 函数式编程的高效落地方案

<!-- 核心依赖（稳定生产版本） --><dependency>    >io.vavr</groupId>    >vavr>    0.10.4</version>>Vavr与Jackson集成（JSON序列化/反序列化） -->    .vavr    avr-jackson>    0.10.4</version>>

implementation 'io.vavr:vavr:0.10.4'implementation 'io.vavr:vavr-jackson:0.10.4' // 可选

import io.vavr.control.Option;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/** * 空值安全的订单商品查询示例 */public class OptionPracticalDemo {    private static final Logger LOGGER = LoggerFactory.getLogger(OptionPracticalDemo.class);    // 业务场景：查询用户订单中的商品名称（用户/订单/商品均可能不存在）    public String getProductName(Long userId, Long orderId) {        return Option.ofNullable(findUserById(userId)) // 包装可能为null的用户                .flatMap(user -> Option.ofNullable(user.findOrderById(orderId))) // 扁平映射订单（避免嵌套Option）                .flatMap(order -> Option.ofNullable(order.getProduct())) // 扁平映射商品                .map(Product::getName) // 提取商品名称                .onEmpty(() -> LOGGER.warn("用户[{}]的订单[{}]未查询到商品", userId, orderId)) // 空值日志记录                .getOrElse("未知商品"); // 空值默认值    }    // 模拟数据库查询：用户可能不存在（返回null）    private User findUserById(Long userId) {        // 实际场景：数据库查询逻辑        return userId == 10001L ? new User("张三") : null;    }    // 核心实体类（简化设计）    static class User {        private final String username;        public User(String username) { this.username = username; }        // 查找用户订单（可能不存在）        public Order findOrderById(Long orderId) {            return orderId == 20001L ? new Order(30001L) : null;        }    }    static class Order {        private final Long productId;        public Order(Long productId) { this.productId = productId; }        // 获取订单商品（可能不存在）        public Product getProduct() {            return productId == 30001L ? new Product("分布式微服务架构实战") : null;        }    }    static class Product {        private final String name;        public Product(String name) { this.name = name; }        public String getName() { return name; }    }    // 测试方法    public static void main(String[] args) {        OptionPracticalDemo demo = new OptionPracticalDemo();        // 正常场景：返回商品名称        System.out.println(demo.getProductName(10001L, 20001L));        // 异常场景：订单不存在，返回默认值并打印日志        System.out.println(demo.getProductName(10001L, 20002L));    }}

import io.vavr.control.Either;import java.util.regex.Pattern;/** * 基于Either的用户认证结果处理示例 */public class EitherPracticalDemo {    // 手机号正则表达式    private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");    /**     * 用户注册接口：成功返回用户ID，失败返回错误信息     */    public Either<ErrorInfo, Long> register(String phone, String password) {        // 1. 参数校验：手机号格式        if (!PHONE_PATTERN.matcher(phone).matches()) {            return Either.left(new ErrorInfo("PHONE_INVALID", "手机号格式错误"));        }        // 2. 参数校验：密码长度        if (password == null || password.length()  {            return Either.left(new ErrorInfo("PASSWORD_INVALID", "密码长度不能少于6位"));        }        // 3. 业务逻辑：模拟注册成功，返回用户ID        Long userId = 10001L; // 实际场景：数据库插入后返回的自增ID        return Either.right(userId);    }    // 错误信息封装类（结构化异常）    static class ErrorInfo {        private final String code; // 错误码        private final String message; // 错误描述        public ErrorInfo(String code, String message) {            this.code = code;            this.message = message;        }        // getter方法        public String getCode() { return code; }        public String getMessage() { return message; }    }    // 业务调用示例    public static void main(String[] args) {        EitherPracticalDemo demo = new EitherPracticalDemo();        // 测试：手机号格式错误        handleRegisterResult(demo.register("123456", "123456"));        // 测试：注册成功        handleRegisterResult(demo.register("13800138000", "123456"));    }    // 统一结果处理逻辑    private static void handleRegisterResult(Either<ErrorInfo, Long> result) {        result.fold(            error -> {                // 失败处理：返回错误响应                System.out.printf("注册失败：[%s]%s%n", error.getCode(), error.getMessage());                return null;            },            userId -> {                // 成功处理：返回用户信息                System.out.printf("注册成功，用户ID：%d%n", userId);                return userId;            }        );    }}

import io.vavr.control.Try;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;/** * 基于Try的数据库查询异常处理示例 */public class TryPracticalDemo {    // 数据库配置（实际场景建议通过配置文件注入）    private static final String DB_URL = "jdbc:mysql://localhost:3306/enterprise_db?useSSL=false";    private static final String DB_USER = "root";    private static final String DB_PWD = "root123456";    /**     * 查询用户余额：自动捕获SQL异常，支持异常恢复     */    public Try> queryUserBalance(Long userId) {        return Try.of(() -> {            // 资源自动关闭（try-with-resources）            try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PWD);                 PreparedStatement pstmt = conn.prepareStatement("SELECT balance FROM t_user WHERE id = ?")) {                pstmt.setLong(1, userId);                ResultSet rs = pstmt.executeQuery();                return rs.next() ? rs.getDouble("balance") : 0.0;            }        })        // 异常分类处理：SQL异常返回默认余额，其他异常抛出        .recover(Exception.class, e -> {            System.err.printf("查询用户[%d]余额失败：%s%n", userId, e.getMessage());            return 0.0; // 异常恢复：返回默认余额        })        // 最终操作：无论成功失败，打印查询日志        .andFinally(() -> System.out.printf("用户[%d]余额查询操作完成%n", userId));    }    // 业务调用示例    public static void main(String[] args) {        TryPracticalDemo demo = new TryPracticalDemo();        // 正常查询        Double balance1 = demo.queryUserBalance(10001L).getOrElse(0.0);        System.out.printf("用户10001余额：%.2f%n", balance1);        // 异常场景（用户不存在或数据库连接失败）        Double balance2 = demo.queryUserBalance(99999L).getOrElse(0.0);        System.out.printf("用户99999余额：%.2f%n", balance2);    }}

import io.vavr.collection.List;import io.vavr.collection.Map;import io.vavr.Tuple3;/** * 基于Vavr不可变集合的订单数据聚合示例 */public class ImmutableCollectionDemo {    /**     * 订单数据聚合：统计各商品的销售总量与总金额     * 输入：订单列表（不可变集合）     * 输出：商品名称→销售汇总（不可变Map）     */    public Map SalesSummary> aggregateOrderData(List {        return orders                // 过滤：仅统计已支付订单                .filter(order -> "PAID".equals(order.getStatus()))                // 扁平映射：将订单拆分为订单项（Order→List<OrderItem>）                .flatMap(Order::getOrderItems)                // 映射：转换为（商品名称，数量，单价）三元组                .map(item -> Tuple3.of(                    item.getProductName(),                    item.getQuantity(),                    item.getUnitPrice()                ))                // 分组：按商品名称分组（key=商品名称，value=三元组列表）                .groupBy(Tuple3::_1)                // 聚合：计算每个商品的销售总量与总金额                .mapValues(group -> {                    int totalQuantity = group.sumBy(Tuple3::_2).intValue();                    double totalAmount = group.sumBy(t -> t._2() * t._3()).doubleValue();                    return new SalesSummary(totalQuantity, totalAmount);                });    }    // 核心实体类（不可变设计：字段final，无setter方法）    static class Order {        private final String status;        private final List<OrderItem> orderItems;        public Order(String status, List orderItems) {            this.status = status;            this.orderItems = orderItems; // 接收不可变List，确保整体不可变        }        // getter方法（仅查询，不提供修改能力）        public String getStatus() { return status; }        public ListItem> getOrderItems() { return orderItems; }    }    static class OrderItem {        private final String productName;        private final int quantity;        private final double unitPrice;        public OrderItem(String productName, int quantity, double unitPrice) {            this.productName = productName;            this.quantity = quantity;            this.unitPrice = unitPrice;        }        public String getProductName() { return productName; }        public int getQuantity() { return quantity; }        public double getUnitPrice() { return unitPrice; }    }    // 销售汇总结果类    static class SalesSummary {        private final int totalQuantity;        private final double totalAmount;        public SalesSummary(int totalQuantity, double totalAmount) {            this.totalQuantity = totalQuantity;            this.totalAmount = totalAmount;        }        // getter方法        public int getTotalQuantity() { return totalQuantity; }        public double getTotalAmount() { return totalAmount; }        @Override        public String toString() {            return String.format("销量：%d，销售额：%.2f", totalQuantity, totalAmount);        }    }    // 测试方法：模拟订单数据聚合    public static void main(String[] args) {        ImmutableCollectionDemo demo = new ImmutableCollectionDemo();        // 1. 创建不可变订单项列表        ListItem> itemList1 = List.of(            new OrderItem("分布式微服务架构实战", 2, 89.0),            new OrderItem("Java并发编程实战", 1, 79.0)        );        List itemList2 = List.of(            new OrderItem("分布式微服务架构实战", 3, 89.0),            new OrderItem("SpringBoot实战", 2, 69.0)        );        // 2. 创建不可变订单列表（包含已支付和未支付订单）        List = List.of(            new Order("PAID", itemList1),    // 已支付订单            new Order("UNPAID", itemList2),  // 未支付订单（会被过滤）            new Order("PAID", itemList2)     // 已支付订单        );        // 3. 数据聚合        Map result = demo.aggregateOrderData(orders);        // 4. 输出结果（不可变Map支持流式遍历）        result.forEach((productName, summary) ->             System.out.printf("商品：%s → %s%n", productName, summary)        );    }}

import io.vavr.Tuple2;import io.vavr.Tuple3;/** * Tuple多返回值示例 */public class TuplePracticalDemo {    /**     * 计算商品价格：返回（原价，折后价，优惠金额）     */    public Tuple3<Double, Double, Double> calculatePrice(int quantity, double unitPrice, double discount) {        double originalPrice = quantity * unitPrice;        double discountPrice = originalPrice * (1 - discount);        double discountAmount = originalPrice - discountPrice;        return Tuple3.of(originalPrice, discountPrice, discountAmount);    }    public static void main(String[] args) {        TuplePracticalDemo demo = new TuplePracticalDemo();        // 购买3件单价99元的商品，折扣0.2（8折）        Tuple3 Double> priceInfo = demo.calculatePrice(3, 99.0, 0.2);        // 取值：_1（原价）、_2（折后价）、_3（优惠金额）        System.out.printf("原价：%.2f 元%n", priceInfo._1());        System.out.printf("折后价：%.2f 元%n", priceInfo._2());        System.out.printf("优惠金额：%.2f 元%n", priceInfo._3());        // 链式操作：映射转换        Tuple2, Double> result = priceInfo.map2(            original -> String.format("原价%.2f元", original),            discountPrice -> discountPrice        );        System.out.printf("结果：%s → 最终支付%.2f元%n", result._1(), result._2());    }}

import io.vavr.API;import static io.vavr.API.$;import static io.vavr.API.Case;import static io.vavr.Predicates.instanceOf;import static io.vavr.Predicates.isEqual;/** * 模式匹配替代if-else/switch示例 */public class MatchPracticalDemo {    /**     * 订单状态描述：支持状态值、类型、条件匹配     */    public String getOrderStatusDesc(OrderStatus status, double amount) {        return API.Match(Tuple2.of(status, amount)).of(            // 精确匹配：状态=PAID + 金额≥1000 → 大额已支付            Case($(t -> t._1() == OrderStatus.PAID && t._2() >= 1000), "大额订单已支付，将优先发货"),            // 精确匹配：状态=PAID + 金额0 → 普通已支付            Case($(t -> t._1() == OrderStatus.PAID && t._2() 1000), "普通订单已支付，等待发货"),            // 枚举匹配：状态=UNPAID → 未支付            Case($(t -> t._1() == OrderStatus.UNPAID), "订单未支付，超时将自动取消"),            // 枚举匹配：状态=CANCELED → 已取消            Case($(t -> t._1() == OrderStatus.CANCELED), "订单已取消，可重新下单"),            // 默认分支：未知状态            Case($(), "未知订单状态")        );    }    // 订单状态枚举    enum OrderStatus { PAID, UNPAID, CANCELED }    public static void main(String[] args) {        MatchPracticalDemo demo = new MatchPracticalDemo();        System.out.println(demo.getOrderStatusDesc(OrderStatus.PAID, 1500.0));  // 大额订单已支付        System.out.println(demo.getOrderStatusDesc(OrderStatus.UNPAID, 200.0)); // 订单未支付    }}