您现在的位置是：首页 > 技术教程 正文

【Web】浅聊JDBC的SPI机制是怎么实现的——DriverManager

admin 阅读： 2024-03-27
后台-插件-广告管理-内容页头部广告（手机）

目录

前言

分析

前言

【Web】浅浅地聊JDBC java.sql.Driver的SPI后门-CSDN博客

上篇文章我们做到了知其然，知道了JDBC有SPI机制，并且可以利用其Driver后门

这篇文章希望可以做到知其所以然，对JDBC的SPI机制的来源做到心里有数

分析

先是回顾一下JDBC的代码

  1. package com.spi;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.Statement;
  8. public class Jdbc_Demo {
  9. public static void main(String[] args) throws Exception {
  10. // 注册驱动（可以删去）
  11. // Class.forName("java.sql.Driver");
  12. // 获取数据库连接对象
  13. Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/security","root", "root");
  14. // 定义sql语句
  15. String sql = "select * from users";
  16. // 获取执行sql的对象Statement
  17. Statement stmt = con.createStatement();
  18. // 执行sql
  19. ResultSet res = stmt.executeQuery(sql);
  20. // 处理对象
  21. while(res.next()) {
  22. System.out.println(res.getString("username"));
  23. }
  24. // 释放资源
  25. res.close();
  26. stmt.close();
  27. con.close();
  28. }
  29. }

我们可以看到

 Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/security","root", "root");

因此JVM会尝试去加载DriverManager类，进而执行DriverManager的静态代码，调用类中的loadInitialDrivers方法（稍微精简了一下代码）

  1. static {
  2. loadInitialDrivers();
  3. println("JDBC DriverManager initialized");
  4. }
  6. private static void loadInitialDrivers() {
  7. String drivers;
  8. try {
  9. drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
  10. public String run() {
  11. return System.getProperty("jdbc.drivers"); // 也可以通过设置系统属性来加载驱动
  12. }
  13. });
  14. } //...
  15. AccessController.doPrivileged(new PrivilegedAction<Void>() {
  16. public Void run() {
  17. ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
  18. Iterator<Driver> driversIterator = loadedDrivers.iterator();
  19. try{
  20. while(driversIterator.hasNext()) {
  21. driversIterator.next();
  22. }
  23. }
  24. // ....
  25. String[] driversList = drivers.split(":");
  26. for (String aDriver : driversList) {
  27. try {
  28. Class.forName(aDriver, true,
  29. ClassLoader.getSystemClassLoader());
  30. } // ...
  31. }
  32. }

 重点关注ServiceLoader.load(Driver.class)进行了类加载

public static ServiceLoader load(Class service) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

 跟进ServiceLoader.load(service, cl);

public static ServiceLoader load(Class service,                                             ClassLoader loader)     {         return new ServiceLoader<>(service, loader);     }

service是Driver.class，loader是 Thread.currentThread().getContextClassLoader()

这里其实还有双亲委派机制的打破可以讲，但强行塞有点过于臃肿了，略去

 跟进ServiceLoader<>(service, loader);

private ServiceLoader(Class svc, ClassLoader cl) { service = Objects.requireNonNull(svc, "Service interface cannot be null"); loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl; acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null; reload(); }

跟进reload();

public void reload() { providers.clear(); lookupIterator = new LazyIterator(service, loader); }

最后得到的driversIterator就是LazyIterator

OK我们再看下上面代码的这段局部

  1. while(driversIterator.hasNext()) {
  2. driversIterator.next();
  3. }

在这段代码中调用 driversIterator.next()之时，便是调用LazyIterator#next

  1. public S next() {
  2. if (acc == null) {
  3. return nextService();
  4. } else {
  5. PrivilegedAction<S> action = new PrivilegedAction<S>() {
  6. public S run() { return nextService(); }
  7. };
  8. return AccessController.doPrivileged(action, acc);
  9. }
  10. }

跟进LazyIterator#nextService

  1. private S nextService() {
  2. if (!hasNextService())
  3. throw new NoSuchElementException();
  4. String cn = nextName;
  5. nextName = null;
  6. Class<?> c = null;
  7. try {
  8. c = Class.forName(cn, false, loader);
  9. }

这段代码的作用是根据存储的类名动态加载一个类(Class.forName)

要注意一点：将 initialize 参数设置为 false，可以实现延迟类的静态初始化，静态初始化块和静态变量的赋值是在类第一次被加载时执行的，如果将 initialize 参数设置为 false，则这些静态操作将被延迟到后续使用该类的过程中才被执行。

类名是哪来的？张口就来吗？我知道你很急，但你先别急，下面就讲。

 String cn = nextName;

看到nextName直接就懂了哇，回头看driversIterator.hasNext()，即LazyIterator#hasNext

  1. public boolean hasNext() {
  2. if (acc == null) {
  3. return hasNextService();
  4. } else {
  5. PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
  6. public Boolean run() { return hasNextService(); }
  7. };
  8. return AccessController.doPrivileged(action, acc);
  9. }
  10. }

跟进LazyIterator#hasNextService

  1. private boolean hasNextService() {
  2. if (nextName != null) {
  3. return true;
  4. }
  5. if (configs == null) {
  6. try {
  7. String fullName = PREFIX + service.getName();
  8. if (loader == null)
  9. configs = ClassLoader.getSystemResources(fullName);
  10. else
  11. configs = loader.getResources(fullName);
  12. } catch (IOException x) {
  13. fail(service, "Error locating configuration files", x);
  14. }
  15. }
  16. while ((pending == null) || !pending.hasNext()) {
  17. if (!configs.hasMoreElements()) {
  18. return false;
  19. }
  20. pending = parse(service, configs.nextElement());
  21. }
  22. nextName = pending.next();
  23. return true;
  24. }

ServiceLoader类有常量属性PREFIX = "META-INF/services/" 

service是传入的Driver.class，service.getName()获取Driver接口全类名，拼接得到SPI文件名，给后续读取得到实现类的类名，最后赋值给nextName，再交给LazyIterator#nextService去进行类的动态加载

  1. while ((pending == null) || !pending.hasNext()) {
  2. if (!configs.hasMoreElements()) {
  3. return false;
  4. }
  5. pending = parse(service, configs.nextElement());
  6. }
  7. nextName = pending.next();
  8. return true;

上面这段话，白话来讲就是，JVM去META-INF/services/下去找Driver接口名的文件，把文件中的内容读出来，也就是我们所要加载的类名，并交由Class.forName来进行动态类的加载。

至此，SPI大成！

标签:
声明

1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。

在线投稿：投稿 站长QQ：1888636

后台-插件-广告管理-内容页尾部广告（手机）
相关文章
关注我们

扫一扫关注我们，了解最新精彩内容

搜索
排行榜
最近发表
标签列表