SpringBoot

Spring Boot

配置文件

默认配置文件

放在src/main/resources下，名称必须为application.yml

使用环境变量

1
2
3

# 首先从环境变量DB_HOST中找，否则使用默认值localhost
db:
	host: ${DB_HOST:localhost}

日志配置文件

名称为logback-spring.xml，用来定义日志级别、日志格式、日志输出位置

<?xml version="1.0" encoding="UTF-8"?>
<configuration  scan="true" scanPeriod="10 seconds">
    <!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
    <!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
    <!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
    <!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->

    <contextName>logback</contextName>
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
    <property name="log.path" value="F:/yygh_log" />

    <!-- 彩色日志 -->
    <!-- 配置格式变量：CONSOLE_LOG_PATTERN 彩色日志格式 -->
    <!-- magenta:洋红 -->
    <!-- boldMagenta:粗红-->
    <!-- cyan:青色 -->
    <!-- white:白色 -->
    <!-- magenta:洋红 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) |%highlight(%-5level) |%blue(%thread) |%blue(%file:%line) |%green(%logger) |%cyan(%msg%n)"/>


    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <!-- 例如：如果此处配置了INFO级别，则后面其他位置即使配置了DEBUG级别的日志，也不会被输出 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>


    <!--输出到文件-->

    <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_info.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 WARN 日志 -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_warn.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_error.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
        <logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              如果未设置此属性，那么当前logger将会继承上级的级别。
    -->
    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="INFO">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给mapper下目录配置DEBUG模式，代码如下，这样配置sql语句会打印，其他还是正常DEBUG级别：
     -->
    <!--开发环境:打印控制台-->
    <springProfile name="dev">
        <!--可以输出项目中的debug日志，包括mybatis的sql日志-->
        <logger name="com.guli" level="INFO" />

        <!--
            root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
            level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，默认是DEBUG
            可以包含零个或多个appender元素。
        -->
        <root level="INFO">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="WARN_FILE" />
            <appender-ref ref="ERROR_FILE" />
        </root>
    </springProfile>


    <!--生产环境:输出到文件-->
    <springProfile name="pro">

        <root level="INFO">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile>

</configuration>

不同环境下的配置

最上面的为默认配置，通过---隔开不同环境的配置

server:
  port: 8080

---

# 开发
spring:
  config:
    activate:
      on-profile: native

server:
  port: 8081

---

# 测试
spring:
  config:
    activate:
      on-profile: test

server:
  port: 8082

---

# 生产
spring:
  config:
    activate:
      on-profile: production

server:
  port: 8083

在idea中通过添加虚拟机参数-Dspring.profiles.active=环境名指定环境
在命令行通过java -Dspring.profiles.active=环境名 -jar xxx.jar 指定环境
不指定环境名时为default

读取配置

通过@Value注解一个个读取配置

@Value("${app.name}")
private String name;

// 带默认值
@Value("${app.port:8080}")
private int port;

// 读取数组
@Value("${app.servers[0]}")
private String firstServer;

通过@ConfigurationProperties一次性读取多个配置

@Configuration
@ConfigurationProperties("storage.local")
public class StorageConfiguration {
    // 会根据变量名来匹配
    ...
}

打包项目

通过spring-boot-maven-plugin插件来打包

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

mvn clean：只清理，不构建
mvn package：直接打包，但不会删除旧文件
mvn clean install ：清理 + 构建 + 把包安装到本地仓库（~/.m2/repository），方便别的项目依赖
mvn clean deploy ：清理 + 构建 + 部署到远程仓库
mvn clean package：打包项目

打包完项目会在target/目录下生成xxx.jar（包含依赖）和xxx.jar.original（不包含依赖）

可通过java -jar xxx.jar直接运行

常用注解

启动类上

@SpringBootApplication：启动Spring Boot应用程序，标注在启动类上

注解包含了
- @SpringBootConfiguration：本质上就是 @Configuration，表示这是一个配置类
- @EnableAutoConfiguration：开启自动配置，会根据项目中的 classpath 依赖和定义的配置，自动配置 Spring 应用所需要的 Bean
- @ComponentScan：负责扫描Bean，默认会扫描启动类所在包及其子包下的组件
@EnableTransactionManagement：开启事务管理@Transactional
@MapperScan：MyBatis 项目里常用，指定 Mapper 接口包路径
@ComponentScan：指定扫描的包，自动发现并注册组件
@Import：显式导入类/配置到容器

配置类上

@Configuration：声明当前类是一个配置类，配合@Bean使用
@Bean：用于方法上，把返回值对象交给 Spring 容器管理

方法的返回值就是要注册到容器中的对象，默认 Bean 名称是方法名

@Lazy：bean 会在第一次使用才创建

方法的参数会被容器解析，相当于@Autowired自动注入
@Conditional：条件装配，根据条件判断是否加载这个Bean
- @ConditionalOnClass：某个类存在时才生效
- @ConditionalOnMissingBean：容器里没有某个 Bean 时才加载
- @ConditionalOnProperty：配置文件里存在某属性时才生效
….
@ConfigurationProperties：把配置文件里的属性绑定到类的属性里
@Profile：只在指定环境下加载Bean

监控运行状态

Actuator 是 Spring Boot 提供的一个监控和管理工具。它可以暴露应用运行状态、指标、健康信息、日志级别动态修改等端点（Endpoints）。对生产环境运维和监控非常有用

引入依赖

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

添加配置

# Actuator会把它能收集到的所有信息都暴露给JMX，出于安全原因，只会把health和infoo暴露给Web
# 可以设置Web能访问的端点
management:
  endpoints:
    web:
      exposure:
        include: info, health, beans, env, metrics

访问
1
http://localhost:8080/actuator/health

使用过滤器

1.实现`Filter`接口

可以重写Filter中的三个方法

name	说明
init(FilterConfig)	创建filter时会调用一次
doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)	拦截客户端请求时调用
destroy()	销毁filter时会调用一次

2.注册拦截器

方式1: 注解注册

通过@WebFilter(filterName, urlPatterns)注解来说明这是一个过滤器

参数	说明
filterName	过滤器名字
urlPatterns	拦截的路径

然后在主启动类上使用@ServletComponentScan注解开启扫描

加上这个注解可以扫描@Servlet、@Filter、@Listener

方式2: 配置类方式注入

@Configuration
public class FilterConfig {
    @Autowired
    private Filter1 filter;

    @Bean
    public FilterRegistrationBean filter() {
        //通过FilterRegistrationBean注入Bean
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //设置过滤器
        registration.setFilter(filter);
        //设置过滤器名和拦截路径
        registration.setName("filter");
        registration.addUrlPatterns("/*");
        //设置优先级别
        registration.setOrder(1);
        return registration;
    }
}

例子

@WebFilter(filterName = "loginCheckFilter", urlPatterns = "/*")
public class LoginCheckFilter implements Filter {
    //路径匹配器
    public static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        //获取请求的uri
        String requestURI = request.getRequestURI();

        //判断是否需要处理
        String[] urls = new String[]{
                //不需要处理的路径
                "/employee/login",
                "/employee/logout",
                "/backend/**",
                "/front/**",
                "/common/**"
        };
        if (check(urls, requestURI)) {
            //不用处理, 放行
            filterChain.doFilter(request, response);
            return;
        } else if (request.getSession().getAttribute("employee") != null) {
            //网页端验证有没有登录
            Long id = (Long) request.getSession().getAttribute("employee");
            BaseContext.setCurrentId(id);
            //已登录, 放行
            filterChain.doFilter(request, response);
            return;
        } else {
            //未登录, 拦截
            response.getWriter().write(JSON.toJSONString(R.error("NOTLOGIN")));
            return;
        }
    }

    /**
     * 匹配请求路径是否不需要处理
     *
     * @param urls
     * @param requestURI
     * @return
     */
    private boolean check(String[] urls, String requestURI) {
        for (String url : urls) {
            if (PATH_MATCHER.match(url, requestURI)) {
                return true;
            }
        }
        return false;
    }
}

自定义异常处理器

案例

自定义异常类

基础异常类

@Data
public class BaseException extends Exception{
    private final Integer code;

    public BaseException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public BaseException(ResultStatus status) {
        super(status.getDescription());
        this.code = status.getCode();
    }
}

根据业务场景派生不同异常

/**
 * 用户权限异常
 */
public class UnauthorizedException extends BaseException{
    public UnauthorizedException(String message) {
        super(ResultStatus.UNAUTHORIZED.getCode(), message);
    }
}

添加全局异常处理类

添加@RestControllerAdvice注解来统一捕获所有异常

@RestControllerAdvice = @ControllerAdvice + @ResponseBody

@RestControllerAdvice
public class GlobalExceptionHandler {
    // 处理自定义业务异常
    @ExceptionHandler(BaseException.class)
    public CommonResult<?> handleBaseException(BaseException e) {
        return CommonResult.fail(e.getCode(), e.getMessage());
    }

    // 处理空指针等运行时异常
    @ExceptionHandler(NullPointerException.class)
    public CommonResult<?> handleNullPointerException(NullPointerException e) {
        return CommonResult.fail(500, "空指针异常");
    }

    // 处理所有其他异常
    @ExceptionHandler(Exception.class)
    public CommonResult<?> handleException(Exception e) {
        return CommonResult.fail(500, "服务器内部错误: " + e.getMessage());
    }
}

业务代码中抛出异常

@GetMapping("/test")
public CommonResult<String> test() throws BaseException {
    if(true) {
        throw new BaseException(666, "testException");
    }

    return CommonResult.success("test");
}

Http请求工具

RestClient

在Spring Boot 3.2之后，使用RestClient代替RestTemplate进行发送Http请求

基本使用

导入依赖

# 包含在了Spring Boot Web依赖中
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

添加RestClientConfig配置类

@Configuration
public class RestClientConfig {
    /**
     * 全局 RestClient Bean
     */
    @Bean
    public RestClient restClient(Builder builder) {
        return builder
            	.defaultHeader("User-Agent", "MyApp/1.0 (SpringBoot 3.3.5)")    // 通用 header
                .baseUrl("http://localhost:5050") // 第三方 API 地址
                .build();
    }
}

测试

@Test
public void test() {
    // 往body()里传将Json反序列化后的对象的.class。 记得该类要有getter、setter和构造方法
    Map<String, Object> body = restClient.get()
        .uri("/version")
        .retrieve()
        .body(String.class);
    System.out.println(body);
}

Spring Boot Starter

预先包含了所需的依赖以及配置

为什么需要

例如要使用Mybatis，需要手动引入 MyBatis、Spring-JDBC、数据库驱动等多个依赖。之后还要写相关配置及注入Bean，写不好还会出现版本冲突。

而使用mybatis-spring-boot-starter就能自动完成上面的操作

命名规范

官方的：spring-boot-starter-xxx
非官方的：xxx-spring-boot-starter

Starter结构

xxx-starter（启动器包）

只做管理依赖，就是一个空壳 pom，把该场景所有需要的 jar 都依赖进来
xxx-starter-autoconfigure（自动配置包）

存放自动配置类、配置属性类、META-INF 配置文件

SpringBoot 启动时会自动扫描META-INF 配置文件，把里面的配置类加载到容器

demo

新建一个demo-spring-boot-starter-demo项目

demo-spring-boot-starter-autoconfigure

在pom.xml内引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 关键：删除了 parent，改用 dependencyManagement -->
    <groupId>com.xw</groupId>
    <artifactId>demo-spring-boot-starter-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-spring-boot-starter-autoconfigure</name>
    <description>demo-spring-boot-starter-autoconfigure</description>

    <properties>
        <java.version>17</java.version>
    </properties>

    <!-- 只管理版本，不做可执行项目 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>4.0.6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- 配置属性绑定 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 自动配置核心 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
    </dependencies>

</project>

自动配置

创建一个类用于注入测试，com/demo/starter/service/DemoHelloService.java

package com.demo.starter.service;

public class DemoHelloService {
    private String name;
    private String msg;

    public String sayHello() {
        return "【自定义Starter】" + name + " : " + msg;
    }

    public void setName(String name) { this.name = name; }
    public void setMsg(String msg) { this.msg = msg; }
}

创建com/demo/starter/props/DemoProperties.java来读取配置

package com.demo.starter.props;

@ConfigurationProperties(prefix = "demo.hello")
public class DemoProperties {
    // 配置 demo.hello.name=xxx
    private String name = "默认名称";
    // 配置 demo.hello.msg=xxx
    private String msg = "默认消息";

    // getter / setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getMsg() { return msg; }
    public void setMsg(String msg) { this.msg = msg; }
}

创建com/demo/starter/config/DemoAutoConfiguration.java来自动配置并注入Bean

package com.demo.starter.config;

// 开启属性绑定
@EnableConfigurationProperties(DemoProperties.class)
@Configuration
public class DemoAutoConfiguration {

    // 容器中没有 DemoHelloService 才自动创建
    @Bean
    @ConditionalOnMissingBean
    public DemoHelloService demoHelloService(DemoProperties properties) {
        DemoHelloService service = new DemoHelloService();
        service.setName(properties.getName());
        service.setMsg(properties.getMsg());
        return service;
    }
}

创建resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports用于依赖注入
1
com.demo.starter.config.DemoAutoConfiguration
mvn clean install

demo-spring-boot-starter

引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.5.14</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.xw</groupId>
	<artifactId>demo-spring-boot-starter</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo-spring-boot-starter</name>
	<description>demo-spring-boot-starter</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<!-- 只依赖自动配置模块 -->
		<dependency>
			<groupId>com.xw</groupId>
			<artifactId>demo-spring-boot-starter-autoconfigure</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

mvn clean install

创建测试项目

引入依赖

<dependency>
    <groupId>com.xw</groupId>
    <artifactId>demo-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

添加配置

demo:
  hello:
    name: "张三"
    msg: "自定义Starter测试成功"

注入DemoHelloService测试

@RestController
public class TestController {

    @Autowired
    private DemoHelloService demoHelloService;

    @GetMapping("/hello")
    public String hello() {
        return demoHelloService.sayHello();
    }
}

原理

扫描自动配置类

启动项目时，Spring Boot 利用 SpringFactoriesLoader 去扫描应用类路径下所有 JAR 包里的特殊配置文件META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

装载自动配置类

之后根据条件装配来选择要实例化的类

@ConditionalOnClass：当类路径下存在某个类时才生效。
@ConditionalOnMissingClass：缺少某类时生效。
@ConditionalOnBean：当容器中已有某个 Bean 时/不在时生效。
@ConditionalOnProperty：当配置文件中某个属性有指定值时生效等等。

自动配置类里的Bean会被注入到容器里

学习笔记 > 后端 > Spring

#后端 #Spring

SpringBoot

http://xwww12.github.io/2022/10/11/后端/Spring/SpringBoot/

作者

发布于

2022年10月11日

许可协议

搭建前端项目上一篇

10.Vuex 下一篇

SpringBoot

Spring Boot

配置文件

默认配置文件

日志配置文件

不同环境下的配置

读取配置

打包项目

常用注解

监控运行状态

使用过滤器

1.实现Filter接口

2.注册拦截器

自定义异常处理器

Http请求工具

RestClient

基本使用

Spring Boot Starter

为什么需要

命名规范

Starter结构

demo

demo-spring-boot-starter-autoconfigure

demo-spring-boot-starter

创建测试项目

原理

扫描自动配置类

装载自动配置类

1.实现`Filter`接口