Java反射机制

最新推荐文章于 2022-11-10 11:27:16 发布
最新推荐文章于 2022-11-10 11:27:16 发布
阅读量100 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeremyl/article/details/112548130
版权
  • java反射机制概述
  • 理解Class类并获取Class实例
  • 类的加载与ClassLoader的理解
  • 创建运行时类的对象
  • 获取运行时类的完整结构
  • 调用运行时类的指定结构
  • 反射的应用：动态代理

1. java反射机制概述

1.1 反射理解

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

框架=反射+注解+设计模式

1.2 反射的动态性

 //体会反射的动态性
    @Test
    public void test2(){
        int num=new Random().nextInt(3);
        String classPath="";
        switch (num){
            case 0:
                classPath="java.util.Date";
                break;
            case 1:
                classPath="java.lang.Object";
                break;
            case 2:
                classPath="java.lang.String";
                break;
        }

        Object obj= null;
        try {
            obj = getInstance(classPath);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        System.out.println(obj);
    }

    /*
    创建一个指定类的对象。
    classPath: 指定类的全类名
     */
    public Object getInstance(String classPath) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }

1.3 反射机制能提供的功能

在这里插入图片描述

1.4 相关API

java.lang.Class：反射的源头
java.lang.reflect.Method
java.lang.reflect.Field
java.lang.reflect.Constructor

2. Class类实例

2.1 Class类的理解

  1. 类的加载过程：
    程序经过javac.exe命令后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释编译运行。
    相当于将某个字节码文件加载到内存中。此过程称为类的加载。
    加载到内存中的类称为运行时类，此运行时类，就作为Class的一个实例
  2. 换句话说，Class的实例就对应着一个运行时类
  3. 加载到内存中的运行时类，会缓存一定时间。在此时间内，我们可以通过不同方式来获取运行时类

2.2 获取Class实例的几种方式

//获取Class的实例的方式（掌握前三）
    @Test
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性
        Class clazz1=Person.class;
        System.out.println(clazz1);

        //方式二：通过运行时类的对象
        Person p1=new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.java.Person");
        System.out.println(clazz3);

        System.out.println(clazz1==clazz2);
        System.out.println(clazz1==clazz3);
    }

2.3 创建类的对象的方式

  1. new+构造器
  2. 要创建Xxx类的对象，可以考虑：Xxx，Xxxs，XxxFactory，XxxBuilder类中是否有静态方法存在。可以调用静态方法创建对象。
  3. 通过反射

2.4 Class实例可以是

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

3. ClassLoader

3.1 类的加载过程

在这里插入图片描述

3.2 Java类编译、运行的执行过程

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

3.3 类加载器的分类

在这里插入图片描述

3.4 使用ClassLoader加载src目录下的配置文件

/*
    Properties: 用来读取配置文件
     */
    @Test
    public void test2() throws IOException {
        Properties pros=new Properties();
        //此时的文件默认在当前的module下
        //读取配置文件的方式一：
//        FileInputStream fis=new FileInputStream("jdbc.properties");
//        pros.load(fis);

        //读取配置文件的方式二：使用ClassLoader
        //配置文件默认识别为：当前module的src下
        ClassLoader classLoader=ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user= pros.getProperty("user");
        String password=pros.getProperty("password");
        System.out.println(user);
        System.out.println(password);
    }

4. 反射应用一：创建运行时类对象

    newInstance(): 调用此方法，创建对应运行时类的对象。内部调用了运行时类的构造器

    要想此方法正常的创建运行时类的对象，要求：
    1. 运行时类必须提供空参构造器
    2. 空参构造器的权限足够。通常设成public

    在javabean中要求提供一个public的空参构造器。原因：
    1. 便于通过反射，创建运行时类的对象
    2. 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器

@Test
    public void test1() throws IllegalAccessException, InstantiationException {

        Class clazz=Person.class;
        Person obj= (Person) clazz.newInstance();
        System.out.println(obj);
    }

5. 反射应用二：获取运行时类的完整结构

@Test
    public void test1(){
        Class clazz= Person.class;

        //获取属性结构
        //getFields(): 获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field f:fields){
            System.out.println(f);
        }

        //getDeclaredFields(): 获取当前运行时类中声明的所有属性，（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f:declaredFields){
            System.out.println(f);
        }
    }

@Test
    public void test1(){
        Class clazz= Person.class;

        //getMethods: 获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for (Method m:methods){
            System.out.println(m);
        }

        //getDeclaredMethods(): 获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m:declaredMethods){
            System.out.println(m);
        }
    }

/*
    获取构造器结构
     */
    @Test
    public void test1(){
        Class clazz= Person.class;

        //getConstructors(): 获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor c:constructors){
            System.out.println(c);
        }

        System.out.println();
        //getDeclaredConstructors(): 获取当前运行时类中声明的所有构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor c:declaredConstructors){
            System.out.println(c);
        }

    }

    /*
    获取运行时类的父类
     */
    @Test
    public void test2(){
        Class clazz=Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);

    }

    /*
    获取运行时类的带泛型父类
     */
    @Test
    public void test3(){
        Class clazz=Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);

    }

    /*
    获取运行时类的带泛型父类的泛型
    */
    @Test
    public void test4(){
        Class clazz=Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType paramType=(ParameterizedType)genericSuperclass;
        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0].getTypeName());
        System.out.println(((Class)actualTypeArguments[0]).getName());

    }

    /*
    获取运行时类实现的接口
     */
    @Test
    public void test5(){
        Class clazz=Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for (Class c:interfaces){
            System.out.println(c);
        }
        System.out.println();
        //获取运行时类的父类的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class c:interfaces1){
            System.out.println(c);
        }

    }

    /*
    获取运行时类所在的包
     */
    @Test
    public void test6(){
        Class clazz=Person.class;

        Package pack = clazz.getPackage();
        System.out.println(pack);
    }

    /*
    获取运行时类的注解
     */
    @Test
    public void test7(){
        Class clazz=Person.class;
        Annotation[] annos = clazz.getAnnotations();

        for (Annotation a:annos){
            System.out.println(a);
        }
    }

6. 反射应用三：调用运行时类的指定结构

调用指定的属性

/*
    如何操作运行时类的指定属性--掌握
     */
    @Test
    public void testField1() throws Exception{
        Class clazz=Person.class;

        //创建运行时类的对象
        Person p=(Person) clazz.newInstance();

        //1. getDeclaredField(String fieldName): 获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");
        //2. 保证当前属性可访问
        name.setAccessible(true);
        //3. 获取，设置指定对象的此属性值
        name.set(p,"Tom");

        System.out.println(name.get(p));
    }

调用指定方法

/*
   如何操作运行时类的指定方法--掌握
    */
    @Test
    public void testMethod() throws Exception {
        Class clazz=Person.class;

        //创建运行时类的对象
        Person p=(Person) clazz.newInstance();

        /*
        1. 获取指定方法
        getDeclaredMethod():参数1：指明获取方法的名称   参数2：指明获取方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2. 保证当前方法可访问
        show.setAccessible(true);

        /*
        3. 调用方法invoke(): 参数1：方法的调用者    参数2：给方法形参赋值的实参
            invoke()的返回值为对应类中调用的方法的返回值
         */
        Object nation = show.invoke(p, "CHN");
        System.out.println(nation);

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

        //private static void showDetail()
        Method showDetail = clazz.getDeclaredMethod("showDetail");
        showDetail.setAccessible(true);
        //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
//        Object returnVal = showDetail.invoke(Person.class);
        Object returnVal = showDetail.invoke(null);
        System.out.println(returnVal);
    }

调用指定构造器

/*
   如何操作运行时类的指定构造器
    */
    @Test
    public void testConstructor() throws Exception{
        Class clazz=Person.class;

        //private Person(String name)
        /*
        1. 获取指定的构造器
        getDeclaredConstructor(): 参数：指明构造器的参数列表
         */
        Constructor cons = clazz.getDeclaredConstructor(String.class);

        //2. 保证此构造器可访问
        cons.setAccessible(true);
        //3. 调用此构造器创建运行时类的对象
        Person per =(Person) cons.newInstance("Tom");
        System.out.println(per);
    }

7. 反射的应用四：动态代理

希望通过一个代理类完成全部的代理功能

7.1 代理模式的原理

使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要用到代理。代理对象决定是否以及何时将方法调用转到原始对象上。

7.2 静态代理

举例：实现Runnable接口的方法创建多线程。

Class MyThread implements Runnable{}

Class Thread implements Runnable{}

main(){
	MyThread t=new MyThread();

	Thread thread=new Thread(t);

	thread.start();
}

代理类和目标对象的类在编译期间确定。

package com.atguigu.java;

/**
 * 静态代理举例
 * 特点：代理类和被代理类在编译期间确定下来了
 *
 * @create 2021-01-13 下午11:14
 */
interface ClothFactory{

    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory; //用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory){
        this.factory=factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");

        factory.produceCloth();

        System.out.println("代理工厂做后续工作");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产运动鞋");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        NikeClothFactory nike=new NikeClothFactory();
        //创建代理类的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}

7.3 动态代理

在程序运行时根据需要动态创建目标类的代理对象。

要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象（通过Proxy.newProxyInstance()实现）
问题二：当通过代理类的对象调用方法a时，如何动态地去调用被代理类中的同名方法a （通过InvocationHandler接口的实现类及其方法invoke()）

package com.atguigu.java;

import java.io.ObjectInputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 动态代理的举例
 *
 * @create 2021-01-14 上午11:30
 */
interface Human{
    String getBelief();

    void eat(String food);

}

//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("I like to eat "+food);
    }
}

class HumanUtil{

    public void method1(){
        System.out.println("=========================通用方法一=========================");
    }

    public void method2(){
        System.out.println("=========================通用方法二=========================");
    }
}


class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj:被代理类的对象
        MyInvocationHandler handler=new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;//需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj=obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动地调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        HumanUtil util=new HumanUtil();
        util.method1();

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj被代理类的对象
        Object returnValue = method.invoke(obj, args);

        util.method2();

        //上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan=new SuperMan();
        //proxyInstance: 代理类对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
        proxyInstance.getBelief();
        proxyInstance.eat("麻辣烫");

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

        NikeClothFactory nikeClothFactory = new NikeClothFactory();

        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);

        proxyClothFactory.produceCloth();
    }
}
Jeremy202109
关注
专栏目录
Java高级篇-Java反射机制
cV展示的学习园
04-29 172
Java反射机制 反射的概念 关于反射的理解 Reflection（反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何 类的内部信息，并能直接操作任意对象的内部属性及方法。 框架 = 反射 + 注解 + 设计模式 反射的初理解 反射是通过内存加载的class文件造对象 //反射之前，对于Person的操作 @Test public void test1() { //1.创建Person类的对象 Person p1
Java之反射机制
子清的博客
08-07 204
类的执行过程 类加载步骤 什么是反射 反射api Class //1.通过Class.forName（）(对于编译器并不知道对象类型，在运行期对未知类型进行操作时) try { Class c=Class.forName("preview.Person"); System.out.println(c.getName()); } catch (ClassNotFoundException e) { e.printStackTrace(); } //2.通过对象实例
Java中反射的实现方式
胡兵(Java)
09-12 3200
所谓反射，是指在运行时状态中，获取类中的属性和方法，以及调用其中的方法的一种机制。这种机制的作用在于获取运行时才知道的类（Class）及其中的属性（Field）、方法（Method）以及调用其中的方法，也可以设置其中的属性值。 在Java中实现反射最重要的一步，也是第一步就是获取Class对象，得到Class对象后可以通过该对象调用相应的方法来获取该类中的属性、方法以及调用该类中的方法。
看懂Class＜T＞ clazz；所需的Java基础知识
weixin_45598285的博客
01-20 1万+
参考博文： https://blog.csdn.net/u012990509/article/details/61494047?spm=1001.2101.3001.6650.6&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-6.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.
java 反射机制
05-09
### Java反射机制深入理解 #### 一、反射机制概述 Java反射机制是一种强大的工具，它允许程序在运行时检查和操作任何类、方法、构造函数和字段等元素。这种能力对于构建灵活的应用程序和框架非常有用，特别是那些...
Java 反射机制实例详解
08-29
Java 反射机制实例详解 Java 反射机制实例详解是一种动态语言机制，允许在程序运行时加载、探知和使用编译期间完全不知道的类、生成其对象实体，调用其方法或者对属性设值。下面是 Java 反射机制实例详解的知识点：...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
利用java反射机制实现自动调用类的简单方法
09-01
Java反射机制是Java语言提供的一种强大功能，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在上述示例中，通过反射机制实现了动态调用类的方法，这种方式在某些场景下非常有用，比如插件...
java反射机制给实体类相同字段自动赋值实例
08-24
在上述的"java反射机制给实体类相同字段自动赋值实例"中，我们看到如何利用反射来实现两个实体类之间相同字段的自动赋值。下面将详细解释这一过程。 1. **创建工具类**： - 在提供的代码中，定义了一个名为`Class...
java反射的三种方式，获取 属性、方法、构造方法 简单明了
最新发布
weixin_56654434的博客
11-10 3970
反射的三种方式，获取全部属性、方法、构造方法
Java的反射机制
Luna_ll的博客
08-23 472
一.何为反射： 反射就是动态加载对象，并对对象进行剖析。在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法，这种动态获取信息以及动态调用对象方法的功能成为Java反射机制。 二.获得一个类的类对象有哪些方式？ （1）Class.forName(classname)：用于做类加载 //根据给定的类名来获得，用于类加载 String ...
java clazz_Java反射机制
weixin_42510360的博客
02-22 3023
一、什么是反射机制 简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。那么就可以通过反射机制来获得类的所有信息。二、哪里用到反射机制有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，Class.forName("com.mysql.jdbc.Driver")但是那时候...
class<?> clazz参数_【Java视频教程】day41-??什么是Class？??
weixin_39603604的博客
11-30 806
Class类介绍java世界中，一切都是对象，所有事物都要使用一个类描述；这个class是不是一个事物呢？是的，所以java中专门定义了一个叫做Class的类来描述它；int[] arr = new int[1];int[] array = new int[2];实际上，除了类使用Class类描述外，一个类中的构造函数、成员变量和一般函数，都是一种事物，java中都会使用一个类描述：构造函数：Co...
Java 反射详解和使用
m0_58375976的博客
04-28 7987
反射(Reflection)机制是Java语言特性之一，是Java被视为动态(或准动态)语言的一个关键特性；
Java中Class对象详述
编程界明世隐的博客
04-16 2273
RTTI（运行时类型信息）： 运行时类型信息可以让你在程序运行时发现和使用类型信息。主要用来运行时获取向上转型之后的对象到底是什么具体的类型。 如下实例： 上方类图分析 基类Vehicle位于顶部，Car、Bus、Bike 3个派生类向下扩展，面向对象编程很重要的目的是：让代码只操作基类的引用，就可以达到我们想要的效果，而不必去直接操作派生类；如果我们想再增加一个派生类 MotorBike，则直接对此类进行扩展即可，无需改变原来的代码逻辑。 Vehicle类 abstract class
java clazz_JNI_Z_01_获取Clazz
weixin_31608037的博客
02-22 269
1、为了能够在C/C++中使用Java类，jni.h头文件中专门定义了jclass类型来表示Java中的Class类(ZC: 就是Clazz)2、2.1、JNIEXPORT void JNICALL Java_包名_类名_函数名01(JNIEnv * _env, jclass _clazz)　　// Java代码中的 静态函数2.2、JNIEXPORT void JNICALLJava_包名_类...
JAVA反射的实现方式
xsggsx的博客
09-12 970
Class clazz = Class.forName("cn.com.huixin.blogcode.Student")通过上述的第一种方式来获取Student的Class对象，这儿的字符串必须是类的全路径名，即包名+类名。当然，该处也可以通过上述的第二种或者第三种方法获得Student的Class对象。例如：     (1)、调用Student类的class属性          
封装篇——获取泛型<T>的Class<T> clazz
热门推荐
温利东 的博客
03-24 4万+
在我们搭建框架中往往会用到泛型,我们知道泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，代码的重用率高， 然而有时候`<method>`的入参并不能直接强制转换成泛型的类型，这就有所限制....
深入理解Java反射机制
"Java反射机制是Java编程中的重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。通过Java反射，开发者可以在不知道具体类名的情况下，对类进行实例化，调用方法，访问和修改属性，实现更加灵活的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值