java实现处理对象不为空则返回,为空则继续

在 Java 中实现“对象不为空则返回，为空则继续”的逻辑，有多种方式。以下是几种常见的实现方法：

1. 使用 Optional 类（Java 8+ 推荐）

基本实现

import java.util.Optional;

public class ObjectProcessor {
    
    /**
     * 如果对象不为空则返回，否则继续执行其他逻辑
     */
    public static <T> T processObject(T obj) {
        return Optional.ofNullable(obj)
                .orElseGet(() -> {
                    // 对象为空时的处理逻辑
                    System.out.println("对象为空，执行备用逻辑");
                    continueProcessing(); // 继续处理
                    return null; // 或者返回一个默认值
                });
    }
    
    private static void continueProcessing() {
        System.out.println("继续执行其他业务逻辑...");
        // 这里可以添加为空时的具体处理逻辑
    }
}

更灵活的用法

public class OptionalExample {
    
    public String findUserById(String id) {
        // 模拟数据库查询，可能返回null
        User user = userRepository.findById(id);
        
        return Optional.ofNullable(user)
                .map(User::getName)  // 如果不为空，提取name
                .orElseGet(() -> {
                    // 为空时执行备用逻辑
                    log.warn("用户 {} 不存在", id);
                    return getDefaultUserName(); // 返回默认值
                });
    }
    
    public void processOrder(Order order) {
        Optional.ofNullable(order)
                .ifPresentOrElse(
                    ord -> {
                        // 对象不为空的处理逻辑
                        System.out.println("处理订单: " + ord.getId());
                        processValidOrder(ord);
                    },
                    () -> {
                        // 对象为空的处理逻辑
                        System.out.println("订单为空，跳过处理");
                        handleEmptyOrder();
                    }
                );
    }
    
    private void processValidOrder(Order order) {
        // 处理有效订单的业务逻辑
    }
    
    private void handleEmptyOrder() {
        // 处理空订单的逻辑
    }
    
    private String getDefaultUserName() {
        return "匿名用户";
    }
}

2. 传统 if-else 方式

public class TraditionalApproach {
    
    public Result processData(Data data) {
        if (data != null) {
            // 对象不为空，直接返回
            return processValidData(data);
        } else {
            // 对象为空，继续处理
            System.out.println("数据为空，执行备用方案");
            return continueWithAlternativeLogic();
        }
    }
    
    public String getUserInfo(User user) {
        if (user == null) {
            // 为空时继续执行其他逻辑
            logger.info("用户对象为空，尝试从缓存获取");
            User cachedUser = cacheService.getUserFromCache();
            if (cachedUser != null) {
                return formatUserInfo(cachedUser);
            }
            return "默认用户信息";
        }
        
        // 不为空时返回处理结果
        return formatUserInfo(user);
    }
    
    private Result processValidData(Data data) {
        // 处理有效数据的业务逻辑
        return new Result(data.toString(), true);
    }
    
    private Result continueWithAlternativeLogic() {
        // 备用处理逻辑
        return new Result("使用默认数据", false);
    }
    
    private String formatUserInfo(User user) {
        return String.format("用户: %s, 年龄: %d", user.getName(), user.getAge());
    }
}

3. 使用三元运算符

public class TernaryOperatorApproach {
    
    public String getValueOrDefault(String input) {
        // 简洁的三元运算符写法
        return input != null ? processInput(input) : getDefaultValueAndContinue();
    }
    
    public Config loadConfig(String configPath) {
        Config config = configLoader.load(configPath);
        return config != null ? config : createDefaultConfigAndLog();
    }
    
    private String processInput(String input) {
        // 处理非空输入
        return input.toUpperCase().trim();
    }
    
    private String getDefaultValueAndContinue() {
        // 为空时执行的逻辑并返回默认值
        System.out.println("输入为空，使用默认值并继续处理");
        performFallbackOperations();
        return "DEFAULT_VALUE";
    }
    
    private Config createDefaultConfigAndLog() {
        System.out.println("配置加载失败，使用默认配置");
        // 记录日志、发送告警等
        alertService.sendAlert("配置加载失败: " + configPath);
        return new DefaultConfig();
    }
    
    private void performFallbackOperations() {
        // 备用操作
        System.out.println("执行备用操作...");
    }
}

4. 结合 Supplier 的函数式实现

import java.util.function.Supplier;

public class FunctionalApproach {
    
    /**
     * 通用处理方法：对象不为空则返回，为空则执行Supplier逻辑
     */
    public static <T> T processIfNotNull(T obj, Supplier<T> fallbackSupplier) {
        return obj != null ? obj : fallbackSupplier.get();
    }
    
    /**
     * 带自定义处理器的版本
     */
    public static <T> T processIfNotNull(T obj, 
                                      Function<T, T> processor, 
                                      Supplier<T> emptyProcessor) {
        return obj != null ? processor.apply(obj) : emptyProcessor.get();
    }
    
    // 使用示例
    public void exampleUsage() {
        User user = userService.findById("123");
        
        // 简单版本
        User result = processIfNotNull(user, () -> {
            System.out.println("用户为空，从缓存获取");
            return cacheService.getUser("default");
        });
        
        // 带处理器的版本
        String userInfo = processIfNotNull(user,
            u -> formatUser(u),  // 不为空时的处理器
            () -> {             // 为空时的处理器
                System.out.println("用户为空，返回默认信息");
                return "游客用户";
            });
    }
    
    private String formatUser(User user) {
        return user.getName() + "(" + user.getRole() + ")";
    }
}

5. 实际业务场景示例

@Service
public class OrderService {
    
    @Autowired
    private PaymentService paymentService;
    
    /**
     * 处理支付：优先使用传入的支付方式，为空则尝试其他方式
     */
    public PaymentResult processPayment(Order order, PaymentMethod method) {
        // 方式1：使用传入的支付方式
        PaymentResult result = processIfNotNull(method, 
            m -> paymentService.process(m, order),
            () -> tryAlternativePaymentMethods(order) // 为空时继续尝试其他方式
        );
        
        return result;
    }
    
    /**
     * 获取用户地址：优先使用用户默认地址，为空则使用配送地址
     */
    public Address getShippingAddress(User user) {
        return Optional.ofNullable(user.getDefaultAddress())
                .or(() -> Optional.ofNullable(user.getShippingAddress()))
                .or(() -> {
                    // 都为空时，继续执行地址获取逻辑
                    System.out.println("用户无预设地址，尝试获取最近使用的地址");
                    Address recentAddress = addressService.getRecentAddress(user.getId());
                    if (recentAddress != null) {
                        return Optional.of(recentAddress);
                    }
                    
                    // 仍然为空，创建临时地址
                    System.out.println("创建临时配送地址");
                    return Optional.of(createTemporaryAddress(user));
                })
                .get();
    }
    
    private PaymentResult tryAlternativePaymentMethods(Order order) {
        System.out.println("尝试备用支付方式...");
        // 尝试微信支付
        PaymentMethod wechatPay = paymentService.createWechatPayMethod();
        if (wechatPay != null) {
            return paymentService.process(wechatPay, order);
        }
        
        // 尝试支付宝
        PaymentMethod aliPay = paymentService.createAliPayMethod();
        if (aliPay != null) {
            return paymentService.process(aliPay, order);
        }
        
        // 所有方式都失败
        return PaymentResult.failed("所有支付方式均不可用");
    }
    
    private Address createTemporaryAddress(User user) {
        // 创建临时地址的逻辑
        return new Address("临时地址", user.getPhone());
    }
}