原标题：Java如何快速获取类附带的注解
如何快速获取或者判断一个类是否有某个注解呢？可以使用对象的Class信息来获取，下面是一个例子：
在上面的例子中，hasAnnotation方法的作用就是判断是否一个对象所属的类包含某个注解，可以分析一下具体的实现，首先，第一个参数类型为AnnotatedElement，代表具体需要判断的对象Class信息，需要注意的是，Class类实现了AnnotatedElement接口，所以传递一个Class对象给这个方法的第一个参数是合法的；第二个参数是注解类的Class信息，是需要检测的目标注解。可以看到，在代码中使用了AnnotatedElement的isAnnotationPresent方法来进行判断是否具有某个注解的功能，可以跟进去看一下具体的实现原理。
可以看一下annotationData方法的具体实现，参考下面的图片：
其中首先会判断是否具有需要的数据，以及是否符合要求，如果数据不存在或者过期了，那么就需要重新获取，重新获取数据的关键方法是createAnnotationData，该方法的实现可以参考下面的代码：
annotationData方法获取到的是一个AnnotationData对象，可以看一下AnnotationData类的定义：
在getAnnotation方法中，该方法获取了AnnotationData字段的annotations字段来判断是否包含目标注解，更加深入的细节可以自行参考Class类的具体实现。本文是一个极短的java技术分享，提供一种获取一个对象的注解信息的思路，其实还有很多类型信息都是可以通过Class来获取到的。返回搜狐，查看更多
责任编辑：

一：获取类上注解的值
定义注解@Target(ElementType.TYPE)用于类，接口等
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Orange {
String getName();
String getValue();
}
获取
@Orange(getName = "3333",getValue = "4444")
public class ParameterNameTest {
。。。
@Test
public void main() throws Exception {
Class clazz = ParameterNameTest.class;
if(clazz.isAnnotationPresent(Orange.class)){
// 获取 "类" 上的注解
Orange getAnnotation = clazz.getAnnotation(Orange.class);
System.out.println("\"类\"上的注解值获取到第一个 ："
+ getAnnotation.getName()+ "，第二个："+ getAnnotation.getValue());
}
}
返回
"类"上的注解值获取到第一个 ：3333，第二个：4444
二：获取属性变量上注解的值
定义注解@Target(ElementType.FIELD)用于属性变量
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Banana {
String length();
String price();
}
获取
public class ParameterNameTest {
@Banana(length = "6666", price = "$888")
String something = "other information";
@Test
public void main() throws Exception {
Class clazz = ParameterNameTest.class;
// 获取 "属性变量" 上的注解的值
Field[] fields = clazz.getDeclaredFields();
for(Field field: fields){
if(field.isAnnotationPresent(Banana.class)){
Banana bananaAnnotation = field.getAnnotation(Banana.class);
System.out.println("\"属性变量\"上的注解值获取到第一个 ："
+ bananaAnnotation.length()+ "，第二个："+ bananaAnnotation.price());
}
}
}
}
返回
"属性变量"上的注解值获取到第一个 ：6666，第二个：$888
三: 获取方法上注解的值
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Apple {
String color();
String number();
}
获取
public class ParameterNameTest {
@Apple(color = "红色", number = "5555")
public void method1(){
// ...
}
@Test
public void main() throws Exception {
Class clazz = ParameterNameTest.class;
// 获取 "方法"上的注解的值
Method[] methods = clazz.getDeclaredMethods();
for (Method method: methods){
if(method.isAnnotationPresent(Apple.class)){
Apple appleAnnotation = method.getAnnotation(Apple.class);
System.out.println("\"方法\"上的注解值获取到第一个 ："
+ appleAnnotation.color()+ "，第二个："+ appleAnnotation.number());
}
}
}
}
返回
"方法"上的注解值获取到第一个 ：红色，第二个：5555
三: 获取" 方法参数 " 上注解的值
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Cherry {
String value();
}
获取
public class ParameterNameTest {
public void method2(@Cherry("1111") String param1, @Cherry("2222") String param2) {
System.out.println(param1 + param2);
}
@Test
public void main() throws Exception {
Class clazz = ParameterNameTest.class;
// 获取 "方法参数" 上的注解的值
Method method = clazz.getDeclaredMethod("method2", String.class, String.class);
String[] parameterNames = getMethodParameterNamesByAnnotation(method);
System.out.println("\"方法参数\"上的注解值获取到"+Arrays.toString(parameterNames));
}
/**
* 获取给 "方法参数" 进行注解的值
*
* @param method 要获取参数名的方法
* @return 按参数顺序排列的参数名列表
*/
public static String[] getMethodParameterNamesByAnnotation(Method method) {
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
if (parameterAnnotations == null || parameterAnnotations.length == 0) {
return null;
}
String[] parameterNames = new String[parameterAnnotations.length];
int i = 0;
for (Annotation[] parameterAnnotation : parameterAnnotations) {
for (Annotation annotation : parameterAnnotation) {
if (annotation instanceof Cherry) {
Cherry param = (Cherry) annotation;
parameterNames[i++] = param.value();
}
}
}
return parameterNames;
}
}
返回
"方法参数"上的注解值获取到[1111, 2222]
小结：主要使用的API是Class类中的实现接口AnnotatedElement的方法
isAnnotationPresent --- 检测该元素是否被对应注解修饰
default boolean isAnnotationPresent(Class extends Annotation> annotationClass) {
return getAnnotation(annotationClass) != null;
}
getAnnotation  --- 获取注解对象
 T getAnnotation(Class annotationClass);

一、注解基本知识
1、元注解
元注解是指注解的注解。包括  @Retention @Target @Document @Inherited四种。
1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
2. 参数成员只能用public或默认(default)这两个访问权修饰
3. 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
4. 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,因为你除此之外没有别的获取注解对象的方法
5. 注解也可以没有定义成员, 不过这样注解就没啥用了
自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效), 是否将注解包含在javadoc中及是否允许子类继承父类中的注解, 具体如下:
1. @Target 表示该注解目标,可能的 ElemenetType 参数包括:
ElemenetType.CONSTRUCTOR 构造器声明
ElemenetType.FIELD 域声明(包括 enum 实例)
ElemenetType.LOCAL_VARIABLE 局部变量声明
ElemenetType.METHOD 方法声明
ElemenetType.PACKAGE 包声明
ElemenetType.PARAMETER 参数声明
ElemenetType.TYPE 类，接口(包括注解类型)或enum声明
2. @Retention 表示该注解的生命周期,可选的 RetentionPolicy 参数包括
RetentionPolicy.SOURCE 注解将被编译器丢弃
RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃
RetentionPolicy.RUNTIME VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
3. @Documented 指示将此注解包含在 javadoc 中
4.  @Inherited 指示允许子类继承父类中的注解
二、在java中如何使用
2.1、定义注解
package com.test.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class MyAnnotation {
/**
* 注解类
* @author T4980D
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyClassAnnotation {
String uri();
String desc();
}
/**
* 构造方法注解
* @author T4980D
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.CONSTRUCTOR)
public @interface MyConstructorAnnotation {
String uri();
String desc();
}
/**
* 我的方法注解
* @author Owner
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyMethodAnnotation {
String uri();
String desc();
}
/**
* 字段注解定义
* @author Owner
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyFieldAnnotation {
String uri();
String desc();
}
/**
*
* 可以同时应用到类上和方法上
* @author T4980D
*
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Yts {
// 定义枚举
public enum YtsType {
util, entity, service, model
}
// 设置默认值
public YtsType classType() default YtsType.util;
// 数组
int[] arr() default {3, 7, 5};
String color() default "blue";
}
}
2.2、基本测试注解
package com.test.annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import com.test.annotation.MyAnnotation.MyClassAnnotation;
import com.test.annotation.MyAnnotation.MyConstructorAnnotation;
import com.test.annotation.MyAnnotation.MyFieldAnnotation;
import com.test.annotation.MyAnnotation.MyMethodAnnotation;
import com.test.annotation.MyAnnotation.Yts;
import com.test.annotation.MyAnnotation.Yts.YtsType;
@MyClassAnnotation(desc = "The class", uri = "com.test.annotation.Test")
@Yts(classType =YtsType.util)
public class TestAnnotation {
@MyFieldAnnotation(desc = "The class field", uri = "com.test.annotation.Test#id")
private String id;
@MyConstructorAnnotation(desc = "The class constructor", uri = "com.test.annotation.Test#MySample")
public TestAnnotation() {
}
public String getId() {
return id;
}
@MyMethodAnnotation(desc = "The class method", uri = "com.test.annotation.Test#setId")
public void setId(String id) {
System.out.println(" method info: "+id);
this.id = id;
}
@MyMethodAnnotation(desc = "The class method sayHello", uri = "com.test.annotation.Test#sayHello")
@Yts
public void sayHello(String name){
if(name == null || name.equals("")){
System.out.println("hello world!");
}else{
System.out.println(name + "\t:say hello world!");
}
}
public static void main(String[] args) throws Exception {
Class clazz = TestAnnotation.class;
// 得到类注解
MyClassAnnotation myClassAnnotation = clazz.getAnnotation(MyClassAnnotation.class);
System.out.println(myClassAnnotation.desc() + " "+ myClassAnnotation.uri());
// 得到构造方法注解
Constructor cons = clazz.getConstructor(new Class[]{});
MyConstructorAnnotation myConstructorAnnotation = cons.getAnnotation(MyConstructorAnnotation.class);
System.out.println(myConstructorAnnotation.desc() + " "+ myConstructorAnnotation.uri());
// 获取方法注解
Method method = clazz.getMethod("setId", new Class[]{int.class});
MyMethodAnnotation myMethodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
System.out.println(myMethodAnnotation.desc() + " "+ myMethodAnnotation.uri());
// 获取字段注解
Field field = clazz.getDeclaredField("id");
MyFieldAnnotation myFieldAnnotation = field.getAnnotation(MyFieldAnnotation.class);
System.out.println(myFieldAnnotation.desc() + " "+ myFieldAnnotation.uri());
}
}
2.3、通过反射解析
package com.test.annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import com.test.annotation.MyAnnotation.MyClassAnnotation;
import com.test.annotation.MyAnnotation.MyMethodAnnotation;
import com.test.annotation.MyAnnotation.Yts;
import com.test.annotation.MyAnnotation.Yts.YtsType;
public class ParseAnnotation {
/**
* 解析方法注解
* @param 
* @param clazz
*/
public static  void parseMethod(Class clazz) {
try {
T obj = clazz.newInstance();
for (Method method : clazz.getDeclaredMethods()) {
MyMethodAnnotation methodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
if (methodAnnotation!=null) {
//通过反射调用带有此注解的方法
method.invoke(obj, methodAnnotation.uri());
}
Yts yts = (Yts) method.getAnnotation(Yts.class);
if (yts != null) {
if (YtsType.util.equals(yts.classType())) {
System.out.println("this is a util method");
} else {
System.out.println("this is a other method");
}
System.out.println(Arrays.toString(yts.arr())); //打印数组
System.out.println(yts.color()); //输出颜色
}
System.out.println("\t\t-----------------------");
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 解析类注解
* @param 
* @param clazz
*/
public static  void parseType(Class clazz) {
try {
Yts yts = (Yts) clazz.getAnnotation(Yts.class);
if (yts != null) {
if (YtsType.util.equals(yts.classType())) {
System.out.println("this is a util class");
} else {
System.out.println("this is a other class");
}
}
MyClassAnnotation classAnnotation = (MyClassAnnotation) clazz.getAnnotation(MyClassAnnotation.class);
if (classAnnotation != null) {
System.err.println(" class info: "+classAnnotation.uri());
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
parseMethod(TestAnnotation.class);
parseType(TestAnnotation.class);
}
}
三、注解应用案例
3.1、关于细粒度权限拦截的问题，在Struts2中可以根据登录用户所具有的的权限进行任一一个action方法的拦截，可以定义一个自定义方法注解，例如
@Retention(RetentionPolicy.RUNTIME)//代表Permission注解保留在的阶段
@Target(ElementType.METHOD)//标注在方法上面
public @interface Permission {
/** 模块 */
String module();
/** 权限值 */
String privilege();
}
3、2 比如有一个部门action，Department.action,有一个方法public String departmentlistUI(){}可以这样定义方法
@Permission(module="department",privilege="view")
public String departmentlistUI(){
}
3.3、然后自定定义一个权限拦截器PrivilegeInterceptor.java并在struts.xml中注册，在实现interceptor接口后，实现方法public String intercept(ActionInvocation invocation) throws Exception {}，在这里调用任一个action方法都会经过该拦截方法，通过invocation可以获取当前调用的action的名字，以及调用的action的哪个方法，通过这段代码可以获取action名字和方法名。
String actionName=invocation.getProxy().getActionName();
String methodName=invocation.getProxy().getMethod();
System.out.println("拦截到：action的名字："+actionName+"方法名："+methodName);
4、然后通过反射技术，获取该方法上的自定义权限注解，获取当前登录的用户(从session中)，遍历当前用户的所拥有的权限组，并且遍历任一个权限组下的所有的权限，看是否包括该方法上注解所需的权限。这样就可以完成细粒度的action方法权限拦截了。
private boolean validate(ActionInvocation invocation) throws SecurityException, NoSuchMethodException {
String methodName=invocation.getProxy().getMethod();
Method currentMethod = invocation.getAction().getClass().getMethod(methodName);
if(currentMethod != null && currentMethod.isAnnotationPresent(Permission.class)){
//得到方法上的注解
Permission permission = currentMethod.getAnnotation(Permission.class);
//该方法上的所需要的权限
SystemPrivilege methodPrivilege = new SystemPrivilege(new SystemPrivilegePK(permission.module(), permission.privilege()));
//得到当前登录的用户
Employee e = (Employee) ActionContext.getContext().getSession().get("loginUser");
//遍历当前用户下的所有的权限组
for(PrivilegeGroup group : e.getGroups()){
//如果该权限组下包含，要访问该方法所需要的权限，就放行
if(group.getPrivileges().contains(methodPrivilege)){
return true;
}
}
//说明遍历的该用户所有的权限组，没有发现该权限，说明没有该权限
return false;
}
//没有标注注解，表示谁都可以调用该方法
return true;
}
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

一、注解基本知识
1、元注解：@Retention @Target @Document @Inherited
2、Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。
3、参数成员只能用public或默认(default)这两个访问权修饰
4、参数成员只能用基本类型byte，short，char，int，long，float，double，boolean八种基本数据类型和String、Enum、Class、annotations等数据类型，以及这一些类型的数组。
5、要获取类、方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,除此之外没有别的获取注解对象的方法
6、注解也可以没有定义成员, 不过这样注解就没啥用了，只起到标识作用
自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效), 是否将注解包含在javadoc中及是否允许子类继承父类中的注解, 具体如下：
1、@Target 表示该注解目标,可能的 ElemenetType 参数包括：
ElemenetType.CONSTRUCTOR 构造器声明
ElemenetType.FIELD 域声明(包括 enum 实例)
ElemenetType.LOCAL_VARIABLE 局部变量声明
ElemenetType.METHOD 方法声明
ElemenetType.PACKAGE 包声明
ElemenetType.PARAMETER 参数声明
ElemenetType.TYPE 类，接口(包括注解类型)或enum声明
2、@Retention 表示该注解的生命周期,可选的 RetentionPolicy 参数包括
RetentionPolicy.SOURCE 注解将被编译器丢弃
RetentionPolicy.CLASS 注解在class文件中可用，但会被JVM丢弃
RetentionPolicy.RUNTIME JVM将在运行期也保留注释，因此可以通过反射机制读取注解的信息
3、@Documented 指示将此注解包含在 javadoc 中
4、@Inherited 指示允许子类继承父类中的注解
二、在java中的使用
2.1、定义注解
packageannotation;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotation.RetentionPolicy;importjava.lang.annotation.Target;public classMyAnnotation {/*** 注解类
*
*@authorsuguoliang
**/@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)public @interfaceMyClassAnnotation {
String uri();
String desc();
}/*** 构造方法注解
*
*@authorsuguoliang
**/@Target(ElementType.CONSTRUCTOR)
@Retention(RetentionPolicy.RUNTIME)public @interfaceMyConstructorAnnotation {
String uri();
String desc();
}/*** 方法注解
*
*@authorsuguoliang
**/@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)public @interfaceMyMethodAnnotation {
String uri();
String desc();
}/*** 字段注解
*
*@authorsuguoliang
**/@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)public @interfaceMyFieldAnnotation {
String uri();
String desc();
}/*** 可以同时应用到类和方法上
*
*@author尐蘇
**/@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)public @interfaceMyClassAndMethodAnnotation {//定义枚举
public enumEnumType {
util, entity, service, model
}//设置默认值
public EnumType classType() defaultEnumType.util;//数组
int[] arr() default { 3, 7, 5};
String color()default "blue";
}
}
2.2基本测试
packageannotation;importjava.lang.reflect.Constructor;importjava.lang.reflect.Field;importjava.lang.reflect.Method;importannotation.MyAnnotation.MyClassAndMethodAnnotation;importannotation.MyAnnotation.MyClassAndMethodAnnotation.EnumType;importannotation.MyAnnotation.MyClassAnnotation;importannotation.MyAnnotation.MyConstructorAnnotation;importannotation.MyAnnotation.MyFieldAnnotation;importannotation.MyAnnotation.MyMethodAnnotation;
@MyClassAnnotation(desc= "The Class", uri = "com.sgl.annotation")
@MyClassAndMethodAnnotation(classType=EnumType.util)public classTestAnnotation {
@MyFieldAnnotation(desc= "The Class Field", uri = "com.sgl.annotation#id")privateString id;
@MyConstructorAnnotation(desc= "The Class Constructor", uri = "com.sgl.annotation#constructor")publicTestAnnotation() {
}publicString getId() {returnid;
}
@MyMethodAnnotation(desc= "The Class Method", uri = "com.sgl.annotation#setId")public voidsetId(String id) {this.id =id;
}
@MyMethodAnnotation(desc= "The Class Method sayHello", uri = "com.sgl.annotation#sayHello")public voidsayHello(String name) {if (name == null || name.equals("")) {
System.out.println("hello world!");
}else{
System.out.println(name+ "\t:say hello world");
}
}public static void main(String[] args) throwsException {
Class clazz = TestAnnotation.class;//获取类注解
MyClassAnnotation myClassAnnotation = clazz.getAnnotation(MyClassAnnotation.class);
System.out.println(myClassAnnotation.desc()+ "+" +myClassAnnotation.uri());//获得构造方法注解
Constructor constructors = clazz.getConstructor(new Class[] {});//先获得构造方法对象
MyConstructorAnnotation myConstructorAnnotation = constructors.getAnnotation(MyConstructorAnnotation.class);//拿到构造方法上面的注解实例
System.out.println(myConstructorAnnotation.desc() + "+" +myConstructorAnnotation.uri());//获得方法注解
Method method = clazz.getMethod("setId", new Class[] { String.class });//获得方法对象
MyMethodAnnotation myMethodAnnotation = method.getAnnotation(MyMethodAnnotation.class);
System.out.println(myMethodAnnotation.desc()+ "+" +myMethodAnnotation.uri());//获得字段注解
Field field = clazz.getDeclaredField("id");//暴力获取private修饰的成员变量
MyFieldAnnotation myFieldAnnotation = field.getAnnotation(MyFieldAnnotation.class);
System.out.println(myFieldAnnotation.desc()+ "+" +myFieldAnnotation.uri());
}
}
2.3通过反射解析
packageannotation;importjava.lang.reflect.Method;importjava.util.Arrays;importannotation.MyAnnotation.MyClassAndMethodAnnotation;importannotation.MyAnnotation.MyClassAndMethodAnnotation.EnumType;importannotation.MyAnnotation.MyClassAnnotation;importannotation.MyAnnotation.MyMethodAnnotation;public classParseAnnotation {/*** 解析方法注解
*
*@paramclazz*/
public static  void parseMethod(Classclazz) {try{
T obj=clazz.newInstance();for(Method method : clazz.getDeclaredMethods()) {
MyMethodAnnotation methodAnnotation= method.getAnnotation(MyMethodAnnotation.class);if (methodAnnotation != null) {//通过反射调用带有此注解的方法
method.invoke(obj, methodAnnotation.uri());
}
MyClassAndMethodAnnotation myClassAndMethodAnnotation=method
.getAnnotation(MyClassAndMethodAnnotation.class);if (myClassAndMethodAnnotation != null) {if(EnumType.util.equals(myClassAndMethodAnnotation.classType())) {
System.out.println("this is a util method");
}else{
System.out.println("this is a other method");
}
System.out.println(Arrays.toString(myClassAndMethodAnnotation.arr()));//打印数组
System.out.println(myClassAndMethodAnnotation.color());//输出颜色
}
System.out.println("\t\t-----------------------");
}
}catch(Exception e) {
e.printStackTrace();
}
}public static  void parseType(Classclazz) {try{
MyClassAndMethodAnnotation myClassAndMethodAnnotation=clazz
.getAnnotation(MyClassAndMethodAnnotation.class);if (myClassAndMethodAnnotation != null) {if(EnumType.util.equals(myClassAndMethodAnnotation.classType())) {
System.out.println("this is a util class");
}else{
System.out.println("this is a other class");
}
}
MyClassAnnotation myClassAnnotation= clazz.getAnnotation(MyClassAnnotation.class);if (myClassAnnotation != null) {
System.err.println(" class info: " +myClassAnnotation.uri());
}
}catch(Exception e) {
e.printStackTrace();
}
}public static voidmain(String[] args) {
parseMethod(TestAnnotation.class);
parseType(TestAnnotation.class);
}
}