程序员经验分享-hwhale

Java反射(Reflex)机制

2023-05-16

反射概述

Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射
在这里插入图片描述

优缺点

  • 优点：可以实现动态创建对象和编译，体现很大的灵活性。
  • 缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

反射相关API

  1. java.lang.Class：代表一个类
  2. java.lang.reflect.Method：代表类的方法
  3. java.lang.reflect.Field：代表类的成员变量
  4. java.lang.reflect.Constructor：代表类的构造器

反射机制提供的功能

  • 在运行时处理注解
  • 在运行时获取泛型
  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 生成动态代理

反射相关知识点

Class类

  • 在Object类中定义了getClass方法，此方法将被所有的子类继承。
    在这里插入图片描述

  • 这个方法返回值的类型是一个Class类，这个类是Java反射的源头。

  • 实际上所谓的反射：从程序的运行结果来看，就是可以通过对象反射求出类的名称。

Class类特点

● Class本身也是一个类。
● Class对象只能由系统建立对象。
● 一个加载的类在JVM中只会有一个Class实例。
● 一个Class对象对应的是一个加载到JVM中的一个.class文件。
● 每个类的实例都会记得自己是由哪个Class实例所生成。
● 通过Class可以完整地得到一个类中的所有被加载的结构。
● Class类是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得相应的Class对象。

Class类的常用方法

在这里插入图片描述

获取Class类的几种方式

  1. 若已知具体的类，可以通过类的class属性获取，该方法最为安全可靠，程序性能最高。 Class clazz = Person.class;
  2. 若已知某个类的实例，调用该实例(对象)的getClass方法获取Class对象。 Class clazz = person.getClass();
  3. 若一致一个类的全限定类名，且该类的类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException异常。
    Class clazz = Class.forName("com.demo.entity.User");
  4. 内置基本数据类型可以直接用类名.Type获得。
  5. 还可以利用ClassLoader获得。
    代码示例
public class ClassCreate {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是：" + person.name);

        //方式一：通过对象获得
        Class<? extends Person> c1 = person.getClass();
        System.out.println(c1.hashCode());

        //方式二：forname获得
        Class<?> c2 = Class.forName("bjpowernode.annotationAndReflex.Student");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得
        Class<Student> c3 = Student.class;
        System.out.println(c3.hashCode());

        //方式四,基本内置类型的包装类都有一个Type属性
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4);

        //获得父类类型
        Class<?> c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

class Person{
    String name;
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public Person() {}
    public Person(String name) {this.name = name;}
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student extends Person{
    public Student(){
        this.name="学生";
    }
}
class Teacher extends Person{
    public Teacher(){
        this.name="老师";
    }
}

哪些类型可以有class对象

在这里插入图片描述
代码示例

public class ClassType {
    public static void main(String[] args) {
        Class c1 = Object.class; //类
        Class c2 = Comparable.class; //接口
        Class c3 = String[].class; //一维数组
        Class c4 = int[][].class; //二维数组
        Class c5 = Override.class; //注解
        Class c6 = ElementType.class; //枚举
        Class c7 = Integer.class; //基本数据类型
        Class c8 = void.class; //void，空类型
        Class c9 = Class.class; //class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一样,就是同一个Class
        int[] a = new int[10];
        int[] b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

在这里插入图片描述
在这里插入图片描述

有了Class对象，我们可以做什么?

  1. 创建类的对象：调用Class对象的newlnstance()方法。
    ○ 类必须有一个无参的构造器。
    ○ 类的构造器的访问权限需要足够。
  2. 没有无参构造器，是否可以创建对象？可以
    ○ 通过CLass类的getDeclaredConstructor(Class…parameter)取得本类的指定形参类型的构造器。
    ○ 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
    ○ 通过Constructor实例化对象。

代码示例

public class Test01 {
    public static void main(String[] args) throws Exception {
        // 获得Class对象
        Class<?> c1 = Class.forName("bjpowernode.annotationAndReflex.User");

        // 构造一个对象
        //User user = (User) c1.newInstance();//本质是调用了类的无参构造器

        // 通过构造器创建对象
        //Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        //User user = (User) constructor.newInstance("张三", 001, 18); //有参构造

        // 通过反射调用普通方法
        User user = (User) c1.newInstance();
        // 通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        // invoke()；激活，第一个参数传递对象，第二个参数方法的值
        setName.invoke(user,"张三");
        System.out.println(user.getName());

        //通过反射操作属性
        User u = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        // 不能直接操作私有属性，需要关闭程序的安全检测，属性或方法的setAccessible值设为true
        name.setAccessible(true);
        name.set(u,"三儿");
        System.out.println(u.getName());
    }
}

调用指定的方法

通过反射，调用类中的方法，通过Method类完成。
1、通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2、之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
在这里插入图片描述
Object invoke(Object obj, Object … args)

Object对应原方法的返回值，若原方法无返回值，此时返回null
若原方法若为静态方法，此时形参Object obj可为null
若原方法形参列表为空，则Object[] args为null
若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

SetAccessible()方法
在这里插入图片描述

性能分析 

public class Performance {
    //普通方式调用
    public static void test01() {
        User user = new User();
        
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式执行10亿次:" + (endTime - startTime) + "ms");
    }
    
    //反射方式调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        
        Method getName = c1.getDeclaredMethod("getName", null);
        
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式执行10亿次:" + (endTime - startTime) + "ms");
    }
    
    //反射方式调用,关闭检测
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);
        
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式执行10亿次,关闭检测:" + (endTime - startTime) + "ms");
   }
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test01(); //9ms
        test02(); //5699ms
        test03(); //1959ms
    }
}

反射操作泛型

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成,所有和泛型有关的类型全部擦除。
为了通过反射操作这些类型，Java新增了ParameterizedType , GenericArrayType ,TypeVariable和 WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.

ParameterizedType:表示一种参数化类型,比如Collection< String>,简单理解就是带<>的参数(带泛型)
GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable:是各种类型变量的公共父接口
WildcardType:代表一种通配符类型表达式

通过反射获取泛型

public class GenericParadigm {
    public void test01(Map<String, User> map, List<User>list) {
        System.out.println("test01");
    }
    public Map<String, User> test02() {
        System.out.println("test02");
        return null;
    }
    public static void main(String[] args) throws NoSuchMethodException {
        //根据反射获取方法
        Method method = Demo13_Generic.class.getMethod("test01", Map.class, List.class);
        
        //获取方法的参数
        Type[] genericExceptionTypes = method.getGenericParameterTypes();
        for (Type genericExceptionType : genericExceptionTypes) {
            System.out.println("#" + genericExceptionType);
            //判断参数是否是参数化类型
            if (genericExceptionType instanceof ParameterizedType){
                //强转后获取参数化类型
                Type[] actualTypeArguments = ((ParameterizedType) genericExceptionType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        
        System.out.println("====================================");
        Method method2 = Demo13_Generic.class.getMethod("test02",null);
        
        //获取返回值的类型
        Type genericReturnType = method2.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

反射操作注解

getAnnotations、getAnnotation
了解什么是ORM？ Object relationship Mapping -->对象关系映射
需求：利用注解和反射完成类和表结构的映射关系

public class Test_ORM {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("cn.doris.reflection.Student2");
        
        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        
        //获得注解value
        TableDoris tableDoris = (TableDoris) c1.getAnnotation(TableDoris.class);
        String value = tableDoris.value();
        System.out.println(value);
        
        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FiledDoris annotation = name.getAnnotation(FiledDoris.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}
@TableDoris("db_student")
class Student2 {
    @FiledDoris(columnName = "db_id", type = "int", length = 10)
    private int id;
    @FiledDoris(columnName = "db_age", type = "int", length = 3)
    private int age;
    @FiledDoris(columnName = "db_name", type = "varchar", length = 200)
    private String name;
    public Student2() {
    }
    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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;
    }
}
//类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableDoris {
    String value();
}
//属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledDoris {
    String columnName();
    String type();
    int length();
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

Reflex

Java反射(Reflex)机制 的相关文章

随机推荐

  • LeetCode438：找到字符串中所有字母异位词

    要求 给定两个字符串 s 和 p xff0c 找到 s 中所有 p 的 异位词 的子串 xff0c 返回这些子串的起始索引 不考虑答案输出的顺序 异位词 指由相同字母重排列形成的字符串 xff08 包括相同的字符串 xff09 思路 方法一

  • LeetCode448：找到所有数组中消失的数字

    要求 给你一个含 n 个整数的数组 nums xff0c 其中 nums i 在区间 1 n 内 请你找出所有在 1 n 范围内但没有出现在 nums 中的数字 xff0c 并以数组的形式返回结果 思路 可以把数组中的元素与索引建立一一对应

  • LeetCode461：汉明距离

    要求 两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目 给你两个整数 x 和 y xff0c 计算并返回它们之间的汉明距离 思路 方法一 xff1a 使用内置位计数功能 大多数编程语言都内置了计算二进制表达中 1 的数

  • LeetCode494：目标和

    要求 给你一个整数数组 nums 和一个整数 target 向数组中的每个整数前添加 43 或 xff0c 然后串联起所有整数 xff0c 可以构造一个 表达式 xff1a 例如 xff0c nums 61 2 1 xff0c 可以在 2

  • Java中Integer.parseInt()方法最全解析

    介绍 是Integer类中提供的一个静态方法 用于将传入的string类型字符串根据要求转为相应进制的int值 如果没有要求进制则按10进制计算 xff0c 属于java lang包的 xff1b 使用讲解 1 parseInt Strin

  • LeetCode538：把二叉搜索树转换为累加树

    要求 给出二叉 搜索 树的根节点 xff0c 该树的节点值各不相同 xff0c 请你将其转换为累加树 xff08 Greater Sum Tree xff09 xff0c 使每个节点 node 的新值等于原树中大于或等于 node val

  • python 最小堆类型： heapq

    目录 1 heapq 的常用方法 2 几个例子 a 最小堆的创建以及增删 b 如何使用 heapq 创建最大堆 c 获取第 k 大 第 k 小数据 d 列表中的元素是元组 heapq 是 python 的一个库 xff0c 用一个列表来维护

  • LeetCode543：二叉树的直径

    要求 给定一棵二叉树 xff0c 你需要计算它的直径长度 一棵二叉树的直径长度是任意两个结点路径长度中的最大值 这条路径可能穿过也可能不穿过根结点 题目解析 这里返回的是 xff1a 两结点之间的路径长度是以它们之间边的数目表示 最大的直径

  • LeetCode560：和为K的子数组

    要求 给你一个整数数组 nums 和一个整数 k xff0c 请你统计并返回 该数组中和为 k 的连续子数组的个数 思路 方法一 xff1a 暴力解 先固定左边界 xff0c 再去枚举右边 span class token keyword

  • LeetCode581：最短无序连续子数组

    要求 给你一个整数数组 nums xff0c 你需要找出一个 连续子数组 xff0c 如果对这个子数组进行升序排序 xff0c 那么整个数组都会变为升序排序 请你找出符合题意的 最短 子数组 xff0c 并输出它的长度 思路 我们可以假设把

  • LeetCoed617：合并二叉树

    要求 给你两棵二叉树 xff1a root1 和 root2 想象一下 xff0c 当你将其中一棵覆盖到另一棵之上时 xff0c 两棵树上的一些节点将会重叠 xff08 而另一些不会 xff09 你需要将这两棵树合并成一棵新二叉树 合并的规

  • LeetCode621：任务调度器

    要求 给你一个用字符数组 tasks 表示的 CPU 需要执行的任务列表 其中每个字母表示一种不同种类的任务 任务可以以任意顺序执行 xff0c 并且每个任务都可以在 1 个单位时间内执行完 在任何一个单位时间 xff0c CPU 可以完成

  • LeetCode647：回文子串

    要求 给你一个字符串 s xff0c 请你统计并返回这个字符串中 回文子串 的数目 回文字符串 是正着读和倒过来读一样的字符串 子字符串 是字符串中的由连续字符组成的一个序列 具有不同开始位置或结束位置的子串 xff0c 即使是由相同的字符

  • LeetCode739：每日温度

    要求 给定一个整数数组 temperatures xff0c 表示每天的温度 xff0c 返回一个数组 answer xff0c 其中 answer i 是指对于第 i 天 xff0c 下一个更高温度出现在几天后 如果气温在这之后都不会升高

  • 八大排序算法

    介绍 排序也称排序算法 Sort Algorithm xff0c 排序是将一组数据 xff0c 依指定的顺序进行排列的过程 排序分类 1 内部排序 指将需要处理的所有数据都加载到内部存储器 内存 中进行排序 2 外部排序法 数据量过大 xf

  • 时间复杂度和空间复杂度详解及排序算法复杂度

    时间复杂度 度量一个程序 算法 执行时间的两种方法 1 事前估算法 通过分析某个算法的时间复杂度来判断哪个算法更优 2 事后统计法 这种方法可行 xff0c 但是有两个问题 xff1a 一是要想对设计的算法的运行性能进行评测 xff0c 需

  • Java反编译工具JAD的安装与简单使用

    jad介绍 jad 是一个使用非常广泛的 Java 反编译工具 可以将java编译后的class文件反编译成对应的java文件 下载地址 JAD下载地址 xff0c 点击跳转https varaneckas com jad 按照自己的需求

  • python Counter() 函数

    目录 1 以统计列表中的词频为例 2 寻找出现次数最多的 k 个数 刷 leetcode 时发现了可以很方便地统计词频的 Counter 函数 xff0c 有了这个函数就不用手动的使用 for 循环来手动统计词频啦 xff01 Counte

  • C++11 新特性简介

    1 auto auto是旧关键字 xff0c 在C 43 43 11之前 xff0c auto用来声明自动变量 xff0c 表明变量存储在栈 xff0c 很少使用 在C 43 43 11中被赋予了新的含义和作用 xff0c 用于类型推断 a

  • Java反射(Reflex)机制

    反射概述 Reflection 反射 是Java被视为动态语言的关键 xff0c 反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息 xff0c 并能直接操作任意对象的内部属性及方法 加载完类之后 xff0c 在

热门标签