zoukankan      html  css  js  c++  java
  • JAVA 注解示例 详解

     注解(Annotation) 为我们在代码中天界信息提供了一种形式化的方法,是我们可以在稍后

    某个时刻方便地使用这些数据(通过 解析注解 来使用这些数据)。

     

        注解的语法比较简单,除了@符号的使用以外,它基本上与java的固有语法一致,java内置了三种

    注解,定义在java.lang包中。

          @Override  表示当前方法是覆盖父类的方法。

          @Deprecated  表示当前元素是不赞成使用的。

          @SuppressWarnings 表示关闭一些不当的编译器警告信息。

     

      下面是一个定义注解的实例

     

    Java代码  收藏代码
    1. package Test_annotation;  
    2.   
    3. import java.lang.annotation.Documented;  
    4. import java.lang.annotation.Inherited;  
    5. import java.lang.annotation.Retention;  
    6. import java.lang.annotation.Target;  
    7. import java.lang.annotation.ElementType;  
    8. import java.lang.annotation.RetentionPolicy;  
    9.   
    10. /* 
    11.  * 元注解@Target,@Retention,@Documented,@Inherited 
    12.  *  
    13.  *     @Target 表示该注解用于什么地方,可能的 ElemenetType 参数包括: 
    14.  *         ElemenetType.CONSTRUCTOR 构造器声明 
    15.  *         ElemenetType.FIELD 域声明(包括 enum 实例) 
    16.  *         ElemenetType.LOCAL_VARIABLE 局部变量声明 
    17.  *         ElemenetType.METHOD 方法声明 
    18.  *         ElemenetType.PACKAGE 包声明 
    19.  *         ElemenetType.PARAMETER 参数声明 
    20.  *         ElemenetType.TYPE 类,接口(包括注解类型)或enum声明 
    21.  *          
    22.  *     @Retention 表示在什么级别保存该注解信息。可选的 RetentionPolicy 参数包括: 
    23.  *         RetentionPolicy.SOURCE 注解将被编译器丢弃 
    24.  *         RetentionPolicy.CLASS 注解在class文件中可用,但会被VM丢弃 
    25.  *         RetentionPolicy.RUNTIME VM将在运行期也保留注释,因此可以通过反射机制读取注解的信息。 
    26.  *          
    27.  *     @Documented 将此注解包含在 javadoc 中 
    28.  *      
    29.  *     @Inherited 允许子类继承父类中的注解 
    30.  *    
    31.  */  
    32. @Target(ElementType.METHOD)  
    33. @Retention(RetentionPolicy.RUNTIME)  
    34. @Documented  
    35. @Inherited  
    36. /* 
    37.  * 定义注解 Test 
    38.  * 注解中含有两个元素 id 和 description 
    39.  * description 元素 有默认值 "no description" 
    40.  */  
    41. public @interface Test {  
    42.     public int id();  
    43.     public String description() default "no description";  
    44. }  
       

    下面是一个使用注解 和 解析注解的实例

     

    Java代码  收藏代码
    1. package Test_annotation;  
    2.   
    3. import java.lang.reflect.Method;  
    4.   
    5. public class Test_1 {  
    6.     /* 
    7.      * 被注解的三个方法 
    8.      */  
    9.     @Test(id = 1, description = "hello method_1")  
    10.     public void method_1() {  
    11.     }  
    12.   
    13.     @Test(id = 2)  
    14.     public void method_2() {  
    15.     }  
    16.   
    17.     @Test(id = 3, description = "last method")  
    18.     public void method_3() {  
    19.     }  
    20.   
    21.     /* 
    22.      * 解析注解,将Test_1类 所有被注解方法 的信息打印出来 
    23.      */  
    24.     public static void main(String[] args) {  
    25.         Method[] methods = Test_1.class.getDeclaredMethods();  
    26.         for (Method method : methods) {  
    27.             /* 
    28.              * 判断方法中是否有指定注解类型的注解 
    29.              */  
    30.             boolean hasAnnotation = method.isAnnotationPresent(Test.class);  
    31.             if (hasAnnotation) {  
    32.                 /* 
    33.                  * 根据注解类型返回方法的指定类型注解 
    34.                  */  
    35.                 Test annotation = method.getAnnotation(Test.class);  
    36.                 System.out.println("Test( method = " + method.getName()  
    37.                         + " , id = " + annotation.id() + " , description = "  
    38.                         + annotation.description() + " )");  
    39.             }  
    40.         }  
    41.     }  
    42.   
    43. }  
       
    输出结果如下:

        Test( method = method_1 , id = 1 , description = hello method_1 )
        Test( method = method_2 , id = 2 , description = no description )
        Test( method = method_3 , id = 3 , description = last method )

      除了@符号,注解很像是一个接口。定义注解的时候需要用到元注解,上面用到了@Target和@RetentionPolicy,它们的含义在上面的表格中已近给出。 

         在注解中一般会有一些元素以表示某些值。注解的元素看起来就像接口的方法,唯一的区别在于可以为其制定默认值。没有元素的注解称为标记注解,上面的@Test就是一个标记注解。 

         注解的可用的类型包括以下几种:所有基本类型、String、Class、enum、Annotation、以上类型的数组形式。元素不能有不确定的值,即要么有默认值,要么在使用注解的时候提供元素的值。而且元素不能使用null作为默认值。注解在只有一个元素且该元素的名称是value的情况下,在使用注解的时候可以省略“value=”,直接写需要的值即可。 

         下面看一个定义了元素的注解。 

    复制代码
    1 @Target(ElementType.METHOD)
    2 @Retention(RetentionPolicy.RUNTIME)
    3 public @interface UseCase {
    4     public String id();
    5     public String description() default "no description";
    6 }
    复制代码

         定义了注解,必然要去使用注解。 

    复制代码
     1 public class PasswordUtils {
     2     @UseCase(id = 47, description = "Passwords must contain at least one numeric")
     3     public boolean validatePassword(String password) {
     4         return (password.matches("\w*\d\w*"));
     5     }
     6 
     7     @UseCase(id = 48)
     8     public String encryptPassword(String password) {
     9         return new StringBuilder(password).reverse().toString();
    10     }
    11 }
    复制代码

         使用注解最主要的部分在于对注解的处理,那么就会涉及到注解处理器。

         从原理上讲,注解处理器就是通过反射机制获取被检查方法上的注解信息,然后根据注解元素的值进行特定的处理。 

    复制代码
     1 public static void main(String[] args) {
     2     List<Integer> useCases = new ArrayList<Integer>();
     3     Collections.addAll(useCases, 47, 48, 49, 50);
     4     trackUseCases(useCases, PasswordUtils.class);
     5 }
     6 
     7 public static void trackUseCases(List<Integer> useCases, Class<?> cl) {
     8     for (Method m : cl.getDeclaredMethods()) {
     9         UseCase uc = m.getAnnotation(UseCase.class);
    10         if (uc != null) {
    11             System.out.println("Found Use Case:" + uc.id() + " "
    12                         + uc.description());
    13             useCases.remove(new Integer(uc.id()));
    14         }
    15     }
    16     for (int i : useCases) {
    17         System.out.println("Warning: Missing use case-" + i);
    18     }
    19 }
    复制代码

    Found Use Case:47 Passwords must contain at least one numeric

    Found Use Case:48 no description

    Warning: Missing use case-49

    Warning: Missing use case-50

         上面的三段代码结合起来是一个跟踪项目中用例的简单例子。

         写到这里博主想到结合枚举、注解、反射、拦截器等内容,是否可以写一套用户权限验证呢?

     

         将用户权限用枚举的方式给出,注解元素表明某个方法必须拥有某些权限才能调用,拦截器拦截请求方法,用户是否有权限对该方法进行调用,根据用户不同的权限进行不同的处理。欢迎讨论!


  • 相关阅读:
    341. Flatten Nested List Iterator
    667. Beautiful Arrangement II
    953. Verifying an Alien Dictionary
    1704. Determine if String Halves Are Alike
    MySQL数据库的数据类型详解【转】
    Dart之数组(List)的相关方法总结【转】
    Flutter解决点击非输入框时关闭键盘问题及TextFormField焦点切换问题【转】
    Flutter Switch开关【转】
    Image Picker
    Flutter按钮添加背景图片及文字【转】
  • 原文地址:https://www.cnblogs.com/daichangya/p/12959026.html
Copyright © 2011-2022 走看看