Scanning for Beans with particular annotation

[Sangel Kapoor]

How to Scan Beans with particular Annotation. For instance I would like to know all the beans  with @Command Annotation on them.

[Tushar Goel]

Quick google gives me several option. One of is this.

You can check that as well.

[Jesper de Jong]

What Tushar posted probably works, but it looks more complicated than necessary. The Spring ApplicationContext has a method to do exactly what you want: getBeansWithAnnotation.

It returns a Map in which the keys are bean names and the values are bean instances.

For example:

@Component
public void Example {

    private final ApplicationContext context;

    @Autowired
    public Example(ApplicationContext context) {
        this.context = context;
    }

    public Map<String, Object> findAllCommandBeans() {
        return context.getBeansWithAnnotation(Command.class);
    }
}

[Tushar Goel]

Thanks Jesper.. I was unaware of that..

[Sangel Kapoor]

Jesper de Jong wrote:What Tushar posted probably works, but it looks more complicated than necessary. The Spring ApplicationContext has a method to do exactly what you want: getBeansWithAnnotation.

It returns a Map in which the keys are bean names and the values are bean instances.

For example:

@Component
public void Example {

    private final ApplicationContext context;

    @Autowired
    public Example(ApplicationContext context) {
        this.context = context;
    }

    public Map<String, Object> findAllCommandBeans() {
        return context.getBeansWithAnnotation(Command.class);
    }
}

Thanks a bunch, I have a follow up question , We also have CommandHandlers which handles particular Command.
I would like to annotate method in class as follows

Class XCommandHandler{

  @CommandHandler
  public void handle(X command){
  }

}

There is another class Router which will route Command to its handler and invoke handle method.

Class Router is as follows

Class Router{
  
 Map<Command,CommandHandler> map = new HashMap<>();

  public Router(HashMap<Map<Command,CommandHandler> map>){
      this.map =  map; 
  } 

  public void subscribe(Command m, CommandHandler ch){
      Method that populates baove map.  
  }

}


I want Spring to populate above map automatically when Spring Context is loaded. How to achieve this , given now I know how to find classes with @Command Annotations.

[Jesper de Jong]

I found this an interesting problem, so I played around with it a bit. Here is my solution. I modified some of your original ideas.

Instead of having a @Command annotation, I made an enum to define the different kinds of commands:

package com.jesperdj.springsandbox;

public enum Command {
    OPEN, CLOSE, SAVE
}

Then I created two annotations: @CommandHandlers, which is supposed to be used on a class that contains handler methods, and @CommandHandler, which is supposed to be used on the methods themselves:

package com.jesperdj.springsandbox;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.stereotype.Component;

@Target(ElementType.TYPE)               // To be used on classes
@Retention(RetentionPolicy.RUNTIME)
@Component                              // Make everything that is annotated with @CommandHandlers also a Spring bean
public @interface CommandHandlers {
}

package com.jesperdj.springsandbox;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)             // To be used on methods
@Retention(RetentionPolicy.RUNTIME)
public @interface CommandHandler {

    Command value();
}

An example of a container with handler methods then looks like this:

package com.jesperdj.springsandbox;

@CommandHandlers
public class ExampleHandlers {

    @CommandHandler(Command.OPEN)
    public void handleOpen(Object data) {
        // Handle OPEN command
    }

    @CommandHandler(Command.CLOSE)
    public void handleClose(Object close) {
        // Handle CLOSE command
    }

    @CommandHandler(Command.SAVE)
    public void handleSave(Object save) {
        // Handle SAVE command
    }
}

Then the Router class. It contains an initialize() method with a @PostConstruct annotation, so that Spring will call this method when it creates the Router bean. The initialize() method is going to look for all Spring beans with the @CommandHandlers annotation. For each one that it finds, it's going to look at all the methods that have a @CommandHandler annotation, and it registers a handler.

package com.jesperdj.springsandbox;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class Router {

    @Autowired
    private ApplicationContext context;

    private final Map<Command, Consumer<Object>> commandHandlers = new HashMap<>();

    @PostConstruct
    public void initialize() {
        // Find beans with @CommandHandlers annotation
        Collection<Object> containers = context.getBeansWithAnnotation(CommandHandlers.class).values();

        // In each container, look for methods with the @CommandHandler annotation
        for (Object container : containers) {
            for (Method method : container.getClass().getDeclaredMethods()) {
                CommandHandler annotation = method.getAnnotation(CommandHandler.class);
                if (annotation != null) {
                    // Register a handler for this method
                    register(annotation.value(), data -> handleCommand(container, method, data));
                }
            }
        }
    }

    private void handleCommand(Object container, Method method, Object data) {
        try {
            method.invoke(container, data);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

    public void register(Command command, Consumer<Object> handler) {
        commandHandlers.put(command, handler);
    }

    public void route(Command command, Object data) {
        commandHandlers.get(command).accept(data);
    }
}

And an example of how to call the router to route a command:

package com.jesperdj.springsandbox;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ExampleUsage {

    @Autowired
    private Router router;

    public void example() {
        // Issue an OPEN command, passing a filename as data for the command
        router.route(Command.OPEN, "C:\\Temp\\hello.txt");
    }
}