使用枚舉類型作爲@ RolesAllowed-Annotation的值參數

Question

我正在開發一個Java企業應用程序，目前正在執行Java EE安全性內容以限制特定用戶對特定功能的訪問。我配置了應用服務器和一切，現在我使用的RolesAllowed的註釋，以確保方法：

@Documented 
@Retention (RUNTIME) 
@Target({TYPE, METHOD}) 
public @interface RolesAllowed { 
    String[] value(); 
} 

當我使用這樣的註解，它工作正常：

@RolesAllowed("STUDENT") 
public void update(User p) { ... } 

但這不是我想要的，因爲我必須在這裏使用字符串，重構變得困難，並且可能發生錯字。因此，我不想使用字符串，而是使用Enum值作爲此註釋的參數。枚舉看起來是這樣的：

public enum RoleType { 
    STUDENT("STUDENT"), 
    TEACHER("TEACHER"), 
    DEANERY("DEANERY"); 

    private final String label; 

    private RoleType(String label) { 
     this.label = label; 
    } 

    public String toString() { 
     return this.label; 
    } 
} 

於是，我就用枚舉作爲這樣的參數：

@RolesAllowed(RoleType.DEANERY.name()) 
public void update(User p) { ... } 

但後來我得到以下編譯器錯誤，儘管Enum.name只返回一個字符串（這總是不變的，不是嗎？）。

The value for annotation attribute RolesAllowed.value must be a constant expression`

我想接下來的事情是一個額外的最終字符串添加到我的枚舉：

public enum RoleType { 
    ... 
    public static final String STUDENT_ROLE = STUDENT.toString(); 
    ... 
} 

但是，這也並不作爲參數工作，會導致相同的編譯器錯誤：

// The value for annotation attribute RolesAllowed.value must be a constant expression 
@RolesAllowed(RoleType.STUDENT_ROLE) 

我該如何實現我想要的行爲？我甚至實現了自己的攔截器來使用我自己的註釋，這很漂亮，但是對於像這樣的小問題，代碼太多了。

免責聲明

這個問題本來是一個Scala問題。我發現Scala不是問題的根源，所以我首先嚐試用Java來做到這一點。

Answer 1

我不認爲你使用枚舉的方法會起作用。我發現，編譯器錯誤走了，如果我在你的最後一個例子改變了STUDENT_ROLE領域的一個常量字符串，而不是一個表達式：

public enum RoleType { 
    ... 
    public static final String STUDENT_ROLE = "STUDENT"; 
    ... 
} 

然而，這則意味着枚舉值將不會被使用任何地方，因爲你會在註釋中使用字符串常量。

在我看來，如果你的RoleType類只包含一堆靜態最終的String常量，那麼你會更好。

---

要知道爲什麼你的代碼是沒有編制，我看看到Java Language Specification（JLS）。所述JLS爲annotations指出，對於與類型T和值V的參數的註釋，

if T is a primitive type or String , V is a constant expression.

甲constant expression包括，除其他外，

Qualified names of the form TypeName . Identifier that refer to constant variables

和constant variable被定義as

a variable, of primitive type or type String , that is final and initialized with a compile-time constant expression

Answer 2

這裏'這是一個使用額外界面和元註釋的解決方案。我已經包含了一個實用工具類來幫助做反射，從一組註釋中獲取角色類型，並對其進行一些測試：

/** 
* empty interface which must be implemented by enums participating in 
* annotations of "type" @RolesAllowed. 
*/ 
public interface RoleType { 
    public String toString(); 
} 

/** meta annotation to be applied to annotations that have enum values implementing RoleType. 
* the value() method should return an array of objects assignable to RoleType*. 
*/ 
@Retention(RetentionPolicy.RUNTIME) 
@Target({ANNOTATION_TYPE}) 
public @interface RolesAllowed { 
    /* deliberately empty */ 
} 

@RolesAllowed 
@Retention(RetentionPolicy.RUNTIME) 
@Target({TYPE, METHOD}) 
public @interface AcademicRolesAllowed { 
    public AcademicRoleType[] value(); 
} 

public enum AcademicRoleType implements RoleType { 
    STUDENT, TEACHER, DEANERY; 
    @Override 
    public String toString() { 
     return name(); 
    } 
} 


public class RolesAllowedUtil { 

    /** get the array of allowed RoleTypes for a given class **/ 
    public static List<RoleType> getRoleTypesAllowedFromAnnotations(
      Annotation[] annotations) { 
     List<RoleType> roleTypesAllowed = new ArrayList<RoleType>(); 
     for (Annotation annotation : annotations) { 
      if (annotation.annotationType().isAnnotationPresent(
        RolesAllowed.class)) { 
       RoleType[] roleTypes = getRoleTypesFromAnnotation(annotation); 
       if (roleTypes != null) 
        for (RoleType roleType : roleTypes) 
         roleTypesAllowed.add(roleType); 
      } 
     } 
     return roleTypesAllowed; 
    } 

    public static RoleType[] getRoleTypesFromAnnotation(Annotation annotation) { 
     Method[] methods = annotation.annotationType().getMethods(); 
     for (Method method : methods) { 
      String name = method.getName(); 
      Class<?> returnType = method.getReturnType(); 
      Class<?> componentType = returnType.getComponentType(); 
      if (name.equals("value") && returnType.isArray() 
        && RoleType.class.isAssignableFrom(componentType)) { 
       RoleType[] features; 
       try { 
        features = (RoleType[]) (method.invoke(annotation, 
          new Object[] {})); 
       } catch (Exception e) { 
        throw new RuntimeException(
          "Error executing value() method in " 
            + annotation.getClass().getCanonicalName(), 
          e); 
       } 
       return features; 
      } 
     } 
     throw new RuntimeException(
       "No value() method returning a RoleType[] type " 
         + "was found in annotation " 
         + annotation.getClass().getCanonicalName()); 
    } 

} 

public class RoleTypeTest { 

    @AcademicRolesAllowed({DEANERY}) 
    public class DeaneryDemo { 

    } 

    @Test 
    public void testDeanery() { 
     List<RoleType> roleTypes = RolesAllowedUtil.getRoleTypesAllowedFromAnnotations(DeaneryDemo.class.getAnnotations()); 
     assertEquals(1, roleTypes.size()); 
    } 
} 

Answer 3

這個怎麼樣？

public enum RoleType { 
    STUDENT(Names.STUDENT), 
    TEACHER(Names.TEACHER), 
    DEANERY(Names.DEANERY); 

    public class Names{ 
     public static final String STUDENT = "Student"; 
     public static final String TEACHER = "Teacher"; 
     public static final String DEANERY = "Deanery"; 
    } 

    private final String label; 

    private RoleType(String label) { 
     this.label = label; 
    } 

    public String toString() { 
     return this.label; 
    } 
} 

而且在註釋，你可以使用它像

@RolesAllowed(RoleType.Names.DEANERY) 
public void update(User p) { ... } 

一個小問題是，對於任何修改，我們需要在兩個地方需要修改。但由於它們在相同的文件中，所以不太可能錯過。作爲回報，我們獲得了不使用原始字符串並避免複雜機制的好處。

或者這聽起來完全愚蠢？ :)