魔法反射--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, 分布式, 云原生感兴趣的朋友,请多多关注💖💖💖
👨‍🔧 个人主页 : 阿千弟