注解-Annotation

一. 注解解析一. 注解解析1.1 注释和注解的区别？（掌握）注释，是给程序员看的。只在Java中有效。在class文件中不存在注释的。当编译之后，会进行注释擦除。注释是给编译器看的吗?不是，当我们的代码编译成class文件之后，在class文件里面是没有注释的，编译的时候它会做一个注释擦除。注解，是给虚拟机看的。当虚拟机看到注解之后，就知道要做什么事情了。什么是注解：Annotation表示注解

GAO.C-H

2564人浏览 · 2023-04-28 23:15:49

GAO.C-H · 2023-04-28 23:15:49 发布

一. 注解解析

1.1 注释和注解的区别？（掌握）

共同点：都可以对程序进行解释说明。
不同点：注释，是给程序员看的。只在Java中有效。在class文件中不存在注释的。
当编译之后，会进行注释擦除。
注释是给编译器看的吗?

不是，当我们的代码编译成class文件之后，在class文件里面是没有注释的，编译的时候它会做一个注释擦除。
注解，是给虚拟机看的。当虚拟机看到注解之后，就知道要做什么事情了。

什么是注解：

Annotation表示注解。是JDK1.5的新特性。
注解的主要作用：对我们的程序进行标注。通过注解可以给类增加额外的信息。
注解是给编译器或JVM(Java 虚拟机)看的，编译器或JVM(Java 虚拟机)可以根据注解来完成对应的功能。

1.2 如何使用注解（掌握）

在以前看过注解@Override。

当子类重写父类方法的时候，在重写的方法上面写@Override。
当虚拟机看到@Override的时候，就知道下面的方法是重写的父类的。检查语法，如果语法正确编译正常，如果语法错误，就会报错。

1.3 Java中已经存在的注解（掌握）

@Override：表示方法的重写
@Deprecated：表示修饰的方法已过时
@SuppressWarnings("all")：压制警告

同时，类名下面波浪线也消失了！

@Deprecated：已过时的方法，还是可以继续使用的，但是一定会有替代解决方案

除此之外，还需要掌握第三方框架中提供的注解：

比如：Junit

@Test 表示运行测试方法
@Before 表示在Test之前运行，进行数据的初始化
@After 表示在Test之后运行，进行数据的还原

二. 自定义注解(了解即可)

自定义注解单独存在是没有什么意义的，一般会跟反射结合起来使用，会用发射去解析注解。
针对于注解，只要掌握会使用别人已经写好的注解即可。
关于注解的解析，一般是在框架的底层已经写好了。
注解名跟类名的命令规则一样，首字母大写，如果有多个单词，每次单词的首字母大写。

默认值可以不用写。

package com.annotation;

/**
   自定义注解（默认值可以不用写）
 */
public @interface MyAnno1 {
    public String name();
    public int age();
}

package com.annotation;

@MyAnno1(name = "shipo" , age = 100)
public class MyAnnoDemo2 {
    @MyAnno1(name = "shipo", age = 100)
    String aaa;
    String bbb;

    @MyAnno1(name = "shipo" , age = 100)
    public void method1(){
        System.out.println("method1方法");
    }

    public void method2(){
        System.out.println("method2方法");
    }

}

特殊属性(掌握)：

value()：

当注解中只有"一个属性",并且属性名是"value",使用注解时,可以省略value属性名

//注解的定义
public @interface Anno2 {
    public String value();

    public int age() default 23;
}

//注解的使用
@Anno2("123")
public class AnnoDemo2 {

    @Anno2("123")
    public void method(){

    }
}

package com.annotation;

/**
   自定义注解
 */
public @interface MyAnno1 {

    public String value();
    public String name();

}

package com.annotation;

@MyAnno1(value = "abc" , name = "shipo")
public class MyAnnoDemo2 {
    String aaa;
    String bbb;

    public void method1(){
        System.out.println("method1方法");
    }

    public void method2(){
        System.out.println("method2方法");
    }

}

三. 元注解(了解)

元注解常见的有两个，不是说只有两个。

@Target注解决定了你下面的这个注解可以写在哪

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
   自定义注解
 */
@Target(ElementType.METHOD) // 规定了该注解只能写在方法上面
// RUNTIME,这个是在程序运行的时候,仍然会保留这个注解[以后使用反射,就必须是这个保留策略]
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno1 {

    public String value();
    public String name();

}

package com.annotation;


public class MyAnnoDemo2 {
    String aaa;
    String bbb;

    @MyAnno1(value = "abc" , name = "shipo")
    public void method1(){
        System.out.println("method1方法");
    }

    @MyAnno1(value = "abc" , name = "shipo")
    public void method2(){
        System.out.println("method2方法");
    }

}

四. 注解解析

自定义注解都是Annotation接口的实现类。

案例：

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE , ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    public String value(); // 书名
    public double price() default 100; // 价格
    public String[] authors(); // 多位作者
}

package com.annotation;

@Book(value = "《精通Java》" , price = 19.9 , authors = {"余胜军","鱼皮"})
public class BookStore {
    @Book(value = "《Redis实战》" , authors = {"詹姆斯高斯林"})
    public void method(){
        System.out.println("method");
    }
}

package com.annotation;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
   目标:完成注解的解析
 */
public class AnnotationParse {
    public static void main(String[] args) throws Exception {
        parseClass();
        System.out.println("====================");
        parseMethod();
    }
    /**
       解析类上面的注解
     */
    public static void parseClass(){
        // a.先得到类对象
        Class clazz = BookStore.class;
        // b.判断这个类上面是否存在这个注解
        if(clazz.isAnnotationPresent(Book.class)){
            // c.直接获取该注解对象
            Book book = (Book) clazz.getDeclaredAnnotation(Book.class);
            System.out.println("书名:" + book.value());
            System.out.println("价格:" + book.price());
            System.out.println("多位作者:" + Arrays.toString(book.authors()));
        }
    }

    /**
       解析该类方法上的注解
     */
    public static void parseMethod() throws Exception{
        // a.先得到类对象
        Class clazz = Class.forName("com.annotation.BookStore");
        // 创建解析类BookStore类的对象
        BookStore bs = new BookStore();
        // b.获取该类上面的指定方法
        Method method = clazz.getDeclaredMethod("method");
        // c.判断该方法上面是否存在注解
        if(method.isAnnotationPresent(Book.class)){
            // d.直接获取该注解对象
            Book book = (Book) method.getDeclaredAnnotation(Book.class);
            // 打印输出注解信息
            System.out.println("书名:" + book.value());
            System.out.println("价格:" + book.price());
            System.out.println("多位作者:" + Arrays.toString(book.authors()));
            // e.暴力反射,表示临时取消访问权限
            method.setAccessible(true);
            // 运行该方法
            method.invoke(bs);
        }
    }

}

五. 注解的应用场景：junit框架

package com.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 表示我们的注解可以写在方法上面,其他地方不能写
@Target(ElementType.METHOD)
// 表示我们的注解可以在任意时期都存在
// 如果写Source,那么只能在源码阶段存在,利用反射无法解析
// 利用反射必须是Runtime这个保留策略
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}

package com.annotation;

public class MyTestDemo {

    // 程序运行之后,会自动运行method1和method3
    @MyTest
    public void method1(){
        System.out.println("method1");
    }


    public void method2(){
        System.out.println("method2");
    }

    @MyTest
    public void method3(){
        System.out.println("method3");
    }
}

package com.annotation;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MyAnnoDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, IllegalAccessException {

        // 1.获取MyTestDemo这个类的字节码文件对象
        Class clazz = Class.forName("com.annotation.MyTestDemo");
        // 创建MyTestDemo的对象
        MyTestDemo mtd = new MyTestDemo();

        // 2.获取所有方法
        Method[] methods = clazz.getDeclaredMethods();
        // 3.遍历得到所有方法
        for (Method method : methods) {
            // 4.暴力反射,临时修改访问权限
            method.setAccessible(true);
            // 5.判断当前方法上有没有MyTest注解
            if(method.isAnnotationPresent(MyTest.class)){
                method.invoke(mtd);
            }
        };
    }
}