Java小知识——Junit、反射、注解

最新推荐文章于 2023-09-06 17:52:54 发布
最新推荐文章于 2023-09-06 17:52:54 发布
阅读量1.2k 收藏 19
点赞数 3
文章标签： Java java 单元测试 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46378049/article/details/114600369
版权

前言

有几个知识点，我一直很模糊、很欠缺，现在开始重新学习一下

Junit

JUnit是一个Java语言的单元测试框架。

测试分类

对于程序的测试，我们一般分成两类：

  • 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望值
  • 白盒测试：需要写代码的。关注程序具体的执行流程

Junit 的使用

我们的单元测试属于白盒测试。

今天我们来学习Java中的单元测试——JUnit

我们以往对代码的测试是怎么做呢？

一般都是如下吧：

public class Calculator {
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b) {
        return a - b;
    }
}
public class CalculatTest {
    public static void main(String[] args) {
        Calculator c=new Calculator();
        int result=c.add(3,4);
        System.out.println(result);
    }
}

这样很明显有很多问题，例如我们在main方法对方法进行测试的时候还需要屏蔽其他的方法；main方法只有一个，不方便统一管理，所以我们需要引入单元测试的方法

使用步骤：

  1. 定义一个测试类（测试用例），建议：类型叫做“被测试的类型+Test”；包名：xxx.xxx.test。
  2. 定义测试方法：可以独立运行，建议：方法名叫做“test测试的方法名”；测试方法的返回值一般用void；参数列表建议空参
  3. 给方法加注解@Test
  4. 导入JUnit的依赖环境（java自带就有，也可以网上去找junit.jar包）

这里我分享一个JUnit4的jar包：

链接：https://pan.baidu.com/s/1If_y5S16T6P1uXCJwTPb4g
提取码：wun0

继续上面的例子，我们创建一个test的包，然后写测试代码：

public class CalculatorTest {
    @Test
    public void testAdd(){
        //1.创建计算器对象
        Calculator c=new Calculator();
        //2.调用add方法
        int result=c.add(3,4);
        System.out.println(result);
    }
}

单机左边的绿色三角，就可以单独执行这个方法了！

注意：junit-4.12的jar包需要同时导入hamcrest-core-1.3.jar，否则会报错

测试中如果程序存在异常，那个绿色的三角形会是红色的，只有是绿色才说明测试成功。

断言

一般来说，我们不会去在单元测试中通过输出来检验，更多使用的是“断言”。

使用断言，可以让单元测试的那个提示三角符号根据情况改变成红色，不是单纯的靠输出结果人脑判断了。

断言Assert非常好用，下面是示例：

public void testAdd(){
    //1.创建计算器对象
    Calculator c=new Calculator();
    //2.调用add方法
    int result=c.add(3,4);
    //断言 断言结果
    Assert.assertEquals(3,result); //参数1：期望；参数2：实际
}

如果不是我们想要的结果，那么就会抛出异常。

补充

一般我们的测试类中，是会有个init方法配合junit，init是为junit中用到的资源的初始化申请，需要加上一个@Before的注解。

@Before：修饰的方法会在测试方法之前被自动被执行。

同理还有一个close方法，类似于C++爸爸中的析构函数，是测试类中负责释放资源的方法，在所有测试方法执行完后，都会执行该方法，需要加上一个@After的注释。

@After：修饰的方法会在测试方法执行之后自动被执行。

public class CalculatorTest {
    @Before
    public void init(){

    }
    @After
    public void close(){

    }
    @Test
    public void testAdd(){
        //1.创建计算器对象
        Calculator c=new Calculator();
        //2.调用add方法
        int result=c.add(3,4);
        //断言 断言结果
        Assert.assertEquals(7,result); //参数1：期望；参数2：实际
    }
}

反射

什么是反射

反射：框架设计的灵魂

框架，也就是半成品软件，我们开发人员将会在框架（半成品软件）的基础上再次进行软件开发，从而高效率地完成项目，简化编码。

而反射是框架的灵魂，即如果使用框架，我们不需要了解太多反射的知识，但是你要亲自开发一个框架，那么就要好好学习和利用反射。

将类的各个组成部分封装成其他对象，这就是反射机制。

Java程序的三个阶段

java代码在计算机中经历的三个阶段：

  1. Source 源代码阶段：.java源文件，包括.class字节码文件存在于硬盘上
  2. Class 类对象阶段：将Source源代码阶段的字节码文件从硬盘上加载到内存中。具体怎么加载呢？通过类加载器（ 对应java中的一个对象——ClassLoader）。到了内存中后，会有一个对象来描述这个字节码文件，这个对象是一个Class类的对象，没错，一个叫Class的类，这个类的对象可以读取这个内存中的被加载进来的类的三大属性：成员变量（被封装为Field对象）；构造方法（被封装为Constructor对象）；成员方法（被封装成Method对象）。最后通过这个类对象的一些行为，我们就可以创建真正的Source源代码中的对象。
  3. 运行时阶段：源代码中的类得到了实例化等操作

是的，Java代码在计算机中的经历就是典型的反射机制，一个类拆开换一种方式表达，最后再拼合还原。

反射机制的好处

  1. 可以在程序运行过程中，操作这些对象
  2. 可以解耦，提高程序的可扩展性

我们使用的编译器的自动提示能力一般也是依赖于反射机制，将用户的输入读取到内存中，找到对应的类，整理一下methods然后显示出来（怪不得IDE通常非常占用内存）。

获取Class对象的方式

 手动加载

如果我们的程序还在源代码阶段，还没有进入内存，我们可以手动让其进入内存。

Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象

类对象中获取Class对象

我们将源代码阶段的类加载进内存之后，该怎么获取呢？

通过类名来获取：

类名.class：通过类名的属性.class来获取

运行时获取Class对象

在目标对象已经运行起来的情况下，我们可以通过Object类的方法getClass来获取（Object类的方法会被子类继承，而Java中的除了基本数据类型以外的类[包括基本数据类型的封装类，例如int的封装类：Integer]都是继承Object类）

对象.getClass()

示例

一个包：com.atluoluo.domain，内部有一个类Person，是一个JavaBean类，可重用组件，具有两个属性name和age。

一个包：com.atluoluo.reflect，内部有一个类ReflectDemo1，代码如下：

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class cls1=Class.forName("com.atluoluo.domain.Person");
        System.out.println(cls1);
        Class cls2= Person.class;
        System.out.println(cls2);
        Person t=new Person();
        Class cls3=t.getClass();
        System.out.println(cls3);

        //比较这几个Class对象的堆内存的地址是否相同
        System.out.println(cls1==cls2); //true
        System.out.println(cls1==cls3); //true
    }
}

如此测试，得出结论：

同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象，都是同一个。

三种方式使用场合

  1. Class.forName()：这种方式多用于配置文件，读取文件，得到字符串，然后通过字符串加载类。
  2. 类名.class：多用于作为参数的传递
  3. 对象.getClass()：多用于对象的获取字节码的方式

使用Class对象

获取属性

我们接下来来看一个具体的Class对象使用案例：

首先我们先来明白一下Class对象的功能：

  • 获取成员变量们
    • Field[]   getFields()：获取所有public修饰的成员变量
    • Field   getField(String name)：获取某个public修饰的成员变量
    • Field[]   getDeclaredFields()：获取所有成员变量
    • Field   getDeclaredField(String name)：获取某个成员变量
  • 获取构造方法们
    • Constructor<?>[]   getConstructors()
    • Constructor<T>   getConstructor(类<?>… parameterTypes)
    • Constructor<?>[]   getDeclaredConstructors()
    • Constructor<T>    getDeclaredConstructor(类<?>… parameterTypes)
  • 获取成员方法们
    • Method[]  getMethods()
    • Method   getMethod(String name, 类<?>… parameterTypes)
    • Method[]  getDeclaredMethods()
    • Method   getDeclaredMethod(String name, 类<?>… parameterTypes)
  • 获取类名
    • String   getName()

方法使用

  • 获取成员变量——Field：

首先给我们前面那个JavaBean类Person类添加几个成员属性来方便我们做实验：

//修饰符权限由大到小
public String a;
protected String b;
String c;
private String d;

注意ToString方法中要重写一下，要包括上这几个成员。

然后写我们的主要测试代码

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass=Person.class;
        //获取成员变量们
        Field[] fields=personClass.getFields();
        for (Field fl:fields ) {
            System.out.println(fl);  //得到public的a
        }
        System.out.println("————————————————————————");
        Field f=personClass.getField("a");
        System.out.println(f);    //同样得到public的a
        //获取成员变量a的值
        Person p=new Person();
        Object value=f.get(p);
        System.out.println(value);
        //设置成员变量a的值
        f.set(p,"张三");
        System.out.println(p);

        System.out.println("————————————————————————");
        //获取所有成员变量（declare：声明）
        Field[] fields2=personClass.getDeclaredFields();
        for (Field fl:fields2 ) {
            System.out.println(fl);  //得到public的a
        }
        System.out.println("————————————————————————");
        Field d=personClass.getDeclaredField("d");
        //设置暴力反射，忽略安全性，允许访问非公有成员
        d.setAccessible(true);
        Object value2=d.get(p);
        System.out.println(value2);
    }
}



输出：
————————————————————————
public java.lang.String com.atluoluo.domain.Person.a
null
Person{name='null', age=0, a='张三', b='null', c='null', d='null'}
————————————————————————
private java.lang.String com.atluoluo.domain.Person.name
private int com.atluoluo.domain.Person.age
public java.lang.String com.atluoluo.domain.Person.a
protected java.lang.String com.atluoluo.domain.Person.b
java.lang.String com.atluoluo.domain.Person.c
private java.lang.String com.atluoluo.domain.Person.d
————————————————————————
null

注意：如果通过getDeclaredField得到一些没有权限操作的成员变量，如果你get或set，IDE是会报错提示你的，你可以设置暴力反射setAccessible来允许对这些成员变量操作。

通过这个例子我们可以深刻感受到，反射机制对于我们的意义，其实就是通过得到类，来对这个类的对象进行处理。

  • 获取构造方法——Constructor
public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass=Person.class;
        //得到构造方法
        Constructor constructor=personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);
        //利用Constructor的方法创建对象
        Object person=constructor.newInstance("张三",23);
        System.out.println(person);

        System.out.println("——————————————————————————");
        //得到构造方法
        Constructor constructor2=personClass.getConstructor();
        //利用Constructor的方法创建对象
        Object person2=constructor2.newInstance();
        System.out.println(person2);

        System.out.println("——————————————————————————");
        //直接利用Class对象创建空参构造的对象
        Object o=personClass.newInstance();
        System.out.println(o);
    }
}
public com.atluoluo.domain.Person(java.lang.String,int)
Person{name='张三', age=23, a='null', b='null', c='null', d='null'}
——————————————————————————
Person{name='null', age=0, a='null', b='null', c='null', d='null'}
——————————————————————————
Person{name='null', age=0, a='null', b='null', c='null', d='null'}

构造方法主要是要来创建这个类的实例化，得到构造方法，即Contructor的对象，然后调用newInstance方法即可创建对象，如果计划以空参创建对象，可以直接使用Class对象的newInstance方法，而不必再去得到Constructor对象，对于私有构造方法也可以使用getDeclaredConstructor，并且设置暴力反射，这里不做演示了。

  •  获取成员方法——Method

我们给之前那个JavaBean类——Person类添加一个方法：

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

好拉，回到ReflectDemo.java

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass=Person.class;
        //得到方法eat（是一个无参方法）
        Method eat_method=personClass.getMethod("eat");
        System.out.println(eat_method);
        //执行这个方法
        Person p=new Person();
        eat_method.invoke(p);

        System.out.println("-----------------");
        //得到方法eat（有参方法重载）
        Method eat2_method=personClass.getMethod("eat",String.class);
        System.out.println(eat2_method);
        //执行这个方法
        eat2_method.invoke(p,"香蕉");

        System.out.println("-----------------");
        //获取所有public修饰的方法
        // 这里得到的方法除了Person还有Object类的方法
        Method[] methods=personClass.getMethods();
        for (Method m:methods) {
            System.out.println(m);
        }
    }
}
public void com.atluoluo.domain.Person.eat()
eat...
-----------------
public void com.atluoluo.domain.Person.eat(java.lang.String)
eat：香蕉
-----------------
public java.lang.String com.atluoluo.domain.Person.toString()
public java.lang.String com.atluoluo.domain.Person.getName()
public void com.atluoluo.domain.Person.setName(java.lang.String)
public void com.atluoluo.domain.Person.setAge(int)
public int com.atluoluo.domain.Person.getAge()
public void com.atluoluo.domain.Person.eat()
public void com.atluoluo.domain.Person.eat(java.lang.String)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()

注意就是得到这个类的方法的时候还有把父类的方法也得到（因为继承关系嘛~），Java中的类都继承Object。

反射的应用案例

学了上面这些，貌似没有体会到反射的牛逼之处，接下来我们来具体做个案例你就会理解很多了。

案例需求：

写一个“框架”，可以帮我们去创建任意类的对象，并且执行其中任意方法

我们在包com.atluoluo.domain中创建一个Studnet类，这个项目还和上面的例子一样，还存在Person类：

public class Student {
    public void sleep(){
        System.out.println("I'm in sleep……");
    }
}

然后在com.atluoluo.reflect包中，写上一个java文件——ReflectDemo.java

如果我们想要创建一个类并且调用其方法，一般都是这样做：

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        Student s=new Student();
        s.sleep();
    }
}

但是这样其实并不能满足框架的需求，所谓框架，是一个软件半成品，我们不允许使用框架的人使用框架的时候还要修改框架的代码，只允许他们去用、他们去增加内容（这里正好对应设计模式中的开放-封闭原则：对增加开放、对修改封闭），如果如上所写，我们创建其他类的对象的时候还要写删删改改，这不能称之为框架。

接下来我们来完成框架：

我们需要做的是利用两个东西：

  1. 配置文件
  2. 反射

将需要创建的对象的全类名和需要执行的方法定义在配置文件中，在程序中去加载读取配置文件，使用反射技术去加载类文件进内存，并且创建对象，并且执行方法。

接下来我们找个合适的位置（在src目录下）来创建Java的配置文件pro.properties：

后缀properties是一种属性文件。
这种文件以key=value格式存储内容
Java中可以使用Properties类来读取这个文件
String value=p.getProperty(key);
就能得到对应的数据
一般这个文件作为一些参数的存储，代码就可以灵活一点

学英语：properties    所有物; 财产; 财物; 不动产; 

className=com.atluoluo.domain.Person
methodName=eat

ReflectDemo.java的文件的内容如下：

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //创建properties对象
        Properties pro=new Properties();

        //加载配置文件，转换为一个集合
        /*这里重点解释一下：我们的本类（ReflectDemo1）
        是被ClassLoader类对象加载进入内存的，
        该ClassLoader的对象可以读取指定资源的字节流*/
        ClassLoader classLoader=ReflectDemo1
                .class
                .getClassLoader();
        InputStream is=classLoader.getResourceAsStream("pro.properties");
        //根据字节流读取配置文件
        pro.load(is);

        //获取配置文件中定义的数据
        String className=pro.getProperty("className");
        String methodName=pro.getProperty("methodName");

        //利用反射，加载该类进入内存
        Class cls=Class.forName(className);
        //利用空参构造创建对象
        Object obj=cls.newInstance();
        //获取方法对象
        Method method=cls.getMethod(methodName);
        //执行方法
        method.invoke(obj);
    }
}

这样就可以成功调用配置文件中写的内容了，目前只能实现无参方法的调用，后续再更新吧！

如果我修改pro.properties：

className=com.atluoluo.domain.Student
methodName=sleep

也是可以正常调用的，框架中的代码一行不用改。

注解

 概念

什么是注释？用文字描述程序的，给程序员看的说明。

注解和注释非常相似，只不过注释是给程序员看的、注解则是给计算机看的。

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

使用注解的方式：@+注解名称

作用分类

  • 编写文档：通过代码里标识的注解生成文档【生成文档doc文档】

众所周知Java里可以使用工具javadoc来生成文档，我们写一个java文件：

/**
 * @Description TODO
 * @author luoluo
 * @Date 2020/5/19
 * @version 2020/7/3 21:08
 */
public class Annotation {
    /**
     * @author luoluo
     * @Description 计算两个类的和
     * @Date 21:09 2020/7/3
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     **/
    public int add(int a,int b){
        return a+b;
    }
}

然后打开该文件所在目录的命令行窗口，使用javadoc Annotation 命令即可。

这里我遇到了不少问题，主要是编码方面和标签不认识的问题，最后解决后的命令是：

javadoc -encoding UTF-8 -charset UTF-8 
         -tag Description:a:" Description" -tag Date:a:" Date" 
         Annotation.java

最后在index.html中，就是我们最后的类文档。

上面的例子中，我们的@param、@version等都属于注解，告诉计算机这些是编译API文档要读取的信息。

  • ⇒代码分析：通过代码里标识的注解对代码进行分析【使用反射】
  • 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查（我们常用Override，编译器检查父类方法的重写）

JDK内置注解

Java的软件开发环境包jdk为我们设置好了一些内置注解

  • @Override：检查方法是否完成了对父类/接口同名方法的覆盖，如果没有则会报错
  • @Deprecated： 对不应该再使用的方法添加注解，当编程人员使用这些方法时，它与javadoc里的@deprecated标记相同的功能（不过它不如Javadoc的deprecated，因为它不支持参数），会提示程序员该方法已过时（不过想用还是可以用）
public class Person {
    @Deprecated
    public void eat(){
        System.out.println("eat");
    }
}
public class Annotation {
    public static void main(String[] args) throws Exception {
        Person p=new Person();
        p.eat(); //'eat()' is deprecated，即方法已过时
    }
}
  • @SuppressWarnings：压制警告（学英语——suppress：压抑、封锁），在编译器中，很多时候会有警告说“某类没有被使用”、“某方法没有被使用”，如果我们在上一行写上@SuppressWarning(“all”)，那么这个类/方法中所有的警告就会消失。

自定义注解

咱们作为 程序员，也可以定义属于自己的注解。

格式

  1. 元注解
  2. public @interface 注解名称{ }

我们可以找到@Override的实现来参观一下

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

本质

我们可以通过反编译的方法来亲自感受一下思考过程：

首先，写一个java文件，写入内容：

public @interface MyAnno {
}

这就是我们的注解@MyAnno，然后我们利用javac命令将其生成对应的字节码文件（.class），然后妙的来了：我们再利用javap命令处理刚才的字节码文件，使其反编译，然后就是这样的内容：

Compiled from "MyAnno.java"
public interface MyAnno extends java.lang.annotation.Annotation {
}

自定义注解的本质：public interface MyAnno extends java.lang.annotation.Annotation{ }。

注释本质上就是一个public的接口（interface），默认继承自Annotation。

属性

注解的属性，也就是接口中可以定义的成员方法（抽象方法）

  • 属性的返回值类型必须是：
    • 基本数据类型（char、boolean、byte、short、int、long、float、double）
    • String
    • 枚举
    • 注解
    • 以上类型的数组

类类型、void都不能作为注解属性的返回值类型

  • 定义了属性，在使用时，需要给属性赋值
public @interface MyAnno {
     String show();
     int show2();
     Person per();
}

例如这样的注解，使用的时候就需要赋值。将接口中定义的方法像是一个字段一样进行了赋值，怪不得我们叫他属性。

@MyAnno(show = "cool",show2 = 3,per = Person.p1)
     public static void main(String[] args) {
}

我们可以使用default关键字来默认赋值

public @interface MyAnno {
    String show();
    int show2() default 3;
    Person per() default Person.p1;
}

在使用的地方只要给没有默认赋值的赋值就好了

    @MyAnno(show = "cool")
    public static void main(String[] args) {
    }
  • 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接括号里写上值即可（没错，@SuppressWarning(“all”)这玩意底层，那个属性就是叫“value”）
  • 数组赋值会比较特殊，值需要使用大括号包裹，如果数组中只有一个值的话，则大括号可以省略
public @interface MyAnno {
    int[] test();
    int[] test2();
}
    @MyAnno(test ={4,6,3},test2 = 6)
    public static void main(String[] args) {
    }

元注解

元注解是一种用于描述注解的注解，你也可以理解为就是系统提供的用于去创造注解的基本注解。

元注解就是JDK为我们定义的注解，用来让我们去定义属于自己的注解

我们需要掌握的元注解：

  • @Target：描述注解能够作用的位置（类/方法/成员变量）
    • ElementType.TYPE：可以作用于类上
    • ElementType.METHOD：可以作用于方法上
    • ElementType.FIELD：可以作用于成员变量上

示例：@Target(value={ElementType.TYPE,ElementType.METHOD})，该注解只能作用于方法和类

  • @Retention：描述注解被保留的阶段（源代码阶段/Class类对象阶段/RunTime阶段）
    • RetentionPolicy.SOURCE：当前被注释的注解，但不会保留到class字节码文件中
    • RetentionPolicy.CLASS：当前被注释的注解，会保留到class字节码文件中，但不会被JVM（Java虚拟机）读取到。
    • RetentionPolicy.RUNTIME：（常用）当前被注释的注解，会保留到class字节码文件中，并在运行时被JVM（Java虚拟机）读取到。
  • @Decumented：描述注解是否被抽取到API文档中

示例：@Documented，然后生成API文档之后，我们的注解那一行也会被记录在doc文档中。

  • @Inherited：描述注解是否被子类继承

示例：

@Inherited
public @interface MyAnno {
}

@MyAnno
class Parent{
    void method(){

    }
}
class Chirden extends Parent{
    @Override
    void method() {
        super.method();
    }
}

这样我们的Chirden类，也会隐式地含有注解@MyAnno

解析注解（注解的作用）

解析注解主要是要获取注解中定义的属性值

我们来个案例你就明白了，记得前面学习反射的时候，我们使用一个配置文件pro.properties来调整要创建的类的对象等信息，现在我们不需要再用配置文件了，我们使用注解。

创建一个注解叫Pro（名字随意）

然后写上如下内容：

/**
 * 描述需要执行的类名、和方法名
 */
@Target({ElementType.TYPE}) //对类起作用
@Retention(RetentionPolicy.RUNTIME) //保留到运行阶段
public @interface Pro {
    String className();  //属性1
    String methodName();  //属性2
}

然后写一个测试的类Demo：

public class Demo {
    public void show(){
        System.out.println("Demo1 show……");
    }
}

然后我们写主类ReflectDemo：

@Pro(className = "com.atluoluo.domain.Demo",methodName = "show")
public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //1.解析主类
        //1.1 获取该类的字节码文件对象
        Class<ReflectDemo> reflectDemoClass=ReflectDemo.class;
        //2.获取上边的注解对象
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        Pro an=reflectDemoClass.getAnnotation(Pro.class);
        //3.调用注解对象中定义的抽象方法来获取返回值
        String className= an.className();
        String methodName=an.methodName();

        //4.加载该类进入内存
        Class cls=Class.forName(className);
        //5.创建对象
        Object obj=cls.newInstance();
        //6.获取方法对象
        Method method=cls.getMethod(methodName);
        //7.执行方法
        method.invoke(obj);
    }
}

其中我们将要创建对象的类和要调用方法的方法名写在了注解当中，然后我们首先获取当前类的字节码文件对象Class对象，然后获取Class对象中的注解对象，这里要重点说一下，其底层实际就是在内存中生成了一个该注解接口的子类实现对象，即你的注解，在内存中被自动创建了一个子类，结构大概是这样：

public class ProImpl implements Pro{
    public String className(){
        return "com.atluoluo.domain.Demo";
    }
    public String methodName(){
        return "show";
    }
}

然后创建了一个这个子类的对象，然后调用其内置方法className/methodName获得相关信息，然后就是利用反射去调用即可。

我们总结一下：

  1. 获取注解定义的位置的对象（Class、Method、Field）
  2. 获取指定的注解：getAnnotation(Class)
  3. 调用注解中的抽象方法获取配置的属性值

简单的测试框架

接下来，咱们来利用自定义注解的能力来写一个简单好用的测试框架，通过个方法添加注解，就可以测试出方法是否存在异常，存在什么异常。

简单的测试框架，当主方法执行后，会自动去执行被检测的所有方法（加了check注解的方法），判断方法是否有异常，然后去记录到文件中。

首先是注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}

然后是一个用于测试的类：

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

然后是主文件：

public class TestCheck {
    public static void main(String[] args) throws IOException {
        //创建计算器对象
        Calculator c=new Calculator();
        //获取字节码文件对象
        Class cls=c.getClass();
        //获取所有的方法
        Method[] methods=cls.getMethods();

        int num=0; //出现异常的次数
        BufferedWriter bw=new BufferedWriter(new FileWriter("bug.txt"));

        //判断方法上是否有check注解
        for(Method method:methods){
            //如果有注解，则执行
            if(method.isAnnotationPresent(Check.class)){
                try{
                    method.invoke(c);
                }catch (Exception e){
                    //捕获异常，记录日志
                    //记录到文件中
                    num++;
                    bw.write(method.getName()+"方法出异常了");
                    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();
    }
}

测试：

总结：

  1. 大多数时候我们会使用注解，而不是自定义注解
  2. 注解给谁用？
    1. 编译器
    2. 给解析程序用
  3. 注解并不是程序的一部分

商业转载 请联系作者获得授权，非商业转载 请标明出处，谢谢

轻舟在过
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Junit测试方法共享成员变量的问题
Luncert的博客
01-28 3645
Junit测试方法共享成员变量的问题问题示例 问题 网上也有对这个问题的讨论，对非静态变量修改无法传递到其他测试方法中。但是现在我发现使用静态变量仍然存在一些问题。当变量不是Java常规类型时，比如是个自定义类User时，对变量引用本身的修改没有问题，而对变量成员的修改无法影响到其他测试方法，见示例。 示例 如下类： @Data @Entity @Table(name = "user") publ...
Junit & 反射
andy的博客
06-30 325
Junit介绍 Junit是Java语言编写单元测试框架，最直观的理解，就是取代java类中的main方法。Junit属于第三方工具，一般情况下需要导入jar包，而多数Java开发环境都集成了Junit。 使用方式 编写测试类，简单理解Junit可以用于取代java的main方法 在测试类方法上添加注解 @Test @Test修饰的方法要求：public...
junit,反射,
weixin_42943720的博客
10-03 343
1.Junit概述; Junit;我们需要测试一段代码,只能把所有代码进行写完之后,才可以进行测试,这样大大降低了效率以及速率.所以junit可以对一段数据进行测试.这样就可以提高速率.Junit是一个第三方的测试工具包,它是基于”注解”的一些java集成的开发环境:如:Eclipse,IDEA内部都集成了junit的工具包,我们可以直接使用. 2.junit单元测试_ junit的使用; a) ...
干货！使用Java注解和反射实现Junit4中的用例调用（附源码）
liwenxiang629的博客
04-19 289
前面我写了关于Java注解和反射的文章，大家可能会问，这些高级的知识点在实际工作中有哪些应用呢？在这里我们来结合java注解和反射的知识做一个实际案例的编写，让大家对其有更深刻的理解！直接上实例！ 实例需求 需求：模拟Junit4中的用例结构，自定义一个标签作为测试用例的标识。 在Junit4中注解@Test表示测试用例，每一个测试用例的本质就是测试类中的一个方法，即： @Test public void test() { fail("Not yet implemented"); } ..
Junit、反射、注解、JDK8新特性
UniqueZXY的博客
06-28 2687
Junit 概述 : Junit是Java语言编写的第三方单元测试框架(工具类) 作用 : 用来做“单元测试”——针对某个普通方法，可以像main()方法一样独立运行，它专门用于测试某个方法。 Junit的使用步骤 1.在模块下创建lib文件夹,把Junit的jar包复制到lib文件夹中 2.选中Junit的jar包,右键选中 add as Library,把JUnit4的jar包添加到classPath中 3.在测试方法上面写上@Test注解 4.执行测试方法 执行测试方法 1.选中方法名—>右键—
JAVA核心知识点整理——java自学资料.rar
08-03
这份"JAVA核心知识点整理——java自学资料.rar"包含了一份详细的Java学习资源，旨在帮助已经具备一定Java基础知识的开发者进一步提升技能，深入理解Java的底层机制。以下是这份资料可能涵盖的一些核心知识点和学习...
Dicoding-Java:知识库课程Java dari编码
03-13
【描述】"编码Java 知识库课程Java dari编码" 提示了本课程的核心目标——教授如何编写高质量的Java代码。这不仅涉及语法层面的讲解，也包括最佳实践、设计模式以及如何利用Java进行实际项目开发的技巧。通过此课程...
java初学者问题——能看懂,不会写怎么办?
12-21
从基础的Java语言特性，如异常处理、I/O流、集合框架，到中级的多线程、JDBC、图形界面，再到高级的反射机制和注解，每个阶段都有相应的知识点需要学习。同时，了解并实践一些常用的应用库，如Log4j、JUnit、Hutool...
java反射机制的学习心得（csdn）————程序.pdf
12-01
5. **元数据处理**：例如Java注解（Annotation），可以通过反射获取类、方法、字段上的注解信息，进行相应的处理。 6. **测试工具**：JUnit等测试框架利用反射访问私有方法，进行单元测试。 7. **插件系统**：在...
JAVA就业2023相关面试题
07-21
13. **反射与注解**：掌握Java反射机制，了解注解的使用和自定义注解的实现。 14. **NIO（New IO）与NIO.2**：理解通道（Channel）、缓冲区（Buffer）、选择器（Selector）的概念，以及非阻塞I/O的优势。 15. **...
Junit&反射
灵活的钱辰昌。
04-21 295
1.junit    @表示注解    Test表示要被测试的代码    Before表示测试前要执行的内容    After表示测试后要执行的内容 2.类的加载     类的加载（初始化）时机？  1、创建对象时  2、使用类中的静态成员  3、反射  4、如果创建了子类对象，父类也会加载  5、使用命令： java XXX 时，这个类也会进内存 3.反射
Junit，反射，注解
qq_43430343的博客
07-13 113
一、Junit junit 初始化方法：用于资源申请，所有测试方法再执行之前都会执行该方法 @Before public void init(){ 方法体 } 释放资源方法：在所有测试方法执行完毕之后，都会自动执行该方法 @After public void close(){ 方法体 } 二、反射 框架设计的灵魂。 框架：半成品软件，可以在框架的基础上进行软件开发，简化编码 反射：将类的各个组成部分封装为其他对象，这就是反射机制 将成员变量封装为Filed对象，将构造方法
Junit、反射、注解
ZHONGZEWEI的博客
02-22 267
学习目标 能够使用Junit进行单元测试 能够通过反射技术获取Class字节码对象 能够通过反射技术获取构造方法对象，并创建对象。 能够通过反射获取成员方法对象，并且调用方法。 能够通过反射获取属性对象，并且能够给对象的属性赋值和取值。 能够说出注解的作用 能够自定义注解和使用注解 能够说出常用的元注解及其作用 能够解析注解并获取注解中的数据 能够完成注解的MyTest案例 第1章 Junit...
Junit单元测试、反射
平安
08-22 1263
目录 Junit单元测试 测试分类 Junit使用：白盒测试 反射 反射概念 获取class对象的三种方式  Class对象功能 获取成员变量 获取构造方法 获取成员方法  Junit单元测试 测试分类          1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。          2. 白盒测试：需要写代码。关注程序具体的执行流程。 Juni...
Junit 反射 注解
二月
01-28 274
web 8.18 文章目录8.18Junit反射注解 Junit 属于白盒测试 使用步骤： 定义测试类：类名 ClassTest、包名 package.test 定义测试方法：void testMethond() @Test并导包 注：junit测试建议参考如上定义方式 判断结果：断言 Assert @Before、@After 反射 反射机制：将类的各个组成部分封装成对象 获取一个Class对象的方式： 3个方法：加载类进内存 1. Class.forName(" 类全名
Junit+反射+注解
sgw101的博客
10-01 489
文章目录1.Junit单元测试1.1 Junit介绍1.2 Junit的使用1.3 常用注解2.反射：框架设计的灵魂2.1 获取Class对象的方式2.2 获取Class对象的信息2.2.1 Class对象相关方法2.3 Constructor类2.3.1 Class类中与Constructor相关方法2.3.2 Constructor类中常用方法2.4 Method类2.4.1 Class类中与...
Junit&反射&注解
weixin_43369516的博客
08-24 74
Junit单元测试： * 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 * Junit使用：白盒测试 * 步骤： 1. 定义一个测试类(测试用例) * 建议： * 测试类名：被测试的类名Test CalculatorTest * 包名：xxx.xxx.xx.test
Junit_反射_注解
最新发布
hillo_的博客
09-06 56
junit--导入包--@Test，允许运行不用main反射就是拆分类，建立框架只对类操作单元测试单元测试就是针对最小的功能单元(方法)，编写测试代码对该功能进行正确性测试。当前测试方法存在问题：只能编写main方法，并在main方法中再去调用其他方法进行测试。Junit单元测试框架JUnit是使用Java语言实现的单元测试框架，它是第三方公司开源出来的，很多开发工具已经集成了Junit框架，比如IDEA。优点：编写的测试代码很灵活，可以指某个测试方法执行测试，也支持一键完成自动化测试。
《Java编程思想》第三版——深入理解Java的世界
9. **枚举和注解**：讨论Java的枚举类型及其在代码中的应用，以及注解（Annotation）的作用和自定义注解的创建。 10. **Java内存管理**：简述Java的垃圾回收机制，以及如何避免内存泄漏和理解对象生命周期。 11. *...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

轻舟在过

您的支持是我创作的最大动力~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值