Choose which methods to run, with user input-CodePudding

I have a list of methods within my class. And then want to have input string array, where the user can choose which methods they want to run. We are running expensive insurance calculations. And have over say eg 20 methods. Is there a way to conduct this without do an if check on each? maybe with reflection or interface?

@Override
public void ProductTest(ProductData productData, String[] methodNames)  {
  
    public void methodA(ProductData productData){...};
    public void methodB(ProductData productData){...};
    public void methodC(ProductData productData){...};
    public void methodD(ProductData productData){...};
    public void methodE(ProductData productData){...};
}

I am willing to change the Array into a different ObjectType if needed, to execute properly.

CodePudding user response：

Use a Map<String, Consumer<ProductData>>, not separate method handles. Main reason - reflection is slow and dangerous when given user "input"

Use map.get(input).accept(product) to call it.

https://docs.oracle.com/javase/8/docs/api/index.html?java/util/function/Consumer.html

Example

Map<String, Consumer<ProductData>> map = new HashMap<>();

map.put("print_it", System.out::println);
map.put("print_id", data -> System.out.println(data.id));
map.put("id_to_hex", data -> {
  int id = data.getId();
  System.out.printf("0x%x%n", id);
});

ProductData data = new ProductData(16);
map.get("print_it").accept(data);
map.get("print_id").accept(data);
map.get("id_to_hex").accept(data);

Outputs

ProductData(id=16)
16
0x10

If you are planning on chaining consumers using andThen, you'd be better having an Optional<ProductData>, and using a Function<ProductData, ProductData> with Optional.map()

CodePudding user response：

One way to do it is via reflection. You can iterate over methods in the class object and look for ones to run by name. Here's some example code--this would print out a list of names the user could type in:

myObject.getClass().getDeclaredMethods().each((method)->System.out.println(method.getName()))

And this is how you would call it once the user had made a selection:

productTest.getDeclaredMethods().each((method)->
    if(method.getName().equals(userSelectedName))
        method.invoke(productTest, productData)
)

The ONLY advantage to this approach is that you don't have to maintain a second structure (Switch, Map, etc...) and add to it every time you add a new method. A personality quirk makes me unwilling to do that (If adding something one place forces you to update a second, you're doing it wrong), but this doesn't bother everyone as much as it bothers me.

This isn't dangerous or anything, if you don't have a method in the class it can't call it, but if you are relying on users "Typing", I'd suggest listing out the options and allowing a numeric selection--or using reflection to build a map like OneCricketeer's.

I've used this pattern to write a testing language and fixture to test set-top TV boxes, it was super simple to parse a group of strings, map some to methods and other to parameters and have a very flexible, easily extensible testing language.

The method object also has a "getAnnotation()" which can be used to allow more flexible matching in the future.

CodePudding user response：

You can use method invocation.

For example, you can have two methods, first one will loop through your methodNames array and call the second method:

public void callPassedMethods(ProductData productData, String[] methodNames) {
   for (String m : methodNames) {
      callMethod(productData, m)
   }
}

And the second method will actually find a method in your class that matches the string passed and invoke it:

public void callMethod(ProductData productData, String methodName) {
   try {
      ClassName yourObj = new ClassName(); // Class where your methods are
      Method method = yourObj.getClass().getDeclaredMethod(methodName, ProductData.class);
      method.invoke(yourObj, productData);
   } catch(NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
      // handle exceptions
   }
}

Or, you can always use the good old switch statement:

 for (String m : methodNames) {

    switch (m) {
      case "methodA":
         methodA();
         break;
      case "methodB":
         methodB();
         break;
      // ... continue with as many cases as you need
    }
 }