👳我亲爱的各位大佬们好😘😘😘
♨️本篇文章记录的为 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,分布式,云原生感兴趣的朋友,请多多关注💖💖💖
👨🔧 个人主页 : 阿千弟
