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

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

让我先写一些代码：

spring项目的简单代码：主类、配置包下的配置类、包存储库下的存储库类、服务包下的服务接口

@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);

}

@SpringBoot应用程序
公共类应用程序{
公共静态void main（字符串[]args）{
run（SomeApplication.class，args）；
}
}
@配置
公共类配置{
@值（“${someConfiguration}”）
私有字符串配置；
公共字符串getSomeConfiguration（）{
返回配置；
}
}
@存储库
公共接口SomeRepository扩展了反应性[…]存储库{}
公共接口服务{
Mono-someCompute（字符串）；
}

（问题不在上面）

现在，作为服务层的实现：首先，面向公众的方法将所有计算委托给后续的私有静态方法，并将字段作为参数传递。（备选方案1）

@服务
公共类SomeServiceImpl实现SomeService{
私有最终SomeConfiguration SomeConfiguration；
私有最终存储库；
私人最终网络客户网络客户；
@自动连线
公共SomeServiceImpl（SomeConfiguration SomeConfiguration，SomeRepository SomeRepository，WebClient WebClient）{
this.someConfiguration=someConfiguration；
this.someRepository=someRepository；
this.webClient=webClient；
}
@凌驾
公共Mono someCompute（字符串）{
Mono s1Mono=发送HttpRequestToSomewhere（网络客户端）；
monos2mono=s1Mono.map（x->computeSomethingWithConfiguration（x，sometconfiguration））；
monos3mono=s2Mono.map（x->saveToSomewhere（x，someRepository））；
返回s3Mono.map（x->computeSomethingElse（x））；
}
专用静态Mono sendHttpRequestToSomewhere（WebClient WebClient）{
返回webClient.get（）.retrieve（）.BodyToNo（String.class）；
}
私有静态字符串computeSomethingWithConfiguration（字符串x，SomeConfiguration SomeConfiguration）{
返回x+someConfiguration.getSomeConfiguration（）；
}
私有静态Mono saveToSomewhere（字符串x，SomeRepository SomeRepository）{
返回someRepository.save（x）；
}
私有静态字符串computeSomethingElse（对象x）{
返回x.toString（）；
}
}

与直接在私有但非静态的方法中使用字段相反。（备选方案2）

@服务
公共类SomeServiceImpl实现SomeService{
私有最终SomeConfiguration SomeConfiguration；
私有最终存储库；
私人最终网络客户网络客户；
@自动连线
公共SomeServiceImpl（SomeConfiguration SomeConfiguration，SomeRepository SomeRepository，WebClient WebClient）{
this.someConfiguration=someConfiguration；
this.someRepository=someRepository；
this.webClient=webClient；
}
@凌驾
公共Mono someCompute（字符串）{
Mono s1Mono=sendHttpRequestToSomewhere（）；
Mono s2Mono=s1Mono.map（x->computeSomethingWithConfiguration（x））；
monos3mono=s2Mono.map（x->saveToSomewhere（x））；
返回s3Mono.map（x->computeSomethingElse（x））；
}
私有Mono sendHttpRequestToSomewhere（）{
返回webClient.get（）.retrieve（）.BodyToNo（String.class）；
}
私有字符串computeSomethingWithConfiguration（字符串x）{
返回x+someConfiguration.getSomeConfiguration（）；
}
专用Mono saveToSomewhere（字符串x）{
返回someRepository.save（x）；
}
私有字符串computeSomethingElse（对象x）{
返回x.toString（）；
}
}

（把它们放在一起）

问题:

选项1可以带来哪些好处

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

• 与选项2相比，选项1在编译时性能方面有哪些好处

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

• 线程安全选项1相对于选项2有哪些好处

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

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

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

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

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

---

谢谢

我不认为这个问题与WebFlux和Spring一般有关，而是与任何以函数式风格编写的代码（java 8 streams也会遇到同样的问题）甚至与以“传统”命令式风格编写的代码有关：什么叫私有静态或私有方法

一般来说，我只能看到私有静态方法和私有方法之间的一个区别：

私有非静态方法可以访问类的状态/依赖项（非静态数据字段），而私有静态方法不能

这意味着您可能希望在以下情况下使用私有

静态方法

：

• 您只能在类中使用它们
• 您要强调的是，该方法不依赖于（re

  @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();
      }
  
  }