Java基础知识-第14章-Java注解

1、注解(Annotation)概述

• 从JDK5.0开始，Java增加了对元数据(MetaData) 的支持，也就是Annotation(注解)
• Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。 代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
• Annotation 可以像修饰符一样被使用，可用于修饰包，类，构造器，方法，成员变量，参数，局部变量的声明，这些信息被保存在Annotation的“name=value”对中。

框架=注解+反射+设计模式

2、常见的Annotation示例

使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素

2.1、生成文档相关的注解

@author//标明开发该类模块的作者，多个作者之间使用，分割
@versio//n标明该类模块的版本
@see//参考转向，也就是相关主题
@since//从哪个版本开始增加的
@param//对方法中某参数的说明，如果没有参数就不能写
@return//对方法返回值的说明，如果方法的返回值类型是void就不能写
@exception//对方法可能抛出的异常进行说明，如果方法没有用throws显式抛出的异常就不能写

其中@param、 @return 和 @exception这三个标记都是只用于方法的。

• @param的格式要求： @param 形参名 形参类型 形参说明
• @return的格式要求： @return 返回值类型 返回值说明
• @exception的格式要求:
  • @exception异常类型异常说明
  • @param和@exception可以并列多个

package com.annotation.javadoc;
/**
* @author lemon
* @version 1.0
* @see Math.java
*/
public class JavadocTest {/*** 程序的主方法，程序的入口* @param args String[] 命令行参数*/public static void main(String[] args) {}/*** 求圆面积的方法* @param radius double 半径值* @return double 圆的面积*/public static double getArea(double radius){return Math.PI * radius * radius;}
}

2.2、JDK内置的三个基本注解

会在编译的时候进行格式检查

• @Override:：限定重写父类方法，该注解只能用于方法
• @Deprecated：用于表示所修饰的元素(类，方法等) 已过时。
• @SuppressWarnings：抑制编译器警告

package com.annotation.javadoc;
public class AnnotationTest{public static void main(String[] args) {@SuppressWarnings("unused")int a = 10;//没有使用这个变量}@Deprecatedpublic void print(){System.out.println("过时的方法");}@Overridepublic String toString() {return "重写的toString方法()";}
}

2.3、跟踪代码依赖性，实现替代配置文件功能

1、Servlet3.0提供了注解(annotation)，使得不再需要在web.xml文件中进行Servlet的部署

@WebServlet("/login")
public class LoginServlet extends HttpServlet {private static final long serialVersionUID = 1L;protected void doGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException { }protected void doPost(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {doGet(request, response);} 
}

xml配置文件

<servlet><servlet-name>LoginServlet</servlet-name><servlet-class>com.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping><servlet-name>LoginServlet</servlet-name><url-pattern>/login</url-pattern>
</servlet-mapping>

2、spring框架中关于“事务”的管理

@Transactional(propagation=Propagation.REQUIRES_NEW,isolation=Isolation.READ_COMMITTED,readOnly=false,timeout=3)
public void buyBook(String username, String isbn) {//1.查询书的单价int price = bookShopDao.findBookPriceByIsbn(isbn);//2. 更新库存bookShopDao.updateBookStock(isbn);//3. 更新用户的余额bookShopDao.updateUserAccount(username, price);
}

xml文件

<!-- 配置事务属性 -->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice"><tx:attributes><!-- 配置每个方法使用的事务属性 --><tx:method name="buyBook" propagation="REQUIRES_NEW"isolation="READ_COMMITTED" read-only="false" timeout="3" /></tx:attributes>
</tx:advice>

3、自定义Annotation

自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效)， 是否将注解包含在javadoc中及是否允许子类继承父类中的注解，具体如下：

参考@SuppressWarnings定义，查看其源码

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {/*** The set of warnings that are to be suppressed by the compiler in the* annotated element.  Duplicate names are permitted.  The second and* successive occurrences of a name are ignored.  The presence of* unrecognized warning names is <i>not</i> an error: Compilers must* ignore any warning names they do not recognize.  They are, however,* free to emit a warning if an annotation contains an unrecognized* warning name.** <p> The string {@code "unchecked"} is used to suppress* unchecked warnings. Compiler vendors should document the* additional warning names they support in conjunction with this* annotation type. They are encouraged to cooperate to ensure* that the same names work across multiple compilers.* @return the set of warnings to be suppressed*/String[] value();
}

所以我们自定义注解步骤如下：

• 定义新的Annotation类型使用@interface关键字

• 自定义注解自动继承了java.lang.annotation.Annotation接口

• Annotation的成员变量 ，在Annotation 定义中以无参数方法的形式来声明，如String[] value();。其方法名和返回值定义了该成员的名字和类型。我们称为配置参数。类型只能是八种基本数据类型、String类 型、Class类型、enum类型、Annotation类型、以上所有类型的数组。

• 可以在定义Annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字，如果只有一个参数成员，建议使用参数名为value

• 如果定义的注解含有配置参数，那么使用该注解时必须指定参数值，格式是“参数名=参数值”，除非它有默认值。如果只有一个参数成员，且名称为value, 则使用注解的时候可以省略“value=”

• 没有成员定义的Annotation称为标记； 包含成员变量的Annotation 称为元数据Annotation，如

  //内部没有任何配置参数定义
  public @interface Override {
  }
  

注意:

• 自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
• 要获取类、方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象，除此之外没有别的获取注解对象的方法

//自定义注解
public @interface MyAnnotation {String value();//配置参数
}//使用注解，由于我们定义的注解含有配置参数，那么使用该注解时必须指定参数值：参数名=参数值，这里可省略
@MyAnnotation(value = "hello")
public class Goods implements Comparable {private int price;@Overridepublic int compareTo(Object o) {if (o instanceof Goods) {Goods goods = (Goods) o;//方法一if (this.price > goods.price) {return 1;} else if (this.price < goods.price) {return -1;} else {return 0;}//方法二// return Double.compare(this.price, goods.price);}throw new RuntimeException("传入的数据类型不一致");}}

当然我们也可以在定义Annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字，如果只有一个参数成员，建议使用参数名为value

//自定义注解
public @interface MyAnnotation {String value() default "hello"
}
//这时候就不需要指定value值了，使用的就是默认值
//@MyAnnotation()
//当然，如果不想使用这个默认值，可以重新指定
@MyAnnotation(value = "abcdefg")
public class Goods implements Comparable {

4、JDK中的元注解——用来修饰注解的注解

JDK的元Annotation用于修饰其他Annotation定义

JDK5.0提供了4个标准的meta-annotation类型， 分别是:

• ➢Retention
• ➢Target
• ➢Documented
• ➢Inherited

4.1、@Retention

@Retention只能用于修饰一个Annotation定义，用于指定该Annotation（注解）的生命周期，@Rentention包含一个RetentionPolicy类型的成员变量，使用@Rentention时必须为该value成员变量指定值:

• RetentionPolicy.SOURCE：在源文件中有效(即源文件保留)，编译器直接丢弃这种策略的注释
• RetentionPolicy.CLASS：在class文件中有效(即class保留)，当运行Java程序时，JVM不会保留注解。这是默认值
• RetentionPolicy.RUNTIME：在运行时有效(即运行时保留)，当运行 Java程序时，JVM会保留注释。只有声明为RetentionPolicy.RUNTIME 生命周期的注解，才能通过反射获取它的注解信息。

我们以注解SuppressWarnings为例，它上面就有@Retention(RetentionPolicy.SOURCE)注解，

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
//表明SuppressWarnings注解可以在编译的时候跳过，即达到取消警告的效果
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {String[] value();
}

我们总结一下@Retention注解的3种生命周期，如下

4.2、@Target

@Target用于修饰Annotation定义，用于指定被修饰的Annotation能用于修饰哪些程序元素。@Target 也包含一个名为value的成员变量(数组类型的)。我们自定义注解一般都会指明两个元注解：@Retention和@Target

我们以注解SuppressWarnings为例，它上面就有@Target注解

//表明SuppressWarnings注解只能修饰类、接口、注解、方法、....
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {String[] value();
}

解释一下它能取的值和对应的意思

4.3、@Documented

用于指定被该元Annotation修饰的Annotation类将被javadoc工具提取成文档。默认情况下，javadoc是不包括注解的。

• 定义为Documented的注解必须设置Retention值为RUNTIME。

4.4、@Inherited

被它修饰的Annotation将具有继承性。如果某个类使用了被@Inherited修饰的Annotation，则其子类将自动具有该注解。

• 比如：如果把标有@Inherited注解的自定义注解标注在类级别上，子类则可以继承父类类级别的注解
• 实际应用中，使用较少

5、使用反射读取注解信息

JDK 5.0 在 java.lang.reflect 包下新增了 AnnotatedElement 接口, 该接口代表程序中可以接受注解的程序元素

• 当一个 Annotation 类型被定义为运行时 Annotation 后, 该注解才是运行时可见，当 class 文件被载入时保存在 class 文件中的 Annotation 才会被虚拟机读取
• 程序可以调用 AnnotatedElement对象的如下方法来访问 Annotation 信息

自定义注解

//表明该注解只能修饰类
@Target(value= {ElementType.TYPE})
//可以通过反射解析
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {String value();
}
//表明该注解只能修饰属性
@Target(value= {ElementType.FIELD}) 
@Retention(RetentionPolicy.RUNTIME)
public @interface MyField {String columnName();String type();int length();
}

使用注解的类:

@Table("tb_student")//修饰类，注解类，只有一个参数成员，且为value，所以可以省略value
public class MyStudent {@MyField(columnName = "id",type = "int",length = 10)private int id;@MyField(columnName = "sname",type = "varchar",length = 50)private String studentName;@MyField(columnName = "age",type = "int",length = 3)private int age;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getStudentName() {return studentName;}public void setStudentName(String studentName) {this.studentName = studentName;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

反射读取注解信息

package com.lemon.java;import java.lang.annotation.Annotation;
import java.lang.reflect.Field;/*** @Author Lemons* @create 2022-02-23-20:57*/
public class Demo {public static void main(String[] args) {try {Class clazz=MyStudent.class;//获得类的所有有效注解Annotation[] annotations=clazz.getAnnotations();for (Annotation a : annotations) {System.out.println(a);}StringBuffer sb=new StringBuffer("CREATE TABLE ");//获得类的指定的注解Table t=(Table) clazz.getAnnotation(Table.class);System.out.println(t.value());sb.append(t.value()+"(");//获得类的指定属性注解Field f=clazz.getDeclaredField("studentName");MyField myF=f.getAnnotation(MyField.class);System.out.println(myF.columnName()+" "+myF.type()+" "+myF.length());//获得类的所有属性注解Field[] fs=clazz.getDeclaredFields();for (Field field : fs) {MyField myField=field.getAnnotation(MyField.class);System.out.println(myField.columnName()+"--"+myField.type()+"--"+myField.length());sb.append(myField.columnName()+" "+myField.type()+"("+myField.length()+"),");}sb.setCharAt(sb.length()-1,')');sb.append(";");//根据获得的表名、字段的信息拼出DDL语句，然后使用JDBC执行这个SQL,在数据库中生成相关的表System.out.println(sb);} catch (Exception e) {e.printStackTrace();}}
}

结果：

@com.lemon.java.Table(value=tb_student)
tb_student
sname varchar 50
id--int--10
sname--varchar--50
age--int--3
CREATE TABLE tb_student(id int(10),sname varchar(50),age int(3));

6、JDK8中注解的新特性

Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。此外， 反射也得到了加强，在Java8中能够得到方法参数的名称，这会简化标注在方法参数上的注解。

6.1、支持重复注解——借助repeatable注解

jdk8之前

@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {MyAnnotation[] value(); //放一个MyAnnotation注解数组类型的，就可以放置多个注解了
}public @interface MyAnnotation {String value();
}//使用MyAnnotations注解
@MyAnnotations({@MyAnnotation(value = "hello"), @MyAnnotation(value = "hello")})
public class Goods {private int price;
}

jdk8之后——借助repeatable注解

• MyAnnotation上声明@Repeatable注解，成员值为MyAnnotations.class
• MyAnnotation上的@Target和@Retention等元注解必须和MyAnnotations上的元注解相同，否则会报错

@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {MyAnnotation[] value();
}@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)//只能用runtime
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotation {String value();
}@MyAnnotation(value = "hello")
@MyAnnotation(value = "nihao")
public class Goods {private int price;
}

6.2、类型注解

JDK1.8之后，关于元注解@Target的参数类型ElementType枚举值多了两个：

• TYPE_PARAMETER
• TYPE_USE。

在Java 8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用在任何地方。

• ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
• ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句

举例1

//使用注解
public class TestTypeDefine<@TypeDefine() U> {private U u;public <@TypeDefine() T> void test(T t){}
}//ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中
@Target({ElementType.TYPE_PARAMETER})
@interface TypeDefine{
}

举例2

@MyAnnotation
public class AnnotationTest<U> {@MyAnnotationprivate String name;public static void main(String[] args) {AnnotationTest<@MyAnnotation String> t = null;int a = (@MyAnnotation int) 2L;@MyAnnotationint b = 10;}public static <@MyAnnotation T> void method(T t) {}public static void test(@MyAnnotation String arg) throws @MyAnnotation Exception {}
}
//ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句
@Target(ElementType.TYPE_USE)
@interface MyAnnotation {
}
ion
public class AnnotationTest<U> {@MyAnnotationprivate String name;public static void main(String[] args) {AnnotationTest<@MyAnnotation String> t = null;int a = (@MyAnnotation int) 2L;@MyAnnotationint b = 10;}public static <@MyAnnotation T> void method(T t) {}public static void test(@MyAnnotation String arg) throws @MyAnnotation Exception {}
}
//ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句
@Target(ElementType.TYPE_USE)
@interface MyAnnotation {
}