Java 反射和注解

Java 反射和注解

文章目录

• Java 反射和注解
• • 1. junit注解
  • • • 作用
      • 示例
      • 注意点
  • 2. Before注解和After注解
  • • • 示例
  • 3. 反射
  • • 3.1 反射的基本概念
    • 3.2 获取各个阶段的Class字节码文件
    • • 注意点
      • 忽略修饰符安全性检查（暴力反射）
      • 示例：获取成员变量们
      • 示例：获取构造方法们
      • 示例：获取成员方法们
  • 4. 一个反射案例
  • • 示例
  • 5. 注解
  • • 5.1注解文档抽取
    • 5.2 jdk内置注解
    • • 示例
    • 5.3 自定义注解
    • • 示例
    • 5.4 元注解
    • • @Target示例:注解只能作用到方法上
    • 5.5 使用（解析）注解
    • • 示例
  • 6. 一个简单的注解框架

1. junit注解

• 一般在一个测试类中定义，不需要定义main方法

• 格式

@Test

• 后面跟上要测试的方法（由该注解的注解（@Target）决定作用于谁）

作用

• （常用）用于测试，使之后的方法代码可以独立允许，而不用像之前那样，在main方法中，每测试一下，就要注释一些无关的代码

示例

• 要测试的方法类

package day01.junit.test;
 
public class Add {
    public Add() {
    }
 
    public int add(int a, int b){
        return a+b;
    }
 
    public int sub(int a,int b){
        return a-b;
    }
}
 

• junit单元测试类

package day01.junit.test;
 
import org.junit.Assert;
import org.junit.Test;
 
public class testAdd {
 
//    1.Test注解,用于测试,使之可以独立运行
//
    @Test
    public void addtest(){
        Add example=new Add();
        int result=example.add(1,2);
        System.out.println(result);
 
//        2.断言操作，一个预期值和实际值比较
        Assert.assertEquals(2,result);
    }
 
    @Test
    public void testsub(){
        Add example=new Add();
        int sub = example.sub(3,1);
        System.out.println(sub);
        Assert.assertEquals(1,sub);
    }
 
}
 

• 效果图

注意点

• 测试过程中只要注解后的函数代码能运行，就是绿色，运行出错才是红色
• 要判断函数是否逻辑正确，需要用到断言操作（图示故意预期错误答案来看效果）

2. Before注解和After注解

• Before注解：初始化方法，所有测试方法在执行前都会先执行Before后面的函数代码
• After 注解：释放资源方法，所有测试方法在执行后都会执行After后面的函数代码

示例

package day01.junit.test;
 
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
 
public class testAdd {
 
//    1.Test注解,用于测试,使之可以独立运行
//
 
//    2.Before注解
    @Before
    public void sayBegin(){
        System.out.println("begin....");
    }
 
    @Test
    public void addtest(){
        Add example=new Add();
        int result=example.add(1,2);
        System.out.println(result);
 
//        2.断言操作，一个预期值和实际值比较
//        Assert.assertEquals(2,result);
    }
 
    @Test
    public void testsub(){
        Add example=new Add();
        int sub = example.sub(3,1);
        System.out.println(sub);
//        Assert.assertEquals(1,sub);
    }
 
//    3.After 注解
    @After
    public void sayEnd(){
        System.out.println("end.....");
    }
 
}
 

• 效果图

3. 反射

• java文件的三个阶段

3.1 反射的基本概念

• 将类的各个组成部分封装为其他对象，这就是反射机制
  • 例如：一个java的源代码中一个类的成员变量，成员方法，构造方法，在还没有运行时，被封装成Class类（一个类）的的对象（成员变量数组，构造方法数组，成员方法数组）

3.2 获取各个阶段的Class字节码文件

• 源代码阶段
  • 多用于配置文件，将类名定义在配置文件中

Class.forName("完整类名")   //完整类名=包名+类名

• 类加载器阶段
  • 多用于参数的传递

类名.class

• 运行时阶段
  • 多用于对象的字节码获取
  • *代表通配符（类的名称）

*.class.getClass()

package Reflect;
 
import static java.lang.Class.forName;
 
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
//        获取Class对象的三种方式
 
//        1.在源代码阶段
        Class<?> aClass = Class.forName("Reflect.Student");
 
 
        System.out.println(aClass);
 
//        2.类加载器阶段
 
        System.out.println(Student.class);
 
//       3. 运行时阶段
 
        Student s = new Student();
        System.out.println(s.getClass());
 
//        比较Class对象是否相等
 
        System.out.println(aClass==Student.class);
        System.out.println(aClass==s.getClass());
    }
}
 

• 效果图

注意点

• 无论在哪个阶段获取字节码文件，在一次程序运行过程中只加载一次，所有获取的都是同一字节码文件

• Class对象功能：
  • 获取功能：

    1. 获取成员变量们

       • Field[] getFields() ：获取所有public修饰的成员变量

       • Field getField(String name) 获取指定名称的 public修饰的成员变量

       • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符

       • Field getDeclaredField(String name)

    2. 获取构造方法们

       • Constructor<?>[] getConstructors()

       • Constructor getConstructor(类<?>… parameterTypes)

       • Constructor getDeclaredConstructor(类<?>… parameterTypes)

       • Constructor<?>[] getDeclaredConstructors()

    3. 获取成员方法们：

       • Method[] getMethods()

       • Method getMethod(String name, 类<?>… parameterTypes)

       • Method[] getDeclaredMethods()

       • Method getDeclaredMethod(String name, 类<?>… parameterTypes)

    4. 获取全类名

       • String getName()

• 获取到的Field成员变量的方法

• Object get(Object obj) 返回由该 Field表示的字段在指定对象上的值。

• void set (Object obj, Object value)将指定的对象参数中由此 Field对象表示的字段设置为指定的新值。

忽略修饰符安全性检查（暴力反射）

Field f=sc.getDeclaredField("d");
        //    忽略修饰符的安全权限检查
        f.setAccessible(true);
		//  被private修饰的d可以被访问
        System.out.println(f.get(s));

示例：获取成员变量们

• 学生类

package Reflect;
 
public class Student {
    private int age;
    private String name;
    public String a;
    protected String b;
    String c;
    private String d;
 
    public Student() {
    }
 
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}
 

• 反射测试类

package Reflect;
 
import java.lang.reflect.Field;
 
public class ReflectDemo2 {
    public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
    //  Field[] getFields() ：获取所有public修饰的成员变量
 
        Class<Student> sc = Student.class;
        Field[] fields = sc.getFields();
        for(Field f:fields){
            System.out.println(f);
        }
 
    //    Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
        Field[] fields2 = sc.getDeclaredFields();
        for(Field f:fields2){
            System.out.println(f);
        }
 
    //    成员变量的操作方法
 
        Student s = new Student();
        //System.out.println(fields[0].get(s));
 
    //暴力反射
 
 
        Field f=sc.getDeclaredField("d");
        //    忽略修饰符的安全权限检查，d本来被private修饰符修饰
        f.setAccessible(true);
        System.out.println(f.get(s));
 
    }
}
 

• 效果图

示例：获取构造方法们

package Reflect;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
 
public class ReflectDemo3 {
    public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
 
    //    获取构造器
 
        Class<Student> sc = Student.class;
    //    Constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor<Student> constructor = sc.getConstructor(int.class, String.class);
 
    //T newInstance​(Object... initargs) 使用由此 Constructor对象表示的构造函数
        // ，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例。
        //创建对象
        Student his = constructor.newInstance(23,"liubi");
 
        System.out.println(his);
 
 
    //    空参构造器
        Constructor<Student> constructor1 = sc.getConstructor();
        Student his1 = constructor1.newInstance();
        System.out.println(his1);
 
    //    等价于
 
        Student his2 = sc.newInstance();
        System.out.println(his2);
	
        //也可以暴力反射，获取被private修饰的成员变量，成员方法
        
    }
}
 

• 效果图

示例：获取成员方法们

• 学生类

package Reflect;
 
public class Student {
    private int age;
    private String name;
    public String a;
    protected String b;
    String c;
    private String d;
 
    public Student() {
    }
 
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
 
    public void eat(){
        System.out.println("eat...");
    }
 
    public void play(String game){
        System.out.println(game);
    }
}
 

• 测试类

package Reflect;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class ReflectDemo4 {
    public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException {
 
    //   获取方法们
        Class<Student> sc = Student.class;
        //空参方法
        Method eat = sc.getMethod("eat");
 
        //    使用方法
        //Object invoke​(Object obj, Object... args) 在具有指定参数的指定对象上调用此 方法对象表示的基础方法。
        Student s = new Student();
        eat.invoke(s);
 
    //    有参方法
        Method play = sc.getMethod("play", String.class);
        play.invoke(s,"王者荣耀");
 
 
    //    获取所有public方法
 
        Method[] methods = sc.getMethods();
 
        for(Method m:methods){
            System.out.println(m);
            //获取方法名
            System.out.println(m.getName());
        //    也可以暴力反射
        }
 
    }
}
 

• 效果图

4. 一个反射案例

• 需求：一个框架，可以在不改动框架代码的前提下，可以创建任意类的对象，执行对象的方法

• 思路

  1. 定义一个配置文件（存放类名，方法名）
  2. 定义一个框架类，将配置文件加载到框架中
  3. 将配置文件中的类加载到内存
  4. 创建类的对象
  5. 执行方法

示例

• 框架

package Reflect;
 
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
 
public class kuanjia {
    public static void main(String[] args) throws Exception {
    //    获取配置文件信息
 
        Properties pr = new Properties();
 
    //    创建一个类加载器
 
        ClassLoader cl = kuanjia.class.getClassLoader();
        // 获取配置文件的流，路径
        InputStream ras = cl.getResourceAsStream("pro.properties");
    //    将流加载进来
 
        pr.load(ras);
 
        //获取类名
        String className = pr.getProperty("className");
        //获取方法名
        String classMethod = pr.getProperty("classMethod");
 
    //    加载该类到内存
        Class aClass = Class.forName(className);
 
    //    创建对象
 
        Object o = aClass.newInstance();
 
    //    调用方法
 
    //    获取方法
 
        Method method = aClass.getMethod(classMethod);
        method.invoke(o);
 
 
 
    }
}
 

• 学生类

package Reflect;
 
public class Student {
    private int age;
    private String name;
    public String a;
    protected String b;
    String c;
    private String d;
 
    public Student() {
    }
 
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
 
    public void eat(){
        System.out.println("eat...");
    }
 
    public void play(String game){
        System.out.println(game);
    }
}
 

• Person类

package Reflect;
 
public class Person {
    private int age;
    private String name;
    public String a;
    protected String b;
    String c;
    private String d;
 
    public Person() {
    }
 
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
 
 
 
    public void play(){
        System.out.println("play...");
    }
}
 

• 效果图

5. 注解

• 概念：说明程序的。给计算机看的

• 注释：用文字描述程序的。给程序员看的

• 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

• 概念描述：

  • JDK1.5之后的新特性
  • 说明程序的
  • 使用注解：@注解名称

• 作用分类：
  ①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
  ②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
  ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

5.1注解文档抽取

• idea抽取文档

• 图解

5.2 jdk内置注解

• JDK中预定义的一些注解
  • @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
  • @Deprecated：该注解标注的内容，表示已过时
  • @SuppressWarnings：压制警告
    • 一般传递参数all @SuppressWarnings(“all”)

示例

package Annoation;
 
//压制警告
 
//压制该类的所有警告
 
@SuppressWarnings("all")
public class Demo1 {
    //检测被该注解标注的方法是否是继承自父类(接口)的
    @Override
    public String toString() {
        return super.toString();
    }
 
    //注解的方法已经过时
    @Deprecated
    public void show1(){
 
    }
 
    public void show2(){
 
    }
 
    public void test(){
        show1();
        //show2();
    }
}
 

• 注解方法已过时

• 压制警告

• 压制后

5.3 自定义注解

• 格式

元注解
    public @interface 注解名称{
    属性列表；
}
    

• 本质：注解的本质是一个接口，该接口默认继承Annotation接口

  public interface MyAnno extends java.lang.annotation.Annotation{
      
  }

• 注解中的属性：接口中的抽象方法

• 属性的返回值类型

  • 基本数据类型
  • String
  • 枚举
  • 注解类型
  • 以上类型的数组

• 属性的赋值（使用注解时需要给属性赋值）

  • 1.在定义属性时，如果用default关键字给属性赋默认初始值，则在使用该注解时可以不用赋值

    2.如果只有一个属性且属性名为value，则在使用注解时属性名可以省略，直接写值即可

    3.数组在赋值时，值使用{}包裹，如果数组中只有一个值，则{}省略

示例

• 注解测试类

package Annoation;
 
//压制警告
 
//压制该类的所有警告
 
@SuppressWarnings("all")
public class Demo1 {
    //检测被该注解标注的方法是否是继承自父类(接口)的
    @Override
    public String toString() {
        return super.toString();
    }
 
    //注解的方法已经过时
    @Deprecated
    public void show1(){
 
    }
    //各个类型的赋值
    @MyAnno(value="12",name = "张三",ps=Person.P1,Anno = @MyAnno2,strs={"abc","efg"})
    public void show2(){
 
    }
 
    public void test(){
        show1();
        //show2();
    }
}
 

• 注解类

package Annoation;
 
public @interface MyAnno {
    //返回值为String类型
    String name();
    String value();
    返回值为基本数据类型
//
//    默认赋值
    int age() default 12;
//
    返回值为枚举类型
//
    Person ps();
//
    返回值为注解类型
//
    MyAnno2 Anno();
//
    返回值为以上类型的数组
//
    String[] strs();
}
 

• 枚举类

package Annoation;
 
public enum Person {
//    枚举类
    P1,p2;
}
 

• 被赋值的注解类

package Annoation;
 
public @interface MyAnno2 {
}
 

5.4 元注解

• 定义：用于描述注解的注解
• 常用的元注解
  • @Target:描述注解能够作用的位置
    • **ElementType取值 **
      • TYPE:可以作用在类上
      • METHOD：可以作用在方法上
      • FIELD：可以作用在成员变量上
  • @Retention:描述注解被保留的阶段
    • @Retention(RetentionPolicy.RUNTIME):当前被描述的注解，会保留到class字节码文件中，并被jvm读取
  • @Documented：描述注解是否导出doc文档
  • @Inherited：描述注解是否被子类继承

@Target示例:注解只能作用到方法上

package Annoation;
 
//压制警告
 
//压制该类的所有警告
 
@SuppressWarnings("all")
@MyAnno(value="12",name = "张三",ps=Person.P1,Anno = @MyAnno2,strs={"abc","efg"})
public class Demo1 {
    //检测被该注解标注的方法是否是继承自父类(接口)的
    @Override
    public String toString() {
        return super.toString();
    }
 
    //注解的方法已经过时
    @Deprecated
    public void show1(){
 
    }
    //各个类型的赋值
    @MyAnno(value="12",name = "张三",ps=Person.P1,Anno = @MyAnno2,strs={"abc","efg"})
    public void show2(){
 
    }
 
    public void test(){
        show1();
        //show2();
    }
}
 

• 效果图

5.5 使用（解析）注解

• 将注解的属性值获取出来
• 可以达到与上文配置文件相同的功能

1. 获取注解定义的位置的对象 （Class，Method,Field）
   2. 获取指定的注解

      • getAnnotation(Class)
        //其实就是在内存中生成了一个该注解接口的子类实现对象

          public class ProImpl implements Pro{
              public String className(){
                  return "cn.itcast.annotation.Demo1";
              }
              public String methodName(){
                  return "show";
              }
          }

   3. 调用注解中的抽象方法获取配置的属性值

示例

• 框架类

package Annoation;
 
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
//使用注解
@MyAnno3(className = "Annoation.Teacher",methodName="show1")
public class kuanjia {
    public static void main(String[] args) throws Exception {
 
    //    使用注解来达到配置文件的作用
    //    获取当前类的字节码文件
 
        Class<kuanjia> kuanjiaClass = kuanjia.class;
        //获取注解位置的对象
 
        MyAnno3 an = kuanjiaClass.getAnnotation(MyAnno3.class);
 
        //获取类名和方法名
 
        String className = an.className();
        String methodName = an.methodName();
 
 
        //    加载该类到内存
        Class aClass = Class.forName(className);
 
    //    创建对象
 
        Object o = aClass.newInstance();
 
    //    调用方法
 
    //    获取方法
 
        Method method = aClass.getMethod(methodName);
        method.invoke(o);
 
 
 
    }
}
 

• 注解接口

package Annoation;
//作用在类上
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//  保留到运行（runtime）阶段
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno3 {
    String className();
    String methodName();
}
 

• 需要测试的Teacher类

package Annoation;
 
public class Teacher {
    public void show1(){
        System.out.println("teacher.show....");
    }
}
 

• 效果图

6. 一个简单的注解框架

• 注解

package Demo;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Check {
}
 

• 被测试的类

package Demo;
 
public class Calculate {
    @Check
    public void add(){
        System.out.println("3+0="+(3+0));
    }
    @Check
    public void sub(){
        System.out.println("3-0="+ (3-0));
    }
    @Check
    public void mul(){
        System.out.println("3*0="+(3*0));
    }
    @Check
    public void div(){
        System.out.println("3/0="+(3/0));
    }
}
 

• 测试框架

package Demo;
 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class Test {
    public static void main(String[] args) throws IOException {
    //    创建计算器对象
 
        Calculate c = new Calculate();
        //获取字节码文件
        Class aClass = c.getClass();
 
    //    获取成员方法们
 
        Method[] methods = aClass.getMethods();
 
 
        //创建bug输出流
 
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));
        //出现异常的次数
 
        int num=0;
        for (Method method : methods) {
            //判断方法上是否有注解
            if(method.isAnnotationPresent(Check.class)){
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    num++;
 
                    bw.write(method+"方法出现了异常");
                    bw.newLine();
                    bw.write("出现的异常"+e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("出现异常的原因"+e.getCause().getMessage());
 
                    bw.newLine();
                    bw.write("----------------------------");
                    bw.newLine();
                }
            }
        }
 
        bw.write("本次一共出现"+num+"次异常");
 
        bw.flush();
        bw.close();
    }
}
 

• 运行测试框架的效果图