问题
It happened to me that I accidentally did this:
@javax.annotation.Nullable
@javax.validation.constraints.NotNull
The compiler didn't complain and everything seemed to work well.
Now I am wondering what is internally happening when two or more annotations contradict each other. Furthermore, does the order matter?
Is this
@Nullable
@NotNull
the same than this?
@NotNull
@Nullable
How is this working for annotations in general? Who wins?
EDIT: I am looking for a general answer, not necessarily about these two annotations
回答1:
Annotations themselves don't bring any logic to your code. Each annotation should be processed with a proper annotation processor. Annotation processor is the guy who makes the annotation meaningful.
Check the official tutorial:
Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate.
Annotations have a number of uses, among them:
- Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
- Compile-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
- Runtime processing — Some annotations are available to be examined at runtime.
Let's consider these 2 particular annotations you mentioned above. First of all, they are not mutual exclusive and have the different nature.
The @javax.annotation.Nullable is a part of JSR-305 and it has the opposite one - @javax.annotation.Nonnull. These annotations are designed to annotate your class fields, method params and method results. You can use them with code analyzers, one of them is Findbugs
The @javax.validation.constraints.NotNull is a part of JSR-303 aka Bean Validation. So this annotation has nothing common with @javax.annotation.Nullable, since these annotations have different processors.
Each time you have any doubts on the annotation semantics, you should check the documentation, and of course you can run you code and see what would happen.
回答2:
Annotations do not change the meaning of your program. The Java compiler adds them to the internal representation of the program (either during compilation only, or saved in the class file, or even at run time), but it ignores them otherwise. In particual, it doesn't know about "conflicting" annotations.
Annotations are used by external tools or libraries, and they may cope with conflicting annotations in any way they want (for example, by printing an error message).
来源：https://stackoverflow.com/questions/38185237/notnull-and-nullable-contradicting-java-annotations