Java SPI机制源码

于 2024-09-04 22:12:31 发布
阅读量364 收藏 7
点赞数 17
文章标签： java 后端 dubbo SPI 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42828342/article/details/140888507
版权

文章目录

SPI简介

Java的SPI（Service Provider Interface）机制允许第三方为应用程序提供插件式的扩展，而不需要修改应用程序本身的代码，从而实现了解耦。Java标准库本身就提供了SPI机制，通常是通过在META-INF/services目录下放置文件来实现的。

在这里插入图片描述
SPI机制的核心组件包括：

  • 服务接口：这是一个Java接口，定义了服务提供者需要实现的方法，应用程序将使用这个接口与具体的服务实现进行交互。

  • 服务实现：这是实现了服务接口的具体类，第三方可以为服务接口提供多个实现。

  • 服务提供者配置文件：这是一个位于META-INF/services目录下的文件，文件名与服务接口的全限定名相同，该文件包含了服务实现类的全限定名，每行一个接口的具体实现类，在运行时就可以加载这些实现类。

  • ServiceLoader：这是Java标准库中的一个类，用于加载服务实现，应用程序可以使用ServiceLoader来获取服务接口的所有具体实现类。

SPI的工作流程如下：

  1. 定义服务接口。

  2. 实现服务接口，创建具体的服务实现类。

  3. 在META-INF/services目录下创建服务提供者配置文件，列出所有服务实现类的全限定名。

  4. 使用ServiceLoader加载服务具体实现类，并根据需要使用它们。

总结就是说SPI机制使得应用程序可以在运行时动态地选择和加载服务实现，从而提高了应用程序的可扩展性和灵活性。

使用案例

首先定义一个服务的接口

public interface Service {
    void execute();
}

接着创建两个两个服务实现类去实现接口，并重写接口中的方法

public class Implementation1 implements Service {
    @Override
    public void execute() {
        System.out.println("服务实现类1");
    }
}

// Implementation2.java
public class Implementation2 implements Service {
    @Override
    public void execute() {
        System.out.println("服务实现类2");
    }
}

然后在META-INF/services目录下创建一个名为com.xydp.SPI.Service(全限定名要与接口的名称对应)的文件，用于存储服务实现类的全限定名。文件内容如下：
在这里插入图片描述

com.xydp.SPI.Implementation1
com.xydp.SPI.Implementation2

编写对应的测试类进行验证

public class SPITest {
    public static void main(String[] args) {
     ServiceLoader<Service> loader = ServiceLoader.load(Service.class);
        Iterator<Service> iterator = loader.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().getClass());
        }
    }
}

输出结果

class com.xydp.SPI.Implementation1
class com.xydp.SPI.Implementation2

SPI的应用

SPI 机制被用于加载和注册 JDBC 驱动程序，JDBC的使用方法如下
首先，导入依赖

 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.18</version>
</dependency>


public class JDBCTest {
    @SneakyThrows
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/hmdp?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8";
        String username = "root";
        String password = "1445413748";

            // 1. 加载JDBC驱动(Driver的静态代码块里面会注册JDBC驱动)
            //	实际上这行代码是可以省略的
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 2. 建立数据库连接
            Connection connection = DriverManager.getConnection(url, username, password);

            // 3. 创建Statement对象
            Statement statement = connection.createStatement();

            // 4. 执行SQL查询
            String sql = "SELECT * FROM test";
            ResultSet resultSet = statement.executeQuery(sql);

            // 5. 处理查询结果
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("value");
                System.out.println("ID: " + id + ", value: " + name);
            }
            //6. 关闭资源
                    connection.close();
        }

}

运行结果
在这里插入图片描述

可以知道JDBC在加载驱动后，节省了注册驱动这一步骤，这是因为在Driver类的静态代码块中已经注册了。

static {
    try {
    //注册驱动
        DriverManager.registerDriver(new Driver());
    } catch (SQLException var1) {
        throw new RuntimeException("Can't register driver!");
    }
}

除此之外，上面代码Class.forName(“com.mysql.cj.jdbc.Driver”)与SPI机制存在关联，会显示去加载Driver类，实际上这行代码是可以省略的，不写的话，下面的DriverManager的静态代码块就会通过ServiceLoader去加载配置文件下的Driver类。
DriverManager类的静态代码块

static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
}

静态代码块就会执行loadInitialDrivers()方法，

private static void loadInitialDrivers() {
        String drivers;
        try {
            drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
                public String run() {
                    return System.getProperty("jdbc.drivers");
                }
            });
        } catch (Exception ex) {
            drivers = null;
        }
      
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
							//通过SPI机制加载Driver类
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
							//获取对应的实现类
                try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                }
                return null;
            }
        });
    }

在不显示加载Driver类的情况下，ServiceLoader 会扫描类路径中的 META-INF/services 目录，查找 java.sql.Driver的配置文件，该配置文件中存在com.mysql.cj.jdbc.Driver这一行字符串，找到之后ServiceLoader通过反射的方式去加载Driver类。
在这里插入图片描述
对此我们可以进行验证JDBC的SPI机制，测试类如下

    public static void main(String[] args) {
        ServiceLoader<Driver> serviceLoader = ServiceLoader.load(Driver.class);
        Iterator<Driver> iterator = serviceLoader.iterator();
        while(iterator.hasNext()){ ;
            Driver driver = (Driver) iterator.next();
            System.out.println("驱动类的包:"+driver.getClass().getPackage()+"=======加载驱动类"+driver.getClass().getName());
        }
    }

运行结果
在这里插入图片描述由此可以得出结论JDBC确实是通过SPI机制去加载com.mysql.cj.jdbc.Driver类。

SPI机制源码

SPI主要是通过 ServiceLoader 类去解析配置文件，然后通过反射的方式创建对应的接口实现类。
ServiceLoader的主要成员

public final class ServiceLoader<S> implements Iterable<S>  
{  
	// 加载的默认配置文件目录
    private static final String PREFIX = "META-INF/services/";  
  
    // 需要被加载的 SPI 服务实现类
    private final Class<S> service;  
  
    // 该类加载器用于加载服务
    private final ClassLoader loader;  
  
    // 访问控制上下文，用于安全控制
    private final AccessControlContext acc;  
  
    // 按照实例化的顺序缓存服务实例
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();  
  
    // 懒查询迭代器
    private LazyIterator lookupIterator;

}
  1. 调用ServiceLoader.load 方法时，会根据接口和类加载器创建懒加载迭代器。
ServiceLoader<Service> loader = ServiceLoader.load(Service.class);
//源码如下
public static <S> ServiceLoader<S> load(Class<S> service, ClassLoader loader)  
{  
    return new ServiceLoader<>(service, loader);  
}


// 构造方法重新加载SPI服务
private ServiceLoader(Class<S> 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;
    // 重新加载SPI的服务
    reload();  
}

public void reload() {
	// 清空服务提供者的缓存列表
    providers.clear();
	// 根据接口类型和类加载器创建懒加载迭代器，达到懒加载的目的，防止资源被浪费
    lookupIterator = new LazyIterator(service, loader);
}

private LazyIterator(Class<S> service, ClassLoader loader) {
    this.service = service;
    this.loader = loader;
}
  1. 获取ServiceLoader 的 iterator

ServiceLoader 类的主要成员包含有LinkedHashMap实现的 providers，providers 用于用于缓存被成功加载的服务实例，key 是接口实现类的全限定名，value 是对应实现类的实例对象。

Iterator<Service> iterator = loader.iterator();
//源码如下
public Iterator<S> iterator() {
		//返回自定义的迭代器
        return new Iterator<S>() {
            
            // 创建缓存
            Iterator<Map.Entry<String,S>> knownProviders = providers.entrySet().iterator();

            
            public boolean hasNext() {
   
                if (knownProviders.hasNext())
                    return true;
                  
                return lookupIterator.hasNext();
            }

            public S next() {
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

        };
    }

3. 迭代器判断是否有数据

iterator.hasNext()
//源码如下
//判断是否还有数据
public boolean hasNext() {
    // 一开始缓存为空
    //（在调用next方法之后才会将服务对象实例放入该缓存，之后调用hasNext就会直接返回true）
    if (knownProviders.hasNext())
        return true;
    //一开始代码会执行到这
    return lookupIterator.hasNext();
}

public boolean hasNext() {
  	//acc访问控制默认为null，代码逻辑执行到这
    if (acc == null) {
        return hasNextService();
    } else {
        PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
            public Boolean run() { return hasNextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}

//判断是否还有服务
private boolean hasNextService() {
    // 判断是否还有服务实现类，有则返回true
    if (nextName != null) {
        return true;
    }
    // 配置刚开始为空
    if (configs == null) {
        try {
            //配置文件目录拼接接口名称 META-INF/services + 接口名称
            // META-INF/services/com.xydp.SPI.Service
            String fullName = PREFIX + service.getName();
         		//根据服务实现类的绝对路径加载配置
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
    // 判断集合是否为空或者已经遍历完毕
    while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
            return false;
        }
        // 从配置文件解析以下的服务实现类
        //class com.xydp.SPI.Implementation1
        //class com.xydp.SPI.Implementation2
        pending = parse(service, configs.nextElement());
    }
    // 遍历集合的服务实现类信息
    //第一次返回class com.xydp.SPI.Implementation1
    nextName = pending.next();
    return true;
}
  1. 获取服务实现类的信息
System.out.println(iterator.next().getClass());
//源码如下
public S next() {
    // 刚开始缓存为空，所以为false1不执行
    if (knownProviders.hasNext())
        return knownProviders.next().getValue();
    //第一次执行到这
    return lookupIterator.next();
}

public S next() {
 		//控制权限默认为空，执行这段代码
    if (acc == null) {
        return nextService();
    } else {
        PrivilegedAction<S> action = new PrivilegedAction<S>() {
            public S run() { return nextService(); }
        };
        return AccessController.doPrivileged(action, acc);
    }
}
//通过反射获取服务实例
private S nextService() {
		//此时 cn = com.xydp.SPI.Implementation1
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    // 使用反射，通过类的全限定名和类加载器得到类
    c = Class.forName(cn, false, loader);
	
    // 创建类的实例对象 
    S p = service.cast(c.newInstance());
    // 将实例对象放入缓存
    // key:com.xydp.SPI.Implementation1
    // value:Implementation1@28d25987
    providers.put(cn, p);
    // 返回实例对象
    return p;
}

SPI弊端：从源码可以知道SPI不能按需加载，需要通过 Iterator 形式遍历所有的服务实现类，无法根据参数名称来获取具体的服务实现类。

SPI与类加载器

在加载 SPI 服务时，需要指定类加载器 ClassLoader，否则无法找到具体的服务实现类，这是受限于双亲委派机制，该机制规定子类加载器可以使用父类已经加载的类，但是父类加载器无法使用子类已经加载的类。
(1) SPI 接口属于 Java 的核心库，是由顶层父类启动类加载器 BootstrapClassLoader所加载的；
(2 )SPI 的具体实现类是由系统类加载器AppClassLoader 加载的，顶层的父类启动类加载器 BootstrapClassLoader 是无法找到具体实现类的，所以需要指定类加载器 ClassLoader来加载。
主要有以下四种类加载器:

1 启动类加载器(Bootstrap ClassLoader)：启动类加载器是最顶层的类加载器，它负责加载Java核心API和核心类库。启动类加载器是由JVM实现的，不是由Java类实现的。用来加载java核心类库，无法被java程序直接引用。

2 扩展类加载器(extensions class loader):扩展类加载器是启动类加载器的子类加载器，它用来加载 Java 的扩展库。Java 虚拟机的实现会提供 一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。

3 系统类加载器（system class loader）：系统类加载器是扩展类加载器的子类加载器，加载路径主要包括应用程序的CLASSPATH环境变量指定的路径。可以通过ClassLoader.getSystemClassLoader()来获取它。

4 用户自定义类加载器，通过继承 java.lang.ClassLoader类重写findClass()方法的方式实现。

双亲委派机制

1.什么是双亲委派机制？

（1）当加载一个类时，当前类加载器先判断此类是否已经被加载，如果类已经被加载则返回；

（2）如果类没有被加载，则先委托父类加载（父类加载时会判断该类有没有被自己加载过），如果父类加载过则返回；如果没被加载过则继续向上委托；

（3）如果一直委托都无法加载，当前类加载器才会尝试自己加载。

2.双亲委派机制作用/优点

双亲委派机制是Java类加载器中的一个重要机制。它的主要作用有以下几点：

  1. 避免类的重复加载：Java中的类是由类加载器加载的，如果没有双亲委派机制，那么可能会出现多个类加载器加载同一个类的情况，造成资源的浪费。

  2. 保证Java核心API的类型安全：双亲委派机制保证了所有的Java应用都至少会使用java.* 开头的类库，而这些由系统类加载器所加载的类库在程序中有着至关重要的地位，比如java.lang.Object类，没有哪个类可以不使用Object类，所以为了防止用户自定义类篡改这些核心类。

    例如：实现了自定义的String时， 当应用程序通过系统类记载器加载核心类String时，它会首先委托给拓展类加载器，再委托给启动类加载器，启动类加载器就会加载核心String类，由于启动类加载器已经加载了正确的核心String类，所以应用程序不会加载到被篡改的String类。

3.为什么要打破双亲委派机制？

打破双亲委派机制的原因主要有以下几点：

  1. 灵活性：双亲委派机制虽然保证了类的唯一性和安全性，但也限制了Java类加载器的灵活性。有时候，我们需要自定义类加载器来实现一些特殊的功能，比如实现代码的热部署、动态加载第三方插件等。在这些场景下，打破双亲委派机制可以让我们更加灵活地控制类的加载过程。
  2. 隔离性：在某些场景下，**我们可能需要在同一个JVM中运行多个相互隔离的应用。这时候，我们可以使用自定义类加载器来实现类的隔离，从而避免类的冲突和安全问题。**打破双亲委派机制可以让我们更加灵活地控制类的加载过程，从而实现应用的隔离。
  3. 增加了类加载时间：在类加载的过程中，需要不断地查询并委托父类加载器，这意味着类加载所需要的时间可能会增加。在类数量庞大或类加载器层次比较深的情况下，这种时间延迟可能会变得更加明显。

4.如何打破双亲委派机制？

继承java.lang.ClassLoader类重写loadClass()方法来打破双亲委派机制，然后直接从自己的类路径中加载类，而不需要委托给父类加载器进行加载。

5.Tomcat是如何打破双亲委派机制的？

Tomcat是一个Java Web应用服务器，它可以运行多个Web应用。为了实现Web应用的隔离和独立部署，Tomcat使用了自定义类加载器来打破双亲委派机制。

在Tomcat中，每个Web应用都有一个对应的WebappClassLoader，它继承了java.lang.ClassLoader类。WebappClassLoader的主要作用是加载Web应用的类和资源。为了实现类的隔离，WebappClassLoader重写了loadClass方法，而不是findClass方法。在loadClass方法中，WebappClassLoader首先尝试从自己的类路径中加载类，如果找不到，再委托给父类加载器进行加载。这样，每个Web应用都可以使用自己的类加载器来加载类，从而实现了类的隔离。

6.如何自定义类加载器？

继承java.lang.ClassLoader类重写findClass()方法实现自定义类加载器。

vibag
关注
  • 17
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java SPI 机制（SPI实战+ServiceLoader源码分析+SPI 应用场景+破坏双亲委派）
06-21
Java SPI 机制详解 Java SPI 机制，全称 Service Provider Interface，是 Java 内置的服务发现机制。SPI 机制的主要思想是解耦，通过提供一个标准接口，允许第三方提供实现类，而无需在程序中硬编码。SPI 机制广泛...
java SPI机制实现服务接口和服务实现分离源码Demo
03-22
SPI机制的核心是`java.util.ServiceLoader`类，它允许我们按照约定在`META-INF/services`目录下创建配置文件，来指定哪些类实现了特定的服务接口。 服务接口定义：在SPI机制中，首先我们需要定义一个服务接口，这个...
Java类加载及SPI机制.pdf
06-27
而SPI机制则提供了一种通用的方式来扩展Java平台功能，使得Java开发者可以在不修改源码的情况下增强平台或第三方库的功能。在实际开发过程中，深入理解和正确使用这两个机制，对于提升软件的灵活性、可维护性以及可...
java spi实现工程
03-27
Java SPI（Service Provider Interface）是Java平台提供的一种服务发现机制，允许JVM在运行时动态加载服务提供商。这个机制使得开发者可以扩展应用的功能，而无需修改原有代码。SPI的核心概念在于，服务接口由主程序...
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1189
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 675
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 562
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8680
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 399
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 841
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1682
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 544
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
Java并发编程 进程与线程
m0_56369671的博客
08-28 1385
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
SpringBoot SSM vue在线作业考试系统
yinjl123456的博客
08-30 1251
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java 虚方法表（虚函数）
一心向阳，光芒万丈
08-31 673
虚方法表是一个类的内部数据结构，用于支持方法的动态绑定（即运行时多态）。每个类在加载时会生成一个虚方法表，其中包含了类中所有虚方法的地址。方法地址的存储：虚方法表存储了类的所有方法（包括继承自父类的方法）的内存地址或指针。这些方法在虚方法表中的顺序与它们在类中声明的顺序一致。动态绑定：当方法调用发生时，JVM 会根据对象的实际类型（而不是声明类型）来查找并调用正确的方法实现。这种机制允许程序在运行时决定调用哪个方法，从而实现多态。被privatestaticfinal。
计算机毕业设计选题推荐-公司考勤管理系统-Java/Python项目实战
IT研究室的博客
09-01 1135
随着企业规模的不断扩大和员工数量的增加，传统的人工考勤管理方式已经无法满足现代企业对高效、精准和自动化管理的需求。根据《人力资源管理杂志》2022年的统计数据，超过70%的中大型企业表示，考勤管理系统已经成为企业日常管理中不可或缺的工具。然而，仍有近40%的企业采用人工或半自动化的方式进行考勤管理，这不仅耗费了大量的人力资源，还容易出现错误和遗漏，导致考勤数据不准确，影响企业的人事管理和员工的工作体验。此外，随着远程办公和弹性工作制的普及，企业对灵活、智能化的考勤管理系统的需求愈发强烈。
Java学习高级六
weixin_45730243的博客
09-02 181
【代码】Java学习高级六。
MyBaits连接字符串和MyBatis的常见错误(BindingException)
Shootingmemory的博客
09-02 140
这里的mapper一定是和mybatis有一个table的距离，否则判断不出来，当然出现下面的情况这样也是正确的。要注意你mapper所在文件主路径是否和yml中的配置一致，更需要找到他们之间配置的关系。查看相关信息是否一 一对应，如果没有则会导致文件互相无法找到。在applicaiton.yml中配置方式应该如图所示。出现上述错误的解决方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值