Java8-反射与注解

时间 2020-05-12

标签 java8 java 反射注解栏目 Java 繁體版

原文原文链接

Java8-反射与注解

反射：框架设计的灵魂

框架：半成品软件。能够在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其余对象，这就是反射机制
好处：
    1. 能够在程序运行过程当中，操做这些对象。
    2. 能够解耦，提升程序的可扩展性。

Java代码的三个阶段java

获取class对象的方式

1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
    多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：经过类名的属性class获取
    多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
    多用于对象的获取字节码的方式

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

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName("全类名")
        Class cls1 = Class.forName("domain.Person");
        System.out.println(cls1);

        //2.类名.class
        Class<Person> cls2 = Person.class;
        System.out.println(cls2);

        //3.对象.getClass()
        Person person = new Person();
        Class<? extends Person> cls3 = person.getClass();

        //== 比较三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true
    }
}

Class对象功能

1. 获取成员变量们
    Field[] getFields() ：获取全部public修饰的成员变量
    Field getField(String name)   获取指定名称的 public修饰的成员变量

    Field[] getDeclaredFields()  获取全部的成员变量，不考虑修饰符
    Field getDeclaredField(String name)  

2. 获取构造方法们
    Constructor<?>[] getConstructors()  
    Constructor<T> getConstructor(类<?>... parameterTypes)  

    Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
    Constructor<?>[] getDeclaredConstructors()  

3. 获取成员方法们：
    Method[] getMethods()  
    Method getMethod(String name, 类<?>... parameterTypes)  

    Method[] getDeclaredMethods()  
    Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

4. 获取全类名    
    String getName()

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {

        //0.获取Person的Class对象
        Class personClass = Person.class;
        
        //1.Field[] getFields()获取全部public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("------------");
        
        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

        System.out.println("===================");

        //Field[] getDeclaredFields()：获取全部的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
        
    }
}


public class ReflectDemo04 {
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class对象
        Class personClass = Person.class;
       
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);


        Method eat_method2 = personClass.getMethod("eat", String.class);
        //执行方法
        eat_method2.invoke(p,"饭");

        System.out.println("-----------------");

        //获取全部public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
            //method.setAccessible(true);
        }

        //获取类名
        String className = personClass.getName();
        System.out.println(className);//cn.itcast.domain.Person

    }
}

Filed成员变量

Field：成员变量
操做：
1. 设置值
    void set(Object obj, Object value)  
2. 获取值
    get(Object obj) 

3. 忽略访问权限修饰符的安全检查
    setAccessible(true):暴力反射

Contructor构造方法

Constructor:构造方法
建立对象：
    T newInstance(Object... initargs)  
    Class对象的newInstance方法；若是使用空参数构造方法建立对象，操做能够简化：

方法对象

Method：方法对象
执行方法：
    Object invoke(Object obj, Object... args)  
获取方法名称：
    String getName:获取方法名

案例

需求：写一个"框架"，不能改变该类的任何代码的前提下，能够帮咱们建立任意类的对象，而且执行其中任意方法
实现：
    1. 配置文件
    2. 反射
        步骤：
        1. 将须要建立的对象的全类名和须要执行的方法定义在配置文件中
        2. 在程序中加载读取配置文件
        3. 使用反射技术来加载类文件进内存
        4. 建立对象
        5. 执行方法

package reflect;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @Author wangjiefang
 * @Date 16:47 2020/5/11
 * @Description
 **/
public class Test {
    public static void main(String[] args) throws Exception {
        //能够建立任意类的对象，能够执行任意方法

        /*
            前提：不能改变该类的任何代码。能够建立任意类的对象，能够执行任意方法
         */
      /*  Person p = new Person();
        p.eat();*/
/*
        Student stu = new Student();
        stu.sleep();*/

        //1.加载配置文件
        //1.1建立Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = Test.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

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


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

    }
}

注解：

概念

概念：说明程序的。给计算机看的
注释：用文字描述程序的。给程序员看的

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

分类

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

预约义注解

JDK中预约义的一些注解
    @Override    ：检测被该注解标注的方法是不是继承自父类(接口)的
    @Deprecated：该注解标注的内容，表示已过期
    @SuppressWarnings：压制警告
        通常传递参数all  @SuppressWarnings("all")

自定义注解

格式：
元注解
public @interface 注解名称{
    属性列表;
}

本质：注解本质上就是一个接口，该接口默认继承Annotation接口
    public interface MyAnno extends java.lang.annotation.Annotation {}

属性：接口中的抽象方法
    要求：
    1. 属性的返回值类型有下列取值
        基本数据类型、String、枚举、注解、以上类型的数组

    2. 定义了属性，在使用时须要给属性赋值
        1. 若是定义属性时，使用default关键字给属性默认初始化值，则使用注解时，能够不进行属性的赋值。
        2. 若是只有一个属性须要赋值，而且属性的名称是value，则value能够省略，直接定义值便可。
        3. 数组赋值时，值使用{}包裹。若是数组中只有一个值，则{}能够省略
    
元注解：用于描述注解的注解
    @Target：描述注解可以做用的位置
        ElementType取值：
            TYPE：能够做用于类上
            METHOD：能够做用于方法上
            FIELD：能够做用于成员变量上
    @Retention：描述注解被保留的阶段
        @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
        @Documented：描述注解是否被抽取到api文档中
        @Inherited：描述注解是否被子类继承

获取注解中定义的属性

在程序使用(解析)注解：获取注解中定义的属性值
1. 获取注解定义的位置的对象  （Class，Method,Field）
2. 获取指定的注解
    getAnnotation(Class)
    //其实就是在内存中生成了一个该注解接口的子类实现对象
3. 调用注解中的抽象方法获取配置的属性值

案例

简单的测试框架
小结：
    1. 之后大多数时候，咱们会使用注解，而不是自定义注解
    2. 注解给谁用？
        1. 编译器
        2. 给解析程序用
    3. 注解不是程序的一部分，能够理解为注解就是一个标签

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

public class Calculator {
    //加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        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 void show(){
        System.out.println("永无bug...");
    }
}


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

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

        for (Method method : methods) {
            //4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                //5.有，执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常
                    //记录到文件中
                    number ++;
                    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("本次测试一共出现 "+number+" 次异常");
        bw.flush();
        bw.close();
    }
}