👳我亲爱的各位大佬们好😘😘😘
♨️本篇文章记录的为 魔法反射–java反射进阶(实战篇) 相关内容，适合在学Java的小白,帮助新手快速上手,也适合复习中，面试中的大佬🙉🙉🙉。
♨️如果文章有什么需要改进的地方还请大佬不吝赐教❤️🧡💛
👨‍🔧 个人主页 : 阿千弟
🔥 相关内容👉👉👉 : 魔法反射–java反射初入门(基础篇)

在学习 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：数据类型的静态属性class3：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

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

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

🔥 相关内容👉👉👉 : 魔法反射–java反射初入门(基础篇)

贰 : 数据库加载驱动

有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() {@Overridepublic 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, 分布式, 云原生感兴趣的朋友,请多多关注💖💖💖
👨‍🔧 个人主页 : 阿千弟