java注解使用、java获取注解的属性、获取注解的字段值
 
 
 
一、前言
 
1、前面一直讲注解的基础知识，注解的定义，对于注解的使用几乎是一笔略过，本篇将着重讲讲注解的使用。 获取注解的属性，通过反射获取注解的属性值。
 
 
 
二、示例代码
 
1、定义一个注解，用于给 全局变量 field 字段 赋值
 
 
 
package com.haha.study.annotation.value;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* description: 定义一个注解，用于给 全局变量 field 字段 赋值,并使用反射取值。 <br>
* 特别提醒： @Rentention(RetentionPolicy.RUNTIME) 时，注解才会被jvm加载，才能使用反射获取。
* @version v1.0
* @author w
* @date 2018年8月1日下午2:37:40
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.FIELD)
public @interface Fields {
    int sort() default 0 ;
    String value() ;
}

 
2、定义一个注解 。
 
package com.haha.study.annotation.value;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* description: 定义一个注解。
* @version v1.0
* @author w
* @date 2018年8月1日下午2:41:45
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ConsAnnotation {
    String[] request();
}
 
 
 
3、创建一个普通的类，使用 @ConsAnnotation、@Fields 注解
 
package com.haha.study.annotation.value;
/**
* description: 创建一个普通的类，使用 @ConsAnnotation、@Fields 注解。
* @version v1.0
* @author w
* @date 2018年8月1日下午2:50:23
*/
@ConsAnnotation(request = { "hello","world","annotation!" })
public class User {

    @Fields("中华人民共和国")
    private String userName;
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

 

  
 
4、针对 com.haha.study.annotation.value.User 类使用注解的测试
 
package com.haha.study.annotation.value;
import java.lang.reflect.Field;
import java.util.Arrays;
/**
* description: 针对 com.haha.study.annotation.value.User 类使用注解的测试
* @version v1.0
* @author w
* @date 2018年8月1日下午2:37:13
*/

public class ValueTest {
    public static void main(String[] args) throws Exception {
        User user = new User();
        // 1、 获取 User类上的注解 @ConsAnnotation
        ConsAnnotation anno = user.getClass().getAnnotation(ConsAnnotation.class);
        String[] arr = anno.request();
        System.out.println(Arrays.toString(arr)); // [hello, world, annotation!]

        // 2、 获取User类中 private String userName; 变量上的注解 @Field
        Field f = user.getClass().getDeclaredField("userName");
        Fields anno2 = f.getAnnotation(Fields.class);
        user.setUserName(anno2.value());
        System.out.println(user.getUserName()); // 中华人民共和国
    }
}
 
 
 
三、学习更多
 
   1、 java注解学习---元注解，注解类型，注解支持元素类型,注解基础（一）
 
   2、java注解学习---自定义注解定义java注解（二）
 
   3、java注解学习---@Target({ElementType.PACKAGE})理解和使用（三）
 
   4、java注解学习---@Inherited注解的理解学习（四）   
 
 

 
目录
 
注解
反射

 
注解
 
注解可以标记在包、类、属性、方法，方法参数以及局部变量上，且同一个地方可以同时标记多个注解。注解最常见的应用是可以通过反射技术去得到类里面的注解，以决定怎么去运行类。
 
负责注解其他注解的注解，java的四个元注解：
 
1.@Target：描述注解的使用范围，即用在类、方法、变量，它的取值范围定义在ElementType 枚举中。
 
public enum ElementType {
	// 类、接口、枚举类
    TYPE, 
    // 成员变量（包括：枚举常量）
    FIELD, 
    // 成员方法
    METHOD, 
    // 方法参数
    PARAMETER, 
    // 构造方法
    CONSTRUCTOR, 
    // 局部变量
    LOCAL_VARIABLE, 
    // 注解类
    ANNOTATION_TYPE, 
    // 可用于修饰：包
    PACKAGE, 
    // 类型参数，JDK 1.8 新增
    TYPE_PARAMETER, 
    // 使用类型的任何地方，JDK 1.8 新增
    TYPE_USE 
}
 
2.@Retention：表示在什么级别保存该注释信息，用于描述注解的生命周期，定义在RetentionPolicy枚举中。（SOURCE<CLASS<RUNTIME)
 
public enum RetentionPolicy {
    // 源文件保留
    SOURCE,    
    // 编译期保留，默认值
    CLASS,     
    // 运行期保留，可通过反射去获取注解信息 
    RUNTIME   
}
 
3.@Documented：说明该注解将被包含在javadoc帮助文档中，没有此注解则不会保留。
 
4.@Inherited：说明子类可以继承父类中的该注解，比方一个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解。
 
自定义注解测试：
 
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnoation {
    //参数类型+参数名
    String name() default "";
    int age() default 0;
    //如果值为默认值-1，代表不存在
    int id() default -1;
    //value才可以省略
    String[] schools() default {"北京大学"};
}
 
反射
 
利用反射读取注解，可以理解为逆着来，以前是从类创建对象，现在从对象获取到类的结构，甚至方法，属性。
 
reflection是java被视为动态语言的关键，反射机制允许程序在执行期间，借助Reflection API取得任何类的内部信息，并能直接操作任意对象的的内部属性及方法。
 
类加载器在加载类的时候，是将.class文件里的二进制数据读取到内存中，将其放在方法区中，然后再在堆内存中创建.Class对象，用来封装类的数据结构，加载类的最终产物是堆内存中的Class对象，我们可以通过这个.Class对象看到类的结构，这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以称之为反射。
 
打印的结果为true，可以知道只有一个class对象加载到内存中
 
测试User类：
 
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int id;
    private int age;
}
 
测试字节码文件是否一致：
 
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("com.mytest.test.model.User");
        Class c2 = Class.forName("com.mytest.test.model.User");
        System.out.println(c1==c2);
    }
 
打印结果为true。
 
 测试获取类的属性，getFields方法只能获取public修饰的属性，getDeclaredFields可以获取所有的
 
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> c = Class.forName("com.mytest.test.model.User");
        Field[] fields = c.getFields();
        fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        
        Method getName = c.getMethod("getName", null);
        Method setName = c.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }
 
打印结果：
 
 
通过反射获取注解及里面的参数
 
注意事项：
 
如果获取的是类的注解，直接从类的class对象中获取注解，再通过注解获取里面的参数
如果是获取方法或者属性的注解，先中类的class对象中获取方法或者属性，再获取里面的参数。
 
getDeclaredFields：获取属性
getAnnotation：获取注解
 
@Slf4j
public class Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> c = Class.forName("com.mytest.test.User2");
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        TableKuang tableKuang = c.getAnnotation(TableKuang.class);
        String value = tableKuang.value();
        System.out.println(value);

        Field[] declaredFields = c.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            FieldKuang annotation = declaredField.getAnnotation(FieldKuang.class);
            System.out.println(annotation);
            System.out.println(annotation.columnName());
            System.out.println(annotation.length());
            System.out.println(annotation.type());
        }
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableKuang {
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldKuang {
    String columnName();

    String type();

    int length();
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableKuang("测试user")
class User2 {
    @FieldKuang(columnName = "name注解", type = "String注解",length = 11)
    private String name;

    @FieldKuang(columnName = "id注解", type = "int注解",length = 12)
    private int id;

    @FieldKuang(columnName = "age注解", type = "int注解",length = 13)
    private int age;
}
 
打印结果：
 
 

 
 
Java 注解注解处理器获取泛型真实类型
   
如何定义注解
获取注解信息
注解处理器
     
AbstractProcessor
示例注解处理器获取泛型信息
示例代码地址
 
 
 
 
 
Java 注解：注解处理器获取泛型真实类型
 
注解 annotation 是 Java 中的一大特性，是插入代码中的元数据。注解的使用能够大大简化代码的编写，所以在很多框架中得到了使用，比如 Web 框架 Spring 中的 @Service、@Resource 注解，比如参数校验框架 hibernate-validator 中的 @NotNull 等注解。
 
如何定义注解
 
定义注解需要用到元注解 meta annotation，即描述注解的注解。元注解有以下几类： 
 1. @Target：描述了注解所修饰的对象范围，比如：类、方法、字段、以及注解本身等等。 
 2. @Retention：定义注解被保留的时间长短，有三种：源文件、class 文件、运行时。 
 3. @Documented：表示含有该注解类型的元素(带有注释的)会通过javadoc或类似工具进行文档化。 
 4. @Inherited：表示注解类型能被自动继承。
 
Java 中使用 Class 来定义类，使用 enum 定义枚举，使用 @interface 来定义注解。具体定义格式如下：
 
　　public @interface 注解名 { 定义体 }
 
其中的定义体里可以写若干方法来表示配置，方法的名称就是参数的名称，返回值类型就是参数的类型，可以通过 default 来声明参数的默认值。下面给出一个注解的示例：
 
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AutoParse {
    String key();
    int type() default 0;
}
 
该注解 AutoParse 可以用于描述 FIELD 即类中字段，在运行时仍然能够获取，不可被继承（没有使用 Inherited 注解描述）。
 
获取注解信息
 
注解通常用来描述类、方法等，那如何获取一个方法或类上的注解呢？可以通过 Class 类或 Method 类对应的 getAnnotation 方法获取：
 
public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
    public Annotation[] getAnnotations();
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass);
    public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass);
    public Annotation[] getDeclaredAnnotations();
}

public final class Method extends Executable {
    public <T extends Annotation> T getAnnotation(Class<T> annotationClass);
    public Annotation[] getDeclaredAnnotations();
    // 返回方法参数的注解
    public Annotation[][] getParameterAnnotations();
}
 
getDeclaredAnnotations 方法只返回直接存在于此元素上的注解，不会返回继承的注解；而 getAnnotation 则返回全部注解，包含继承的。
 
注：Field 也有类似的方法可以获取注解。
 
注解处理器
 
注解处理器 annotation processor 是 javac 内置的编译时扫描和处理注解的工具，比较常见的用法是在编译时获取注解信息，动态生成 Java 文件。
 
AbstractProcessor
 
想要自定义注解处理器需要继承实现 AbstractProcessor 类： 
 1. init 方法入参是环境变量 ProcessingEnvironment，从中可以拿到报告错误信息的 Messager，用于生成代码文件的 Filer。 
 2. process 抽象方法，是我们需要实现的，用于处理注解信息的方法，生成类文件的代码放这里。
 
public abstract class AbstractProcessor implements Processor {
    public synchronized void init(ProcessingEnvironment processingEnv) {
        if (initialized)
            throw new IllegalStateException("Cannot call init more than once.");
        Objects.requireNonNull(processingEnv, "Tool provided null ProcessingEnvironment");

        this.processingEnv = processingEnv;
        initialized = true;
    }

    public abstract boolean process(Set<? extends TypeElement> annotations,
                                    RoundEnvironment roundEnv);
}
 
示例：注解处理器获取泛型信息
 
Java 中的泛型有一个类型擦除的概念：
 
 
 
Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。
 
 
那么如何在运行时获取某对象的某个 Field 的真实类型信息呢？既然是在编译期间擦除的，那么我们就可以注解处理器在编译期间获取泛型的真实类型信息。
 
以下给出一个处理上面的 @AutoParse 注解的注解处理器示例，该注解处理器获取了注解所描述字段的类型信息，并将这些信息写入了一个类文件中： 
 1. @SupportedAnnotationTypes：指明要处理的注解。 
 2. @SupportedSourceVersion(SourceVersion.RELEASE_7)：指明适合的 Java 版本。 
 3. 继承 process 方法，做真正的处理工作。 
 4. Filer 用于创建新的 Java 类。 
 5. RoundEnvironment 类包含了被注解所描述的 Field 的真实类型信息。
 
@SupportedAnnotationTypes({ "com.albon.arith.annotation.procecssor.AutoParseField" })
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class AutoParseFieldProcessor extends AbstractProcessor {

    private Filer filer;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        filer = processingEnv.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Map<String, String> fieldTypeMap = Maps.newHashMap();

        for (Element elem : roundEnv.getElementsAnnotatedWith(AutoParseField.class)) {
            AutoParseField annotation = elem.getAnnotation(AutoParseField.class);
            String message = System.currentTimeMillis() + " - annotation found in " + elem.getSimpleName()
                    + " with key " + annotation.key() + " kind " + elem.getKind() + " class " + elem.getClass()
                    + " asType " + elem.asType() + "\n\tgetEnclosingElement().getSimpleName() "
                    + elem.getEnclosingElement().getSimpleName() + "\n\tgetEnclosingElement().asType() "
                    + elem.getEnclosingElement().asType();
            fieldTypeMap.put(elem.getEnclosingElement().asType().toString() + "#" + elem.getSimpleName(),
                    elem.asType().toString());

            processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, message);
        }

        if (fieldTypeMap.isEmpty()) {
            return true;
        }

        Writer writer = null;
        try {
            JavaFileObject jfo = filer
                    .createSourceFile("com.albon.arith.annotation.service.AutoParseFieldInfo");
            writer = jfo.openWriter();
            writer.write("package com.albon.arith.annotation.service;\n" +
                    "\n" +
                    "import com.google.common.collect.Maps;\n" +
                    "\n" +
                    "import java.util.Map;\n" +
                    "\n" +
                    "public class AutoParseFieldInfo {\n" +
                    "\n" +
                    "    // key: classpath#fieldName, value: fieldType\n" +
                    "    public static final Map<String, String> FIELD_TYPE_MAP = Maps.newHashMap();\n" +
                    "\n" +
                    "    static {\n");

            for (Map.Entry<String, String> entry : fieldTypeMap.entrySet()) {
                writer.write("        FIELD_TYPE_MAP.put(\"" +
                        entry.getKey() +
                        "\", \"" +
                        entry.getValue() +
                        "\");\n");
            }

            writer.write("    }\n" +
                    "\n" +
                    "    public static void main(String[] args) {\n" +
                    "        System.out.println(FIELD_TYPE_MAP);\n" +
                    "    }\n" +
                    "}\n");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return true; // no further processing of this annotation type
    }
}
 
我们写了一个使用 @AutoParse 注解描述的 SimplePoJo 类：
 
public class SimplePoJo {

    @AutoParse(key = "first")
    private Integer first;
    @AutoParse(key = "second")
    private String second;
    @AutoParse(key = "third")
    private List<String> third;
}
 
还需要在配置文件中指定使用该注解处理器，请在 resources 文件夹下新建 META-INF/services 文件夹，再新建文件 javax.annotation.processing.Processor，文件内容如下：
 
com.albon.arith.annotation.procecssor.AutoParseFieldProcessor
 
代码完成之后，使用 mvn clean package 进行编译，编译后可以看到经由注解处理器生成的 AutoParseFieldInfo.java 文件，其内容如下所示：
 
public class AutoParseFieldInfo {
    // key: classpath#fieldName, value: fieldType
    public static final Map<String, String> FIELD_TYPE_MAP = Maps.newHashMap();

    static {        FIELD_TYPE_MAP.put("com.albon.arith.annotation.service.SimplePoJo#third", "java.util.List<java.lang.String>");
        FIELD_TYPE_MAP.put("com.albon.arith.annotation.service.SimplePoJo#second", "java.lang.String");
        FIELD_TYPE_MAP.put("com.albon.arith.annotation.service.SimplePoJo#first", "java.lang.Integer");
    }

    public static void main(String[] args) {
        System.out.println(FIELD_TYPE_MAP);
    }
}
 
示例代码地址
 
完整的示例代码请看 GitHub: annotation-processor。

  java hibernate 根据 @Table 注解 获取 数据库 表名 字段名 工具类 
 
 @author www.soservers.com 晚风工作室 
 
 
 
 
 
 
 标签： 
  Hibernate
 
 
 
 [1].[代码] 根据 @Table 注解 获取 数据库 表名 字段名 工具类 @author www.soservers.com 晚风工作室 跳至 [1]
 
 
 
  
 
   
 
    ?
   
 
   
 
       

         1
       
 
       

         2
       
 
       

         3
       
 
       

         4
       
 
       

         5
       
 
       

         6
       
 
       

         7
       
 
       

         8
       
 
       

         9
       
 
       

         10
       
 
       

         11
       
 
       

         12
       
 
       

         13
       
 
       

         14
       
 
       

         15
       
 
       

         16
       
 
       

         17
       
 
       

         18
       
 
       

         19
       
 
       

         20
       
 
       

         21
       
 
       

         22
       
 
       

         23
       
 
       

         24
       
 
       

         25
       
 
       

         26
       
 
       

         27
       
 
       

         28
       
 
       

         29
       
 
       

         30
       
 
       

         31
       
 
       

         32
       
 
       

         33
       
 
       

         34
       
 
       

         35
       
 
       

         36
       
 
       

         37
       
 
       

         38
       
 
       

         39
       
 
       

         40
       
 
       

         41
       
 
       

         42
       
 
       

         43
       
 
       

         44
       
 
       

         45
       
 
       

         46
       
 
       

         47
       
 
       

         48
       
 
       

         49
       
 
       

         50
       
 
       

         51
       
 
 
       
 
        
 
         import 
          java.lang.reflect.Method;
        
 
        

           
        
 
        
 
         import 
          javax.persistence.Table;
        
 
        
 
         /**
        
 
        
 
          
         * 通过注解javax.persistence.Table获取数据库表的具体信息
        
 
        
 
          
         * java hibernate 根据 Table 注解 获取 数据库 表名 字段名 工具类
        
 
        
 
          
         * 需要 注解方式为 javax.persistence.Table的注解
        
 
        
 
          
         * 【备注： 如果哪位大牛感觉我的代码有问题或者有待优化，请明确提出，帮助我这个小菜鸟提高下，谢谢】
        
 
        
 
          
         * @author www.soservers.com 晚风工作室
        
 
        
 
          
         *
        
 
        
 
          
         */
        
 
        
 
         public 
          class 
          HibernateToolsUtil {
        
 
        

           
        
 
        
 
             
         /**
        
 
        
 
              
         * 获得表名
        
 
        
 
              
         * 
        
 
        
 
              
         * @param clazz 映射到数据库的po类
        
 
        
 
              
         * @return String
        
 
        
 
              
         */
        
 
        
 
             
         @SuppressWarnings
         (
         "unchecked"
         )
        
 
        
 
             
         public 
          static 
          String getTableName(Class clazz) {
        
 
        
 
                 
         Table annotation = (Table)clazz.getAnnotation(Table.
         class
         );
        
 
        
 
                 
         if
         (annotation != 
         null
         ){
        
 
        
 
                     
         return 
          annotation.name();
        
 
        
 
                 
         }
        
 
        

           
        
 
        
 
                 
         return 
          null
         ;
        
 
        
 
             
         }
        
 
        

           
        
 
        
 
             
         /**
        
 
        
 
              
         * 获得列名
        
 
        
 
              
         * 
        
 
        
 
              
         * @param clazz 映射到数据库的po类
        
 
        
 
              
         * @param icol 第几列
        
 
        
 
              
         * @return String
        
 
        
 
              
         */
        
 
        
 
             
         @SuppressWarnings
         (
         "unchecked"
         )
        
 
        
 
             
         public 
          static 
          String getColumnName(Class clazz, String name) {
        
 
        
 
                  
        
 
        
 
                 
         try 
          {
        
 
        
 
                     
         new 
          Exception(
         "---貌似java属性如果用注解形式的话 属性和 数据库字段名一致 因为项目没有需要用 写出没有进过有效验证 所以暂未放出 如果谁想用或者有着方面的需求 可以给我留评论"
         );
        
 
        
 
                      
        
 
        
 
                 
         }
         catch 
          (Exception e) {
        
 
        
 
                     
         // TODO Auto-generated catch block
        
 
        
 
                     
         e.printStackTrace();
        
 
        
 
                 
         }
        
 
        
 
                  
        
 
        
 
                 
         return 
          ""
         ;
        
 
        
 
             
         }
        
 
        

           
        
 
        
 
         }