SpringBoot自动配置的原理篇，剖析自动配置原理；实现自定义启动类！附有代码及截图详细讲解

SpringBoot 自动配置

Condition

Condition 是在Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作

思考：SpringBoot是如何知道要创建哪个Bean的？比如SpringBoot是如何知道要创建RedisTemplate的？

演示1:
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1. 没有添加坐标前，发现为空，报错
    ConfigurableApplicationContext context =
    SpringApplication.run(SpringbootCondition01Application.class, args);
    Object redisTemplate = context.getBean("redisTemplate");
    System.out.println(redisTemplate);
2. 有添加坐标前，发现有对象
    ConfigurableApplicationContext context =
    SpringApplication.run(SpringbootCondition01Application.class, args);
    Object redisTemplate = context.getBean("redisTemplate");
    System.out.println(redisTemplate);
疑问，他怎么知道的配置哪个类案例1：

案例1：

Spring的IOC容器中有一个User的Bean现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载

代码实现：

  1. POJO实体类：User

    public class User {
}

  2. 现在对User的加载有条件，不能直接用@Component注入，需要写配置类通过@Bean的方式注入

    @Configuration
public class UserConfig {
    @Bean
    @Conditional(value = ClassCondition.class)    // 注入条件
    public User user(){
        return  new User();
    }
}

    @Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之

  3. 创建ClassCondition类实现Condition接口，重写matches方法

    public class ClassCondition implements Condition {
  @Override
  public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
    boolean falg = true;
    try {
      Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
    } catch (ClassNotFoundException e) {
      falg=false;
    }
    return falg;
  }
}

  4. 启动类：

    @SpringBootApplication
public class SpringbootCondition01Application {
  public static void main(String[] args) {
    //启动SpringBoot的应用，返回Spring的IOC容器
    ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition01Application.class,args);
    
    //获取Bean，redisTemplate
    //情况1 没有添加坐标前，发现为空
    //情况2 有添加坐标前，发现有对象
    Object user = context.getBean("user");
    System.out.println(user);
  }
}

  5. 测试，通过pom文件中对Jedis坐标是否注释

    1. Jedi坐标未注释，可以打印出User对象地址

    2. Jedis坐标被注释掉，报错，不打印User对象地址

案例二：

在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定

实现步骤：

  1. 不使用@Conditional(ClassCondition.class)注解
  2. 自定义注解@ConditionOnClass,因为他和之前@Conditional注解功能一直，所以直接复制
  3. 编写ClassCondition中的matches方法

代码实现：

  1. POJO实体类User和案例1相同

  2. User的注入条件需要改变，使用@ConditionOnClass

    @Configuration
public class UserConfig {
    @Bean
//    @ConditionOnClass(value = "redis.clients.jedis.Jedis")  有jedis坐标注入User
    @ConditionOnClass(value = {"redis.clients.jedis.Jedis","com.alibaba.fastjson.JSON"})  //jedis和json都有才注入 
    public User user(){
        return new User();
    }
}

  3. 重写matches方法

    public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        System.out.println("map:"+map);
        String[] value = (String[]) map.get("value");

        boolean isok = true;
        try {
            for(String val : value){
                Class<?> cls = Class.forName(val);
            }
        }catch (ClassNotFoundException e){
            isok = false;
        }
        return isok;
    }
}

  4. 自定义注解

    @Target({ElementType.TYPE,ElementType.METHOD})//可以修饰在类与方法上
@Retention(RetentionPolicy.RUNTIME)//注解生效节点runtime
@Documented//生成文档
@Conditional(value = ClassCondition.class)
public @interface ConditionOnClass {
    String[] value(); //设置此注解的属性redis.clients.jedis.Jedis
}

  5. 启动类

    @SpringBootApplication
public class SpringbootCondition02Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition02Application.class, args);
        Object user = context.getBean("user");
        System.out.println(user);
    }
}

  6. 测试：通过pom文件中的Jedis和JSON坐标测试

    • Jedis和JSON坐标都有：打印User对象地址
    • 只有一个坐标或者都没有：报错，不打印User对象地址

Condition总结

自定义条件：

  1. 定义条件类：自定义类实现Condition接口，重写 matches 方法，在 matches 方法中进行逻辑判断，返回boolean值 。matches 方法两个参数：
    • context：上下文对象，可以获取属性值，获取类加载器，获取BeanFactory等。
    • metadata：元数据对象，用于获取注解属性。
  2. 判断条件： 在初始化Bean时，使用 @Conditional(条件类.class)注解

SpringBoot提供的常用条件注解：

一下注解在springBoot-autoconfigure的condition包下

  1. ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean
  2. ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
  3. ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean
  4. ConditionalOnBean：判断环境中有对应Bean才初始化Bean

@Enable注解

SpringBoot中提供了很多Enable开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注 解导入一些配置类，实现Bean的动态加载

思考 SpringBoot 工程是否可以直接获取jar包中定义的Bean？

@Enable的底层核心：@Import

@Enable底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：

  1. 导入Bean
  2. 导入配置类
  3. 导入 ImportSelector 实现类。一般用于加载配置文件中的类
  4. 导入 ImportBeanDefinitionRegistrar 实现类

导入Bean

代码实现：

需要用到多模块编程，项目结构如图：

在这里插入图片描述

springboot_enable_02：

  1. springboot项目，pom文件不需要格外到坐标

  2. User

    public class User {
}

  3. UserConfig

    @Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
}

  4. EnableUser自定义注解

    @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

  5. 启动类

    @SpringBootApplication
public class SpringbootEnable02Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable02Application.class, args);
        Object user = context.getBean("user");   // enable_02中肯定能取到User
        System.out.println(user);
    }
}

springboot_enable_01：

  1. pom文件导入springboot_enable_02的gav：

    <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

<!--模块2-->
<dependency>
  <groupId>com.dong</groupId>
  <artifactId>springboot_enable_02</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</dependency>

  2. 测试：

    //@Import(User.class)
//@Import(UserConfig.class)
//@EnableUser
@ComponentScan("com.dong.springboot_enable_02.config")
@SpringBootApplication
public class SpringbootEnable01Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable01Application.class, args);
        Object user = context.getBean(User.class);
        System.out.println(user);
    }
}

    因为enable_01导如了enable_02的坐标，相当是把02的所有代码拷贝在与01的启动类同级目录下，如果包名和包的层级都相同，就可以直接装配User类，但是包的层级不同就必须加注解

    • @Import(User.class)：对应第一个使用场景

      ​ 导入02中的User类

    • @Import(UserConfig.class)：对应第二个使用场景

      ​ 加载02中的UserConfig配置类，加载配置类中所有的方法和类

    • @EnableUser：

      ​ 自定义的注解，包装了一个@Import(User.class)

    • @ComponentScan(“com.dong.springboot_enable_02.config”)：

      ​ 扫描包，加载类和配置类

导入配置类

见上方示例的@Import(UserConfig.class)，导入配置类加载配置类中所有的方法和类

导入ImportSelector 实现类

导入 ImportBeanDefinitionRegistrar 实现类

ImportSelector 和 ImportBeanDefinitionRegistrar 一起演示

代码实现：

​ 项目结构
在这里插入图片描述

springboot_enable_04

  1. springboot项目，pom文件不需要额外到坐标

  2. POJO

    实体类：User

    public class User {
}

    Student

    public class Student {
}

  3. UserConfig配置类

    @Configuration
public class UserConfig {
    @Bean
    public User user(){
        return  new User();
    }
}

  4. MyImportSelector

    public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.dong.springboot_enable_04.pojo.User","com.dong.springboot_enable_04.pojo.Student"};
    }
}

  5. MyImportBeanDefinitionRegistrar

    public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user1",beanDefinition);
    }
}

springboot_enable_03

  1. springboot_enable_03pom文件导入springboot_enable_04坐标

    <dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
	<!--springboot_enable_04坐标-->
  <dependency>
    <groupId>com.dong</groupId>
    <artifactId>springboot_enable_04</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </dependency>
</dependencies>

  2. 测试：启动类

    @ComponentScan("com.dong.springboot_enable_04.config")
@Import(User.class)
@Import(UserConfig.class)
@Import(MyImportSelector.class)
@Import(MyImportBeanDefinitionRegistrar.class)
@SpringBootApplication
public class SpringbootEnable03Application {
  public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable03Application.class, args);
    User user = context.getBean(User.class);
    System.out.println(user);

    Student student = context.getBean(Student.class);
    System.out.println(student);

    User user1 = (User) context.getBean("user1");
    System.out.println(user1);
  }
}

    • @Import(MyImportSelector.class)：对应第三个使用场景

      ​ MyImportSelector实现了ImportSelector接口，重写了selectImports方法，在字符出数组中的完全相对路径即注入了容器，因为引入了enable_04，所以03中可以获取到User和Student

    • @Import(MyImportBeanDefinitionRegistrar.class)：对应第四个使用场景

      ​ MyImportBeanDefinitionRegistrar实现了ImportBeanDefinitionRegistrar接口，registerBeanDefinitions方法，在此方法中就可以对Bean进行注册，如案例演示，04注入了一个User对象，id是user1，所以03中就可以获取到User这个对象，打印出地址

@EnableAutoConfiguration注解

  • 主启动类

    //@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
  public static void main(String[] args) {
    //以为是启动了一个方法，没想到启动了一个服务
    SpringApplication.run(SpringbootApplication.class, args);
  }
}

  • @SpringBootApplication注解内部

    @SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
// ......
}

    1. @ComponentScan

      这个注解在Spring中很重要 ,它对应XML配置中的元素。

      作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

    2. @SpringBootConfiguration

      作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；

      //@SpringBootConfiguration注解内部
//这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
@Configuration
public @interface SpringBootConfiguration {}
//里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用
@Component
public @interface Configuration {}

  • AutoConfigurationPackage ：自动配置包

    //AutoConfigurationPackage的子注解
//Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

  • @EnableAutoConfiguration开启自动配置功能

    以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

    @Import({AutoConfigurationImportSelector.class})：给容器导入组件 ；

    AutoConfigurationImportSelector ：自动配置导入选择器，给容器中导入一些组件

AutoConfigurationImportSelector.class
					↓
		selectImports方法
					↓
this.getAutoConfigurationEntry(annotationMetadata)方法
					↓
this.getCandidateConfigurations(annotationMetadata, attributes)方法
					↓
方法体：
		List<String> configurations =
SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass
(), this.getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
return configurations;
					↓
在所有包名叫做autoConfiguration的包下面都有META-INF/spring.factories文件

总结原理：

  • @EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)

    来加载配置类。

  • 配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot

    应用启动时，会自动加载这些配置类，初始化Bean

  • 并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

SpringBoot自动配置原理扒源代码图解

在这里插入图片描述

自定义启动类的实现

案例需求：

自定义redis-starter，要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean

参考：

可以参考mybatis启动类的应用

在这里插入图片描述

实现步骤：

  1. 创建redis-spring-boot-autoconfigure模块
  2. 创建redis-spring-boot-starter模块,依赖redis-spring-boot-autoconfigure的模块
  3. 在redis-spring-boot-autoconfigure模块中初始化Jedis的Bean，并定义META-INF/spring.factories文件
  4. 在测试模块中引入自定义的redis-starter依赖，测试获取Jedis的Bean，操作redis

代码实现演示：

​ 目录结构

  • redis-spring-boot-autoconfigure模块

    1. pom文件

      <dependencies>
  <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <!--spring-boot-starter-test注释掉了-->
</deendencies>

    2. RedisAutoConfiguration配置类

      @Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    @Bean
    public Jedis jedis(RedisProperties redisProperties){
        return new Jedis(redisProperties.getHost(),redisProperties.getPort());
    }
}

    3. 动态获取主机号和端口号的类

      @ConfigurationProperties(prefix = "spring.redis")  
//如果配置文件中有就读取配置文件中的spring.redis下面get、set方法就会对host和port达到动态效果，如果配置文件中没有spring.redis就默认localhost和6379
public class RedisProperties {
    private String host="localhost";
    private int port=6379;
    public String getHost() {
        return host;
    }
    public void setHost(String host) {
        this.host = host;
    }
    public int getPort() {
        return port;
    }
    public void setPort(int port) {
        this.port = port;
    }
}

    4. 在resources目录下创建META-INF文件夹，下创建spring.factories文件，写入键值

      org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.dong.redisspringbootautoconfigure.config.RedisAutoConfiguration

  • redis-spring-boot-start模块

    此模块只需要在pom文件中导入上个模块的gav，test文件夹和java下的目录都可以删除

    <dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!--引入自定义的redis-spring-boot-autoconfigure-->
    <dependency>
        <groupId>com.dong</groupId>
        <artifactId>redis-spring-boot-autoconfigure</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

  • 测试模块springboot_enable_05

    1. pom文件导入redis-spring-boot-start模块gav

      <dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <!--导入自定义启动类-->
  <dependency>
    <groupId>com.dong</groupId>
    <artifactId>redis-spring-boot-start</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </dependency>
</dependencies>

    2. yaml配置文件修改端口

      spring:
  redis:
    port: 6060

    3. 测试：

      @SpringBootApplication
public class SpringbootEnable05Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable05Application.class, args);
        Jedis bean = context.getBean(Jedis.class);
        System.out.println(bean);
    }
}

      输出内容：BinaryJedis{Connection{DefaultJedisSocketFactory{localhost:6060}}}

      说明走了我们自定义的启动器

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/125232.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

剖析WPF模板机制的内部实现

剖析WPF模板机制的内部实现

剖析WPF模板机制的内部实现 众所周知&#xff0c;在WPF框架中&#xff0c;Visual类是可以提供渲染&#xff08;render&#xff09;支持的最顶层的类&#xff0c;所有可视化元素&#xff08;包括UIElement、FrameworkElment、Control等&#xff09;都直接或间接继承自Visual类。…
阅读更多...
单例模式 rust和java的实现

单例模式 rust和java的实现

文章目录 单例模式介绍应用实例&#xff1a;优点使用场景 架构图JAVA 实现单例模式的几种实现方式 rust实现 rust代码仓库 单例模式 单例模式&#xff08;Singleton Pattern&#xff09;是最简单的设计模式之一。这种类型的设计模式属于创建型模式&#xff0c;它提供了一种创建…
阅读更多...
好用的工具

好用的工具

阅读更多...
【第2章 Node.js基础】2.4 Node.js 全局对象...持续更新

【第2章 Node.js基础】2.4 Node.js 全局对象...持续更新

什么是Node.js 全局对象 对于浏览器引擎来说&#xff0c;JavaScript 脚本中的 window 是全局对象&#xff0c;而Node.js程序中的全局对象是 global&#xff0c;所有全局变量(除global本身外)都是global 对象的属性。全局变量和全局对象是所有模块都可以调用的。Node.is 的全局…
阅读更多...
docker部署mongodb

docker部署mongodb

1&#xff1a;拉去momgodb镜像 2&#xff1a;拉去成功后&#xff0c;通过docker-compose.yml配置文件启动mongodb&#xff0c;docker-compose.yml配置如下 version: 3.8 services:mongodb-1:container_name: mongodbimage: mongo ports:- "27017:27017"volumes:- G:…
阅读更多...
TCP/IP详解

TCP/IP详解

TCP/IP详解 一、网络基础1.TCP/IP网络分层2.IP地址和端口号3.封装与分用4.客户-服务端模型 二、链路层1.以太网IEEE802封装2.环回接口 Loopback Interface3.最大传输单元MTU和路径MTU 三、网络层 - IP1.IP首部的关键信息2.IP路由选择3.子网寻址和子网掩码4.ICMP和IGMP 四、传输…
阅读更多...
python爬虫hook定位技巧、反调试技巧、常用辅助工具

python爬虫hook定位技巧、反调试技巧、常用辅助工具

一、浏览器调试面板介绍 二、hook定位、反调试 Hook 是一种钩子技术&#xff0c;在系统没有调用函数之前&#xff0c;钩子程序就先得到控制权&#xff0c;这时钩子函数既可以加工处理&#xff08;改变&#xff09;该函数的执行行为&#xff0c;也可以强制结束消息的传递。简单…
阅读更多...
Postgresql数据类型-布尔类型

Postgresql数据类型-布尔类型

前面介绍了PostgreSQL支持的数字类型、字符类型、时间日期类型&#xff0c;这些数据类型是关系型数据库的常规数据类型&#xff0c;此外PostgreSQL还支持很多非常规数据类型&#xff0c;比如布尔类型、网络地址类型、数组类型、范围类型、json/jsonb类型等&#xff0c;从这一节…
阅读更多...
python poetry的教程

python poetry的教程

Poetry Python世界中&#xff0c;Poetry是一个近年来备受瞩目的工具&#xff0c;它为开发者提供了一个灵活且强大的依赖管理解决方案。Poetry可以帮助开发者管理项目的依赖关系&#xff0c;同时提供了一系列的工具和功能&#xff0c;使开发者能够更轻松地创建和管理复杂的项目。…
阅读更多...
简单的小调度器

简单的小调度器

收集小资源下的简单调度器 https://github.com/sigma318/TOS/tree/master https://github.com/smset028/xxddq
阅读更多...
Go cobra简介

Go cobra简介

当你需要为你的 Go 项目创建一个强大的命令行工具时&#xff0c;你可能会遇到许多挑战&#xff0c;比如如何定义命令、标志和参数&#xff0c;如何生成详细的帮助文档&#xff0c;如何支持子命令等等。为了解决这些问题&#xff0c;github.com/spf13/cobra 就可以派上用场。 g…
阅读更多...
说说对高阶组件的理解？应用场景?

说说对高阶组件的理解？应用场景?

一、是什么 高阶函数&#xff08;Higher-order function&#xff09;&#xff0c;至少满足下列一个条件的函数 接受一个或多个函数作为输入输出一个函数 在React中&#xff0c;高阶组件即接受一个或多个组件作为参数并且返回一个组件&#xff0c;本质也就是一个函数&#xf…
阅读更多...
Linux环境配置（云服务器）

Linux环境配置（云服务器）

目录 1.第一步&#xff1a;购买云服务器 2.第二步&#xff1a;下载Xshell 7 3.第三步&#xff1a;打开Xshell&#xff0c;登录云服务器 4.第四步&#xff1a;更加便捷的云服务器登录方式 1.第一步&#xff1a;购买云服务器 &#xff08;推荐&#xff1a;阿里云、华为云、腾…
阅读更多...
k8s----27、云原生存储StorageClass、CSI、Rook

k8s----27、云原生存储StorageClass、CSI、Rook

1、动态存储介绍 StorageClass:存储类&#xff0c;由K8s管理员创建&#xff0c;用于动态PV的管理&#xff0c;可以链接至不同的后端存储&#xff0c; 比如Ceph、GlusterFS等。之后对存储的请求可以指向StorageClass&#xff0c;然后StorageClass会自动 的创建、删除PV。 实现方…
阅读更多...
数据结构(c语言版) 栈

数据结构(c语言版) 栈

顺序栈 要求&#xff1a;实现顺序栈的入栈&#xff0c;出栈&#xff0c;显示栈 代码 #include <stdio.h> #define MAXSIZE 100struct liststack{int data[MAXSIZE];int top; };//初始化栈 void init(struct liststack * LS){LS->top -1; }//入栈操作 void instack…
阅读更多...
Git详解及常用命令

Git详解及常用命令

前言 Git 是一个分布式版本控制系统&#xff0c;用于跟踪和管理项目的代码变化。它由Linus Torvalds在2005年创建&#xff0c;现在是开源社区中最流行的版本控制工具之一。 国内码云地址&#xff1a;工作台 - Gitee.com 版本控制系统 (VCS)&#xff1a;Git 用于跟踪文件和目录…
阅读更多...
yolov8+多算法多目标追踪+实例分割+目标检测+姿态估计（代码+教程）

yolov8+多算法多目标追踪+实例分割+目标检测+姿态估计（代码+教程）

多目标追踪实例分割目标检测 YOLO (You Only Look Once) 是一个流行的目标检测算法&#xff0c;它能够在图像中准确地定位和识别多个物体。 本项目是基于 YOLO 算法的目标跟踪系统&#xff0c;它将 YOLO 的目标检测功能与目标跟踪技术相结合&#xff0c;实现了实时的多目标跟…
阅读更多...
MUYUCMS v2.1：一款开源、轻量级的内容管理系统基于Thinkphp开发

MUYUCMS v2.1：一款开源、轻量级的内容管理系统基于Thinkphp开发

MuYuCMS&#xff1a;一款基于Thinkphp开发的轻量级开源内容管理系统&#xff0c;为企业、个人站长提供快速建站解决方案。它具有以下的环境要求&#xff1a; 支持系统&#xff1a;Windows/Linux/Mac WEB服务器&#xff1a;Apache/Nginx/ISS PHP版本&#xff1a;php > 5.6 (…
阅读更多...
【c++】——类和对象(中)——赋值运算符重载

【c++】——类和对象(中)——赋值运算符重载

作者:chlorine 专栏:c专栏 你站在原地不动,就永远都是观众。 【学习目标】 拷贝复制——赋值运算符重载 目录 &#x1f393;运算符重载的初步认识 &#x1f308;运算符重载 &#x1f308;赋值运算符重载格式 (上) &#x1f308;operator__判断俩个日期是否相等 &#x…
阅读更多...
【Shell脚本8】Shell printf 命令

【Shell脚本8】Shell printf 命令

Shell printf 命令 printf 命令模仿 C 程序库&#xff08;library&#xff09;里的 printf() 程序。 printf 由 POSIX 标准所定义&#xff0c;因此使用 printf 的脚本比使用 echo 移植性好。 printf 使用引用文本或空格分隔的参数&#xff0c;外面可以在 printf 中使用格式化…
阅读更多...
最新文章

Copyright @ 2022~2023