SpringBoot

SpringBoot特性

快速创建独立 Spring 应用
SSM:导包、写配置、启动运行
直接嵌入Tomcat、Jettyor Undertow(无需部署 war包)【Servlet容器】
linux java tomcat mysql: war放到tomcat 的webapps下
jar:java环境;java -jar
重点：提供可选的starter，简化应用整合
场景启动器(starter):web、json、邮件、oss(对象存储)、异步、定时任务、缓存...
导包一堆，控制好版本。
为每一种场景准备了一个依赖;web-starter。
重点：按需自动配置 Spring 以及第三方库
如果这些场景我要使用(生效)。这个场景的所有配置都会自动配置好。
约定大于配置:每个场景都有很多默认配置。
提供生产级特性:如监控指标、健康检查、外部化配置等
监控指标、健康检查(k8s)
无代码生成、无xml

总结:简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

写一个demo

创建maven项目

导包

     <!--所有springboot项目都必须继承自 spring-boot-starter-parent-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.3</version>
    </parent>
 
    <!--web开发的场景启动器-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
 
    <!--SpringBoot应用打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

导完spring-boot-starter-web后可以发现maven依赖里面就自动添加了spring-boot-starter、spring-boot-starter-json、spring-boot-starter-tomcat、spring-web、spring-webmvc

对应第三个特性：提供可选的starter，简化应用整合

编写主程序

 /**
 * 启动springBoot项目的主入口程序
 * @author happywei
 * @version 1.0
 */
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}

写一个controller

 **
 * @author happywei
 * @version 1.0
 */
//@ResponseBody   //表示这个类的所有方法都是返回Jason或是纯文本数据
//@Controller
@RestController //上面两个注解的合体
public class HelloController {
 
 
    @GetMapping("/hello")
    public String Hello(){
        return "Hello";
    }
}

写好项目后，可以用maven的clean，再打包生成一个jar包，可以直接再cmd上运行

 java -jar boot3-01-demo-1.0-SNAPSHOT.jar

成功运行，对应第二个特性：直接嵌入Tomcat、Jettyor Undertow(无需部署 war包)【Servlet容器】

想象一下用springMVC来写：

创建webapp项目
导入spring、springMVC的jar包
在web.xml里配spring容器，配置springMVC的DispatcherServlet
写controller，写getMapping处理请求返回数据

应用分析

依赖管理机制

思考：
1、为什么导入starter-web所有相关依赖都导入进来？

开发什么场景，导入什么场景启动器。
maven依赖传递原则。A-B-C： A就拥有B和C
导入场景启动器。场景启动器自动把这个场景的所有核心依赖全部导入进来

2、为什么版本号都不用写？

每个boot项目都有一个父项目spring-boot-starter-parent
parent的父项目是spring-boot-dependencies
父项目 版本仲裁中心，把所有常见的jar的依赖版本都声明好了。
比如：mysql-connector-j

3、自定义版本号

利用maven的就近原则
直接在当前项目properties标签中声明父项目用的版本属性的key
直接在导入依赖的时候声明版本
4、第三方的jar包
boot父项目没有管理的需要自行声明好

自动配置机制

1. 初步理解

自动配置的 Tomcat、SpringMVC 等
- 导入场景，容器中就会自动配置好这个场景的核心组件
- 以前：DispatcherServlet(拦截所有请求)、ViewResolver(页面跳转视图解析)、CharacterEncodingFilter....
- 现在：自动配置好的这些组件
- 验证：容器中有了什么组件，就具有什么功能

可以看到主程序里的run方法返回了一个ConfigurableApplicationContext对象

     public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }

拿到这个对象看看里面有哪些组件

     public static void main(String[] args) {
 
        //java10： 局部变量类型的自动推断
        var ioc = SpringApplication.run(MainApplication.class, args);
 
        //1、获取容器中所有组件的名字
        String[] names = ioc.getBeanDefinitionNames();
        //2、挨个遍历：
        // dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver
        // SpringBoot把以前配置的核心组件现在都给我们自动配置好了。
        for (String name : names) {
            System.out.println(name);
        }
 
    }

默认的包扫描规则
- @SpringBootApplication 标注的类就是主程序类
- SpringBoot只会扫描主程序所在的包及其下面的子包，自动的component-scan功能
- 自定义扫描路径
  - @SpringBootApplication(scanBasePackages = "com.atguigu")
  - @ComponentScan("com.atguigu") 直接指定扫描的路径
配置默认值
- 配置文件的所有配置项是和某个类的对象值进行一一绑定的。
- 绑定了配置文件中每一项值的类： 属性类。
- 比如：
  - ServerProperties绑定了所有Tomcat服务器有关的配置
  - MultipartProperties绑定了所有文件上传相关的配置
按需加载自动配置
- 导入场景spring-boot-starter-web
- 场景启动器除了会导入相关功能依赖，导入一个spring-boot-starter，是所有starter的starter，基础核心starter
- pring-boot-starter导入了一个包 spring-boot-autoconfigure。包里面都是各种场景的AutoConfiguration自动配置类
- 虽然全场景的自动配置都在 spring-boot-autoconfigure这个包，但是不是全都开启的。
  - 导入哪个场景就开启哪个自动配置

总结：导入场景启动器、触发 spring-boot-autoconfigure这个包的自动配置生效、容器中就会具有相关场景的功能

4、核心技能

思考以前是怎么给ioc容器注册一些组件
编写实体类
配置xml文件

     <bean id="user" class="com.happywei.boot.bean.User" scope="prototype">
        <property name="id" value="1"></property>
        <property name="name" value="zhangsan"></property>
    </bean>
 
    <bean id="cat" class="com.happywei.boot.bean.Cat">
        <property name="id" value="1"></property>
        <property name="name" value="Tom"></property>
    </bean>

后面用注解替代配置文件

1.常用注解

SpringBoot摒弃XML配置方式，改为全注解驱动

1. 组件注册

@Configuration、@SpringBootConfiguration
@Bean、@Scope
@Controller、 @Service、@Repository、@Component
@Import
@ComponentScan

步骤：
1、@Configuration 编写一个配置类
2、在配置类中，自定义方法给容器中注册组件。配合@Bean
3、或使用@Import 导入第三方的组件

 @Configuration  //这是一个配置类，替代以前的配置文件
public class AppConfig {
 
    @Scope("prototype")
    @Bean   //替代以前的Bean标签。组件在容器中的名字默认是方法名，可以直接修改注解的值
    public User user(){
        var user = new User();
        user.setId(1L);
        user.setName("张三");
        return user;
    }
}

2. 条件注解

如果注解指定的条件成立，则触发指定行为

@ConditionalOnXxx
@ConditionalOnClass：如果类路径中存在这个类，则触发指定行为
@ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为
@ConditionalOnBean：如果容器中存在这个Bean（组件），则触发指定行为
@ConditionalOnMissingBean：如果容器中不存在这个Bean（组件），则触发指定行为

场景：
● 如果存在FastsqlException这个类，给容器中放一个Cat组件，名cat01，
● 否则，就给容器中放一个Dog组件，名dog01
● 如果系统中有dog01这个组件，就给容器中放一个 User组件，名zhangsan
● 否则，就放一个User，名叫lisi

在配置类里创建返回Cat对象的方法，在方法上添加@ConditionalOnClass(name="..FastsqlException")
在配置类里创建返回Dog对象的方法，在方法上添加@ConditionalOnMissingClass(name="..FastsqlException")
在配置类里创建返回User对象的方法，在方法上添加@ConditionalOnClass(name="..Dog")
在配置类里创建返回User对象的方法，在方法上添加@ConditionalOnMissingClass(name="..Dog")

@ConditionalOnBean（value=组件类型，name=组件名字）：判断容器中是否有这个类型的组件，并且名字是指定的值

3.属性绑定

@ConfigurationProperties：声明组件的属性和配置文件哪些前缀开始项进行绑定
@EnableConfigurationProperties：快速注册注解：

场景：SpringBoot默认只扫描自己主程序所在的包。如果导入第三方包，即使组件上标注了 @Component、@ConfigurationProperties 注解，也没用。因为组件都扫描不进来，此时使用这个注解就可以快速进行属性绑定并把组件注册进容器

将容器中任意组件（Bean）的属性值和配置文件的配置项的值进行绑定
● 1、给容器中注册组件（@Component、@Bean）
● 2、使用@ConfigurationProperties 声明组件和配置文件的哪些配置项进行绑定

 @ConfigurationProperties(prefix = "pig")
@Component
public class Pig {
    private Long id;
    private String name;
    private int age;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Pig{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 pig.id=1
pig.name=佩奇
pig.age=5

也可以把@Component注释掉，用方法new一个Pig。加上注解@Bean，放进容器后因为有@ConfigurationProperties(prefix = "pig"),会自动绑定。@ConfigurationProperties也可以放在方法上面。比如newPig方法

日志配置

1. 简介

Spring使用commons-logging作为内部日志，但底层日志实现是开放的。可对接其他日志框架。
- spring5及以后 commons-logging被spring直接自己写了。
支持 jul，log4j2,logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。
logback是默认使用的
虽然日志框架很多，但是我们不用担心，使用 SpringBoot 的默认配置就能工作的很好。

SpringBoot怎么把日志默认配置好的

每个starter场景，都会导入一个核心场景spring-boot-starter
创建web项目时，默认的pom.xml文件，有一个spring-boot-starter-web,如下图

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

追进去spring-boot-starter-web,发现还有一个starter
而且这一层主要是web方面的依赖json、tomcat、web、webmvc。

     <!--starter-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--json-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--tomcat-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--spring-web-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>6.1.4</version>
      <scope>compile</scope>
    </dependency>
    <!--spring-webmvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>6.1.4</version>
      <scope>compile</scope>
    </dependency>

追进spring-boot-starter,可以看到logging就在里面

 <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--autoconfigure-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-autoconfigure</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--logging-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
      <version>3.2.3</version>
      <scope>compile</scope>
    </dependency>
    <!--annotation-api-->
    <dependency>
      <groupId>jakarta.annotation</groupId>
      <artifactId>jakarta.annotation-api</artifactId>
      <version>2.1.1</version>
      <scope>compile</scope>
    </dependency>
    <!--spring-core-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>6.1.4</version>
      <scope>compile</scope>
    </dependency>
    <!--yaml-->
    <dependency>
      <groupId>org.yaml</groupId>
      <artifactId>snakeyaml</artifactId>
      <version>2.2</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

核心场景引入了日志的所用功能spring-boot-starter-logging
追进logging

   <dependencies>
    <!--logback-->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.4.14</version>
      <scope>compile</scope>
    </dependency>
    <!--log4j-to-slf4j-->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-to-slf4j</artifactId>
      <version>2.21.1</version>
      <scope>compile</scope>
    </dependency>
    <!--jul-to-slf4j-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jul-to-slf4j</artifactId>
      <version>2.0.12</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

默认使用了logback + slf4j 组合作为默认底层日志
日志是系统一启动就要用，xxxAutoConfiguration是系统启动好了以后放好的组件，后来用的。
日志是利用监听器机制配置好的。ApplicationListener。
日志所有的配置都可以通过修改配置文件实现。以logging开始的所有配置。

日志格式

 2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.7]

默认输出格式：

时间和日期：毫秒级精度
日志级别：ERROR, WARN, INFO, DEBUG, or TRACE.
进程 ID
---：消息分割符
线程名：使用[]包含
Logger 名：通常是产生日志的类名
消息：日志记录的内容
注意： logback 没有FATAL级别，对应的是ERROR

记录日志

 Logger logger = LoggerFactory.getLogger(getClass());
 
或者使用Lombok的@Slf4j注解

日志级别

● 由低到高：ALL,TRACE, DEBUG, INFO, WARN, ERROR,FATAL,OFF；

○ 只会打印指定级别及以上级别的日志
○ ALL：打印所有日志
○ TRACE：追踪框架详细流程日志，一般不使用
○ DEBUG：开发调试细节日志
○ INFO：关键、感兴趣信息日志
○ WARN：警告但不是错误的信息日志，比如：版本过时
○ ERROR：业务错误日志，比如出现各种异常
○ FATAL：致命错误日志，比如jvm系统崩溃
○ OFF：关闭所有日志记录
● 不指定级别的所有类，都使用root指定的级别作为默认级别
● SpringBoot日志默认级别是 INFO

posted @ 2024-02-28 21:45 不会des 阅读(21) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Spring-自动配置

· spring6入门开发案例步骤

· Java框架 —— SpringBoot（一）

· springboot

· 【SpringBoot】学习笔记

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· C#/.NET/.NET Core技术前沿周刊 | 第 29 期（2025年3.1-3.9）
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异

公告

昵称：不会des
园龄： 2年3个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

tigerWei