java - What benefits can delegation to private static methods have over private methods in a springboot webflux (functional program style)

I have a question regarding the use of private static methods in the context of a java springboot webflux project.

Let me put some code first:

The straightforward codes of a spring project: a Main class, a Configuration class found under a config package, a Repository class found under the package repository, a Service interface found under the service package.

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

}

(The question is not on above)

Now, as the implementation of the service layer: First, a version where the public facing method is delegating all computations to subsequent private static methods, passing the fields as parameter. (option 1)

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

}

As opposed to using the fields directly in a private but non-static method. (option 2)

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

}

(putting them together)

Question:

What are the benefits option 1 can bring?

This is a technical question, not opinion based. I am sure there is more than just code style preferences. I am seeing more and more projects adopting option 1 in the context of java webflux functional programs.

• What are the benefits in terms of compile time performance option 1 have or lack over option 2?

• What are the benefits in terms of runtime performance option 1 have or lack over option 2?

• What are the benefits in terms of thread safety option 1 have or lack over option 2?

• What are the benefits in terms of testability option 1 have or lack over option 2?

• What are the benefits in terms of mocks option 1 have or lack over option 2?

• What are the benefits in terms of maintainability option 1 have or lack over option 2?

• What are the benefits in terms of readability option 1 have or lack over option 2?

• What are other benefits option 1 have or lack over option 2 please?

Thank you

I don't think this question is related to WebFlux and to Spring in general, but rather to any code written in a functional style (you'll face the same with java 8 streams) and even to a code written in a "traditional" imperative style: what to call private static or private method?

In general I can see only one difference between private static methods and private methods:

private non-static methods can access the state/dependencies (non static data fields) of the class, whereas private static methods can't

This means that you might want to use private static methods if:

• You only use them within the class
• You want to emphasize that the method doesn't depend (read doesn't access) the internal state of the object its defined in.

On the opposite, if you already maintain the state/dependency, like WebClient in the example, then using the static makes you passing this parameter to the method. In My Opinion this is unnecessary: what if you have not 1, but say 3 parameters to pass and you call this method from many places in the source class.

Other than that I don't see much difference:

• Mocks (testing) is just the same because you don't test private methods anyway and you can mock your dependencies in both cases in a same way by using constructor injection or some advanced techniques of mockito.

• Performance penalty - roughly the same, I can't think about the case where the usage of one method over another will be a source of performance issues.

• Maintainability - again, depends on your usecase, if the method is accessing the internal state you better use non static variant to reduce the clutter, if you want to emphasize that you use a "util" method that doesn't depend on the state - use private static method.

• Multithreading - you should synchronize the state in both cases if its required, the fact that the method has static modifier by itself doesn't deal with multithreading at all.

I've also found this thread that can be useful for this question, again its applicable for general programming style (code organization) not only for webflux.