SpringBoot原理分析-1

SpringBoot原理分析

作为一个javaer，和boot打交道是很常见的吧。熟悉boot的人都会知道，启动一个springboot应用，就是用鼠标点一下启动main方法，然后等着就行了。我们来看看这个main里面。

@SpringBootApplication
public class ExampleApplication {public static void main(String[] args) {SpringApplication.run(ExampleApplication.class, args);}
}

这个类很简单吧，有三个注意点。

  • ExampleApplication就是类名，为了规范起见，这个类名一般都是xxxApplication。
  • 有一个注解@SpringBootApplication。
  • 然后就一个main方法，里面使用了SpringApplication的静态方法run()，传进去了俩参数。

这就神奇地启动起来了，为什么呢？

分析的版本：SpringBoot 2.7.18

需要结合以前用xml文件来配置Spring容器的形式来对比Boot用注解的形式

1.注解&自动配置

目前只知道注解的作用即可，至于这些注解是怎么起作用的，见后续…

@SpringBootApplication

这一节来详细聊一聊这个注解。@SpringBootApplication 是 Spring Boot 框架中的一个核心注解，用于简化 Spring Boot 应用的配置和启动

它的作用

  • @SpringBootApplication 标注在应用的主类上，用于启动 Spring Boot 应用。
  • 它启用了 Spring Boot 的自动配置机制，根据项目的依赖自动配置 Spring 应用。
  • 组件扫描：它启用了组件扫描，自动发现并注册带有 @Component、@Service、@Repository、@Controller 等注解的类。
  • 配置类：它标记该类为 Spring 的配置类，相当于 @Configuration 注解。

点进去看看，该注解的结构如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited // 四个元注解
@SpringBootConfiguration
@EnableAutoConfiguration //启用SpringBoot的自动配置机制。SpringBoot会根据类路径中的依赖自动配置应用。例如，如果类路径中有spring-boot-starter-web，SpringBoot会自动配置Tomcat和SpringMVC。@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) // 启用组件扫描，并排除一些特定的过滤器。默认是注解标注的类所在包及其子包。实际上是不是就是主启动类所在包及其子包！！！！！
public @interface SpringBootApplication {
..............
}// 发现这是一个组合注解

@SpringBootConfiguration 注解：主要作用是标记一个类为 Spring Boot 的配置类与 @Configuration 类似，但它专门用于 Spring Boot 应用。这个注解和@ComponentScan注解结合到一起，达成了如下效果。（左边是xml文件配置形式，右边是SpringBoot注解的形式），这俩注解在一起，就是扫描主启动类所在包及其子包下的被@Controller、@Service、…标注的类，将他们归到Spring容器里面去。

在这里插入图片描述

@EnableAutoConfiguration

@EnableAutoConfiguration注解： 这个注解不得了啊。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class) // 这里。
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";Class<?>[] exclude() default {};String[] excludeName() default {};}

发现@Import注解。这个注解的作用是干啥的？这里给出GPT的回答：@Import 是 Spring 框架提供的一个注解，用于将一个或多个配置类（@Configuration 类）或组件类导入到当前的 Spring 应用上下文中。它可以用来显式地引入其他配置类或 Bean 定义，从而实现模块化配置和代码复用。

这里有一个非常重要的东西，那就是当前的Spring上下文，也就是主启动类所在包及其子包，@Import(AutoConfigurationImportSelector.class)这句话的意思是将SpringBoot官方写的AutoConfigurationImportSelector类导入到当前Spring上下文中，在当前Spring上下文注册这样一个bean。

AutoConfigurationImportSelector探究

public interface ImportSelector {String[] selectImports(AnnotationMetadata importingClassMetadata);
}
// 实现了DeferredImportSelector接口，DeferredImportSelector实现了ImportSelector
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {@Overridepublic String[] selectImports(AnnotationMetadata annotationMetadata) {...........AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata); // 1.进去return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}// 2.这个方法protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if (!isEnabled(annotationMetadata)) {return EMPTY_ENTRY;}AnnotationAttributes attributes = getAttributes(annotationMetadata);// 3.进入这里List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);...........}// 4. 3调用的这个方法protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {List<String> configurations = new ArrayList<>(// 5. 继续往下SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);Assert.notEmpty(configurations,"No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "+ "are using a custom packaging, make sure that file is correct.");return configurations;}// 6. 5处调用的方法public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {...... // loadSpringFactoriesreturn loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());}// 7// 最终可以在loadSpringFactories方法里面看到这样一行代码//Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);// public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";// 结合官方给的解释The location to look for factories. Can be present in multiple JAR files. 寻找工厂的位置。可以存在于多个 JAR 文件中。
}

结合idea打断点调试：我们发现getCandidateConfigurations扫描到了引入的所有jar包的META-INF/spring.factories，共有156个xxxAutoConfigure类。但是这些都会用到吗，别忘了，SpringBoot有个非常强大的特点：那就是导入场景、对应的场景才会生效！！
在这里插入图片描述

继续往下走，请看下图：（发现只有50个了，例如上图里面的amqp，由于项目中没有用到，故在这里就没有了，经过了filter过滤）
在这里插入图片描述

以RabbitMq自动配置为例

@AutoConfiguration
@ConditionalOnClass({ RabbitTemplate.class, Channel.class }) // 这两个类存在时才生效，项目里面没导入相关jar包，故RabbitAutoConfiguration不会被导入Spring容器生效，下面就来说这个注解
@EnableConfigurationProperties(RabbitProperties.class)
@Import({ RabbitAnnotationDrivenConfiguration.class, RabbitStreamConfiguration.class })
public class RabbitAutoConfiguration {................
}

@ConditionalOnClass

先看看其源码

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class) // 这里***
public @interface ConditionalOnClass {Class<?>[] value() default {};String[] name() default {};
}

@ConditionalOnClass注解的作用是当项目中存在某个类时才会使标有该注解的类或方法生效；

先看我们的主类**【1. 此时，没有引入test.demo.test.list.Student所在的maven依赖】**

/* 下面是这俩类
public class Cat {private Integer id;private String name;
}
public class Dog {private Integer id;private String name;
}*/@SpringBootApplication
@MapperScan("com.feng.tackle.dao")
public class DateApplication {public static void main(String[] args) {ConfigurableApplicationContext context = SpringApplication.run(DateApplication.class, args);ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();Iterator<String> iterator = beanFactory.getBeanNamesIterator();while (iterator.hasNext()) {String name = iterator.next();if ( name.equals("dog01") || name.equals("cat01") ) System.out.println(name); // 看看有没有这两个名字的bean}}
}
// 最后的输出结果
/*
cat01
*/

在配置类中，我们这样做

@Configuration
public class ConditionTestConfig {@ConditionalOnClass(name = "test.demo.test.list.Student") // 类路径有这个类，就往容器中放入该bean@Beanpublic Dog dog01() {return new Dog(2, "汪汪汪");}@ConditionalOnMissingClass("test.demo.test.list.Student") // 类路径没有这个类，就往容器中放入该bean@Beanpublic Cat cat01() {return new Cat(1, "喵喵喵");}
}

main最后的输出结果是cat01。"test.demo.test.list.Student"是另一个maven项目里面的类。
在这里插入图片描述

【2. 项目中引入Student所在的maven】

<dependency><groupId>com.feng.test</groupId><artifactId>test-demo</artifactId><version>1.0-SNAPSHOT</version>
</dependency>

再次启动main，输出结果dog01
在这里插入图片描述

通过这个例子，我们可以知道SpringBoot自动配置，导入具体starter，对应的场景才会生效。【由于没有导入MQ的starter，故此配置类不会生效】
在这里插入图片描述

总结

**自动配置： **

以spring-boot-starter-web为例子，引入该启动器，他的父级pom里面有spring-boot-starter，spring-boot-starter的父级pom有spring-boot-autoconfigure。

spring-boot-autoconfigure里面有Spring官方定义的所有场景。

在这里插入图片描述

  • @EnableAutoConfiguration 注解：这是自动配置的入口，通常由 @SpringBootApplication 注解组合引入。
  • spring.factories 文件：Spring Boot 通过 META-INF/spring.factories 文件加载自动配置类。
  • 条件化配置：通过 @Conditional 系列注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等）实现按需加载配置。

自动配置的流程：

  1. 加载自动配置类
  • @SpringBootApplication 注解：该注解是一个组合注解，包含了 @EnableAutoConfiguration，用于启用自动配置。
  • @EnableAutoConfiguration 的作用：该注解会通过 SpringFactoriesLoader 加载 META-INF/spring.factories 文件中定义的自动配置类。
  1. 条件化配置

自动配置类通常使用 @Conditional 系列注解来控制是否生效

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {// 自动配置逻辑
}
//如果类路径中存在 DataSource 和 EmbeddedDatabaseType，且容器中没有 ConnectionFactory Bean，则自动配置 DataSource。
  1. 加载配置属性
  • @EnableConfigurationProperties：自动配置类通常会通过该注解加载配置属性。
  • application.properties 或 application.yml：Spring Boot 会读取这些配置文件中的属性，并将其绑定到对应的配置类中。
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties {private String url;private String username;private String password;// getters and setters
}
  1. 注册bean
  • 自动配置类通过 @Bean 方法向容器中注册 Bean。
  • 这些 Bean 通常是框架的核心组件，如 DataSource、DispatcherServlet、SecurityFilterChain 等。

2. 启动过程

SpringApplication.run(ExampleApplication.class, args);这一行代码做了啥？这才是重点！

从run开始看，一层一层往下面点进去

// 1.
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) { // 会返回一个正在运行的Spring容器return run(new Class<?>[] { primarySource }, args); // 调用重载的run方法
}
// 2.
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {return new SpringApplication(primarySources).run(args); // 先调用该构造方法,然后再调用run方法，将程序参数传进去
}
// 3.
public SpringApplication(Class<?>... primarySources) {this(null, primarySources); //primarySource 是传入的主配置类（通常带有 @SpringBootApplication 注解的类），Spring Boot 会将其作为配置源。
}// 4. [构造方法] 构造方法
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {........ // 见下一节构造方法
}

先调用该构造方法,然后再调用run方法

①构造方法

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {this.resourceLoader = resourceLoader; // null的Assert.notNull(primarySources, "PrimarySources must not be null");this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));  // 一、设置主配置类this.webApplicationType = WebApplicationType.deduceFromClasspath();  // 二、推断应用类型this.bootstrapRegistryInitializers = new ArrayList<>( // 三、getSpringFactoriesInstances(BootstrapRegistryInitializer.class));setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));// 四、setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));// 五、this.mainApplicationClass = deduceMainApplicationClass(); // 六、通过堆栈信息推断出主类（即 main 方法所在的类）。
}
1.推断应用类型
  • WebApplicationType.deduceFromClasspath() 方法会根据类路径中是否存在特定的类来推断应用类型。
  • 可能的类型包括：
    • WebApplicationType.SERVLET：基于 Servlet 的 Web 应用（如 Spring MVC）。
    • WebApplicationType.REACTIVE：基于 Reactive 的 Web 应用（如 Spring WebFlux）。
    • WebApplicationType.NONE：非 Web 应用。
2.加载并初始化 BootstrapRegistryInitializer 实例

分析一下核心方法getSpringFactoriesInstances，下面两个都会调用这个。

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {ClassLoader classLoader = getClassLoader();// Use names and ensure unique to protect against duplicatesSet<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader)); // 下一步List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);AnnotationAwareOrderComparator.sort(instances);return instances;
}// SpringFactoriesLoader.loadFactoryNames(type, classLoader) 到这儿来了
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {ClassLoader classLoaderToUse = classLoader;if (classLoaderToUse == null) {classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();}String factoryTypeName = factoryType.getName();return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}//loadSpringFactories(classLoaderToUse)
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {// static final Map<ClassLoader, Map<String, List<String>>> cache = new ConcurrentReferenceHashMap<>();// 从缓存map中拿到对应classLoader的map，如果该classLoader已经存在了，就不用走下面的了Map<String, List<String>> result = cache.get(classLoader);if (result != null) {return result;}result = new HashMap<>();try {/*public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";结合官方给的解释The location to look for factories. Can be present in multiple JAR files. 寻找工厂的位置。可以存在于多个 JAR 文件中。*/Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);..............return result;
}

可以看到这里，在第一章《注解&自动配置》也出现了这个，如今在SpringApplication的构造方法，底层也调用到了这里。二者有什么区别或者联系呢？

SpringFactoriesLoader.loadFactoryNames是Spring Boot 提供的工具方法，用于从 META-INF/spring.factories 文件中加载指定类型的配置类。

两者都依赖于 META-INF/spring.factories 文件，该文件是 Spring Boot 自动配置和扩展机制的核心配置文件。两者都通过类路径扫描，加载所有 META-INF/spring.factories 文件，并解析出指定类型的配置类。

（1）调用位置

  • AutoConfigurationImportSelector：
    • 位于 org.springframework.boot.autoconfigure 包中。
    • 是 Spring Boot 自动配置的核心组件之一，负责加载自动配置类。
    • 在 Spring 容器的配置类解析阶段被调用（具体是在 @EnableAutoConfiguration 注解的处理过程中）。
  • SpringApplication：
    • 位于 org.springframework.boot 包中。
    • 是 Spring Boot 应用的启动类，负责初始化应用上下文、加载配置等。
    • 在应用启动时被调用。

（2）加载的配置类型

  • AutoConfigurationImportSelector：
    • 主要加载 META-INF/spring.factories 文件中 org.springframework.boot.autoconfigure.EnableAutoConfiguration 键下的自动配置类。
    • 这些配置类用于实现 Spring Boot 的自动配置功能（如 DataSourceAutoConfiguration、WebMvcAutoConfiguration 等）。
  • SpringApplication：
    • 加载多种类型的配置类，包括：
      • ApplicationContextInitializer
      • ApplicationListener
      • BootstrapRegistryInitializer
    • 这些配置类用于初始化应用上下文、监听应用事件等。

（3）调用时机

  • AutoConfigurationImportSelector：
    • 在 Spring 容器解析配置类时调用（具体是在 ConfigurationClassPostProcessor 处理 @Configuration 类时）。
    • 属于 Spring 容器初始化的早期阶段。
  • SpringApplication：
    • 在应用启动时调用（具体是在 SpringApplication 的构造方法或 run 方法中）。
    • 属于应用启动的早期阶段。

（4）返回值的使用

  • AutoConfigurationImportSelector：
    • 返回的自动配置类会被 Spring 容器加载并处理，最终生成相应的 Bean 定义。
    • 这些配置类通常包含 @Configuration 注解和 @Conditional 注解，用于按需加载 Bean。
  • SpringApplication：
    • 返回的配置类会被直接实例化并注册到应用中。
    • 例如，ApplicationContextInitializer 会被调用以初始化应用上下文，ApplicationListener 会被注册以监听应用事件。
3.加载并设置 ApplicationContextInitializer 实例

同2

4.加载并设置 ApplicationListener 实例

同2

总结

  • BootstrapRegistryInitializer：用于应用启动的最早阶段，初始化引导阶段的组件。
  • ApplicationContextInitializer：用于在 ApplicationContext 创建之后、刷新之前，对上下文进行自定义初始化。
  • ApplicationListener：用于监听应用生命周期中的事件，并在特定阶段执行逻辑。

这三者共同扩展了 Spring Boot 应用的启动过程，提供了灵活的扩展点，可以满足不同场景下的需求。

5.三者的实现

分别编写实现类

public class MyBootstrapInit implements BootstrapRegistryInitializer {@Overridepublic void initialize(BootstrapRegistry registry) {System.out.println("【MyBootstrapInit】--------------方法执行了");}
}public class MyApplicationContextInit implements ApplicationContextInitializer<ConfigurableApplicationContext> {@Overridepublic void initialize(ConfigurableApplicationContext applicationContext) {System.out.println("【MyApplicationContextInit】------------" + applicationContext.getApplicationName());}
}public class MyContextListener implements ApplicationListener<ApplicationStartedEvent> { // 该监听器对此事件感兴趣@Overridepublic void onApplicationEvent(ApplicationStartedEvent event) {System.out.println("【MyContextListener】--监听器--" + event.getSource());}
}

然后在resource目录下面创建META-INF，在其中的spring.factories中

org.springframework.boot.BootstrapRegistryInitializer=com.feng.tackle.config.source.MyBootstrapInit
org.springframework.context.ApplicationContextInitializer=com.feng.tackle.config.source.MyApplicationContextInit
org.springframework.context.ApplicationListener=com.feng.tackle.config.source.MyContextListener

启动应用：
在这里插入图片描述

疑问？ 我可以在这三者的实现类上面加@Configuration注解，不要spring.factories，可以实现类似效果吗？

答案是，只有ApplicationListener可以。为什么？请看下面的run方法里面

②run

public ConfigurableApplicationContext run(String... args) {// 记录应用启动的开始时间，用于后续计算启动耗时。long startTime = System.nanoTime(); //创建一个 BootstrapContext，用于在应用启动的早期阶段提供一些基础设施支持（如环境配置、属性源等）================DefaultBootstrapContext bootstrapContext = createBootstrapContext();ConfigurableApplicationContext context = null;// 设置系统属性 java.awt.headless，确保应用在没有图形界面环境（如服务器）中也能正常运行configureHeadlessProperty();/*获取所有 SpringApplicationRunListener 实例，用于监听应用启动的各个阶段。调用 listeners.starting()，通知监听器应用正在启动。*/SpringApplicationRunListeners listeners = getRunListeners(args);listeners.starting(bootstrapContext, this.mainApplicationClass);try {ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);// 加载和配置应用的环境（Environment），包括配置文件（如 application.properties 或 application.yml）、命令行参数等。ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);configureIgnoreBeanInfo(environment);// 打印 Spring Boot 的启动 Banner（默认或自定义）。Banner printedBanner = printBanner(environment);// 根据应用类型（Servlet、Reactive 等）创建相应的 ApplicationContext。context = createApplicationContext();context.setApplicationStartup(this.applicationStartup);// 准备应用上下文prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);// 调用 AbstractApplicationContext.refresh() 方法，完成 Bean 的实例化、依赖注入和初始化。refreshContext(context);afterRefresh(context, applicationArguments);// 计算启动耗时并记录日志。Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);}listeners.started(context, timeTakenToStartup);// 执行所有 ApplicationRunner 和 CommandLineRunner 的实现类，用于在应用启动后执行自定义逻辑。callRunners(context, applicationArguments);}catch (Throwable ex) {handleRunFailure(context, ex, listeners);throw new IllegalStateException(ex);}try {// 计算应用启动到就绪的总耗时。Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);listeners.ready(context, timeTakenToReady);}catch (Throwable ex) {handleRunFailure(context, ex, null);throw new IllegalStateException(ex);}return context;
}

这个run这里分析得不够深入。受篇幅影响，在后续文章中再来分析。

end. 参考

  1. 尚硅谷雷丰阳老师的课

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

前端（API）学习笔记（CLASS 4）：进阶

前端（API）学习笔记（CLASS 4）：进阶

1、日期对象 日期对象&#xff1a;用来表示事件的对象 作用&#xff1a;可以得到当前系统时间 1、实例化 在代码中发现了new关键字&#xff0c;一般将这个操作称为实例化 创建一个时间对象并获取时间 获得当前时间 const datenew Date() 使用日志查看&#xff0c;得到的…
阅读更多...
力扣刷题：二叉树OJ篇（上）

力扣刷题：二叉树OJ篇（上）

大家好&#xff0c;这里是小编的博客频道 小编的博客&#xff1a;就爱学编程 很高兴在CSDN这个大家庭与大家相识&#xff0c;希望能在这里与大家共同进步&#xff0c;共同收获更好的自己&#xff01;&#xff01;&#xff01; 目录 1.单值二叉树&#xff08;1&#xff09;题目描…
阅读更多...
4.1.2 栈和队列（二）

4.1.2 栈和队列（二）

文章目录 队列的定义队列的基本运算队列的存储结构 队列的定义 队列先进先出&#xff0c;仅允许一端插入、一端删除 队尾(Rear)&#xff0c;插入 队头(Front)&#xff0c;删除 队列的基本运算 队列的基本运算 初始化空队列&#xff1a;initQueue(Q)判队空&#xff1a;isEmpty…
阅读更多...
【HeadFirst系列之HeadFirst设计模式】第1天之HeadFirst设计模式开胃菜

【HeadFirst系列之HeadFirst设计模式】第1天之HeadFirst设计模式开胃菜

HeadFirst设计模式开胃菜 前言 从今日起&#xff0c;陆续分享《HeadFirst设计模式》的读书笔记&#xff0c;希望能够帮助大家更好的理解设计模式&#xff0c;提高自己的编程能力。 今天要分享的是【HeadFirst设计模式开胃菜】&#xff0c;主要介绍了设计模式的基本概念、设计模…
阅读更多...
Oracle数据库如何找到 Top Hard Parsing SQL 语句？

Oracle数据库如何找到 Top Hard Parsing SQL 语句？

有一个数据库应用程序存在过多的解析问题&#xff0c;因此需要找到产生大量硬解析的主要语句。 什么是硬解析 Oracle数据库中的硬解析&#xff08;Hard Parse&#xff09;是指在执行SQL语句时&#xff0c;数据库需要重新解析该SQL语句&#xff0c;并创建新的执行计划的过程。这…
阅读更多...
【GBT32960协议学习系列】GBT 32960协议的背景、目的和适用范围

【GBT32960协议学习系列】GBT 32960协议的背景、目的和适用范围

GBT 32960协议的背景、目的和适用范围 1. GBT 32960协议的背景 GBT 32960是中国国家标准&#xff0c;全称为《电动汽车远程服务与管理系统技术规范》。该标准由中国国家标准化管理委员会发布&#xff0c;旨在规范电动汽车远程服务与管理系统的技术要求&#xff0c;确保电动汽车…
阅读更多...
蓝桥杯备赛：C++基础，顺序表和vector（STL）

蓝桥杯备赛：C++基础，顺序表和vector（STL）

目录 一.C基础 1.第一个C程序&#xff1a; 2.头文件&#xff1a; 3.cin和cout初识&#xff1a; 4.命名空间&#xff1a; 二.顺序表和vector&#xff08;STL&#xff09; 1.顺序表的基本操作&#xff1a; 2.封装静态顺序表&#xff1a; 3.动态顺序表--vector&#xff1a;…
阅读更多...
创建并配置华为云虚拟私有云

创建并配置华为云虚拟私有云

目录 私有云 创建虚拟私有云 私有云 私有云是一种云计算模式&#xff0c;它将云服务部署在企业或组织内部的私有基础设施上&#xff0c;仅供该企业或组织内部使用&#xff0c;不对外提供服务.私有云的主要特点包括&#xff1a; 私密性&#xff1a;私有云的资源&#xff08;如…
阅读更多...
OWASP ZAP之API 请求基础知识

OWASP ZAP之API 请求基础知识

ZAP API 提供对 ZAP 大部分核心功能的访问，例如主动扫描器和蜘蛛。ZAP API 在守护进程模式和桌面模式下默认启用。如果您使用 ZAP 桌面，则可以通过访问以下屏幕来配置 API： Tools -> Options -> API。 ZAP 需要 API 密钥才能通过 REST API 执行特定操作。必须在所有 …
阅读更多...
音视频入门基础：MPEG2-PS专题（3）——MPEG2-PS格式简介

音视频入门基础：MPEG2-PS专题（3）——MPEG2-PS格式简介

一、引言 本文对MPEG2-PS格式进行简介。 进行简介之前&#xff0c;请各位先下载MPEG2-PS的官方文档。ITU-T和ISO/IEC都分别提供MPEG2-PS的官方文档。但是ITU提供的文档是免费的&#xff0c;ISO/IEC是付费的&#xff0c;所以我们主要阅读ITU提供的官方文档&#xff0c;比如较新…
阅读更多...
CPT203 Software Engineering 软件工程 Pt.3 系统建模（中英双语）

CPT203 Software Engineering 软件工程 Pt.3 系统建模（中英双语）

文章目录 5. System Modeling&#xff08;系统建模&#xff09;5.1 Context models&#xff08;上下文模型&#xff09;5.2 Interaction models&#xff08;交互模型&#xff09;5.2.1 Use case modeling&#xff08;用况建模&#xff09;5.2.2 Sequence diagram&#xff08;顺…
阅读更多...
什么是Kafka的重平衡机制？

什么是Kafka的重平衡机制？

Kafka 的重平衛机制是指在消费者组中新增或删除消费者时&#xff0c;Kafka 集群会重新分配主题分区给各个消费者&#xff0c;以保证每个消费者消费的分区数量尽可能均衡。 重平衡机制的目的是实现消费者的负载均衡和高可用性&#xff0c;以确保每个消费者都能够按照预期的方式…
阅读更多...
Nginx——反向代理（三/五）

Nginx——反向代理（三/五）

目录 1.Nginx 反向代理1.1.Nginx 反向代理概述1.2.Nginx 反向代理的配置语法1.2.1.proxy_pass1.2.2.proxy_set_header1.2.3.proxy_redirect 1.3.Nginx 反向代理实战1.4.Nginx 的安全控制1.4.1.如何使用 SSL 对流量进行加密1.4.2.Nginx 添加 SSL 的支持1.4.3.Nginx 的 SSL 相关指…
阅读更多...
VBA（Visual Basic for Applications）编程|excel|一系列网址或文件路径快速转换为可点击的超链接

VBA（Visual Basic for Applications）编程|excel|一系列网址或文件路径快速转换为可点击的超链接

很多时候&#xff0c;我们需要把导入的数据某一列转换成超链接&#xff0c;比如URL形式的列。 那么&#xff0c;大批量的情况下&#xff0c;无疑一个个手动点击是非常愚蠢的办法&#xff0c;这个时候我们就需要VBA编程来编写宏&#xff0c;通过编写宏来简化这些手动操作并不现…
阅读更多...
【C++】图像模糊处理题目详解与实现

【C++】图像模糊处理题目详解与实现

博客主页&#xff1a; [小ᶻ☡꙳ᵃⁱᵍᶜ꙳] 本文专栏: C 文章目录 &#x1f4af;前言&#x1f4af;题目描述题目内容输入格式输出格式示例输入&#xff1a;输出&#xff1a; &#x1f4af;题目分析问题拆解 &#x1f4af;我的做法代码实现代码分析 &#x1f4af;老师的做法…
阅读更多...
在 Ubuntu 22.04 上部署 AppArmor 应用安全教程

在 Ubuntu 22.04 上部署 AppArmor 应用安全教程

在这篇教程中&#xff0c;我们将为你设置 AppArmor 以增强应用程序的安全性。 AppArmor 是一个 Linux 安全模块&#xff0c;允许你限制各个程序的功能。通过强制执行强制访问控制策略&#xff0c;AppArmor 增强了你的应用程序和系统的安全性。 AppArmor 是一个易于使用的 Lin…
阅读更多...
Nginx：动静分离

Nginx：动静分离

什么是动静分离？ 动静分离 是指将网站中的静态资源（如图片、样式表、脚本等）和动态内容（如 PHP、Python、Node.js 等后端生成的内容）分开部署和处理。这样做的好处是可以利用不同的服务器或缓存策略来优化不同类型的资源。 动静分离的好处 提高性能：静态资源可以直接从…
阅读更多...
每天40分玩转Django：Django插件开发

每天40分玩转Django：Django插件开发

Django插件开发 一、插件开发概述表 阶段主要任务技术要点难度准备工作项目结构设计、环境配置项目布局、setup.py★★★☆☆开发实现功能开发、测试编写Django AppConfig、Signals★★★★☆文档编写API文档、使用说明Markdown、reStructuredText★★★☆☆发布部署PyPI打包…
阅读更多...
什么是TDD测试驱动开发(Test Driven Development)？

什么是TDD测试驱动开发(Test Driven Development)？

什么是测试驱动开发&#xff1f; 软件开发团队通常会编写自动化测试套件来防止回归。这些测试通常是在编写应用程序功能代码之后编写的。我们将采用另一种方法&#xff1a;在实现应用程序代码之前编写测试。这称为测试驱动开发 (TDD)。 为什么要应用 TDD&#xff1f;通过在实…
阅读更多...
后台管理系统用户退出登录方案实现

后台管理系统用户退出登录方案实现

退出登录一直是一个通用的前端实现方案&#xff0c;对于退出登录而言&#xff0c;它的触发时机一般有两种&#xff1a; 1. 用户主动退出&#xff0c;即用户点击登录按钮之后退出&#xff1b; 2. 用户被动退出&#xff0c;Token过期或被 其他人"顶下来" 时退出&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023