java的注解
以下内容为基础用法,我这里有个问题,想跟大家伙探讨.关于ElementType中的五个属性的用法,到底怎么用?解释字面意思的不要留言了.
定义一个注解
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; public @interface NotNull { }
以上代码定义了一个@NotNull注解.这个注解可以在任意的地方被使用.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; @NotNull public class TestBean { @NotNull public String name; @NotNull public TestBean(){} @NotNull public void show(@NotNull int age){ @NotNull int s = 12; } }
以上代码则使用到了@NotNull注解,可以看到,我们几乎可以在一个类的任意地方使用自定义的注解.
限定使用范围 @Target
自定义注解可以使用元注解修饰,所谓元注解就是JDK包中带的注解,通常用来描述自定义注解的使用权限.
@Target元注解就是这样.我们可以将该注解添加到@NotNull自定义注解上.@Target注解的value属性的值是数组类型,数组的元素必须为ElementType的枚举项
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/* * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.annotation; /** * Indicates the contexts in which an annotation type is applicable. The * declaration contexts and type contexts in which an annotation type may be * applicable are specified in JLS 9.6.4.1, and denoted in source code by enum * constants of {@link ElementType java.lang.annotation.ElementType}. * * <p>If an {@code @Target} meta-annotation is not present on an annotation type * {@code T} , then an annotation of type {@code T} may be written as a * modifier for any declaration except a type parameter declaration. * * <p>If an {@code @Target} meta-annotation is present, the compiler will enforce * the usage restrictions indicated by {@code ElementType} * enum constants, in line with JLS 9.7.4. * * <p>For example, this {@code @Target} meta-annotation indicates that the * declared type is itself a meta-annotation type. It can only be used on * annotation type declarations: * <pre> * @Target(ElementType.ANNOTATION_TYPE) * public @interface MetaAnnotationType { * ... * } * </pre> * * <p>This {@code @Target} meta-annotation indicates that the declared type is * intended solely for use as a member type in complex annotation type * declarations. It cannot be used to annotate anything directly: * <pre> * @Target({}) * public @interface MemberType { * ... * } * </pre> * * <p>It is a compile-time error for a single {@code ElementType} constant to * appear more than once in an {@code @Target} annotation. For example, the * following {@code @Target} meta-annotation is illegal: * <pre> * @Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD}) * public @interface Bogus { * ... * } * </pre> * * @since 1.5 * @jls 9.6.4.1 @Target * @jls 9.7.4 Where Annotations May Appear */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.ANNOTATION_TYPE) public @interface Target { /** * Returns an array of the kinds of elements an annotation type * can be applied to. * @return an array of the kinds of elements an annotation type * can be applied to */ ElementType[] value(); }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/* * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.annotation; /** * The constants of this enumerated type provide a simple classification of the * syntactic locations where annotations may appear in a Java program. These * constants are used in {@link Target java.lang.annotation.Target} * meta-annotations to specify where it is legal to write annotations of a * given type. * * <p>The syntactic locations where annotations may appear are split into * <em>declaration contexts</em> , where annotations apply to declarations, and * <em>type contexts</em> , where annotations apply to types used in * declarations and expressions. * * <p>The constants {@link #ANNOTATION_TYPE} , {@link #CONSTRUCTOR} , {@link * #FIELD} , {@link #LOCAL_VARIABLE} , {@link #METHOD} , {@link #PACKAGE} , * {@link #PARAMETER} , {@link #TYPE} , and {@link #TYPE_PARAMETER} correspond * to the declaration contexts in JLS 9.6.4.1. * * <p>For example, an annotation whose type is meta-annotated with * {@code @Target(ElementType.FIELD)} may only be written as a modifier for a * field declaration. * * <p>The constant {@link #TYPE_USE} corresponds to the 15 type contexts in JLS * 4.11, as well as to two declaration contexts: type declarations (including * annotation type declarations) and type parameter declarations. * * <p>For example, an annotation whose type is meta-annotated with * {@code @Target(ElementType.TYPE_USE)} may be written on the type of a field * (or within the type of the field, if it is a nested, parameterized, or array * type), and may also appear as a modifier for, say, a class declaration. * * <p>The {@code TYPE_USE} constant includes type declarations and type * parameter declarations as a convenience for designers of type checkers which * give semantics to annotation types. For example, if the annotation type * {@code NonNull} is meta-annotated with * {@code @Target(ElementType.TYPE_USE)}, then {@code @NonNull} * {@code class C {...}} could be treated by a type checker as indicating that * all variables of class {@code C} are non-null, while still allowing * variables of other classes to be non-null or not non-null based on whether * {@code @NonNull} appears at the variable's declaration. * * @author Joshua Bloch * @since 1.5 * @jls 9.6.4.1 @Target * @jls 4.1 The Kinds of Types and Values */ public enum ElementType { /** Class, interface (including annotation type), or enum declaration */ TYPE, /** Field declaration (includes enum constants) */ FIELD, /** Method declaration */ METHOD, /** Formal parameter declaration */ PARAMETER, /** Constructor declaration */ CONSTRUCTOR, /** Local variable declaration */ LOCAL_VARIABLE, /** Annotation type declaration */ ANNOTATION_TYPE, /** Package declaration */ PACKAGE, /** * Type parameter declaration * * @since 1.8 */ TYPE_PARAMETER, /** * Use of a type * * @since 1.8 */ TYPE_USE }
我们这里给@NotNull注解使用几个属性试试.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE}) public @interface NotNull { }
当我们给@Target元注解的value赋值为ElementType.TYPE时,发现使用@NotNull注解的TestBean类爆红了.显示@NotNull不能使用在成员变量,构造器等等.原因就是,当一个自定义注解没有使用@Target属性时,它并不限制使用范围,一旦使用了@Target元注解则使用范围只为@Target注解的value值.
我们给@NotNull注解多增加几个可使用范围.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) public @interface NotNull { }
@Target元注解声明了6种可使用范围,分别为类,方法,成员变量,构造器,方法参数,局部变量.这六种也是最长用的.其实JDK直到1.8已经支持10种使用范围了.
注解的属性
元注解@Target有属性value,我们自定义的注解也可以有属性.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) public @interface NotNull { String value(); }
我们给自定义注解@NotNull声明了一个value属性.此时使用@NotNull注解的类报错了,原因是,我们声明了value属性,但是没有给出值.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
@NotNull(value = "a") public class TestBean { @NotNull(value = "a") public String name; @NotNull(value = "a") public TestBean() { } @NotNull("a") public void show(@NotNull("a") int age) { @NotNull("a") int s = 12; } }
给注解增加属性,若注解的属性为value且仅有这一个则可以忽略属性名.
如果有多个属性,则不能省略value属性名.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) public @interface NotNull { String value(); String name(); }
我们可以在创建注解时,给属性赋值默认值,这样使用该注解时,则不会要求必须覆盖此属性.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.lang.annotation.ElementType; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) public @interface NotNull { String value(); String name(); int age() default 100; }
读取注解
当我们使用注解在代码中,其实没有实际的意义.注解的意义在于我们这样处理带有这些注解的类,方法.
那么为什么此时我们获取不到注解呢?原因是我们自定义的注解还需要有@Retention注解.该注解有value属性,属性的类型是RetentionPolicy
该类型有三个可选值.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/* * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.annotation; /** * Annotation retention policy. The constants of this enumerated type * describe the various policies for retaining annotations. They are used * in conjunction with the {@link Retention} meta-annotation type to specify * how long annotations are to be retained. * * @author Joshua Bloch * @since 1.5 */ public enum RetentionPolicy { /** * Annotations are to be discarded by the compiler. */ SOURCE, /** * Annotations are to be recorded in the class file by the compiler * but need not be retained by the VM at run time. This is the default * behavior. */ CLASS, /** * Annotations are to be recorded in the class file by the compiler and * retained by the VM at run time, so they may be read reflectively. * * @see java.lang.reflect.AnnotatedElement */ RUNTIME }
SOURCE注释将被编译器丢弃。CLASS保存在class文件中,是默认的值,通过特定的class文本读取工具可以读取到,常规的我们使用第三个值.RUNTIME在运行时被VM保留,因此它们可以被反射性地读取。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) @Retention(RetentionPolicy.RUNTIME) public @interface NotNull { String value(); String name(); int age() default 100; }
读取注解的属性值
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Parameter; public class Main { public static void main(String[] args) throws Exception { TestBean testBean = new TestBean(); Class<? extends TestBean> aClass = testBean.getClass(); NotNull annotation = aClass.getAnnotation(NotNull.class); if (annotation != null) { System.out.println("TestBean类上有@NotNull注解"); String value = annotation.value(); String name = annotation.name(); int age = annotation.age(); System.out.println(value + "--" + name + "--" + age); } else { System.out.println("TestBean类上没有@NotNull注解"); } Field nameField = aClass.getField("name"); NotNull annotation1 = nameField.getAnnotation(NotNull.class); if (annotation1 != null) { System.out.println("name上有@NotNull注解"); String value = annotation1.value(); String name = annotation1.name(); int age = annotation1.age(); System.out.println(value + "--" + name + "--" + age); } else { System.out.println("name上没有@NotNull注解"); } Constructor<? extends TestBean> declaredConstructor = aClass.getDeclaredConstructor(); NotNull annotation2 = declaredConstructor.getAnnotation(NotNull.class); if (annotation2 != null) { System.out.println("构造器上有@NotNull注解"); String value = annotation2.value(); String name = annotation2.name(); int age = annotation2.age(); System.out.println(value + "--" + name + "--" + age); } else { System.out.println("构造器上没有@NotNull注解"); } Method showMethod = aClass.getMethod("show",int.class); NotNull annotation3 = showMethod.getAnnotation(NotNull.class); if (annotation3 != null) { System.out.println("show方法上有@NotNull注解"); String value = annotation3.value(); String name = annotation3.name(); int age = annotation3.age(); System.out.println(value + "--" + name + "--" + age); } else { System.out.println("show方法上没有@NotNull注解"); } Parameter[] parameters = showMethod.getParameters(); for (Parameter parameter:parameters){ String name1 = parameter.getName(); if (parameter.getName().equals("age")){ NotNull annotation4 = parameter.getAnnotation(NotNull.class); System.out.println("age参数上有@NotNull注解"); String value = annotation4.value(); String name = annotation4.name(); int age = annotation4.age(); System.out.println(value + "--" + name + "--" + age); } } } }
子类可以继承父类的注解吗?
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; public class TestBean2 extends TestBean{ }
从结果上看,子类确实没有继承到父类的注解.
@Inherited元注解注释到自定义注解上,则表示该注解可以继承.父类只能是class,不能是抽象的,也不能是接口.
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package com.datang.pet.data.anno; import java.lang.annotation.*; @Target(value = {ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE}) @Retention(RetentionPolicy.RUNTIME) @Inherited public @interface NotNull { String value(); String name(); int age() default 100; }