Java记录类深度实战：不可变数据建模与现代API设计指南 | Java编程教程

// 基础记录类定义
public record User(
    String username,
    String email,
    LocalDateTime createdAt
) {
    // 紧凑构造器（Compact Constructor）
    public User {
        Objects.requireNonNull(username, "用户名不能为空");
        Objects.requireNonNull(email, "邮箱不能为空");
        
        if (!email.contains("@")) {
            throw new IllegalArgumentException("邮箱格式不正确");
        }
        
        // 字段初始化后自动完成
    }
    
    // 自定义方法
    public String displayName() {
        return username + " ";
    }
    
    // 静态工厂方法
    public static User of(String username, String email) {
        return new User(username, email, LocalDateTime.now());
    }
    
    // 静态字段
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");
}

// 嵌套记录类
public record Order(
    String orderId,
    List items,
    Customer customer,
    OrderStatus status
) {
    // 本地记录类（Local Record）
    public record OrderSummary(String orderId, BigDecimal total) {}
    
    public OrderSummary toSummary() {
        BigDecimal total = items.stream()
            .map(OrderItem::subtotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        return new OrderSummary(orderId, total);
    }
}

// 泛型记录类
public record Response(
    boolean success,
    T data,
    String message,
    Instant timestamp
) {
    // 类型安全的构建器模式
    public static  Response success(T data) {
        return new Response(true, data, "操作成功", Instant.now());
    }
    
    public static  Response error(String message) {
        return new Response(false, null, message, Instant.now());
    }
}

// 密封接口 + 记录类模式匹配
public sealed interface Shape 
    permits Circle, Rectangle, Triangle {
    
    double area();
    
    record Circle(double radius) implements Shape {
        @Override
        public double area() {
            return Math.PI * radius * radius;
        }
    }
    
    record Rectangle(double width, double height) implements Shape {
        @Override
        public double area() {
            return width * height;
        }
    }
    
    record Triangle(double base, double height) implements Shape {
        @Override
        public double area() {
            return 0.5 * base * height;
        }
    }
}

// 模式匹配使用示例
public class ShapeCalculator {
    public String describe(Shape shape) {
        return switch (shape) {
            case Shape.Circle c -> 
                String.format("圆形: 半径=%.2f, 面积=%.2f", 
                    c.radius(), c.area());
            case Shape.Rectangle r -> 
                String.format("矩形: 宽=%.2f, 高=%.2f, 面积=%.2f", 
                    r.width(), r.height(), r.area());
            case Shape.Triangle t -> 
                String.format("三角形: 底=%.2f, 高=%.2f, 面积=%.2f", 
                    t.base(), t.height(), t.area());
        };
    }
}

语法特性解析：

1. 紧凑构造器：在字段赋值前进行验证和转换
2. 自动生成方法：equals(), hashCode(), toString(), 组件访问器
3. 不可变性：所有字段都是final的
4. 模式匹配友好：与Java模式匹配完美结合
5. 序列化支持：自动实现Serializable接口

// 完整的电商领域模型示例
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

// 值对象：货币
public record Money(
    BigDecimal amount,
    String currency
) implements Comparable {
    public Money {
        Objects.requireNonNull(amount, "金额不能为空");
        Objects.requireNonNull(currency, "货币不能为空");
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("金额不能为负数");
        }
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("货币类型不匹配");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money multiply(int quantity) {
        return new Money(
            this.amount.multiply(BigDecimal.valueOf(quantity)),
            this.currency
        );
    }
    
    @Override
    public int compareTo(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("货币类型不匹配");
        }
        return this.amount.compareTo(other.amount);
    }
}

// 值对象：地址
public record Address(
    String country,
    String province,
    String city,
    String street,
    String postalCode
) {
    public String fullAddress() {
        return String.format("%s%s%s%s, 邮编: %s", 
            country, province, city, street, postalCode);
    }
}

// 实体：商品
public record Product(
    String productId,
    String name,
    String description,
    Money price,
    int stock,
    List categories
) {
    public Product withPrice(Money newPrice) {
        return new Product(productId, name, description, 
                          newPrice, stock, categories);
    }
    
    public Product reduceStock(int quantity) {
        if (quantity > stock) {
            throw new IllegalArgumentException("库存不足");
        }
        return new Product(productId, name, description, 
                          price, stock - quantity, categories);
    }
}

// 实体：订单项
public record OrderItem(
    String itemId,
    Product product,
    int quantity,
    Money unitPrice
) {
    public OrderItem {
        Objects.requireNonNull(product, "商品不能为空");
        Objects.requireNonNull(unitPrice, "单价不能为空");
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须大于0");
        }
    }
    
    public Money subtotal() {
        return unitPrice.multiply(quantity);
    }
}

// 聚合根：订单
public record Order(
    String orderId,
    String customerId,
    List items,
    Address shippingAddress,
    Address billingAddress,
    OrderStatus status,
    LocalDateTime createdAt,
    LocalDateTime updatedAt
) {
    // 静态工厂方法
    public static Order create(String customerId, 
                              List items,
                              Address shippingAddress,
                              Address billingAddress) {
        String orderId = "ORD-" + UUID.randomUUID().toString().substring(0, 8);
        return new Order(
            orderId,
            customerId,
            List.copyOf(items), // 防御性复制
            shippingAddress,
            billingAddress,
            OrderStatus.CREATED,
            LocalDateTime.now(),
            LocalDateTime.now()
        );
    }
    
    // 业务方法
    public Money totalAmount() {
        return items.stream()
            .map(OrderItem::subtotal)
            .reduce(Money::add)
            .orElse(new Money(BigDecimal.ZERO, "CNY"));
    }
    
    public Order addItem(OrderItem newItem) {
        List updatedItems = new ArrayList(items);
        updatedItems.add(newItem);
        return new Order(
            orderId, customerId, updatedItems,
            shippingAddress, billingAddress,
            status, createdAt, LocalDateTime.now()
        );
    }
    
    public Order updateStatus(OrderStatus newStatus) {
        return new Order(
            orderId, customerId, items,
            shippingAddress, billingAddress,
            newStatus, createdAt, LocalDateTime.now()
        );
    }
    
    // 领域事件
    public record OrderCreatedEvent(
        String orderId,
        String customerId,
        Money totalAmount,
        LocalDateTime occurredAt
    ) implements DomainEvent {
        public static OrderCreatedEvent from(Order order) {
            return new OrderCreatedEvent(
                order.orderId(),
                order.customerId(),
                order.totalAmount(),
                LocalDateTime.now()
            );
        }
    }
}

// 枚举：订单状态
public enum OrderStatus {
    CREATED, PAID, SHIPPED, DELIVERED, CANCELLED
}

// 服务层使用示例
public class OrderService {
    private final OrderRepository orderRepository;
    private final EventPublisher eventPublisher;
    
    public OrderResult placeOrder(CreateOrderCommand command) {
        // 验证业务规则
        validateCommand(command);
        
        // 创建订单聚合
        Order order = Order.create(
            command.customerId(),
            command.items(),
            command.shippingAddress(),
            command.billingAddress()
        );
        
        // 保存聚合
        orderRepository.save(order);
        
        // 发布领域事件
        eventPublisher.publish(Order.OrderCreatedEvent.from(order));
        
        return new OrderResult(
            order.orderId(),
            order.totalAmount(),
            order.status()
        );
    }
    
    public record OrderResult(
        String orderId,
        Money totalAmount,
        OrderStatus status
    ) {}
}

领域驱动设计最佳实践：

性能优化建议：

从传统POJO迁移到记录类：

// 迁移前：传统Java Bean
public class User {
    private Long id;
    private String username;
    private String email;
    
    // 构造器、getter、setter、equals、hashCode、toString...
    // 总共约50行代码
}

// 迁移步骤1：转换为基本记录类
public record User(
    Long id,
    String username,
    String email
) {
    // 自动生成所有方法
}

// 迁移步骤2：添加验证逻辑
public record User(
    Long id,
    String username,
    String email
) {
    public User {
        Objects.requireNonNull(username, "用户名不能为空");
        Objects.requireNonNull(email, "邮箱不能为空");
        
        if (!EMAIL_PATTERN.matcher(email).matches()) {
            throw new IllegalArgumentException("邮箱格式不正确");
        }
    }
    
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");
}

// 迁移步骤3：添加业务方法
public record User(
    Long id,
    String username,
    String email
) {
    public User {
        // 验证逻辑...
    }
    
    public String displayName() {
        return username + " ";
    }
    
    public User withEmail(String newEmail) {
        return new User(id, username, newEmail);
    }
    
    // 保持向后兼容的静态工厂方法
    public static User of(Long id, String username, String email) {
        return new User(id, username, email);
    }
}

// 迁移步骤4：处理序列化兼容性
public record User(
    Long id,
    String username,
    String email
) implements Serializable {
    private static final long serialVersionUID = 1L;
    
    // 为Jackson等序列化框架提供兼容性
    @JsonCreator
    public static User create(
        @JsonProperty("id") Long id,
        @JsonProperty("username") String username,
        @JsonProperty("email") String email) {
        return new User(id, username, email);
    }
}

Java记录类是现代Java开发中的重要工具，它通过减少样板代码、增强类型安全性和促进不可变性，
显著提高了代码质量和开发效率。正确使用记录类可以构建更健壮、更易维护的应用程序。