springboot 启动方式 装配流程 自定义starter 文件加载顺序 常见设计模式

目录

springboot介绍

核心特性

快速搭建 Spring Boot 项目

方式一:使用 Spring Initializr

方式二:使用 IDE 插件

示例代码

1. 创建项目并添加依赖

2. 创建主应用类

3. 创建控制器类

4. 运行应用程序

配置文件

部署和监控

部署

监控

与其他技术集成

启动方式

装配原理

核心注解

1. @SpringBootApplication

2. @EnableAutoConfiguration

自动装配的流程

1. 加载自动配置类的元数据

2. 筛选自动配置类

3. 配置自动配置类

示例代码分析

总结

springboot自定义start

1. 创建项目结构

2. 创建配置属性类

MyServiceProperties.java

3. 创建服务类

MyService.java

4. 创建自动配置类

MyServiceAutoConfiguration.java

5. 创建 spring.factories 文件

spring.factories

6. 打包和使用自定义 Starter

打包

使用

配置

使用服务

Springboot 约定优于配置

@Scheduled注解

注解概述

常用属性

1. fixedRate

2. fixedDelay

3. initialDelay

4. cron

使用示例

1. 创建 Spring Boot 项目

2. 启用定时任务

3. 创建定时任务类

注意事项

@Scheduled注解配置定时任务串行、并行

串行执行定时任务

1. 创建 Spring Boot 项目

2. 启用定时任务

3. 创建定时任务类

并行执行定时任务

1. 创建线程池配置类

2. 创建定时任务类

springboot文件加载顺序

1. 配置文件类型

2. 加载顺序

2.1 打包在 jar 包中的默认配置文件

2.2 打包在 jar 包中的特定环境配置文件

2.3 外部的默认配置文件

2.4 外部的特定环境配置文件

2.5 外部根目录下的默认配置文件

2.6 外部根目录下的特定环境配置文件

3. 激活特定环境

3.1 在 application.properties 或 application.yml 中指定

3.2 通过命令行参数指定

4. 其他配置源

配置文件的生效顺序,会对值进行覆盖

springboot 启动Tomcat

基本原理

启动步骤

1. 创建 Spring Boot 项目

2. 编写主应用类

3. 启动应用程序

修改 Tomcat 配置

使用 application.properties

使用 application.yml

部署到外置 Tomcat

1. 修改打包方式

2. 排除嵌入式 Tomcat

3. 继承 SpringBootServletInitializer

4. 打包并部署

tomcat配置优化

性能优化

1. 调整线程池参数

2. 启用 APR 模式

3. 调整压缩配置

稳定性优化

1. 调整 JVM 参数

2. 配置连接超时时间

3. 监控和日志配置

安全性优化

1. 关闭不必要的服务和端口

2. 配置安全的 Connector

3. 防止目录遍历攻击

Spring Boot 中常见设计模式

单例模式

概念

Spring Boot 中的应用

工厂模式

概念

Spring Boot 中的应用

代理模式

概念

Spring Boot 中的应用

观察者模式

概念

Spring Boot 中的应用

策略模式

概念

Spring Boot 中的应用

组件

1. Spring Boot Starter 系列

Spring Boot Starter Web

Spring Boot Starter Data JPA

Spring Boot Starter Security

2. Spring Boot Actuator

3. Spring Boot DevTools

4. Spring Boot Configuration Processor

5. Spring Boot Test

6. Spring Boot Admin

Cors 跨资源共享


Spring Boot 一款用于简化 Spring 应用开发的框架,它通过提供默认配置和自动配置功能减少了大量的样板代码和配置文件,使得开发者能够更快速地搭建和开发基于 Spring 的应用程序。以下从多个方面对 Spring Boot 进行详细介绍:

springboot介绍

核心特性

  1. 自动配置:Spring Boot 会根据项目中引入的依赖自动进行配置,减少了开发者手动配置的工作量。例如,当项目中引入了 Spring Data JPA 和 MySQL 驱动时,Spring Boot 会自动配置数据源和 JPA 相关的 Bean。
  2. 起步依赖:提供了一系列的起步依赖,这些依赖是一组经过精心挑选的依赖集合,开发者可以根据项目的需求选择相应的依赖,Spring Boot 会自动处理依赖关系。例如,spring-boot-starter-web 包含了构建 Web 应用所需的所有依赖。
  3. 嵌入式服务器:支持嵌入式服务器,如 Tomcat、Jetty 等,开发者可以将应用程序打包成可执行的 JAR 文件,直接运行,无需额外部署到服务器上。
  4. Actuator:提供了生产级别的监控和管理功能,通过 RESTful 接口或 JMX 可以方便地查看应用程序的运行状态、性能指标等信息。
  5. 命令行界面(CLI):Spring Boot CLI 允许开发者使用命令行快速创建和运行 Spring Boot 应用程序,支持 Groovy 脚本,进一步简化了开发过程。

快速搭建 Spring Boot 项目

方式一:使用 Spring Initializr

Spring Initializr 是一个基于 Web 的工具,可帮助开发者快速生成 Spring Boot 项目的基础结构。访问 Spring Initializr,按照以下步骤操作:

  1. 选择项目的基本信息,如项目类型(Maven 或 Gradle)、语言(Java、Kotlin 或 Groovy)、Spring Boot 版本等。
  2. 添加项目依赖,例如 Spring Web 用于构建 Web 应用。
  3. 点击 Generate 按钮下载项目压缩包,解压后导入到 IDE 中即可开始开发。
方式二:使用 IDE 插件

许多 IDE 都提供了 Spring Boot 项目创建的插件,例如 IntelliJ IDEA 中的 Spring Initializr 插件。通过 IDE 插件可以更方便地创建 Spring Boot 项目,步骤与使用 Spring Initializr 类似。

示例代码

以下是一个简单的 Spring Boot Web 应用示例:

1. 创建项目并添加依赖

在 pom.xml 中添加 spring-boot-starter-web 依赖:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
2. 创建主应用类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class HelloWorldApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloWorldApplication.class, args);
    }
}
3. 创建控制器类
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}
4. 运行应用程序

运行 HelloWorldApplication 类的 main 方法,启动 Spring Boot 应用程序。在浏览器中访问 http://localhost:8080/hello,即可看到返回的 Hello, World! 信息。

配置文件

Spring Boot 使用 application.properties 或 application.yml 作为配置文件,用于配置应用程序的各种属性。例如,配置服务器端口:

server.port=8081
server:
  port: 8081

部署和监控

部署

Spring Boot 应用程序可以打包成可执行的 JAR 文件,通过命令行直接运行:

java -jar your-application.jar
监控

通过添加 spring-boot-starter-actuator 依赖,可以使用 Actuator 提供的监控和管理功能。例如,访问 http://localhost:8080/actuator/health 可以查看应用程序的健康状态。

与其他技术集成

Spring Boot 可以方便地与其他技术进行集成,如数据库(MySQL、Oracle、MongoDB 等)、消息队列(RabbitMQ、Kafka 等)、缓存(Redis 等)。通过添加相应的起步依赖和进行简单的配置,即可实现集成。

总之,Spring Boot 极大地简化了 Spring 应用的开发过程,提高了开发效率,是构建现代 Java 应用的首选框架之一。

Spring 时代我们一般通过 XML 文件来配置 Bean,

后来开发人员觉得 XML 文件来配置不太好,

于是 SpringBoot 注解配置就慢慢开始流行起来。

内置容器:Jetty,Tomcat,Undertow。/ˈʌndətəʊ/

启动方式

借助 内置的Tomcat或者运行main方法启动

使用 @SpringBootApplication 注解,右击 Run AS -> Java Application

打包成可执行 JAR 文件启动 :

                通过命令行 java -jar 的方式

                 通过spring-boot-plugin的方式

装配原理

Spring Boot 的自动装配是其核心特性之一,它能够根据项目中引入的依赖自动配置 Spring 应用,极大地简化了开发过程。下面将详细介绍 Spring Boot 自动装配的原理。

核心注解

1. @SpringBootApplication

这是一个组合注解,通常标注在 Spring Boot 应用的主类上,它主要包含了以下三个重要注解:

  • @SpringBootConfiguration:本质上就是 @Configuration 注解,用于表明该类是一个配置类,能够定义 Bean。
  • @EnableAutoConfiguration:开启自动装配功能,让 Spring Boot 根据项目依赖自动配置 Spring 应用。
  • @ComponentScan:开启组件扫描,会自动扫描主类所在包及其子包下被 @Component@Service@Repository@Controller 等注解标注的类,并将它们注册为 Bean。
2. @EnableAutoConfiguration

该注解是自动装配的关键,它借助 @Import 注解导入 AutoConfigurationImportSelector 类。这个类负责加载自动配置类。

自动装配的流程

1. 加载自动配置类的元数据

在 META - INF/spring.factories 文件中,定义了一系列的自动配置类。Spring Boot 在启动时,会通过 SpringFactoriesLoader 类加载这个文件,并读取其中以 org.springframework.boot.autoconfigure.EnableAutoConfiguration 为键的所有自动配置类。

例如,在 Spring Boot 的核心依赖中,spring.factories 文件可能包含如下内容:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
...
2. 筛选自动配置类

加载完所有自动配置类后,Spring Boot 会根据一系列的条件注解(如 @ConditionalOnClass@ConditionalOnMissingBean@ConditionalOnProperty 等)对这些自动配置类进行筛选,只有满足条件的自动配置类才会被应用。

  • @ConditionalOnClass:当类路径下存在指定的类时,对应的自动配置类才会生效。
  • @ConditionalOnMissingBean:当容器中不存在指定类型的 Bean 时,对应的自动配置类才会生效。
  • @ConditionalOnProperty:当配置文件中存在指定的属性,并且属性值满足指定条件时,对应的自动配置类才会生效。
3. 配置自动配置类

筛选出满足条件的自动配置类后,Spring Boot 会将这些自动配置类作为配置类进行处理,将其中定义的 Bean 注册到 Spring 容器中。

示例代码分析

以下是一个简单的自动配置类示例:

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 当类路径下存在 MyService 类时,该自动配置类才会生效
@ConditionalOnClass(MyService.class)
@Configuration
public class MyAutoConfiguration {

    // 当容器中不存在 MyService 类型的 Bean 时,创建一个 MyService 实例并注册到容器中
    @ConditionalOnMissingBean
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

在上述示例中,MyAutoConfiguration 是一个自动配置类。@ConditionalOnClass(MyService.class) 表示只有当类路径下存在 MyService 类时,该自动配置类才会生效;@ConditionalOnMissingBean 表示只有当容器中不存在 MyService 类型的 Bean 时,才会创建一个 MyService 实例并注册到容器中。

总结

Spring Boot 的自动装配原理基于约定优于配置的思想,通过 @EnableAutoConfiguration 注解开启自动装配功能,利用 SpringFactoriesLoader 加载自动配置类的元数据,再根据条件注解筛选出满足条件的自动配置类,最后将这些自动配置类中的 Bean 注册到 Spring 容器中,从而实现自动配置的目的。

1、容器在启动的时候会调用 EnableAutoConfigurationImportSelector.class 的

          selectImports方法「获取一个全面的常用 BeanConfiguration 列表」

2、之后会读取 spring-boot-autoconfigure.jar 下面的spring.factories,

「获取到所有的 Spring 相关的 Bean 的全限定名 ClassName」

3、之后继续「调用 filter 来一一筛选」,过滤掉一些我们不需要不符合条件的 Bean

4、最后把符合条件的 BeanConfiguration 注入默认的 EnableConfigurationPropertie 类里面    的属性值,并且「注入到 IOC 环境当中」

@springBootApplication里面有三个主要注解

1.@SpringBootConfiguration:该注解与Configuration注解作用相同,

用来声明当前也是一个配置类(使用Configuration配置类等同于XML文件)。

2.@ComponentScan:组件扫描,默认扫描当前引导类所在的包及其子包。

将@Controller/@Service/@Component/@Repository等注解加载到IOC容器中。3.@EnableAutoConfiguration:开启自动配置功能

@ConditionalOnClass 判断是否有对应字节码

@Import:给IOC容器导入组件

@Import+@configuration+srping spi

springboot自定义starter

Spring Boot 的自定义 Starter 可以将一些通用的功能封装起来,方便在不同项目中复用。下面为你详细介绍创建自定义 Starter 的步骤和示例。

1. 创建项目结构

首先,你需要创建一个 Maven 项目,这个项目将作为自定义 Starter 的载体。在项目的 pom.xml 中添加必要的依赖。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.4</version>
    </parent>

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

</project>

2. 创建配置属性类

配置属性类用于绑定应用配置文件(如 application.properties 或 application.yml)中的属性。

MyServiceProperties.java
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
    private String message = "Default message";

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

3. 创建服务类

服务类是自定义 Starter 提供的核心功能类。

MyService.java
public class MyService {
    private final String message;

    public MyService(String message) {
        this.message = message;
    }

    public String sayHello() {
        return "Hello, " + message;
    }
}

4. 创建自动配置类

自动配置类负责根据条件创建 Bean 并进行配置。

MyServiceAutoConfiguration.java
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(MyServiceProperties.class)
public class MyServiceAutoConfiguration {

    private final MyServiceProperties properties;

    public MyServiceAutoConfiguration(MyServiceProperties properties) {
        this.properties = properties;
    }

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService(properties.getMessage());
    }
}

5. 创建 spring.factories 文件

在 src/main/resources/META - INF 目录下创建 spring.factories 文件,用于指定自动配置类。

spring.factories

properties

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyServiceAutoConfiguration

6. 打包和使用自定义 Starter

打包

在项目根目录下执行 mvn clean install 命令,将自定义 Starter 打包并安装到本地 Maven 仓库。

使用

在其他 Spring Boot 项目的 pom.xml 中添加自定义 Starter 的依赖:

<dependency>
    <groupId>com.example</groupId>
    <artifactId>my-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
配置

在 application.properties 或 application.yml 中配置自定义属性:

my.service.message=Custom message
使用服务

在需要使用服务的地方注入 MyService 并调用其方法:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp implements CommandLineRunner {

    @Autowired
    private MyService myService;

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

    @Override
    public void run(String... args) throws Exception {
        System.out.println(myService.sayHello());
    }
}

通过以上步骤,你就可以创建并使用自定义的 Spring Boot Starter 了。自定义 Starter 可以将一些常用的功能封装起来,提高代码的复用性和可维护性。

Springboot 约定优于配置

四个方面回答

1、约定优于配置是一种软件设计的范式,

  它的核心思想是减少软件开发人员对于配置项的维护,从而让开发人员聚焦在业务逻辑上。

2、Springboot就是约定优于配置的产物,它是spring框架下的一个脚手架,可以快速开发spring生态下的应用程序。

3、基于传统的spring框架开发,需要做很多与业务无关配置项,像

  1. 管理jar包的依赖、
  2. web.xml维护
  3. dispatch-servlet.xml
  4. 应用部署到web容器
  5. 第三方组件集成到springIOC中维护。

   Springboot 已经不需要了,基于约定优于配置思想。

4、Springboot 约定优于配置体现

  1. Springboot 约定优于配置体现(springboot Starter启动依赖 ,它能帮助我们管理所有jar包版本)

  2. 如果当前项目依赖web jar,它会自动内置tomcat容器来运行web应用不需要单独部署。

  3. 自动装配机制的实现中通过扫描约定路径下的spring.factories文件,去识别配置类,从而进行bean的自动装载。

  4. 默认会加载resource目录下的application.properties文件

5、核心本质:更加高效、便捷实现软件系统开发维护。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

what_2018

你的鼓励是我前进的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值