在SpringBoot项目中使用Java8函数式接口的方法示例

import java.util.function.Function;
import org.springframework.stereotype.Component;

@Component
public class UserConverter implements Function<UserDto, User> {
    @Override
    public User apply(UserDto userDto) {
        User user = new User();
        user.setName(userDto.getName());
        user.setEmail(userDto.getEmail());
        // 更多属性转换
        return user;
    }
}

import java.util.function.Consumer;
import org.springframework.stereotype.Component;

@Component
public class UserLogger implements Consumer<User> {
    @Override
    public void accept(User user) {
        System.out.println("Creating user: " + user.getName());
        // 这里可以添加更多的日志逻辑或其他操作
    }
}

import java.util.function.Supplier;
import org.springframework.stereotype.Component;

@Component
public class ConnectionSupplier implements Supplier<Connection> {
    @Override
    public Connection get() {
        // 这里可以是创建数据库连接的逻辑
        return new Connection();
    }
}

class Connection {
    // 数据库连接的逻辑
}

import java.util.function.Predicate;
import org.springframework.stereotype.Component;

@Component
public class EmailValidator implements Predicate<String> {
    @Override
    public boolean test(String email) {
        // 简单的邮箱格式验证
        return email != null && email.contains("@");
    }
}

@Service
public class UserService {

    private final Function<User, UserDto> toDto = user -> new UserDto(user.getId(), user.getName(), user.getEmail());

    public UserDto getUserDto(User user) {
        return toDto.apply(user);
    }
}

@Service
public class UserActivationService {

    private final Consumer<User> activateUser = user -> user.setActive(true);

    public void activateUsers(List<User> users) {
        users.forEach(activateUser);
    }
}

@Service
public class ConfigurationService {

    private final Supplier<Optional<Configuration>> configSupplier = 
        () -> Optional.ofNullable(loadConfiguration());

    public Configuration getConfiguration() {
        return configSupplier.get().orElseThrow(() -> new IllegalStateException("Configuration not found"));
    }

    private Configuration loadConfiguration() {
        // 加载配置逻辑
        return new Configuration();
    }
}

class Configuration {
    // 配置相关逻辑
}

@Service
public class UserService {

    private final Predicate<User> isValidUser = 
        user -> user.getEmail() != null && user.getEmail().contains("@") && user.isActive();

    public List<User> filterValidUsers(List<User> users) {
        return users.stream().filter(isValidUser).collect(Collectors.toList());
    }
}

@Service
public class CalculationService {

    private final BiFunction<Integer, Integer, Integer> sumFunction = (a, b) -> a + b;

    public Integer sum(Integer a, Integer b) {
        return sumFunction.apply(a, b);
    }
}

@Service
public class StringService {

    private final UnaryOperator<String> addExclamation = s -> s + "!";

    public String makeExciting(String input) {
        return addExclamation.apply(input);
    }
}

@Service
public class MathService {

    private final BinaryOperator<Integer> multiply = (a, b) -> a * b;

    public Integer multiplyTwoIntegers(Integer a, Integer b) {
        return multiply.apply(a, b);
    }
}

@Service
public class NumberService {

    private final IntPredicate isEven = x -> x % 2 == 0;

    public boolean isNumberEven(int number) {
        return isEven.test(number);
    }
}

@Service
public class OptionalService {

    private final Function<String, Optional<Integer>> parseToInt = s -> {
        try {
            return Optional.of(Integer.parseInt(s));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    };

    public Optional<Integer> safeParse(String s) {
        return parseToInt.apply(s);
    }
}