Аннотации

public enum Commands {
    UPPERCASE,
    ASTERISK,
    SNAKE_CASE;
}

public interface Command {
    void execute();
}

@Retention(RUNTIME)
public @interface CommandConfiguration {
    Commands[] allowedCommands();
}

@Retention(RUNTIME)
public @interface CommandId {
    Commands value();
}

@CommandId(ASTERISK)
public class AsteriskCommand implements Command {
    @Override
    public void execute() {
        System.out.println("Executing AsteriskCommand: printing asterisks *****************");
    }
}

@CommandId(SNAKE_CASE)
public class SnakeCaseCommand implements Command {
    @Override
    public void execute() {
        System.out.println("Executing SnakeCaseCommand: printing_in_snake_case_everything");
    }
}

@CommandId(UPPERCASE)
public class UppercaseCommand implements Command {
    @Override
    public void execute() {
        System.out.println("Executing UppercaseCommand: PRINTING IN UPPERCASE");
    }
}

public abstract class Book {
    private String description;
 
    public Book(String description) {
        this.description = description;
    }
 
    public String getDescription() {
        return description;
    }
 
    public void setDescription(String description) {
        this.description = description;
    }
}

@CommandConfiguration(allowedCommands = {ASTERISK, SNAKE_CASE})
public class Moby****Book extends Book {
    public Moby****Book() {
        super("Book about Moby ****");
    }
}

@CommandConfiguration(allowedCommands = {SNAKE_CASE, ASTERISK, UPPERCASE})
public class WarAndPeaceBook extends Book {
    public WarAndPeaceBook() {
        super("WAR and PEACE");
    }
}

public class Executor {
    private static final Command DENIED_COMMAND = () -> System.out.println("DENIED");
    private static final Command NOT_IMPLEMENTED_COMMAND = () -> System.out.println("NOT IMPLEMENTED");
 
    private final EnumMap<Commands, Command> commandMap = new EnumMap<>(Commands.class);
 
    private final String packageToScan;
 
    public Executor(String packageToScan) {
        this.packageToScan = packageToScan;
    }
 
    public void init() {
        Reflections reflections = new Reflections(packageToScan);
 
        Set<Class<? extends Command>> commands = reflections.getSubTypesOf(Command.class);
 
        for (Class<? extends Command> command : commands) {
            if (command.isAnnotationPresent(CommandId.class)) {
                CommandId id = command.getAnnotation(CommandId.class);
 
                Command instance;
                try {
                    instance = command.getDeclaredConstructor().newInstance();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
 
                commandMap.put(id.value(), instance);
            }
        }
    }
 
    public void applyCommand(Commands command, Book book) {
        if (book.getClass().isAnnotationPresent(CommandConfiguration.class)) {
            CommandConfiguration configuration = book.getClass().getAnnotation(CommandConfiguration.class);
 
            Command commandToRun = determineCommand(configuration, command);
 
            System.out.println(book.getDescription());
 
            commandToRun.execute();
        }
    }
 
    private Command determineCommand(CommandConfiguration configuration, Commands command) {
        if (Arrays.asList(configuration.allowedCommands()).contains(command))
            return commandMap.getOrDefault(command, NOT_IMPLEMENTED_COMMAND);
 
        return DENIED_COMMAND;
    }
}

public class Main {
    public static void main(String[] args) {
        Executor executor = new Executor("com.test");
 
        executor.init();
 
        Book moby**** = new Moby****Book();
        Book warAndPeace = new WarAndPeaceBook();
 
        testBook(moby****, executor);
        testBook(warAndPeace, executor);
    }
 
    private static void testBook(Book book, Executor executor) {
        Arrays.stream(Commands.values()).forEach(command -> executor.applyCommand(command, book));
    }
}