Question

目前我的监听器需要一个切换树来调用内部方法。

public class Car{


   public void listener(String e){
      if(e.equals("Honk"))
        this.blowHorn();
   }

   @Honk
   private void blowHorn(){...}

}

是否可以利用反射和方法注释，以便可以在运行时生成侦听器方法？它会根据输入是否等于方法注释来切换。这比使用普通反射更好，因为它减少了开销。

Answer 1

*********************回答回复***********************

首先，您将声明新注释：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CarListener{
    public String carAction();
}

所以在你的班级Car中你会有：

public class Car {

    //Here you´ll be looking at all the methods  you have in the class Car (I´d advice to 
    // put them in another class, so as to keep it clean, I didn´t do it here in order to
    // explain it better. These methods have the corresponding annotation you created

    public void listener(String e) { 
        Method[] methods = Car.class.getMethods();
            for(Method method:methods) {

        //Now that you have all the methods all you need is to figure which one you want
        // you´ll do that according to the "e" string, which represents the car action (for 
        // example "Honk") I´d also advice you to rename that too.

            if(rightMethod(method, e))

                //Now that you have found it, then you invoke the method, "call it"
                // which is what you wre doing in the previos code with "this.blowHorn()"

                return invokeMethod(method);
        }
        //This will help you in case you did NOT find the correct method, it´s just help 
        // if you don´t put it in it won´t break your code
        // fun fact about RuntimExceptions: you don´t have to declare them, meaning
        // you dont have to add them as "throws" or catch

        throw new RuntimeException("No listener found for car Action"+e);
    }

    private boolean rightMethod(Method method, String expression) {

    //First if asks if the method found has an annoation present, and if it does
    // then it asks if it corresponds to the annoation you created

        if (method.isAnnotationPresent(NewAnnotationInterfaceName.class))

    //if the method in fact has the annotation created all you are doing is asking what
    // carAction is associated to that method, you do that with the .carAction()

            return method.getAnnotation(NewAnnotationInterfaceName.class).carAction().equals(expression);
        return false;
    }


    //Now all you have to do is invoke it :) This just follows how to invoke a method
    // I won´t explain it

    private void  invokeMethod(Method method) {
        try {
            return method.invoke(Car.class.newInstance(), new Object[]{});
        } catch (InstantiationException | IllegalAccessException
                 | InvocationTargetException | IllegalArgumentException ex) {
            Logger.getLogger(Car.class.getName()).log(Level.SEVERE, null, ex);
        }
        throw new RuntimeException("Could not invoke method");
    }


    @CarListener(carAction= "Honk")
    public void blowHorn() {  
        ...
    }

     @CarListener(carAction= "SomethingElse")
    public void someOtherAction() {  
        ...
    }

}

希望有所帮助！

*********************回答Hashmap和命令设计******************** ***

public abstract class CarAction {

    public abstract void execute(Car car){};

}

public class HonkAction extends CarAction{

    @Override
    public void execute(Car car) {
           car.blowHorn();
    }    

}

public class Car {

    private HashMap<String, CarAction> carActions;

    public Car() {
        ...
        initializeCarActions();
    }

    public void initializeCarActions() {
        this.carActions = new HashMap<>();
        this.carActions.put("Honk", new HonkAction());
        ...
    }

    public void listener(String e) {
        CarAction action = this.carActions.get(e);
        if(action!=null) action.execute(this);
    }

}

如果您使用这种方式，我建议让某人注入HashMap，以便Car不必依赖于CarActions（只是抽象类），要么使用类或Guice。此外，如果所有carActions都需要“Car”才能执行，这就有效。

祝你好运！

Answer 2

public listener(String e){
      if(e.equals("Honk"))
        this.blowHorn();
   }

不是正确的Java方法签名。

同样，如果使用反射，则无需“动态”生成侦听器方法

Answer 3

如果你真的想用注释做这个，你可以用这样的东西来做：

public void listener(String e) {
    for (Method m : this.getClass().getDeclaredMethods()) {
        for (Annotation a : m.getDeclaredAnnotations()) {
            if (a.getClass().getSimpleName().equals(e)) {
                m.setAccessible(true); // Need to do this so we can run private methods
                m.invoke(this);
            }
        }
    }
}

这将使用名称与给定名称匹配的注释调用每个方法。坚持这种一般设计，我建议两个核心改进：

预构建注释＆lt; - ＆gt;方法映射通过执行上述操作但将其存储在注释名称中 - ＆gt;方法hashmap而不是调用它
获取注释的实例而不是字符串（listener(Class<? extends Annotation> annotation)而不是listener(String e)），这样您就可以将方法上的注释的输入与equals进行比较，而不是必须名字和比较字符串，这似乎特别令人讨厌。

这不是一个很棒的设计;更典型的是，您可以将这些硬件作为一系列简单的if语句（如果有少量选项），或者如果有很多选项，您可以使用类似命令模式的东西（将每个可调用方法封装到对象中）），让每个命令在创建时注册一个名称，然后将它们存储在一个地图中，然后您可以从该地图中查找相关命令。

在运行时添加方法，该方法取决于具有相同类中的注释的方法

3 个答案: