找到优雅的方法来包装可运行方法并将其作为函数传递给 java

Question

Im with java 11, Let's say I have multiple runnable methods all them are same structure except the number of parameters as in example:

private Runnable deleteIndex(String targetIndex) {
        return () -> {
            try {
                iIndexerManagementService.deleteIndex(targetIndex);
            } catch (Exception e) {
                log.error("Cannot perform delete:", e);
            }
        };
    }
    
    
private Runnable deleteDataBySource(String targetIndex, String source) {
        return () -> {
            try {
                indexerDocumentService.deleteBySource(targetIndex, source);
            } catch (Exception e) {
                log.error("Cannot perform delete:", e);
            }
        };
    }
    
    
private Runnable createDeleteTaskByScanID(String targetIndex, String scandId, String source) {
        return () -> {
            try {
                indexerDocumentService.deleteByScanId(targetIndex, scandId, source);
            } catch (Exception e) {
                log.error("Cannot perform delete:", e);
            }
        };
} .... 
  and more ....

Later on I use it like here on each runnable method:

    public void submitDeleteIndexTask(String targetIndex) {
       Optional.ofNullable(syncControlRepository.findByName(CATALOG_ENTITY_TYPE_KEYWORD))
                        .ifPresent(strategy -> {
                            Future<?> future =  uploadersExecutor.submit(deleteIndex(targetIndex));
                            if (featureFlagEnabled && config.isTestProfile()) {
                                try {
                                    future.get(1, TimeUnit.MINUTES);
                                } catch (Exception e) {
                                    log.error("Cannot wait on thread block:", e);
                                }
                            }
                    });
            } 
.... and more

I works perfect.

But I want to find nicer elegant way not to hold lots of runnable methods in class cause it might be more. My purpose create 1 generic runnable wrapper to be able pass any kind of function so when I'll use it i will pass only the function itself and the parameters to invoke.

I thought about this way, bit i'm not sure it is correct

// generic runnable wrapper to pass any function

    public Runnable runAsync(Function foo, Object o) {
        return () -> {
            try {
                foo.apply(o);
            } catch (Exception e) {
                log.error("Cannot perform delete:", e);
            }
        };
    }

and then it should be 1 general method to be able receive function to fit the runnables methods:

public void runGeneralAsync(... HERE PASS FUNCTION ..??. ) {
        Optional.ofNullable(syncControlRepository.findByName(CATALOG_ENTITY_TYPE_KEYWORD))
                .ifPresent(strategy -> {
                    Future<?> future =  uploadersExecutor.submit(runAsync(....FUNCTOIN... ?? ));
                    if (featureFlagEnabled && config.isTestProfile()) {
                        try {
                            future.get(1, TimeUnit.MINUTES);
                        } catch (Exception e) {
                            log.error("Cannot wait on thread block:", e);
                        }
                    }
            });
    }

Please advice

Answer 1

What you're asking for is tantamount to 'stringly typed' / dynamic, and is fundamentally unjavalike. You may think you want this; you don't. The entire java ecosystem will be fighting you every step of the way if you try.

NB: Your runGeneralAsync is deplorably bad - you're really abusing Optional here. That code is a long-winded way of saying: Look up a thingie, if it does exist, do this, if it does not, silently do nothing. Aside from the long-windedness (there's nothing wrong with if !), "Do nothing" is a horrible fallback. Horrible in the sense of: A single bug in the name or setup means nothing happens, so, you'll be chasing that bug for hours. An NPE takes 1 minute. If you ever write code where you can't fathom null occuring, just write it. If null does happen you want that exception, so you know where to fix things.

At any rate:

Instead, Runnable, itself, is the answer. Wrap lambdas in lambdas.

You're thinking of something like:

// API:
public void runGeneralAsync(String methodName, Object... args) {
  // Lots of reflective shenanigans to find it.
  // Lots of issues with dealing with exceptions -
  // what if the method name does not exist? What if the wrong amount
  // of args were passed? Or the wrong type? Or there is an overload?

  // .. and then of course code to stick it all into an executor.submit
}

// usage:

runGeneralAsync("deleteIndexTask", "my-index");

but what you want to do is something like this:

public void runGeneralAsync(Runnable task) {
  uploadersExecutor.submit(runAsync(....));
}

// usage:

runGeneralAsync(() -> deleteIndex("my-index"));

Depending on needs, you may want to use Callable instead of Runnable here (you can return things, and throw things).