Java--反射机制原理、几种Class获取方式及应用场景_xx

柏林的冬

于 2024-05-23 15:28:47 发布

阅读量705

点赞数 13

分类专栏：程序员文章标签： java 学习经验分享

本文链接：https://blog.csdn.net/2301_78399550/article/details/139149293

版权

程序员专栏收录该内容

202 篇文章 0 订阅

订阅专栏

🎵二、Java反射机制中获取Class的三种方式及区别？

在这里插入图片描述

📀2.1 Class的几种获取方式

（1）获取类的java.lang.Class实例对象，常见的三种方式分别为：

通过MyClass.class获取，这里的MyClass指具体类~~
通过Class.forName("类的全局定名")获取，全局定名为包名+类名
通过new MyClass().getClass()获取，这里的MyClass指具体类~

（2）通过MyClass.class获取，JVM会使用ClassLoader类加载器将类加载到内存中，但并不会做任何类的初始化工作，返回java.lang.Class对象

（3）通过Class.forName("类的全局定名")获取，同样，类会被JVM加载到内存中，并且会进行类的静态初始化工作，返回java.lang.Class对象

（4）通过new MyClass().getClass()获取，这种方式使用了new进行实例化操作，因此静态初始化和非静态初始化工作都会进行，getClass方法属于顶级Object类中的方法，任何子类对象都可以调用，哪个子类调用，就返回那个子类的java.lang.Class对象

PS： 这3种方式，最终在JVM堆区对应类的java.lang.Class对象都属于同一个，也就是内存地址相同，进行==双等号比较结果为true，原因是JVM类加载过程中使用的是同一个ClassLoader类加载器加载某个类，不论加载多少次，生成到堆区的java.lang.Class对象始终只有一个，除非自定义类加载器，破坏JVM的双亲委派机制，使得同一个类被不同类加载器加载，JVM才会把它当做两个不同的java.lang.Class对象

🔊2.2 代码演示几种方式的区别

创建一个实体类，分别在实体类中创建类的静态代码块、动态代码块、有参构造方法、无参构造方法，方便测试几种方式的区别及内存地址是否相同~

（1）实体类：

public class MyClass {
    private static final String staticStr = "Hi";
    private static int staticInt = 2021;
    private String id;

    static {
        System.out.println("静态代码块：staticStr=" + staticStr + ",staticInt=" + staticInt);
    }

    {
        System.out.println("动态代码块~");
    }

    public MyClass() {
        System.out.println("无参构造方法~");
    }

    public MyClass(String id) {
        System.out.println("有参构造方法~");
        this.id = id;
    }

    public String getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "MyClass{" +
                "id='" + id + '\'' +
                '}';
    }
}

（2）单元测试类：
通过@Test注解对三种方式分别进行单元测试，再对这三种方式的组合进行单元测试~

package com.justin.java.lang;

import org.junit.Test;

/\*\*
 \* @program: Jdk1.8Test
 \* @description: Java反射机制中获取类的Class实例对象的常见三种方式及区别对比
 \* @author: JustinQin
 \* @create: 2021/8/22 15:04
 \* @version: v1.0.0
 \*\*/
public class MyClassTest {

    @Test
    public void test1() {
        System.out.println("一、MyClass.class方式=========");
        Class<?> class1 = MyClass.class;
    }

    @Test
    public void test2() throws ClassNotFoundException {
        System.out.println("二、Class.forName方式=========");
        Class class2 = Class.forName("com.justin.java.lang.MyClass");
    }


    @Test
    public void test3() {
        System.out.println("三、new MyClass().getClass方式=========");
        Class class3 = new MyClass().getClass();
    }

    @Test
    public void test12() throws ClassNotFoundException {
        System.out.println("一、MyClass.class方式=========");
        Class<?> class1 = MyClass.class;
        System.out.println("二、Class.forName方式=========");
        Class class2 = Class.forName("com.justin.java.lang.MyClass");
    }

    @Test
    public void test13() {
        System.out.println("一、MyClass.class方式=========");
        Class<?> class1 = MyClass.class;
        System.out.println("三、new MyClass().getClass方式=========");
        Class class3 = new MyClass().getClass();
    }

    @Test
    public void test23() throws ClassNotFoundException {
        System.out.println("二、Class.forName方式=========");
        Class class2 = Class.forName("com.justin.java.lang.MyClass");
        System.out.println("三、new MyClass().getClass方式=========");
        Class class3 = new MyClass().getClass();
    }

    @Test
    public void test() throws ClassNotFoundException {
        System.out.println("四、三种方式内存地址比较=========");
        Class<?> class1 = MyClass.class;
        Class class2 = Class.forName("com.justin.java.lang.MyClass");
        Class class3 = new MyClass().getClass();
        System.out.println("比较结果=========");
        System.out.println("MyClass.class和Class.forName内存地址比较是否相同：" + (class1 == class2));
        System.out.println("MyClass.class和new MyClass().getClass内存地址比较是否相同：" + (class1 == class3));
        System.out.println("Class.forName和new MyClass().getClass内存地址比较是否相同：" + (class2 == class3));
    }
}

逐个执行单元，得出测试结果为：

\* test1()方法
一、MyClass.class方式=========

\*  test2()方法
二、Class.forName方式=========
静态代码块：staticStr=Hi,staticInt=2021

\*  test3()方法
三、new MyClass().getClass方式=========
静态代码块：staticStr=Hi,staticInt=2021
动态代码块~
无参构造方法~

\*  test12()方法
一、MyClass.class方式=========
二、Class.forName方式=========
静态代码块：staticStr=Hi,staticInt=2021

\*  test13()方法
一、MyClass.class方式=========
三、new MyClass().getClass方式=========
静态代码块：staticStr=Hi,staticInt=2021
动态代码块~
无参构造方法~

\*  test23()方法
二、Class.forName方式=========
静态代码块：staticStr=Hi,staticInt=2021
三、new MyClass().getClass方式=========
动态代码块~
无参构造方法~

\*  test()方法
四、三种方式内存地址比较=========
静态代码块：staticStr=Hi,staticInt=2021
动态代码块~
无参构造方法~
比较结果=========
MyClass.class和Class.forName内存地址比较是否相同：true
MyClass.class和new MyClass().getClass内存地址比较是否相同：true
Class.forName和new MyClass().getClass内存地址比较是否相同：true

通过test1、test2、test3的测试结果验证了2.1 三种方式及区别中黄色标记部分的区别说明，即：

MyClass.class不会做任何类的初始化工作
Class.forName会进行类的静态初始化工作
new MyClass().getClass静态初始化和非静态初始化工作都会进行
使用这三种方式任意一种最终在JVM加载到内存中都会是内存地址相同的

而test23组合得到的测试结果，说明静态代码块只会被加载一次~

讲了这么多，除了知道基本原理和基本使用之外，更重要的还是要知道它的一些比较实际的应用场景，往下介绍~

💥三、Java反射机制的应用场景有哪些？

在这里插入图片描述

🎶3.1 应用场景

工厂模式中的简单工厂模式优化
代理模式中的动态代理方式实现
Java JDBC数据库操作

🎧3.2 简单工厂模式优化

📢3.2.1 什么是简单工厂模式？

Java中主要有23种设计模式，其中工厂模式就是其中一种，而简单工厂模式，顾名思义，也是属于工厂模式中的一种，只不过比较简单。简单工厂模式也可以叫做静态方法模式（因为工厂类一般都是在内部定义了一个静态方法）。
从现实生活角度来理解的话，工厂是专门负责生产产品的，同样在设计模式中，简单工厂模式我们可以理解为专门负责生产对象的一个类，称为“工厂类”。

🎹3.2.2 简单工厂模式有什么用？

简单工厂模式通过创建一个对应的工厂类，将类实例化的操作与使用对象的操作进行分开，让使用者不用知道具体参数就可以实例化出所需要的具体产品类，从而避免了在客户端代码中显式指定，实现了解耦。即使用者可直接消费产品而不需要知道其生产的细节~

🎸3.2.3 如何实现简单工程模式？

实现简单工程模式的核心是创建一个工厂类，并且在内部定义了一个静态方法，传入不同的参数标识通过switch进行分组，通过new实例化创建不同的子类对象返回~

实现例子：

步骤1：创建抽象产品类

public interface Product {
    public abstract void show();
}

步骤2：创建具体产品类：

public class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品A");
    }
}
public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品B");
    }
}

public class ProductC implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品C");
    }
}

步骤3：创建简单工厂类

public class SimpleFactory {
    /\*\*
 \* 实现简单工厂模式
 \* @param pName 产品标识
 \* @return 返回具体的产品
 \*/
    public static Product createProduct(String pName){
        switch (pName){
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                return null;
        }
    }
}

步骤4：调用简单工厂类

public class SimpleFactoryTest {
    public static void main(String[] args) {
        try {
            SimpleFactory.createProduct("A").show();
        } catch (NullPointerException e) {
            System.out.println("没有A这款产品，无法生产~");
        }
        try {
            SimpleFactory.createProduct("B").show();
        } catch (NullPointerException e) {
            System.out.println("没有B这款产品，无法生产~");
        }
        try {
            SimpleFactory.createProduct("C").show();
        } catch (NullPointerException e) {
            System.out.println("没有C这款产品，无法生产~");
        }
        try {
            SimpleFactory.createProduct("D").show();
        } catch (NullPointerException e) {
            System.out.println("没有D这款产品，无法生产~");
        }
    }
}

📣3.2.4 简单工厂模式优化

（1）简单工厂模式弊端

操作成本高：每增加一个接口的子类，必须修改工厂类的逻辑
系统复杂性提高：每增加一个接口的子类，都必须向工厂类添加逻辑

这两点弊端从前面的例子SimpleFactory工厂类的实现，可以看出简单工厂模式中对工厂类SimpleFactory的维护成本有点大，因为实际中可能会很频繁的去更新具体产品类，每一次变更都需要去修改工厂类，此时就可以利用Java反射机制对简单工厂模式进行优化~

（2）简单工厂模式的优化思路
采用Java反射机制，通过传入子类全局定名（包名+类名） 动态的创建不同的子类对象实例，从而使得在不增加产品接口子类和修改工厂类的逻辑的情况下还能实现了工厂类对子类实例对象的统一创建~

（3）简单工厂模式的优化步骤
步骤1：创建工厂类
采用Java反射机制对工厂类进行优化，主要是将className即子类全局定名（包名+类名）作为入参，通过Class.forName方式获取类的java.lang.Class实例对象，再通过Class实例对象的getInstance方法获取到具体子类的实例对象~

public class Factory {
    public static Product getInstance(String className) {
        Product realProduct = null;
        try {
            Class pClass = Class.forName(className);
            realProduct = (Product) pClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return realProduct;
    }
}

步骤2：调用工厂类

public class FactoryTest {
    public static void main(String[] args) {
        try {
            Product productA = Factory.getInstance("com.justin.java.lang.ProductA");
            productA.show();
        } catch (NullPointerExc

[video(video-8PGqMbZO-1716354551447)(type-bilibili)(url-https://player.bilibili.com/player.html?aid=1804892953)(image-https://img-blog.csdnimg.cn/img_convert/d03a705143646f4f3f6ea879d59b2788.png)(title-必看视频！获取2024年最新Java开发全套学习资料 备注Java)]

eption e) {
            System.out.println("没有A这款产品，无法生产~");
        }

        try {
            Product productB = Factory.getInstance("com.justin.java.lang.ProductB");
            productB.show();
        } catch (NullPointerException e) {
            System.out.println("没有B这款产品，无法生产~");
        }

        try {
            Product productC = Factory.getInstance("com.justin.java.lang.ProductC");
            productC.show();
        } catch (NullPointerException e) {
            System.out.println("没有C这款产品，无法生产~");
        }

        try {
            Product productD = Factory.getInstance("com.justin.java.lang.ProductD");
            productD.show();
        } catch (Exception e) {
            System.out.println("没有D这款产品，无法生产~");
        }


    }
}

优化结果：

使用Java反射机制优化简单工厂模式后，可以看到，不论具体产品类更新多频繁，都不需要再修改工厂类，从而解决了普通简单工厂模式操作成本高和系统复杂性高的问题~

🎵3.2.5 简单工厂模式再次优化

（1）再次优化背景

简单工厂模式的工厂类采用Java反射机制进行优化后，此时的仍然存在这样一个问题，子类的全局定名（包名+类名）是写死的，但是实际上开发者在写代码时是很难提前预知所有的子类的全局定名（包名+类名）的，因此需要进行二次优化~

（2）再次优化实现思路

通过配置文件方式，统一定义类名对应全局定名（包名+类名），将配置文件存放到资源目录下，程序运行时通过ClassLoader类加载器动态获取到配置文件中定义的子类的全局定名~

（3）再次优化实现步骤

再次优化步骤1：相关优化与第一次优化保持不变~

再次优化步骤2：配置类名对应全局定名（包名+类名）
创建属性配置文件Product.properties

//产品抽象类Product相关子类的全局定名（包名+类名）定义
ProductA = com.justin.java.lang.ProductA
ProductB = com.justin.java.lang.ProductB
ProductC = com.justin.java.lang.ProductC

注意：将Product.properties需要存放在src/main/resources资源目录下，若资源目录不存在则需要手动创建~

再次优化步骤3：修改调用工厂类

public class FactoryTest {
    @Test
    public void test() throws IOException {
        ClassLoader classLoader = this.getClass().getClassLoader();
        Properties prop = new Properties();
        prop.load(classLoader.getResourceAsStream("Product.properties"));

        String className = "";
        try {
            className = prop.getProperty("ProductA");
            Product productA = Factory.getInstance(className);
            productA.show();
        } catch (NullPointerException e) {
            System.out.println("没有A这款产品，无法生产~");
        }

        try {
            className = prop.getProperty("ProductB");
            Product productA = Factory.getInstance(className);
            productA.show();
        } catch (NullPointerException e) {
            System.out.println("没有B这款产品，无法生产~");
        }

        try {
            className = prop.getProperty("ProductC");
            Product productA = Factory.getInstance(className);
            productA.show();
        } catch (NullPointerException e) {
            System.out.println("没有C这款产品，无法生产~");
        }
    }
}

运行结果：

生产了产品A
生产了产品B
生产了产品C

📀3.3 代理模式中的动态代理实现

在这里插入图片描述

🔊3.3.1 什么是代理模式？

代理（Proxy）模式是一种设计模式，通过代理对象来访问目标对象，还可以在不修改目标对象的情况下，对代理对象进行拓展，增强目标对象的功能~

什么？还是不太理解？

更通俗一点的说代理模式，就是想做某件事（买火车票），自己能买（直接去火车站买），却委托别人去买（没空还是代理点买吧），还可以让别人帮自己做其他事（订好酒店）~

在这里插入图片描述

代理模式又分为静态代理、动态代理，往下介绍~

💥3.3.2 什么是静态代理？

（1）静态代理属于代理模式的一种代理方式，需要代理对象和目标对象实现相同的接口
（2）静态代理的代理类是由程序员编写源码，编译后即可获取到代理类的class字节码文件，也就是在程序运行前就已经得到实际的代理类class字节码文件了

🎶3.3.2 什么是动态代理？

动态代理

（1）动态代理也属于代理模式的一种代理方式，不过只需要目标对象实现接口，代理对象不需要实现接口~
（2）动态代理的代理类编译后是没有class字节码文件的，而是在运行时利用Java反射机制动态的生成代理类的class字节码文件~

动态代理最常用的是JDK原生动态代理和cglib动态代理，往下介绍~

JDK 原生动态代理

JDK 原生动态代理，主要利用了JDK API的
java.lang.reflect.Proxy和java.lang.relfect.InnvocationHandler 这两个类来实现~

通过java.lang.reflect.Proxy代理类的newProxyInstance方法，传递3个参数，分别是：
目标对象的加载器 通过MyClass.getClass().getClassLoader方式获取
目标对象的实现接口类型 通过Object.getClass().getInterfaces()方式获取
InnvocationHandler事件处理器 通过new实例化对象并重写invoke方法方式获取

例子：

用户接口类IUserDao

public interface IUserDao {
    //添加数据
    public void insert();
}

目标对象类UserDao

/\*\*
 \* @program: DataStructures
 \* @description:
 \* @author: JustinQin
 \* @create: 2021/8/23 23:32
 \* @version: v1.0.0
 \*\*/
public class UserDao implements IUserDao{

    @Override
    public void insert() {
        System.out.println("添加数据");
    }
}

动态代理类UserProxy


/\*\*
 \* @program: Jdk1.8Test
 \* @description: 动态代理类
 \* @author: JustinQin
 \* @create: 2021/8/23 23:31
 \* @version: v1.0.0
 \*\*/
public class UserProxy {
    private Object target; //目标对象

    public UserProxy(Object target) {
        this.target = target;
    }

    /\*\*
 \* 利用JDK API获取到代理对象
 \* @return
 \*/
    public Object getProxyInstance() {
        //目标对象的加载器
        ClassLoader loader = target.getClass().getClassLoader();

        //目标对象的实现接口类型
        Class<?>[] interfaces = target.getClass().getInterfaces();

        //InnvocationHandler事件处理器实例对象
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("添加数据前：手动开启事务");
                // 执行目标对象方法
                Object value = method.invoke(target, args);
                System.out.println("添加数据后：手动提交事务");
                return null;
            }
        };
        //传入3个参数，创建代理类的实例对象，并返回
        return Proxy.newProxyInstance(loader, interfaces,h);
    }
}

动态代理单元测试类

/\*\*
 \* @program: 动态代理单元测试类
 \* @description:
 \* @author: JustinQin
 \* @create: 2021/8/23 23:42
 \* @version: v1.0.0
 \*\*/
public class UserProxyTest {
    @Test
    public void test() {
        IUserDao target = new UserDao();
        System.out.println("目标对象信息：" + target.getClass());
        //获取代理类实例对象
        IUserDao proxy = (IUserDao) new UserProxy(target).getProxyInstance();
        System.out.println("代理对象信息：" + proxy.getClass());
        //执行代理方法
        proxy.insert();
    }
}

单元测试执行结果

目标对象信息：class com.justin.java.reflect.UserDao
代理对象信息：class com.sun.proxy.$Proxy2
添加数据前：手动开启事务
添加数据
添加数据后：手动提交事务

cglib动态代理

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

Spring AOP结合了cglib动态代理和JDK原生动态代理来实现，这里不过多介绍，有兴趣小伙伴可以查阅资料学习下~

🎧3.3.3 动态代理中如何利用Java反射机制？

JDK原生动态代理中，获取代理示例对象过程中，获取目标对象的类加载器，通过target.getClass().getClassLoader(获取到目标对象的类加载器，target.getClass()方式获取目标对象的Class实例对象使用的就是Java反射机制来实现的~

📢3.4 Java JDBC数据库操作实现

🎹3.4.1 利用反射加载JDBC驱动

相信很多小伙伴都知道Java JDBC连接数据库主要分为七大步骤，其中第一步加载JDBC驱动，利用Java反射机制通过传入不同的驱动名称，加载不同数据库的驱动~

Class.forName("com.mysql.jdbc.Driver"); //加载MySQL驱动
Class.forName("oracle.jdbc.driver.OracleDriver"); //加载Oracle驱动

链接：Mysql驱动架包mysql-connector-java-5.1.30.jar 提取码：pc63

链接：Oracle驱动架包ojdbc14-10.2.0.4.0.jar 免提取码

🎸3.4.2 Java JDBC连接示例

创建测试库表及数据

create DATABASE test;
-- DROP TABLE IF EXISTS test.user;
create table test.user(
id int(7) primary key not null auto_increment,
name varchar(255),
sex char(1),
age int(3)
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
insert into TEST.user(name,sex,age) values('张一','男',21);
insert into TEST.user(name,sex,age) values('张二','女',22);
insert into TEST.user(name,sex,age) values('张三','男',23);


![](https://img-blog.csdnimg.cn/img_convert/db07037b516fac3bbb0cc032965ceb38.webp?x-oss-process=image/format,png)

最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分

![](https://img-blog.csdnimg.cn/img_convert/06ef08e05125fdf2af15135df3c683d8.webp?x-oss-process=image/format,png)


bc.driver.OracleDriver"); //加载Oracle驱动

链接：Mysql驱动架包mysql-connector-java-5.1.30.jar 提取码：pc63

链接：Oracle驱动架包ojdbc14-10.2.0.4.0.jar 免提取码

🎸3.4.2 Java JDBC连接示例

创建测试库表及数据

create DATABASE test;
-- DROP TABLE IF EXISTS test.user;
create table test.user(
id int(7) primary key not null auto_increment,
name varchar(255),
sex char(1),
age int(3)
)ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci;
insert into TEST.user(name,sex,age) values('张一','男',21);
insert into TEST.user(name,sex,age) values('张二','女',22);
insert into TEST.user(name,sex,age) values('张三','男',23);


[外链图片转存中...(img-ksowxt8t-1716449304755)]

最近我根据上述的技术体系图搜集了几十套腾讯、头条、阿里、美团等公司21年的面试题，把技术点整理成了视频（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分

[外链图片转存中...(img-ZS87WVe8-1716449304756)]

柏林的冬

关注

13
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java--反射机制原理、几种Class获取方式及应用场景_xx

Java中主要有23种设计模式，其中工厂模式就是其中一种，而简单工厂模式，顾名思义，也是属于工厂模式中的一种，只不过比较简单。简单工厂模式也可以叫做静态方法模式（因为工厂类一般都是在内部定义了一个静态方法）。从现实生活角度来理解的话，工厂是专门负责生产产品的，同样在设计模式中，简单工厂模式我们可以理解为专门负责生产对象的一个类，称为“工厂类”。代理（Proxy）模式是一种设计模式，通过代理对象来访问目标对象，还可以在不修改目标对象的情况下，对代理对象进行拓展，增强目标对象的功能~什么？还是不太理解？
复制链接

扫一扫

专栏目录