Spring6--基础概念

2024-03-18 08:04
文章标签 基础 概念 spring6

本文主要是介绍Spring6--基础概念，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1. 概述

1.1. Spring是什么

Spring 是一套广泛应用于 Java 企业级应用开发领域的轻量级开源框架，由 Rod Johnson 创立，旨在显著降低 Java 企业应用的复杂性，缩短开发周期，并提升开发效率。Spring 不仅适用于服务器端开发，也因其简单的设计、卓越的可测试性和倡导的松耦合原则，使得几乎所有类型的 Java 应用都能从中获得好处。

Spring 框架的核心价值在于提供了诸如控制反转（IoC）、面向切面编程（AOP）等机制，增强了代码的可维护性和可扩展性，并且集成了众多第三方库和框架，如数据库访问、事务管理、MVC、RESTful API 构建、安全控制等，从而形成了一个全方位的企业级应用开发解决方案。

随着版本的不断迭代升级，Spring 已发展到第 6 个主要版本——Spring 6.1.4，这个版本代表了 Spring 团队在响应式编程、模块化支持、性能优化、以及与现代 Java 和云原生环境兼容等方面的最新成果。

须知：现在是更新到了6.1.4，该笔记是基于尚硅谷的6.0.2

1.2. Spring 的狭义和广义

在不同的语境中，Spring 所代表的含义是不同的。

广义的 Spring：Spring 技术生态体系
在广义上，Spring 指的是围绕 Spring Framework 扩展建立的一个庞大的技术生态系统，其中包括多个紧密关联的子项目或模块。这个技术栈致力于满足不同层次的开发需求，例如 Web 开发（Spring MVC）、快速应用搭建（Spring Boot）、分布式服务治理（Spring Cloud）、数据访问抽象（Spring Data）、安全控制（Spring Security）等等。每一个子项目都基于 Spring Framework 的核心能力进行构建，为开发者提供了从基础架构到高级应用场景的一整套解决方案。

狭义的 Spring：Spring Framework
狭义上的 Spring 即 Spring Framework，这是整个 Spring 生态系统的核心部分，通常我们称之为 Spring 框架。它是一种轻量级的 Java 应用开发框架，通过提供 IoC（控制反转）和 AOP（面向切面编程）两大核心技术，简化了企业级应用的复杂性，提升了开发效率。

  • IoC (Inver of Control 控制反转)：这是一种设计思想，意味着对象的创建不再由程序本身直接控制，转而交由 Spring 容器统一管理和负责创建、注入。这样可以降低代码之间的耦合度，提高组件重用性和可测试性。
  • AOP (Aspect of Control 面向切面编程)：AOP 主要是针对横切关注点进行处理的技术，它可以将分散在各个业务模块中的通用功能（如日志记录、事务管理、权限验证等）抽取出来形成“切面”，然后织入到目标组件执行的过程中。这种机制极大地减少了代码重复，提高了系统的可维护性和灵活性，同时降低了模块间的耦合度。

总结简单解释就是

广义的 Spring可以理解为一个完整的 Java 技术生态系统，包括一系列由 Spring 团队开发和维护的子项目，这些项目各具特色，互相配合，共同服务于企业级应用的开发全过程，从基础的依赖注入、面向切面编程，到 Web 开发、微服务架构、数据访问、安全性控制等方面均有覆盖，极大地方便了开发者构建高质量、高效率的软件系统。

狭义的 Spring则特指 Spring Framework 这一具体框架，它是整个 Spring 生态系统的基石。Spring Framework 通过实现控制反转（IoC）来解耦组件之间的依赖关系，让代码更加灵活易管理；同时，它引入了面向切面编程（AOP）机制，使得开发者能方便地在系统中定义和应用横切关注点，如日志、事务管理等，进而增强代码复用性和系统可维护性。

1.3. Spring Framework特点

Spring Framework 的五大特点：

  1. 非侵入式设计：
  • Spring 在不影响应用程序原有结构的前提下提供强大的功能支持。它允许开发者保持领域模型的纯净，仅需在功能性组件上添加少量注解，即可无缝集成 Spring 功能，使整体架构更为整洁、精炼。
  • Spring Framework 设计得非常巧妙，就像一位隐形助手。在你使用它的功能时，不需要大幅改动你的原有代码结构或者模型。比如，你只需在需要的地方轻轻添加几个注解（像是贴标签一样），Spring 就能识别并帮你完成复杂的依赖管理，而不改变你的核心业务逻辑代码，让代码更清爽，易于理解和维护。

  1. 控制反转 (IoC)：
  • Spring 引入了 IoC 原则，即控制权由应用程序转移到容器，实现了资源的自动装配和管理。开发人员无需手动创建和管理对象，而是由 Spring 容器负责创建和组装对象，通过依赖注入的方式供应用程序使用。
  • IoC 就像一个贴心的管家。在没有 Spring 之前，你需要自己动手创建对象、找对象并管理它们的关系。有了 IoC 后，你就不用亲自操心这些事情了。你只需要告诉 Spring 容器你想要什么，Spring 会主动为你准备妥当，然后送到你面前（即所谓的资源注入）。这样一来，你的代码变得更专注于业务逻辑，而非对象的创建和管理。

  1. 面向切面编程 (AOP)：
  • Spring 支持 AOP，允许开发者在不修改原始代码的情况下，通过声明式的方式对程序进行功能增强。这种方式有助于提高代码的复用性和模块间的解耦。
  • AOP 就像是给代码加了一个神奇的调料包。在不修改主菜（业务代码）的前提下，你可以通过 AOP 添加一些通用的功能，比如“调味品”（如日志、权限检查、事务管理等）。这些“调料”会在合适的时间自动加入到“主菜”中，让你的代码具备更多功能的同时，保持主体部分干净简洁，避免了重复代码和过度耦合。

  1. 容器化管理：
  • Spring IoC 容器扮演着组件工厂的角色，全面管理组件对象的生命周期。容器提供的自动化管理大大减轻了开发者的负担，简化了对象的创建和管理过程，显著提高了开发效率。
  • Spring IoC 容器就如同一个全能的智能工场，它负责孕育和管理所有对象（组件）的生命周期。当你注册组件到容器后，容器会帮你实例化对象、管理对象间依赖关系，甚至还能自动回收无用的对象。这种容器化管理大大降低了编程的复杂度，让开发者更专注于业务逻辑的实现，而不是琐碎的底层对象管理工作。

  1. 组件化与一站式整合：
  • Spring 支持组件化开发，通过 XML 或 Java 注解等方式灵活组装对象，便于构建复杂的大型应用系统。此外，Spring 凭借其 IoC 和 AOP 的核心能力，可以很好地集成各类开源框架和第三方类库，实现一站式开发，满足企业级应用的多元化需求。Spring 旗下的诸多项目已覆盖云计算、微服务、数据访问等多个层面，成为构建完整 Java 应用生态的理想选择。
  • Spring 提倡组件化开发，就好比搭积木一样，每个积木块都是一个独立且功能明确的小组件。通过简单的配置（XML 或 Java 注解），你可以把这些组件拼接在一起，构建出庞大而复杂的应用系统。同时，Spring 拥有一站式的整合能力，可以轻松融入多种开源框架和第三方库，从而为开发者打造了一站式的开发环境，让开发 Java 应用变得更加高效便捷。

1.4. Spring模块组成

官网地址：Spring | Home

上图中包含了 Spring 框架的所有模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。下面分别对这些模块的作用进行简单介绍。

  1. Spring Core（核心容器）
    • spring-core：提供Spring框架的基础功能，包括控制反转（IoC）和依赖注入（DI）的基本实现，使得开发者无需手动管理对象的创建和依赖关系。
    • spring-beans：定义了BeanFactory接口和相关的类，用于管理和装配Java Bean对象，这是Spring IoC容器的基础组件。
    • spring-context：扩展了BeanFactory，提供了ApplicationContext上下文，它是完整功能的IoC容器，还包含国际化、资源加载、事件传播等功能。
    • spring-expression（SpEL）：Spring表达式语言，提供了在运行时查询和操作对象图的强大的表达式语言。

  1. Spring AOP（面向切面编程）
    • spring-aop：实现面向切面编程的基础模块，支持代理机制如JDK动态代理、CGLIB字节码生成等方式。
    • spring-aspects：集成了AspectJ，增强了Spring框架的AOP能力，允许在程序中无缝插入横切关注点。
    • spring-instrument：提供了类加载器级别的代理工具类，主要用于监控和处理类加载过程，以便于进行AOP代理和其他类型的类增强。

  1. Spring Data Access
    • spring-jdbc：简化了JDBC的操作，提供了一套方便的API进行数据库访问。
    • spring-orm：提供了与主流ORM框架（如Hibernate、MyBatis等）的集成支持。
    • spring-oxm：提供对象与XML之间的映射支持，方便数据的序列化和反序列化。
    • spring-jms：对Java消息服务（JMS）的抽象封装，便于在分布式系统中实现消息传递。
    • spring-tx：实现了声明式事务管理，可以方便地在业务逻辑层进行事务控制。

  1. Spring Web
    • spring-web：提供了基本的Web应用支持，构建在Spring Context之上，可以通过Servlet或者监听器初始化IoC容器。
    • spring-webmvc：基于模型-视图-控制器（MVC）架构模式的实现，简化了Web应用程序的开发。
    • spring-websocket：提供WebSocket的支持，实现服务器与客户端的全双工实时通信。
    • spring-webflux：Spring 5.0后新增的非阻塞式Reactive Web框架，适用于异步、非阻塞、事件驱动的Web应用开发。

  1. Spring Messaging
    • spring-messaging：为Spring框架增加了对消息传递（Messaging）的支持，比如处理HTTP请求、WebSocket消息等。

  1. Spring Test
    • spring-test：提供了对JUnit和其他测试框架的集成支持，简化了对Spring应用进行集成测试的过程。

2. 入门案例开发

2.1. 环境要求

  • JDK：Java17+（Spring6要求JDK最低版本是Java17）
  • Maven：3.6+
  • Spring：6.0.2

注：我自己笔记上面演示的IDEA版本是2023.3.3，也是我现在用的版本

2.2. 构建模块

  1. 构建父模块spring6

这里Spring6是父工程，它的src文件可有可无，其中的子模块才是重点

  1. 构建子模块Spring6-First

2.3. 程序开发

第1步 引入spring相关依赖

第2步 创建类，定义属性和方法

第3步 按照spring要求创建配置文件(xml格式)

第4步 在spring配置文件配置相关信息

第5步 进行最终测试

  1. 第1步 引入Spring相关依赖

在Maven或Gradle项目中，通过pom.xml或build.gradle文件添加Spring框架及其相关的依赖项，例如Spring Core、Spring Context、Spring DAO等，以便在项目中使用Spring的功能。

在子模块下的Spring-First的pom.xml文件配置以下依赖

<!-- 依赖关系定义 --><dependencies><!-- 引入Spring Context依赖，它是Spring框架的基础模块，提供了环境配置、Bean生命周期管理、事件传播等功能 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.2</version></dependency><!-- 引入JUnit5测试框架，用于编写和运行单元测试 --><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version></dependency></dependencies>

刷新后并查看依赖

  1. 第2步 创建类，定义属性和方法
  • 根据业务逻辑，创建Java类，包括实体类（Entity）、数据访问接口（DAO，Data Access Object）、实现类、服务类（Service）以及控制器类（Controller）等。在类中定义属性及相应的getter/setter方法，以及业务处理方法。

  1. 第3步 按照Spring要求创建配置文件（XML格式）
  • 在项目的资源目录下创建Spring的核心配置文件，如applicationContext.xml或spring-config.xml，用于配置Spring容器如何管理和装配bean。

在resources文件夹创建Spring配置文件，名字无所谓，但后缀要为 . xml

我这里为 bean.xml

  1. 第4步 在Spring配置文件配置相关信息
  • 在配置文件中声明bean，包括数据源、事务管理器、DAO实现类、服务类等，并通过<bean>标签定义它们的生命周期和依赖关系，也可以配置AOP、事务管理等相关设置。

创建完bean.xml配置文件后，配置该文件，像下面这样

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 定义一个Bean实例，id为"helloWorld"，类型为com.sakurapaid.spring6_01.HelloWorld类 --><bean id="helloWorld" class="com.sakurapaid.spring6_01.HelloWorld"></bean></beans>

进一步说明：

Bean：在Spring框架中，Bean是一个由Spring IoC（控制反转）容器管理的对象。它是由Spring容器负责创建、装配以及管理其完整生命周期的Java对象。

id属性：每个Bean都需要一个唯一的标识符，id就是用来满足这一需求的属性。通过这个唯一的ID，开发者可以在Spring容器中方便地查找和获取所需的Bean。

class属性：class属性指定用来创建Bean实例的Java类的全限定名。当Spring容器读取到这个配置时，它会根据提供的类名创建对应的类实例，并依据需要进行依赖注入和其他配置处理，最终生成一个可操作的Bean对象供应用程序使用。

创建一个测试类HelloWorldTest，并写上对应内容

package com.sakurapaid.spring6;import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloWorldTest {@Testpublic void test() {//加载spring配置文件，对象创建ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");//获取创建对象HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");//调用方法，输出结果helloWorld.sayHello();}
}

  1. 第5步 进行最终测试
  • 编写单元测试和集成测试，确保各个组件能够按照预期与Spring容器一起工作。启动应用并测试整体功能是否正常，如通过HTTP请求测试控制器层是否能正确调用服务层并返回响应。

2.4. 案例分析

1. 底层是怎么创建对象的，是通过反射机制调用无参数构造方法吗？

修改HelloWorld类：

public class HelloWorld {//无参构造public HelloWorld() {System.out.println("这是无参构造输出的HelloWorld");}public void sayHello(){System.out.println("HelloWorld");}
}

执行结果：

测试得知：创建对象时确实调用了无参数构造方法。

  1. Spring是如何创建对象的呢？原理是什么？
// dom4j解析beans.xml文件，从中获取class属性值，类的全类名// 通过反射机制调用无参数构造方法创建对象Class clazz = Class.forName("com.sakurapaid.spring6.HelloWorld");//Object obj = clazz.newInstance();Object object = clazz.getDeclaredConstructor().newInstance();

当Spring框架读取配置文件（如beans.xml）时，它会通过DOM4J等XML解析工具解析出各个bean的定义信息，其中包括bean的类名。之后，Spring利用Java反射机制，通过Class.forName()方法加载指定类的字节码，然后调用getDeclaredConstructor().newInstance()方法创建该类的对象实例，这就相当于调用了无参构造函数来初始化对象。

  1. 把创建好的对象存储到一个什么样的数据结构当中了呢？

bean对象最终存储在spring容器中，在spring源码底层就是一个map集合，存储bean的map在DefaultListableBeanFactory类中：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

Spring容器加载到Bean类时 , 会把这个类的描述信息, 以包名加类名的方式存到beanDefinitionMap 中,Map<String,BeanDefinition> , 其中 String是Key , 默认是类名首字母小写 , BeanDefinition , 存的是类的定义(描述信息) , 我们通常叫BeanDefinition接口为 : bean的定义对象。

创建好的对象并不是立即丢弃，而是由Spring IoC（Inversion of Control，控制反转）容器统一管理。在Spring的底层实现中，对象是以Bean的形式存储在一个名为beanDefinitionMap的ConcurrentHashMap中。这个Map的键是Bean的名字（通常是类名首字母小写，遵循默认命名规则），值是BeanDefinition对象。BeanDefinition是一个接口，它包含了创建和配置Bean所需的所有元数据信息，如类名、构造函数参数、属性值、依赖关系等。这样，Spring容器就能根据需要随时查找、获取并初始化Bean对象。

  1. Spring创建对象的过程：
  • 当你在Spring配置文件中定义了一个Bean（比如HelloWorld类），Spring会读取这个配置文件，并找到你所指定的类名。
  • 然后，Spring利用Java的反射API，通过Class.forName()加载指定类的字节码（也就是类的定义）。
  • 接下来，Spring调用类的无参构造方法（即没有参数的构造函数）来创建这个类的一个实例，就像我们手动用new关键字创建对象一样。
  1. Spring管理对象的方式：
  • 创建出来的对象并不是单独存在，而是被Spring的IoC（控制反转）容器统一管理。
  • 这个容器实际上维护了一个类似字典的数据结构，也就是一个Map（具体是ConcurrentHashMap类型），其中：
    • 键（key）是Bean的名称，通常按照约定（如类名首字母小写）来命名。
    • 值（value）是BeanDefinition对象，它包含了创建和配置Bean所需要的所有细节，比如类的具体位置、属性值、依赖关系等。

简单来说，Spring通过读取配置文件，利用反射技术自动创建对象，并把这些对象的相关信息保存在一个特殊的“容器”中。当你需要使用某个对象时，只需告诉Spring它的名称，Spring就会从容器中取出已经创建好的对象给你使用。这样不仅简化了对象的创建过程，也使得对象间的依赖关系更容易管理和维护。这就是Spring框架的核心机制之一——IoC容器的作用。

总结起来就是，Spring通过解析配置文件获取类的信息，运用反射创建对象，并将这些对象以及对象的配置信息以一种高效的数据结构（Map）进行管理，实现了对Bean对象的集中控制和生命周期管理，这就是Spring框架的核心功能之一——IoC容器的运作机制

2.5. Log4j2日志框架

2.5.1. Log4j2概述

Apache Log4j2 是一款专为Java应用程序设计的强大且灵活的开源日志框架。在软件开发领域，尤其是在Java项目中，日志扮演着至关重要的角色，它能详尽地记录下系统运行过程中的各种事件和状态变化，就像一本详细的电子日记，涵盖了何时（when）、何地（where）、何种行为（what）以及为何发生（why）等重要信息。

Log4j2 是原始Log4j项目的重大升级版本，相较于传统的System.out.println()方法，它提供了更高级别的功能和控制能力，使得开发者能够根据不同的需求定制日志输出格式、级别、存储位置等，并且支持异步日志处理，提高了系统的性能表现。

以下几个关键特性体现了Log4j2的优势：

  1. 多级日志：Log4j2 支持多种日志级别，包括 TRACE、DEBUG、INFO、WARN、ERROR 和 FATAL，允许开发者根据实际需要调整日志详细程度，确保既能获取足够的调试信息，又不会因为过多的日志而影响性能或占用过多存储空间。
  2. 配置灵活：通过XML、JSON或Properties等格式的配置文件，开发者可以轻松地定义日志输出的格式、过滤规则、输出目的地（如控制台、文件、数据库等），甚至可以动态地重新加载配置文件，无需重启应用。
  3. 性能优化：Log4j2 引入了异步日志处理机制，这意味着即使在大量日志生成的情况下，也不会阻塞应用的主线程，显著提升了系统的响应速度。
  4. 扩展性好：Log4j2 设计上考虑了扩展性，开发者可以通过插件机制添加自定义的Appenders（输出器）、Filters（过滤器）和其他组件，满足特定应用场景的需求。

总之，Apache Log4j2 提供了一个全面、高效且可高度定制的日志解决方案，有助于提高软件开发效率、简化运维工作，并为系统的稳定性和可靠性提供有力支撑。对于任何Java项目，特别是大型企业级应用来说，选择Log4j2作为日志框架都是一个明智之举。

2.5.2. 引入Log4j2依赖

在pom.xml引入相关依赖

<!--log4j2的依赖-->
<dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-core</artifactId><version>2.19.0</version>
</dependency>
<dependency><groupId>org.apache.logging.log4j</groupId><artifactId>log4j-slf4j2-impl</artifactId><version>2.19.0</version>
</dependency>

注意，我这里是写在了父工程里的子工程(Spring6-First)里面的pom文件

2.5.3. 加入日志配置文件

在类的根路径下提供log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下。）

<?xml version="1.0" encoding="UTF-8"?>
<configuration><loggers><!--level指定日志级别，从低到高的优先级：TRACE < DEBUG < INFO < WARN < ERROR < FATALtrace：追踪，是最低的日志级别，相当于追踪程序的执行debug：调试，一般在开发中，都将其设置为最低的日志级别info：信息，输出重要的信息，使用较多warn：警告，输出警告的信息error：错误，输出错误信息fatal：严重错误--><root level="DEBUG"><appender-ref ref="spring6log"/><appender-ref ref="RollingFile"/><appender-ref ref="log"/></root></loggers><appenders><!--输出日志信息到控制台--><console name="spring6log" target="SYSTEM_OUT"><!--控制日志输出的格式--><PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/></console><!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用--><File name="log" fileName="F:/Program/Spring6Log/test.log" append="false"><PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/></File><!-- 这个会打印出所有的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档--><RollingFile name="RollingFile" fileName="F:/Program/Spring6Log/app.log"filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz"><PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/><SizeBasedTriggeringPolicy size="50MB"/><!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 --><DefaultRolloverStrategy max="20"/></RollingFile></appenders>
</configuration>

在resources文件夹右键创建文件——log4j2.xml

注意，log4j2日志运行时会在本地生产日志文件，所以在配置文件里要设置日志文件的存放位置，比如我这里就是F盘下的

F:/Program/Spring6Log/test.log 和 F:/Program/Spring6Log/app.log

根据自己的实际情况来

2.5.4. 测试

运行刚才的程序 HelloWorldTest.java得到运行结果

2.5.5. 手动使用日志

上述为自动写入日志，其实也是可以手动写入日志的，如下述步骤

把刚才的测试类改为这样

package com.sakurapaid.spring6_01;import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloWorldTest {@Testpublic void test() {//获取日志对象Logger logger = LoggerFactory.getLogger(HelloWorldTest.class);//加载spring配置文件，对象创建ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");//获取创建对象HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");//调用方法，输出结果helloWorld.sayHello();//输出日志logger.info("### 手动输入日志~");}}

测试结果

这篇关于Spring6--基础概念的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/821702。

相关文章

零基础学习Redis(10) -- zset类型命令使用

零基础学习Redis(10) -- zset类型命令使用

zset是有序集合，内部除了存储元素外，还会存储一个score，存储在zset中的元素会按照score的大小升序排列，不同元素的score可以重复，score相同的元素会按照元素的字典序排列。 1. zset常用命令 1.1 zadd  zadd key [NX | XX] [GT | LT]   [CH] [INCR] score member [score member ...]
阅读更多...
【Linux 从基础到进阶】Ansible自动化运维工具使用

【Linux 从基础到进阶】Ansible自动化运维工具使用

Ansible自动化运维工具使用 Ansible 是一款开源的自动化运维工具，采用无代理架构（agentless），基于 SSH 连接进行管理，具有简单易用、灵活强大、可扩展性高等特点。它广泛用于服务器管理、应用部署、配置管理等任务。本文将介绍 Ansible 的安装、基本使用方法及一些实际运维场景中的应用，旨在帮助运维人员快速上手并熟练运用 Ansible。 1. Ansible的核心概念
阅读更多...
AI基础 L9 Local Search II 局部搜索

AI基础 L9 Local Search II 局部搜索

Local Beam search 对于当前的所有k个状态，生成它们的所有可能后继状态。 检查生成的后继状态中是否有任何状态是解决方案。 如果所有后继状态都不是解决方案，则从所有后继状态中选择k个最佳状态。 当达到预设的迭代次数或满足某个终止条件时，算法停止。 — Choose k successors randomly, biased towards good ones — Close
阅读更多...
【VUE】跨域问题的概念，以及解决方法。

【VUE】跨域问题的概念，以及解决方法。

目录 1.跨域概念 2.解决方法 2.1 配置网络请求代理 2.2 使用@CrossOrigin 注解 2.3 通过配置文件实现跨域 2.4 添加 CorsWebFilter 来解决跨域问题 1.跨域概念 跨域问题是由于浏览器实施了同源策略，该策略要求请求的域名、协议和端口必须与提供资源的服务相同。如果不相同，则需要服务器显式地允许这种跨域请求。一般在springbo
阅读更多...
音视频入门基础：WAV专题（10）——FFmpeg源码中计算WAV音频文件每个packet的pts、dts的实现

音视频入门基础：WAV专题（10）——FFmpeg源码中计算WAV音频文件每个packet的pts、dts的实现

一、引言 从文章《音视频入门基础：WAV专题（6）——通过FFprobe显示WAV音频文件每个数据包的信息》中我们可以知道，通过FFprobe命令可以打印WAV音频文件每个packet（也称为数据包或多媒体包）的信息，这些信息包含该packet的pts、dts： 打印出来的“pts”实际是AVPacket结构体中的成员变量pts，是以AVStream->time_base为单位的显
阅读更多...
C 语言基础之数组

C 语言基础之数组

文章目录 什么是数组数组变量的声明多维数组 什么是数组 数组，顾名思义，就是一组数。 假如班上有 30 个同学，让你编程统计每个人的分数，求最高分、最低分、平均分等。如果不知道数组，你只能这样写代码： int ZhangSan_score = 95;int LiSi_score = 90;......int LiuDong_score = 100;int Zhou
阅读更多...
c++基础版

c++基础版

c++基础版 Windows环境搭建第一个C++程序c++程序运行原理注释常亮字面常亮符号常亮 变量数据类型整型实型常量类型确定char类型字符串布尔类型 控制台输入随机数产生枚举定义数组数组便利 指针基础野指针空指针指针运算动态内存分配 结构体结构体默认值结构体数组结构体指针结构体指针数组函数无返回值函数和void类型地址传递函数传递数组 引用函数引用传参返回指针的正确写法函数返回数组
阅读更多...
【QT】基础入门学习

【QT】基础入门学习

文章目录 浅析Qt应用程序的主函数使用qDebug()函数常用快捷键Qt 编码风格信号槽连接模型实现方案 信号和槽的工作机制Qt对象树机制 浅析Qt应用程序的主函数 #include "mywindow.h"#include <QApplication>// 程序的入口int main(int argc, char *argv[]){// argc是命令行参数个数，argv是
阅读更多...
【MRI基础】TR 和 TE 时间概念

【MRI基础】TR 和 TE 时间概念

重复时间 (TR) 磁共振成像 (MRI) 中的 TR（重复时间，repetition time）是施加于同一切片的连续脉冲序列之间的时间间隔。具体而言，TR 是施加一个 RF（射频）脉冲与施加下一个 RF 脉冲之间的持续时间。TR 以毫秒 (ms) 为单位，主要控制后续脉冲之前的纵向弛豫程度（T1 弛豫），使其成为显著影响 MRI 中的图像对比度和信号特性的重要参数。 回声时间 (TE)
阅读更多...
Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO 文件操作字节流与字符流OutputStream字节输出流FileOutputStream InputStream字节输入流FileInputStream Writer字符输出流FileWriter Reader字符输入流字节流与字符流的区别转换流InputStreamReaderOutputStreamWriter 文件复制 字符编码内存操作流(
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2