Значение Enum по умолчанию для значения аннотации перечисления Java

Я не уверен, каков ваш вариант использования, поэтому у меня есть два ответа:

Ответ 1:

Если вы просто хотите написать как можно меньше кода, вот мое предложение, расширяющее ответ Dunes:

public enum ImplicitType {
    DO_NOT_USE;
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyAnnotation {

    Class<? extends Enum<?>> clazz() default ImplicitType.class;

    String value();
}

@MyAnnotation("A"); 
private MyEnumType myEnumField;

Когда clazz равно ImplicitType.class, используйте тип полей как класс перечисления.

Ответ 2:

Если вы хотите использовать некоторую магию фреймворка и хотите поддерживать безопасность типов, проверенных компилятором, вы можете сделать что-то вроде этого:

/** Marks annotation types that provide MyRelevantData */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface MyAnnotation {
}

И в клиентском коде у вас будет

/** Provides MyRelevantData for TheFramework */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@MyAnnotation
public @interface MyEnumAnnotation {

    MyEnumType value(); // default MyEnumType.FOO;

}

@MyEnumAnnotation(MyEnum.FOO)
private MyEnumType myValue;

В этом случае вы должны просмотреть поле на наличие аннотаций, которые снова отмечены MyAnnotation. Однако вам нужно будет получить доступ к значению через отражение объекта аннотации. Похоже, этот подход более сложен на стороне фреймворка.

Не совсем уверен, что вы имеете в виду, когда говорите, что получите значение по умолчанию, если указанное значение не было указано в аргументах конструктора, но не заботитесь об универсальном типе во время выполнения.

Следующее работает, но это немного уродливый хак.

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

public class Main {

    @MyAnnotation(clazz = MyEnum.class, name = "A")
    private MyEnum value;

    public static v oid main(String[] args) {
        new Main().printValue();
    }

    public void printValue() {
        System.out.println(getValue());
    }

    public MyEnum getValue() {
        if (value == null) {
            value = getDefaultValue("value", MyEnum.class);
        }
        return value;
    }

    private <T extends Enum<?>> T getDefaultValue(String name, Class<T> clazz) {

        try {
            MyAnnotation annotation = Main.class.getDeclaredField(name)
                    .getAnnotation(MyAnnotation.class);

            Method valueOf = clazz.getMethod("valueOf", String.class);

            return clazz.cast(valueOf.invoke(this, annotation.value()));

        } catch (SecurityException e) {
            throw new IllegalStateException(e);
        } catch (NoSuchFieldException e) {
            throw new IllegalArgumentException(name, e);
        } catch (IllegalAccessException e) {
            throw new IllegalStateException(e);
        } catch (NoSuchMethodException e) {
                throw new IllegalStateException(e);
        } catch (InvocationTargetException e) {
            if (e.getCause() instanceof RuntimeException) {
                throw (RuntimeException) e.getCause();
                /* rethrow original runtime exception 
                 * For instance, if value = "C" */
            }
            throw new IllegalStateException(e);
        }
    }

    public enum MyEnum {
        A, B;
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface MyAnnotation {

        Class<? extends Enum<?>> clazz();

        String name();
    }
}

изменить: я изменил getDefaultValue для работы с помощью метода перечисления valueOf, что дает лучшее сообщение об ошибке, если заданное значение не является эталонным экземпляром перечисления.

Проще говоря, вы не можете этого сделать. Перечисления нельзя легко использовать в качестве универсальных типов; возможно, с одним исключением, которое заключается в том, что Enums может фактически реализовывать интерфейсы, которые допускают несколько динамическое использование. Но это не будет работать с аннотациями, поскольку набор типов, которые можно использовать, строго ограничен.

Синтаксис вашего универсального типа немного отличается. Должен быть:

public @interface MyAnnotation<T extends Enum<T>> {...

но компилятор выдает ошибку:

Синтаксическая ошибка, объявление аннотации не может иметь параметры типа

Хорошая идея. Похоже не поддерживается.

Фреймворки, использующие аннотации, могут действительно выиграть от использования apt. . Это препроцессор, содержащийся в javac, который позволит вам анализировать объявления и их аннотации (но не локальные объявления внутри методов).

Для вашей проблемы вам нужно будет написать AnnotationProcessor (класс, используемый в качестве отправной точки для предварительной обработки) для анализа аннотации с помощью Зеркальный API. На самом деле аннотация Dunes довольно близка к тому, что здесь нужно. Жаль, что имена перечислений не являются постоянными выражениями, иначе решение Dunes было бы довольно хорошим.

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
public @interface MyAnnotation {
    Class<? extends Enum<?>> clazz();
    String name() default "";
}

А вот пример перечисления: enum MyEnum { FOO, BAR, BAZ, ; }

При использовании современной IDE вы можете отображать ошибки непосредственно в элементе аннотации (или значении аннотации), если имя не является допустимой константой перечисления. Вы даже можете предоставить подсказки по автозаполнению, поэтому, когда пользователь напишет @MyAnnotation(clazz = MyEnum.class, name = "B") и нажмет горячие клавиши для автозавершения после написания B, вы можете предоставить ему список на выбор, содержащий все константы, начинающиеся с < em>B: БАР и БАЗ.

Мое предложение реализовать значение по умолчанию состоит в том, чтобы создать аннотацию маркера, чтобы объявить константу перечисления как значение по умолчанию для этого перечисления. Пользователю по-прежнему необходимо указать тип перечисления, но он может опустить имя. Однако, вероятно, есть и другие способы сделать значение значением по умолчанию.

Вот руководство по apt и здесь AbstractProcessor, который следует расширить, чтобы переопределить метод getCompletions.

Мое предложение похоже на предложение kapep. Разница в том, что я предлагаю использовать обработчик аннотаций для создания кода.

Простым примером может быть, если вы намеревались использовать это только для перечислений, которые вы сами написали. Аннотируйте перечисление специальным перечислением. Затем процессор аннотаций сгенерирует новую аннотацию только для этого перечисления.

Если вы работаете с большим количеством перечислений, которые вы не писали, то вы могли бы реализовать некоторую схему сопоставления имен: имя перечисления -> имя аннотации. Затем, когда обработчик аннотаций встречал одно из этих перечислений в вашем коде, он автоматически генерировал соответствующую аннотацию.

Вы просили:

1. Одна аннотация, которую можно использовать повторно для всех перечислений... технически нет, но я думаю, что эффект тот же.
2. Минимальные усилия/сложность для получения значения перечисления по умолчанию в виде перечисления из экземпляров аннотации... вы можете получить значение перечисления по умолчанию без какой-либо специальной обработки

У меня была аналогичная потребность, и я придумал следующее довольно простое решение:

Фактический интерфейс @Default:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Default {}

Использование:

public enum Foo {
    A,
    @Default B,
    C;
}

Находим значение по умолчанию:

public abstract class EnumHelpers {
    public static <T extends Enum<?>> T defaultEnum(Class<T> clazz) {
        Map<String, T> byName = Arrays.asList(clazz.getEnumConstants()).stream()
            .collect(Collectors.toMap(ec -> ec.name(), ec -> ec));

        return Arrays.asList(clazz.getFields()).stream()
             .filter(f -> f.getAnnotation(Default.class) != null)
             .map(f -> byName.get(f.getName()))
             .findFirst()
             .orElse(clazz.getEnumConstants()[0]);
    }   
}

Я также играл с возвратом Optional<T> вместо того, чтобы по умолчанию использовать первую константу Enum, объявленную в классе.

Это, конечно, будет объявление по умолчанию для всего класса, но это соответствует тому, что мне нужно. YMMV :)