魔法反射--java反射进阶(实战篇)-阿里云开发者社区

👳我亲爱的各位大佬们好😘😘😘
♨️本篇文章记录的为 JDK8 新特性 Stream API 进阶 相关内容，适合在学Java的小白,帮助新手快速上手,也适合复习中，面试中的大佬🙉🙉🙉。
♨️如果文章有什么需要改进的地方还请大佬不吝赐教❤️🧡💛
👨‍🔧 个人主页 : 阿千弟
🔥 相关内容👉👉👉 : 都2023年了,如果不会Lambda表达式、函数式编程？你确定能看懂公司代码？

在学习 Java 基础的时候，一般都会学过反射。我在初学反射的时候，并不能理解反射是用来干嘛的。学了一些 API 发现：“明明我自己能直接 new 一个对象，为什么它要绕一个圈子，先拿到 Class 对象，再调用 Class 对象的方法来创建对象呢，这不是多余吗？”

相信很多人在初学反射的时候也都会有这个想法（我就不相信就只有我一个人这么蠢！！）

大多数人不了解反射的原因并不是不了解, 而是不知道它到底能用来干什么

今天就来为大家分享一下反射的用法

基础回顾

其实反射就是围绕着 Class 对象和 java.lang.reflect 类库来学习，就是各种的 API
我并不是说这些 API 我都能记住，只是这些 API 教程在网上有非常非常多，也足够通俗易懂了。在入门的时候，其实掌握以下几种也差不多了：

知道获取 Class 对象的几种途径
通过 Class 对象创建出对象，获取出构造器，成员变量，方法
通过反射的 API 修改成员变量的值，调用方法

下面我简要概述一下反射怎么用, 具体的API不熟悉的话点击这里

想要使用反射，我先要得到class文件对象，其实也就是得到Class类的对象
Class类主要API：
        成员变量  - Field
        成员方法  - Constructor
        构造方法  - Method
获取class文件对象的方式：
        1：Object类的getClass()方法
        2：数据类型的静态属性class
        3：Class类中的静态方法：public static Class ForName(String className)
--------------------------------  
获取成员变量并使用
        1: 获取Class对象
        2：通过Class对象获取Constructor对象
        3：Object obj = Constructor.newInstance()创建对象
        4：Field field = Class.getField("指定变量名")获取单个成员变量对象
        5：field.set(obj,"") 为obj对象的field字段赋值
如果需要访问私有或者默认修饰的成员变量
        1:Class.getDeclaredField()获取该成员变量对象
        2:setAccessible() 暴力访问  
---------------------------------          
通过反射调用成员方法
        1：获取Class对象
        2：通过Class对象获取Constructor对象
        3：Constructor.newInstance()创建对象
        4：通过Class对象获取Method对象  ------getMethod("方法名");
        5: Method对象调用invoke方法实现功能
如果调用的是私有方法那么需要暴力访问
        1: getDeclaredMethod()
        2: setAccessiable();

反射的常用场景

通过配置信息调用类的方法
结合注解实现特殊功能
按需加载 jar 包或 class

壹 : 通过配置信息调用类的方法

在个方法在上期内容 "反射的最基本用法" 中已经讲解过了, 不太了解的朋友可以点击传送门

贰 : 数据库加载驱动

有javaWeb编程基础的朋友们应该都知道,
数据库有mysql和oracle两种常见的数据库, 对应不同的驱动分别为"com.mysql.jdbc.Driver", "oracle.jdbc.driver.OracleDriver"
ok，这里就有个问题，当你读取到了"com.mysql.jdbc.Driver"这个字符串后，怎么把它变成实际的mysql对应的那个Driver的对象？你当然可以这么干。

// load json，得到dbconfig
if (dbconfig.dbDrvier.equals("com.mysql.jdbc.Driver")) {
   
   
     Driver d = new com.mysql.jdbc.Driver(dbconfig.dbUri, dbconfig.dbUsername, dbconfig.dbPassword);
} else if (dbconfig.dbDriver.equals("oracle.jdbc.driver.OracleDriver")) {
   
   
    Driver d = new oracle.jdbc.driver.OracleDriver(dbconfig.dbUri, dbconfig.dbUsername, dbconfig.dbPassword);
 // ...
}

这个就叫hard code，但编译期可以确定类型的写法。这么写是可行的，只不过每次增加driver的种类时，就得改这个代码增加一行else if

又或者这样干

public class DBConnectionUtil {
   
   
    /** 指定数据库的驱动类 */
    private static final String DRIVER_CLASS_NAME = "com.mysql.jdbc.Driver";

    public static Connection getConnection() {
   
   
        Connection conn = null;
        // 加载驱动类
        Class.forName(DRIVER_CLASS_NAME);
        // 获取数据库连接对象
        conn = DriverManager.getConnection("jdbc:mysql://···", "root", "root");
        return conn;
    }
}
// 如果dbDriver这个class找不到，又或者clz不是个Driver，抛异常就可以了

如果dbDriver这个class找不到，又或者clz不是个Driver，就会抛异常了

这就相当于让Java在运行时帮你找名字是这个字符串的那个类在不在，如果在就创建一个。这就是反射。因为编译的时候，你是不知道未来那个配置文件写成什么的，所以只能这么写，让Java去现查。

叁 : 反射 + 抽象工厂模式

传统的工厂模式，如果需要生产新的子类，需要修改工厂类，在工厂类中增加新的分支；

public class MapFactory {
   
   
    public Map<Object, object> produceMap(String name) {
   
   
        if ("HashMap".equals(name)) {
   
   
            return new HashMap<>();
        } else if ("TreeMap".equals(name)) {
   
   
            return new TreeMap<>();
        } // ···
    }
}

利用反射和工厂模式相结合，在产生新的子类时，工厂类不用修改任何东西，可以专注于子类的实现，当子类确定下来时，工厂也就可以生产该子类了。

反射 + 抽象工厂的核心思想是：

在运行时通过参数传入不同子类的全限定名获取到不同的 Class 对象，调用 newInstance () 方法返回不同的子类。细心的读者会发现提到了子类这个概念，所以反射 + 抽象工厂模式，一般会用于有继承或者接口实现关系。

例如，在运行时才确定使用哪一种 Map 结构，我们可以利用反射传入某个具体 Map 的全限定名，实例化一个特定的子类。

public class MapFactory {
   
   
    /**
     * @param className 类的全限定名
     */
    public Map<Object, Object> produceMap(String className) {
   
   
        Class clazz = Class.forName(className);
        Map<Object, Object> map = clazz.newInstance();
        return map;
    }
}

className 可以指定为 java.util.HashMap，或者 java.util.TreeMap 等等，根据业务场景来定。

结合注解实现特殊功能

案例1: 仿写@TableName注解

大家如果学习过 mybatis plus 都应该学习过这样的一个注解 TableName，这个注解表示当前的实例类 Student 对应的数据库中的哪一张表。如下问代码所示，Student 所示该类对应的是 t_student 这张表。

@TableName("t_student")
public class Student {
   
   
    public String nickName;
    private Integer age;
}

下面我们自定义 TableName 这个注解

@Target(ElementType.TYPE)  //表示TableName可作用于类、接口或enum Class, 或interface
@Retention(RetentionPolicy.RUNTIME) //表示运行时由JVM加载
public @interface TableName {
   
   
       String value() ;   //则使用@TableName注解的时候： @TableName(”t_student”);
}

有了这个注解，我们就可以扫描某个路径下的 java 文件，至于类注解的扫描我们就不用自己开发了，引入下面的 maven 坐标就可以

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.9.10</version>
</dependency>

看下面代码：先扫描包，从包中获取标注了 TableName 注解的类，再对该类打印注解 value 信息

// 要扫描的包
String packageName = "com.jrmedu.java.reflection";
Reflections f = new Reflections(packageName);
// 获取扫描到的标记注解的集合
Set<Class<?>> set = f.getTypesAnnotatedWith(TableName.class);
for (Class<?> c : set) {
   
   
// 循环获取标记的注解
TableName annotation = c.getAnnotation(TableName.class);
// 打印注解中的内容
System.out.println(c.getName() + "类，TableName注解value=" + annotation.value());

输出结果是：

com.zimug.java.reflection.Student类，TableName注解value=t_student

案例2 : 自定义注解给不同的接口增加权限

@permission("添加分类")
/*添加分类*/ void addCategory(Category category);

/*查找分类*/
void findCategory(String id);

@permission("查找分类")
/*查看分类*/ List<Category> getAllCategory();

返回一个代理的 Service 对象来处理自定义注解：

public class ServiceDaoFactory {
   
   

    private static final ServiceDaoFactory factory = new ServiceDaoFactory();

    private ServiceDaoFactory() {
   
   
    }

    public static ServiceDaoFactory getInstance() {
   
   
        return factory;
    }


    //需要判断该用户是否有权限
    public <T> T createDao(String className, Class<T> clazz, final User user) {
   
   

        System.out.println("添加分类进来了！");

        try {
   
   
            //得到该类的类型
            final T t = (T) Class.forName(className).newInstance();
            //返回一个动态代理对象出去
            return (T) Proxy.newProxyInstance(ServiceDaoFactory.class.getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
   
   

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, PrivilegeException {
   
   
                    //判断用户调用的是什么方法
                    String methodName = method.getName();
                    System.out.println(methodName);

                    //得到用户调用的真实方法，注意参数！！！
                    Method method1 = t.getClass().getMethod(methodName,method.getParameterTypes());

                    //查看方法上有没有注解
                    permission permis = method1.getAnnotation(permission.class);

                    //如果注解为空，那么表示该方法并不需要权限，直接调用方法即可
                    if (permis == null) {
   
   
                        return method.invoke(t, args);
                    }

                    //如果注解不为空，得到注解上的权限
                    String privilege = permis.value();

                    //设置权限【后面通过它来判断用户的权限有没有自己】
                    Privilege p = new Privilege();
                    p.setName(privilege);

                    //到这里的时候，已经是需要权限了，那么判断用户是否登陆了
                    if (user == null) {
   
   

                        //这里抛出的异常是代理对象抛出的，sun公司会自动转换成运行期异常抛出，于是在Servlet上我们根据getCause()来判断是不是该异常，从而做出相对应的提示。
                        throw new PrivilegeException("对不起请先登陆");
                    }

                    //执行到这里用户已经登陆了，判断用户有没有权限
                    Method m = t.getClass().getMethod("findUserPrivilege", String.class);
                    List<Privilege> list = (List<Privilege>) m.invoke(t, user.getId());

                    //看下权限集合中有没有包含方法需要的权限。使用contains方法，在Privilege对象中需要重写hashCode和equals()
                    if (!list.contains(p)) {
   
   
                        //这里抛出的异常是代理对象抛出的，sun公司会自动转换成运行期异常抛出，于是在Servlet上我们根据getCause()来判断是不是该异常，从而做出相对应的提示。
                        throw new PrivilegeException("您没有权限，请联系管理员！");
                    }

                    //执行到这里的时候，已经有权限了，所以可以放行了
                    return method.invoke(t, args);
                }
            });

        } catch (Exception e) {
   
   
            new RuntimeException(e);
        }
        return null;
    }

增加程序的灵活性

我们来看一个更加贴近开发的例子：

利用反射连接数据库，涉及到数据库的数据源。在 SpringBoot 中一切约定大于配置，想要定制配置时，使用 application.properties 配置文件指定数据源

角色 1 - Java 的设计者：

我们设计好DataSource接口，你们其它数据库厂商想要开发者用你们的数据源监控数据库，就得实现我的这个接口！

角色 2 - 数据库厂商：
MySQL 数据库厂商：我们提供了 com.mysql.cj.jdbc.MysqlDataSource 数据源，开发者可以使用它连接 MySQL。
阿里巴巴厂商：我们提供了 com.alibaba.druid.pool.DruidDataSource 数据源，我这个数据源更牛逼，具有页面监控，慢 SQL 日志记录等功能，开发者快来用它监控 MySQL 吧！
SQLServer 厂商：我们提供了 com.microsoft.sqlserver.jdbc.SQLServerDataSource 数据源，如果你想实用 SQL Server 作为数据库，那就使用我们的这个数据源连接吧

角色 3 - 开发者：

我们可以用配置文件指定使用DruidDataSource数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

需求变更：某一天，老板来跟我们说，Druid 数据源不太符合我们现在的项目了，我们使用 MysqlDataSource 吧，然后程序猿就会修改配置文件，重新加载配置文件，并重启项目，完成数据源的切换。

spring.datasource.type = com.mysql.cj.jdbc.MysqlDataSource

在改变连接数据库的数据源时，只需要改变配置文件即可，无需改变任何代码，原因是：

Spring Boot 底层封装好了连接数据库的数据源配置，利用反射，适配各个数据源。

下面来简略的进行源码分析。我们用ctrl+左键点击spring.datasource.type进入 DataSourceProperties 类中，发现使用 setType () 将全类名转化为 Class 对象注入到type成员变量当中。在连接并监控数据库时，就会使用指定的数据源操作。

private Class<? extends DataSource> type;

public void setType(Class<? extends DataSource> type) {
   
   
    this.type = type;
}

在这里插入图片描述

破坏类的封装性

很明显的一个特点，反射可以获取类中被private修饰的变量、方法和构造器，这违反了面向对象的封装特性，因为被 private 修饰意味着不想对外暴露，只允许本类访问，而setAccessable(true)可以无视访问修饰符的限制，外界可以强制访问。

还记得单例模式一文吗？里面讲到反射破坏饿汉式和懒汉式单例模式，所以之后用了枚举避免被反射 KO。

SmallPineapple 里有一个 weight 属性被 private 修饰符修饰，目的在于自己的体重并不想给外界知道。

public class SmallPineapple {
   
   

    public String name;
    public int age;
    private double weight; // 体重只有自己知道

    public SmallPineapple(String name, int age, double weight) {
   
   
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

}

虽然 weight 属性理论上只有自己知道，但是如果经过反射，这个类就像在裸奔一样，在反射面前变得一览无遗。

SmallPineapple sp = new SmallPineapple("小菠萝", 21, "54.5");
Clazz clazz = Class.forName(sp.getClass());
Field weight = clazz.getDeclaredField("weight");
weight.setAccessable(true);
System.out.println("窥觑到小菠萝的体重是：" + weight.get(sp));
// 窥觑到小菠萝的体重是：54.5 kg

反射基础篇文末总结

反射的思想：反射就像是一面镜子一样，在运行时才看到自己是谁，可获取到自己的信息，甚至实例化对象。
反射的作用：在运行时才确定实例化对象，使程序更加健壮，面对需求变更时，可以最大程度地做到不修改程序源码应对不同的场景，实例化不同类型的对象。
反射的应用场景常见的有 3 个：Spring 的 IOC 容器，反射 + 工厂模式使工厂类更稳定，JDBC 连接数据库时加载驱动类
反射的 3 个特点：增加程序的灵活性、破坏类的封装性以及性能损耗

如果这篇【文章】有帮助到你💖，希望可以给我点个赞👍，创作不易，如果有对Java后端或者对spring, 分布式, 云原生感兴趣的朋友,请多多关注💖💖💖
👨‍🔧 个人主页 : 阿千弟

魔法反射--java反射进阶(实战篇)

基础回顾

反射的常用场景

壹 : 通过配置信息调用类的方法

贰 : 数据库加载驱动

叁 : 反射 + 抽象工厂模式

结合注解实现特殊功能

案例1: 仿写@TableName注解

案例2 : 自定义注解给不同的接口增加权限

增加程序的灵活性

破坏类的封装性

反射基础篇文末总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

魔法反射--java反射进阶(实战篇)

基础回顾

反射的常用场景

壹 : 通过配置信息调用类的方法

贰 : 数据库加载驱动

叁 : 反射 + 抽象工厂模式

结合注解实现特殊功能

案例1: 仿写@TableName注解

案例2 : 自定义注解给不同的接口增加权限

增加程序的灵活性

破坏类的封装性

反射基础篇文末总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景