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

1. 创建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，简化应用整合

2. 编写主程序

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

3. 写一个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来写：

1. 创建webapp项目
2. 导入spring、springMVC的jar包
3. 在web.xml里配spring容器，配置springMVC的DispatcherServlet
4. 写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怎么把日志默认配置好的

1. 每个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>

2. 核心场景引入了日志的所用功能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>

3. 默认使用了logback + slf4j 组合作为默认底层日志
4. 日志是系统一启动就要用，xxxAutoConfiguration是系统启动好了以后放好的组件，后来用的。
5. 日志是利用监听器机制配置好的。ApplicationListener。
6. 日志所有的配置都可以通过修改配置文件实现。以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