java—在SpringBootWebFlux(函数式程序风格)中,委托给私有静态方法比私有方法有什么好处

我有一个关于在JavaSpringBootWebFlux项目上下文中使用私有静态方法的问题。

@SpringBootApplication
public class SomeApplication {

    public static void main(String[] args) {
        SpringApplication.run(SomeApplication.class, args);
    }

}

@Configuration
public class SomeConfiguration {

    @Value("${someConfiguration}")
    private String someConfiguration;

    public String getSomeConfiguration() {
        return someConfiguration;
    }

}

@Repository
public interface SomeRepository extends Reactive[...]Repository<String, String> { }

public interface SomeService {

    Mono<String> someCompute(String string);

}

(问题不在上面)

现在,作为服务层的实现:首先,一个面向公众的方法将所有计算委托给后续服务层的版本 私有静态方法

@Service
public class SomeServiceImpl implements SomeService {

    private final SomeConfiguration someConfiguration;
    private final SomeRepository    someRepository;
    private final WebClient         webClient;

    @Autowired
    public SomeServiceImpl(SomeConfiguration someConfiguration, SomeRepository someRepository, WebClient webClient) {
        this.someConfiguration = someConfiguration;
        this.someRepository = someRepository;
        this.webClient = webClient;
    }

    @Override
    public Mono<String> someCompute(String string) {
        Mono<String> s1Mono = sendHttpRequestToSomewhere(webClient);
        Mono<String> s2Mono = s1Mono.map(x -> computeSomethingWithConfiguration(x, someConfiguration));
        Mono<Object> s3Mono = s2Mono.map(x -> saveToSomewhere(x, someRepository));
        return s3Mono.map(x -> computeSomethingElse(x));
    }

    private static Mono<String> sendHttpRequestToSomewhere(WebClient webClient) {
        return webClient.get().retrieve().bodyToMono(String.class);
    }

    private static String computeSomethingWithConfiguration(String x, SomeConfiguration someConfiguration) {
        return x + someConfiguration.getSomeConfiguration();
    }

    private static Mono<String> saveToSomewhere(String x, SomeRepository someRepository) {
        return someRepository.save(x);
    }

    private static String computeSomethingElse(Object x) {
        return x.toString();
    }

}

而不是直接在私有数据库中使用字段 但非静态

@Service
public class SomeServiceImpl implements SomeService {

    private final SomeConfiguration someConfiguration;
    private final SomeRepository    someRepository;
    private final WebClient         webClient;

    @Autowired
    public SomeServiceImpl(SomeConfiguration someConfiguration, SomeRepository someRepository, WebClient webClient) {
        this.someConfiguration = someConfiguration;
        this.someRepository = someRepository;
        this.webClient = webClient;
    }

    @Override
    public Mono<String> someCompute(String string) {
        Mono<String> s1Mono = sendHttpRequestToSomewhere();
        Mono<String> s2Mono = s1Mono.map(x -> computeSomethingWithConfiguration(x));
        Mono<Object> s3Mono = s2Mono.map(x -> saveToSomewhere(x));
        return s3Mono.map(x -> computeSomethingElse(x));
    }

    private Mono<String> sendHttpRequestToSomewhere() {
        return webClient.get().retrieve().bodyToMono(String.class);
    }

    private String computeSomethingWithConfiguration(String x) {
        return x + someConfiguration.getSomeConfiguration();
    }

    private Mono<String> saveToSomewhere(String x) {
        return someRepository.save(x);
    }

    private String computeSomethingElse(Object x) {
        return x.toString();
    }

}

(把它们放在一起)

问题:

选项1可以带来哪些好处?

这是一个技术性的问题,不是基于观点的。我确信不仅仅是代码样式的首选项。我看到越来越多的项目在JavaWebFlux功能程序的上下文中采用选项1。

• 与选项2相比,选项1在运行时性能方面有哪些好处?

• 与选项2相比,选项1在可测试性方面有哪些好处?

• 与选项2相比,模拟选项1有哪些好处?

• 与选项2相比,选项1在可维护性方面有哪些好处?

• 与选项2相比,选项1在可读性方面有哪些好处?

• 与选项2相比,选项1还有哪些其他好处?

非常感谢。