Java 反射和注解

最新推荐文章于 2024-05-22 14:21:06 发布

凌歆

最新推荐文章于 2024-05-22 14:21:06 发布

阅读量58

点赞数

分类专栏： java 基础文章标签：学习 java

本文链接：https://blog.csdn.net/qq_33938234/article/details/123262243

版权

java 基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java 反射和注解

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 使用（解析）注解

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

获取注解定义的位置的对象（Class，Method,Field）
1. 获取指定的注解
  - getAnnotation(Class)
    //其实就是在内存中生成了一个该注解接口的子类实现对象
```
  public class ProImpl implements Pro{
      public String className(){
          return "cn.itcast.annotation.Demo1";
      }
      public String methodName(){
          return "show";
      }
  }
```
2. 调用注解中的抽象方法获取配置的属性值

示例

框架类

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();
    }
}

运行测试框架的效果图

在这里插入图片描述

凌歆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
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. j
复制链接

扫一扫