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对象功能:
- 获取功能:
-
获取成员变量们
-
Field[] getFields() :获取所有public修饰的成员变量
-
Field getField(String name) 获取指定名称的 public修饰的成员变量
-
Field[] getDeclaredFields() 获取所有的成员变量,不考虑修饰符
-
Field getDeclaredField(String name)
-
-
获取构造方法们
-
Constructor<?>[] getConstructors()
-
Constructor getConstructor(类<?>… parameterTypes)
-
Constructor getDeclaredConstructor(类<?>… parameterTypes)
-
Constructor<?>[] getDeclaredConstructors()
-
-
获取成员方法们:
-
Method[] getMethods()
-
Method getMethod(String name, 类<?>… parameterTypes)
-
Method[] getDeclaredMethods()
-
Method getDeclaredMethod(String name, 类<?>… parameterTypes)
-
-
获取全类名
- 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. 一个反射案例
-
需求:一个框架,可以在不改动框架代码的前提下,可以创建任意类的对象,执行对象的方法
-
思路
- 定义一个配置文件(存放类名,方法名)
- 定义一个框架类,将配置文件加载到框架中
- 将配置文件中的类加载到内存
- 创建类的对象
- 执行方法
示例
- 框架
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:可以作用在成员变量上
- **ElementType取值 **
- @Retention:描述注解被保留的阶段
- @Retention(RetentionPolicy.RUNTIME):当前被描述的注解,会保留到class字节码文件中,并被jvm读取
- @Documented:描述注解是否导出doc文档
- @Inherited:描述注解是否被子类继承
- @Target:描述注解能够作用的位置
@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)
- 获取指定的注解
-
getAnnotation(Class)
//其实就是在内存中生成了一个该注解接口的子类实现对象public class ProImpl implements Pro{ public String className(){ return "cn.itcast.annotation.Demo1"; } public String methodName(){ return "show"; } }
-
- 调用注解中的抽象方法获取配置的属性值
- 获取指定的注解
示例
- 框架类
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();
}
}
- 运行测试框架的效果图