Java反射

最新推荐文章于 2024-09-30 10:36:33 发布
最新推荐文章于 2024-09-30 10:36:33 发布
阅读量737 收藏 15
点赞数 6
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44284271/article/details/136343861
版权

反射概述

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

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

Class类

对象反射以后可以得到的信息：某个类的属性，方法和构造器，某个类到底实现了那些接口。

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定的某个结构的有关信息。

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

哪些类型有Class对象

  1. class:外部类。成员（成员内部类，静态内部类），局部内部类，匿名内部类
  2. interface：接口
  3. []：数组
  4. enum：枚举
  5. annotation：注解
  6. primitive type：基本数据类型
  7. void

类的初始化

类的主动引用（一定发生类的初始化）：

  1. 虚拟机启动，首先初始化main方法所在类
  2. new一个类对象
  3. 调用类的静态成员（除了final常量）和静态方法
  4. 调用java.lang.reflect包的方法对类进行反射调用
  5. 当初始化一个类，其父类没有被初始化，先初始化它的父类

类的被动引用（不会发生类的初始化）：

  1. 当访问一个静态域时，只有真正声明这个域才会被初始化，如：当通过子类引用父类的静态变量，不会导致子类初始化
  2. 通过数组定义类的引用，不会触发此类初始化
  3. 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类常量池中）

通过反射获得类的结构

package com.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1=Class.forName("com.reflection.Person");

        System.out.println(c1.getName());//获取包和类名
        System.out.println(c1.getSimpleName());//获取类名
        System.out.println("==================");

        Field[] fields=c1.getFields();//获取public属性
        for (Field field:fields){
            System.out.println(field);
        }

        Field[] fields1=c1.getDeclaredFields();//获取所有属性
        for (Field field:fields1){
            System.out.println(field);
        }

        Field field=c1.getDeclaredField("name");//获取指定属性
        System.out.println(field);
        System.out.println("==================");

        Method[] methods=c1.getMethods();//获取类及其父类的public方法
        for(Method method:methods){
            System.out.println("获得public的："+method);
        }
        Method[] methods1=c1.getDeclaredMethods();//获取本类的所有方法（private，public，protected）
        for (Method method:methods1){
            System.out.println(method);
        }
        Method method=c1.getMethod("setName", String.class);//获取指定的方法 后面的参数为所需的值的class 便于区分重载的方法
        System.out.println(method);
        System.out.println("==================");

        Constructor[] constructors=c1.getConstructors();//获取所有的public构造方法
        for (Constructor constructor:constructors){
            System.out.println(constructor);
        }
        Constructor[] constructors1=c1.getDeclaredConstructors();//获取所有的全部构造方法
        for (Constructor constructor:constructors1){
            System.out.println(constructor);
        }
        Constructor constructor=c1.getConstructor(String.class,int.class,int.class);//获取指定的构造器
        System.out.println(constructor);
    }
}

通过反射 创建对象 调用方法 设置属性

package com.reflection;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1=Class.forName("com.reflection.Person");
        Person person= (Person) c1.newInstance();//调用无参构造函数 已经过时
        System.out.println(person);

        Person person1=(Person) c1.getDeclaredConstructor().newInstance();//调用无参构造
        System.out.println(person1);

        //调用有参构造函数并且赋值
        Person person2=(Person) c1.getDeclaredConstructor(String.class,int.class,int.class).newInstance("陈旭",18,001);
        System.out.println(person2);

        //反射调用方法
        Person person3=(Person) c1.getDeclaredConstructor().newInstance();
        //反射获取方法
        Method setName=c1.getMethod("setName", String.class);
        //invoke（）激活方法，第一个参数为方法作用的对象，第二个为方法参数
        setName.invoke(person3,"晨晨");
        System.out.println(person3);

        //反射调用属性
        Person person4=(Person) c1.getDeclaredConstructor().newInstance();
        Field field=c1.getDeclaredField("name");
        //设置属性 第一个为该属性的对象 第二个为属性的值
        //如果属性是private的无法直接访问 需要关闭权限检测
        //field.setAccessible(true)关闭安全检测
        field.setAccessible(true);
        field.set(person4,"花花");
        System.out.println(person4);
    }
}

结果：

"D:\Program Files (x86)\jdk13\bin\java.exe" --enable-preview "-javaagent:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\lib\idea_rt.jar=55644:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\IDEA\JavaSE\out\production\基础语法 com.reflection.Test6
Person{name='null', age=0, id=0}
Person{name='null', age=0, id=0}
Person{name='陈旭', age=18, id=1}
Person{name='晨晨', age=0, id=0}
Person{name='花花', age=0, id=0}

Process finished with exit code 0

附录：setAccessible

Method和Field，Constructor对象都有setAccessible()方法

setAccessible()方法是用于启动和禁用访问安全检查的开关

参数值为true则指示反射的对象在使用时应该取消Java语言的访问检查

  1. 提高反射效率，若代码中必须使用反射，且该代码句使用频率较高 设为true
  2. 使原本无法访问的私有成员可以被访问

参数值false则指示反射的对象应该实施Java语言访问检查

性能对比分析

package com.reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test7 {
    public  static void test1(){
        Person person=new Person();
        long startTime=System.currentTimeMillis();
        for (int i = 0; i <1000000000 ; i++) {
            person.getName();
        }
        long endTime=System.currentTimeMillis();
        System.out.println("普通方式："+(endTime-startTime)+"ms");
    }
    public  static void test2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c1=Class.forName("com.reflection.Person");
        Person person=(Person) c1.getDeclaredConstructor().newInstance();
        Method getName=c1.getMethod("getName",null);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i <1000000000 ; i++) {
            getName.invoke(person,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("反射方式："+(endTime-startTime)+"ms");
    }
    public  static void test3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c1=Class.forName("com.reflection.Person");
        Person person=(Person) c1.getDeclaredConstructor().newInstance();
        Method getName=c1.getMethod("getName",null);
        getName.setAccessible(true);
        long startTime=System.currentTimeMillis();
        for (int i = 0; i <1000000000 ; i++) {
            getName.invoke(person,null);
        }
        long endTime=System.currentTimeMillis();
        System.out.println("去除检测的反射方式："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        test1();
        test2();
        test3();
    }
}

结果：

"D:\Program Files (x86)\jdk13\bin\java.exe" --enable-preview "-javaagent:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\lib\idea_rt.jar=55926:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\IDEA\JavaSE\out\production\基础语法 com.reflection.Test7
普通方式：16ms
反射方式：2319ms
去除检测的反射方式：1118ms

Process finished with exit code 0

通过反射获取注解

package com.reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class Test8 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1=Class.forName("com.reflection.Person3");
        //通过反射获取类注解
        Annotation[] annotations=c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取类注解的值
        //注解强行转化为MyAnnotation类型
        MyAnnotation annotation=(MyAnnotation) c1.getAnnotation(MyAnnotation.class);
        System.out.println(annotation.value());

        //通过反射获取属性注解
        Field f=c1.getDeclaredField("name");
        MyAnnotation1 myAnnotation1=f.getAnnotation(MyAnnotation1.class);
        System.out.println(myAnnotation1.name());
        System.out.println(myAnnotation1.type());
        System.out.println(myAnnotation1.length());
    }
}
@MyAnnotation("person_db")
class Person3{
    @MyAnnotation1(name = "Name",type = "String",length = 100)
    private String name;
    @MyAnnotation1(name = "Age",type = "int",length = 10)
    private int age;
    @MyAnnotation1(name = "id",type = "int",length = 10)
    private int id;

    public Person3() {
    }

    public Person3(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface  MyAnnotation{
    public String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface  MyAnnotation1{
    public String name();
    public String type();
    public int length();
}

结果：

"D:\Program Files (x86)\jdk13\bin\java.exe" --enable-preview "-javaagent:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\lib\idea_rt.jar=56322:D:\IDEA\IntelliJ IDEA Community Edition 2020.1.3\bin" -Dfile.encoding=UTF-8 -classpath D:\IDEA\JavaSE\out\production\基础语法 com.reflection.Test8
@com.reflection.MyAnnotation(value="person_db")
person_db
Name
String
100

Process finished with exit code 0
KoreyChan...
关注
Java反射技术详解
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
java 反射
喵酱
03-29 2379
参考资料： Java反射技术详解_黄林晴的博客-CSDN博客_java反射 Java高级篇（四）——反射 - JAdam - 博客园 一、什么是反射 　　反射就是把Java类中的各个成分映射成一个个的Java对象。 即在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能调用它的任意一个方法和属性。 这种动态获取信息及动态调用对象方法的功能叫Java的反射机制。 1. 反射机制的功能 　　Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属
Java反射（通俗易懂）
qq_51515673的博客
05-17 10万+
目录 1、反射介绍 2、反射API 2.1 获取类对应的字节码的对象（三种） 2.2 常用方法 3、反射的应用 3.1 创建 : 测试物料类 3.2 获取类对象 3.3 获取成员变量 3.4 通过字节码对象获取类的成员方法 3.5 通过字节码对象获取类的构造方法 4、创建对象 1、反射介绍 Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，...
Java反射的用途
果酱 の 博客
07-20 4967
Java反射是一项强大的特性，它为我们提供了在运行时获取和操作类的信息的能力。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至实现动态代理。Java反射是一种强大的特性，它允许我们在运行时获取和操作类的信息。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至可以实现动态代理。通过动态代理，我们可以在运行时生成代理对象，并在代理对象中添加额外的逻辑。在许多情况下，我们需要在运行时获取类的信息，例如类的名称、修饰符、父类、接口等。通过反射，我们可以访问和修改对象的字段。
Java反射（超详细！）
热门推荐
一只小菜鸡
10-02 13万+
1、反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 2、反射机制的相关类在哪个包下？ java.lang.reflect.*; 3、反射机制相关的重要的类有哪些？ 类 含义 java.lang.Class 代表整个字节码。代表一个类型，代表整个类。 java.lang.reflect.Method 代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Con
java反射调用get/set方法
吴名氏的博客
06-14 9万+
java反射调用get/set方法
Java 反射
卓原的进化之旅
11-15 1855
JAVA反射机制 JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制 功能 1、获得某个对象的属...
JAVA反射
Dgs的博客
06-30 1307
JDK 反射使用
Java反射介绍
派大星的博客
09-21 1506
总结介绍java反射基本知识，希望对java安全初学者有所帮助。
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
Java反射技术原理与用法实例分析
08-19
Java反射技术原理与用法实例分析 Java反射技术是Java语言中的一种动态语言技术，能够在运行时解析外部对象的信息。通过反射技术，可以动态地获取类以及类中的成员，并可以调用该类成员。 产生反射技术的需求： 在...
工厂模式的介绍及实现
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
java将word转pdf
紫月7575的博客
09-30 245
java将word转pdf
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 298
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 379
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
深入理解Java反射机制
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。这一机制使得Java具有高度的灵活性和强大的功能，尤其在框架开发、插件系统、元数据处理等方面发挥着关键作用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值