What can be real case use of Repeating annotations?

Question

Actually, I am going through new things in Java 8. There are many new stuff has come i.e Lambda expressions , Default methods and so many..

One of the feature is Repeating Annotations,

" Repeating Annotations provide the ability to apply the same annotation type more than once to the same declaration or type use "

Here I can Understand that I can use same Annotation many times.

I am trying understand real / practical usage of this addition. and trying to understand why they missed it until java 7.

Answer 1

It is much helpful when you have multiple fields declared in an annotation. For example:

@Repeatable
public @interface Role {
   String type;
   String[] allowed;
}

In this case, it is much easier to use this kind of annotation for multiple roles:

@Role(type="readonly", allowed={"view"})
@Role(type="admin", allowed={"view,add,update,delete"})
public boolean checkAllowed() {
}

Answer 2

If you have, for example, some role-based security, you'd be able to write something like:

@Authorize(role="USER")
@Authorize(role="ADMIN")
public void doStuff(){
...codez
}

In previous Java versions, to achieve the same, you'd have to do something like:

@Authorize(roles={"USER", "ADMIN"})
public void doStuff(){
...codez
}

or

@Authorize(role="USER, ADMIN")
public void doStuff(){
..moar codez
}

The difference, as you can see for yourself, is minimal, and the @Repeatable annotation is more syntactic sugar than a huge breakthrough. The benefit is not obvious unless you consider some more verbose annotations, say bunch of Quartz cron expressions. Prior java 8, you'd have to do something like:

@Cron(values={"* * * * * 10", "12 * * * * 0", "4 * 5 * 6 * 7"})
public void doCron(){

}

But in java 8 you could have a separate cron at each line, which makes the expression more readable.

Answer 3

The answer is the obvious: You want to annotate something with multiple values.

Prior to this feature you'd need to parse the single allowed argument in your annotation processing code:

@SomeAnnotation(value="this,that")
String foo;

Or (from comments):

@SomeAnnotation(value={"author1","author2"})
String foo;

The annotation processing code would need to have logic to deal with splitting the value and dealing with it, or getting multiple values. Allowing multiple annotations makes this simpler from a logic perspective. It's just a convenience feature.