精华内容
下载资源
问答
  • 原标题:Java如何快速获取类附带的注解如何快速获取或者判断一个类是否有某个注解呢?可以使用对象Class信息来获取,下面是一个例子: 在上面例子中,hasAnnotation方法作用就是判断是否一个对象所属类包含...

    原标题:Java如何快速获取类附带的注解

    如何快速获取或者判断一个类是否有某个注解呢?可以使用对象的Class信息来获取,下面是一个例子:

    a6c524ada42593abc08401fe5a2f8efc.png

    在上面的例子中,hasAnnotation方法的作用就是判断是否一个对象所属的类包含某个注解,可以分析一下具体的实现,首先,第一个参数类型为AnnotatedElement,代表具体需要判断的对象Class信息,需要注意的是,Class类实现了AnnotatedElement接口,所以传递一个Class对象给这个方法的第一个参数是合法的;第二个参数是注解类的Class信息,是需要检测的目标注解。可以看到,在代码中使用了AnnotatedElement的isAnnotationPresent方法来进行判断是否具有某个注解的功能,可以跟进去看一下具体的实现原理。

    37e19727f97774e6de251abe309a5593.png

    可以看一下annotationData方法的具体实现,参考下面的图片:

    db17eba227dbdc711d4ec7575bcd9437.png

    其中首先会判断是否具有需要的数据,以及是否符合要求,如果数据不存在或者过期了,那么就需要重新获取,重新获取数据的关键方法是createAnnotationData,该方法的实现可以参考下面的代码:

    3b0da2d7598536001ab9e7406852faf2.png

    annotationData方法获取到的是一个AnnotationData对象,可以看一下AnnotationData类的定义:

    a8d027d5a89c897fab5f640c969b51f8.png

    在getAnnotation方法中,该方法获取了AnnotationData字段的annotations字段来判断是否包含目标注解,更加深入的细节可以自行参考Class类的具体实现。本文是一个极短的java技术分享,提供一种获取一个对象的注解信息的思路,其实还有很多类型信息都是可以通过Class来获取到的。返回搜狐,查看更多

    责任编辑:

    展开全文
  • 一:获取类注解的值定义注解@Target(ElementType.TYPE)用于类,接口等@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Orange {String getName();String getValue();}获取@Orange...

    一:获取类上注解的值

    定义注解@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);

    展开全文
  • java 通过反射获取类注解,方法上注解注解值及方法参数,项目为maven项目。导入时记得选择maven项目
  • 一、注解基本知识1、元注解元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去...

    一、注解基本知识

    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 @Inherited2、Annotation型定义为@interface, 所有Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。3、参数成员...

    一、注解基本知识

    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);

    }

    }

    展开全文
  • 一、介绍元注解的作用就是负责注解其他注解,Java5.0定义了4个标准的meta-annotation类型,它们被用来提供对其它 annotation类型作说明。...下面我们看一下每个元注解的作用和相应分参数的使用说明。...
  • 获取类,方法,构造函数或字段所有注释,我们使用getAnnotations()方法。此方法返回一个数组Annotation在以下示例中,我们尝试从该sayHi()方法读取所有注释。首先,我们需要获取自身方法对象。因为sayHi()方法...
  • 一:获取类注解的值定义注解@Target(ElementType.TYPE)用于类,接口等@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Orange {String getName();String getValue();}获取@Orange...
  • 元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的或是接口.2. 参数...
  • 一:获取类注解的值 定义注解@Target(ElementType.TYPE)用于类,接口等 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Orange { String getName(); String getValue...
  • 项目为maven项目,导入时请注意!说明:此类为本人开发工具类,具体应用在什么地方呢。...再过反射获取类注解,方法上注解注解值。获取每一个url地址,与地址上解释,生产一一对应资源。例...
  • 1、元注解元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。1. Annotation型定义为@interface, 所有的Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的或是接口....
  • 此类为本人开发工具,具体应用在什么地方呢。本人在实际项目中,权限管理这一块有所应用,应该是权限这一块有所需求而开发。 应用场景说明:权限资源自动化生产时,用户点击界面一键生成资源时,接口中就会...
  • 一:获取类注解的值 定义注解@Target(ElementType.TYPE)用于类,接口等 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Orange { String getName(); String getValue(); } ...
  • 前言大家都知道随着java8的使用,在相应的方法签名中增加了新的对象Parameter,用于表示特定的参数信息,通过它的getName可以获取相应的参数名.即像在代码中编写的,如命名为username,那么在前台进行传参时,即不需要再...
  • 1.介绍:@PropertySouce是spring3.1开始引入基于java config的注解。通过@PropertySource注解将properties配置文件中值存储到SpringEnvironment中,Environment接口提供方法去读取配置文件中值,参数是...
  • 前言大家都知道随着java8的使用,在相应的方法签名中增加了新的对象Parameter,用于表示特定的参数信息,通过它的getName可以获取相应的参数名.即像在代码中编写的,如命名为username,那么在前台进行传参时,即不需要再...
  • Java 语言中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同,Java 标注可以通过反射获取标注内容。在编译器生成文件时,标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容,在运行时可以获取到...
  • 本篇提供两个有用工具,是小编在写某web框架时候开发,挺有用.分享给大家.该项目包含很多工具,本文只描述这两个简单工具,希望为你工程有所帮助! 该源码中还有很多有用小工具,eg:json,xml,cache,...
  •  2、Annotation型定义为@interface, 所有Annotation会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口。  3、参数成员只能用public或默认(default)这两个访问权修饰  4、参数...
  • 1.测试参数public JsonResult test(@SocketParam("a") String a) {//自定义注解的参数和方法的参数名字相同JsonResult reSocket = new JsonResult<>();reSocket.setResult("dddd");reSocket.setStatus...
  • 从JDK5开始,Java增加对元数据的支持,也就是注解注解与注释是有一定区别的,可以...注解,可以看作是对 一个 /方法 的一个扩展的模版,每个 /方法 按照注解类中的规则,来为 /方法 注解不同的参数,在用到的...
  • 前言大家都知道随着java8的使用,在相应的方法签名中增加了新的对象Parameter,用于表示特定的参数信息,通过它的getName可以获取相应的参数名.即像在代码中编写的,如命名为username,那么在前台进行传参时,即不需要再...
  • 1、支持通过Spring的xml配置文件来制定要获取注解类的包,如何获取配置文件的参数:/*** 通过依赖注入获取配置文件中的属性值* @param basePackages*/@Resourcepublic void setBasePackages(String... basePackages)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 746
精华内容 298
关键字:

java获取类注解的参数

java 订阅