1、什么是SPI？

SPI是串行外设接口(Serial Peripheral Interface)的缩写。是 Motorola 公司推出的一
种同步串行接口技术，是一种高速的，全双工，同步的通信总线。

2、SPI优点
支持全双工通信
通信简单
数据传输速率块

3、缺点
没有指定的流控制，没有应答机制确认是否接收到数据，所以跟IIC总线协议比较在数据
可靠性上有一定的缺陷。

4、特点
1）：高速、同步、全双工、非差分、总线式
2）：主从机通信模式

5、协议通信时序详解
1）：SPI的通信原理很简单，它以主从方式工作，这种模式通常有一个主设备和一个或多
个从设备，需要至少4根线，事实上3根也可以(单向传输时)。也是所有基于SPI的设备共
有的，它们是SDI(数据输入)、SDO(数据输出)、SCLK(时钟)、CS(片选)。
(1)SDO/MOSI – 主设备数据输出，从设备数据输入;
(2)SDI/MISO – 主设备数据输入，从设备数据输出;
(3)SCLK – 时钟信号，由主设备产生;
(4)CS/SS – 从设备使能信号，由主设备控制。当有多个从设备的时候，因为每个从设
备上都有一个片选引脚接入到主设备机中，当我们的主设备和某个从设备通信时将需
要将从设备对应的片选引脚电平拉低或者是拉高。

2）：需要说明的是，我们SPI通信有4种不同的模式，不同的从设备可能在出厂是就是配
置为某种模式，这是不能改变的；但我们的通信双方必须是工作在同一模式下，所以我们
可以对我们的主设备的SPI模式进行配置，通过CPOL（时钟极性）和CPHA（时钟相位）来
控制我们主设备的通信模式，具体如下：
Mode0：CPOL=0，CPHA=0
Mode1：CPOL=0，CPHA=1
Mode2：CPOL=1，CPHA=0
Mode3：CPOL=1，CPHA=1

时钟极性CPOL是用来配置SCLK的电平出于哪种状态时是空闲态或者有效态，时钟相位CPHA
是用来配置数据采样是在第几个边沿：
CPOL=0，表示当SCLK=0时处于空闲态，所以有效状态就是SCLK处于高电平时
CPOL=1，表示当SCLK=1时处于空闲态，所以有效状态就是SCLK处于低电平时
CPHA=0，表示数据采样是在第1个边沿，数据发送在第2个边沿
CPHA=1，表示数据采样是在第2个边沿，数据发送在第1个边沿

例如：
CPOL=0，CPHA=0：此时空闲态时，SCLK处于低电平，数据采样是在第1个边沿，也就是
SCLK由低电平到高电平的跳变，所以数据采样是在上升沿，数据发送是在下降沿。

CPOL=0，CPHA=1：此时空闲态时，SCLK处于低电平，数据发送是在第1个边沿，也就是
SCLK由低电平到高电平的跳变，所以数据采样是在下降沿，数据发送是在上升沿。

CPOL=1，CPHA=0：此时空闲态时，SCLK处于高电平，数据采集是在第1个边沿，也就是
SCLK由高电平到低电平的跳变，所以数据采集是在下降沿，数据发送是在上升沿。

CPOL=1，CPHA=1：此时空闲态时，SCLK处于高电平，数据发送是在第1个边沿，也就是
SCLK由高电平到低电平的跳变，所以数据采集是在上升沿，数据发送是在下降沿。

       

需要注意的是：我们的主设备能够控制时钟，因为我们的SPI通信并不像UART或者IIC通信
那样有专门的通信周期，有专门的通信起始信号，有专门的通信结束信号；所以我们的
SPI协议能够通过控制时钟信号线，当没有数据交流的时候我们的时钟线要么是
保持高电平要么是保持低电平。

6、内部工作机制

SSPSR 是 SPI 设备内部的移位寄存器(Shift Register). 它的主要作用是根据 SPI
时钟信号状态, 往 SSPBUF 里移入或者移出数据, 每次移动的数据大小由 Bus-Width 以
及 Channel-Width 所决定.

1.1、小例子

　　首先，我们需要定义一个接口，SPIService

1 package com.viewscenes.netsupervisor.spi;
2 public interface SPIService 
3 {
4     void execute();
5 }

　　然后，定义两个实现类，没别的意思，只输入一句话。

 1 package com.viewscenes.netsupervisor.spi;
 2 public class SpiImpl1 implements SPIService
 3 {
 4     public void execute() 
 5     {
 6         System.out.println("SpiImpl1.execute()");
 7     }
 8 }
 9 ----------------------我是乖巧的分割线----------------------
10 package com.viewscenes.netsupervisor.spi;
11 public class SpiImpl2 implements SPIService
12 {
13     public void execute() 
14     {
15         System.out.println("SpiImpl2.execute()");
16     }
17 }

　　最后呢，要在ClassPath路径下配置添加一个文件。文件名字是接口的全限定类名，内容是实现类的全限定类名，多个实现类用换行符分隔。 文件路径如下：

 

 　　内容就是实现类的全限定类名：

1 com.viewscenes.netsupervisor.spi.SpiImpl1
2 com.viewscenes.netsupervisor.spi.SpiImpl2

1.2、测试

　　然后我们就可以通过ServiceLoader.load或者Service.providers方法拿到实现类的实例。其中，Service.providers包位于sun.misc.Service，而ServiceLoader.load包位于java.util.ServiceLoader。

 1 public class Test {
 2     public static void main(String[] args) {    
 3         Iterator<SPIService> providers = Service.providers(SPIService.class);
 4         ServiceLoader<SPIService> load = ServiceLoader.load(SPIService.class);
 5 
 6         while(providers.hasNext()) {
 7             SPIService ser = providers.next();
 8             ser.execute();
 9         }
10         System.out.println("--------------------------------");
11         Iterator<SPIService> iterator = load.iterator();
12         while(iterator.hasNext()) {
13             SPIService ser = iterator.next();
14             ser.execute();
15         }
16     }
17 }

 

　　两种方式的输出结果是一致的：

1 SpiImpl1.execute()
2 SpiImpl2.execute()
3 --------------------------------
4 SpiImpl1.execute()
5 SpiImpl2.execute()

二、源码分析

　　我们看到一个位于sun.misc包，一个位于java.util包，sun包下的源码看不到。我们就以ServiceLoader.load为例，通过源码看看它里面到底怎么做的。

2.1、ServiceLoader

　　首先，我们先来了解下ServiceLoader，看看它的类结构。

 

 1 public final class ServiceLoader<S> implements Iterable<S>
 2     //配置文件的路径
 3     private static final String PREFIX = "META-INF/services/";
 4     //加载的服务类或接口
 5     private final Class<S> service;
 6     //已加载的服务类集合
 7     private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
 8     //类加载器
 9     private final ClassLoader loader;
10     //内部类，真正加载服务类
11     private LazyIterator lookupIterator;
12 }

2.2、Load

　　load方法创建了一些属性，重要的是实例化了内部类，LazyIterator。最后返回ServiceLoader的实例。

 1 public final class ServiceLoader<S> implements Iterable<S>
 2     private ServiceLoader(Class<S> svc, ClassLoader cl) {
 3         //要加载的接口
 4         service = Objects.requireNonNull(svc, "Service interface cannot be null");
 5         //类加载器
 6         loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
 7         //访问控制器
 8         acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
 9         //先清空
10         providers.clear();
11         //实例化内部类 
12         LazyIterator lookupIterator = new LazyIterator(service, loader);
13     }
14 }

 

2.3、查找实现类

　　查找实现类和创建实现类的过程，都在LazyIterator完成。当我们调用iterator.hasNext和iterator.next方法的时候，实际上调用的都是LazyIterator的相应方法。

 1 public Iterator<S> iterator() {
 2     return new Iterator<S>() {
 3         public boolean hasNext() {
 4             return lookupIterator.hasNext();
 5         }
 6         public S next() {
 7             return lookupIterator.next();
 8         }
 9         .......
10     };
11 }

 

　　所以，我们重点关注lookupIterator.hasNext()方法，它最终会调用到hasNextService。

 

 1 private class LazyIterator implements Iterator<S>{
 2     Class<S> service;
 3     ClassLoader loader;
 4     Enumeration<URL> configs = null;
 5     Iterator<String> pending = null;
 6     String nextName = null; 
 7     private boolean hasNextService() {
 8         //第二次调用的时候，已经解析完成了，直接返回
 9         if (nextName != null) {
10             return true;
11         }
12         if (configs == null) {
13             //META-INF/services/ 加上接口的全限定类名，就是文件服务类的文件
14             //META-INF/services/com.viewscenes.netsupervisor.spi.SPIService
15             String fullName = PREFIX + service.getName();
16             //将文件路径转成URL对象
17             configs = loader.getResources(fullName);
18         }
19         while ((pending == null) || !pending.hasNext()) {
20             //解析URL文件对象，读取内容，最后返回
21             pending = parse(service, configs.nextElement());
22         }
23         //拿到第一个实现类的类名
24         nextName = pending.next();
25         return true;
26     }
27 }

2.4、创建实例

　　当然，调用next方法的时候，实际调用到的是，lookupIterator.nextService。它通过反射的方式，创建实现类的实例并返回。

 1 private class LazyIterator implements Iterator<S>{
 2     private S nextService() {
 3         //全限定类名
 4         String cn = nextName;
 5         nextName = null;
 6         //创建类的Class对象
 7         Class<?> c = Class.forName(cn, false, loader);
 8         //通过newInstance实例化
 9         S p = service.cast(c.newInstance());
10         //放入集合，返回实例
11         providers.put(cn, p);
12         return p; 
13     }
14 }

 

　　看到这儿，我想已经很清楚了。获取到类的实例，我们自然就可以对它为所欲为了！

三、JDBC中的应用

　　我们开头说，SPI机制为很多框架的扩展提供了可能，其实JDBC就应用到了这一机制。回忆一下JDBC获取数据库连接的过程。在早期版本中，需要先设置数据库驱动的连接，再通过DriverManager.getConnection获取一个Connection。

 

1 String url = "jdbc:mysql:///consult?serverTimezone=UTC";
2 String user = "root";
3 String password = "root";
4 
5 Class.forName("com.mysql.jdbc.Driver");
6 Connection connection = DriverManager.getConnection(url, user, password);

 

　　在较新版本中(具体哪个版本，笔者没有验证)，设置数据库驱动连接，这一步骤就不再需要，那么它是怎么分辨是哪种数据库的呢？答案就在SPI。

3.1、加载

　　我们把目光回到DriverManager类，它在静态代码块里面做了一件比较重要的事。很明显，它已经通过SPI机制， 把数据库驱动连接初始化了。

1 public class DriverManager {
2     static {
3         loadInitialDrivers();
4         println("JDBC DriverManager initialized");
5     }
6 }

　　具体过程还得看loadInitialDrivers，它在里面查找的是Driver接口的服务类，所以它的文件路径就是：META-INF/services/java.sql.Driver。

 1 public class DriverManager {
 2     private static void loadInitialDrivers() {
 3         AccessController.doPrivileged(new PrivilegedAction<Void>() {
 4             public Void run() {
 5                 //很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
 6                 //所以它要找的就是META-INF/services/java.sql.Driver文件
 7                 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
 8                 Iterator<Driver> driversIterator = loadedDrivers.iterator();
 9                 try{
10                     //查到之后创建对象
11                     while(driversIterator.hasNext()) {
12                         driversIterator.next();
13                     }
14                 } catch(Throwable t) {
15                     // Do nothing
16                 }
17                 return null;
18             }
19         });
20     }
21 }

　　那么，这个文件哪里有呢？我们来看MySQL的jar包，就是这个文件，文件内容为：com.mysql.cj.jdbc.Driver。

 

 3.2、创建实例

　　上一步已经找到了MySQL中的com.mysql.cj.jdbc.Driver全限定类名，当调用next方法时，就会创建这个类的实例。它就完成了一件事，向DriverManager注册自身的实例。

 1 public class Driver extends NonRegisteringDriver implements java.sql.Driver {
 2     static {
 3         try {
 4             //注册
 5             //调用DriverManager类的注册方法
 6             //往registeredDrivers集合中加入实例
 7             java.sql.DriverManager.registerDriver(new Driver());
 8         } catch (SQLException E) {
 9             throw new RuntimeException("Can't register driver!");
10         }
11     }
12     public Driver() throws SQLException {
13         // Required for Class.forName().newInstance()
14     }
15 }

 

3.3、创建Connection

　　在DriverManager.getConnection()方法就是创建连接的地方，它通过循环已注册的数据库驱动程序，调用其connect方法，获取连接并返回。

 

 1 private static Connection getConnection(
 2         String url, java.util.Properties info, Class<?> caller) throws SQLException {   
 3     //registeredDrivers中就包含com.mysql.cj.jdbc.Driver实例
 4     for(DriverInfo aDriver : registeredDrivers) {
 5         if(isDriverAllowed(aDriver.driver, callerCL)) {
 6             try {
 7                 //调用connect方法创建连接
 8                 Connection con = aDriver.driver.connect(url, info);
 9                 if (con != null) {
10                     return (con);
11                 }
12             }catch (SQLException ex) {
13                 if (reason == null) {
14                     reason = ex;
15                 }
16             }
17         } else {
18             println("    skipping: " + aDriver.getClass().getName());
19         }
20     }
21 }

 

3.4、再扩展

　　既然我们知道JDBC是这样创建数据库连接的，我们能不能再扩展一下呢？如果我们自己也创建一个java.sql.Driver文件，自定义实现类MyDriver，那么，在获取连接的前后就可以动态修改一些信息。  还是先在项目ClassPath下创建文件，文件内容为自定义驱动类com.viewscenes.netsupervisor.spi.MyDriver

　　我们的MyDriver实现类，继承自MySQL中的NonRegisteringDriver，还要实现java.sql.Driver接口。这样，在调用connect方法的时候，就会调用到此类，但实际创建的过程还靠MySQL完成。

 1 package com.viewscenes.netsupervisor.spi
 2 
 3 public class MyDriver extends NonRegisteringDriver implements Driver{
 4     static {
 5         try {
 6             java.sql.DriverManager.registerDriver(new MyDriver());
 7         } catch (SQLException E) {
 8             throw new RuntimeException("Can't register driver!");
 9         }
10     }
11     public MyDriver()throws SQLException {}
12     
13     public Connection connect(String url, Properties info) throws SQLException {
14         System.out.println("准备创建数据库连接.url:"+url);
15         System.out.println("JDBC配置信息："+info);
16         info.setProperty("user", "root");
17         Connection connection =  super.connect(url, info);
18         System.out.println("数据库连接创建完成!"+connection.toString());
19         return connection;
20     }
21 }
22 --------------------输出结果---------------------
23 
`12准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
24 JDBC配置信息：{user=root, password=root}
25 数据库连接创建完成[email protected]