1.SpringBoot-入门

1.了解SpringBoot

为什么用SpringBoot?

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.link

能快速创建出生产级别的Spring应用。

SpringBoot优点

• 创建独立Spring应用

• 内嵌web服务器

• 自动starter依赖，简化构建配置

• 自动配置Spring以及第三方功能

• 提供生产级别的监控、健康检查及外部化配置

• 无代码生成、无需编写XML

• SpringBoot是整合Spring技术栈的一站式框架

• SpringBoot是简化Spring技术栈的快速开发脚手架

SpringBoot的缺点

• 人称版本帝，迭代快，需要时刻关注变化
• 封装太深，内部原理复杂，不容易精通

---

2.入门小案例

1.创建maven工程

2.引入依赖

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

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

3.创建主程序

@SpringBootApplication //这是SpringBoot项目的启动类
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

4.编写业务

@RestController
public class helloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello world";
    }
}

5.设置配置

# 设置端口号
server:
  port: 8888

6.运行测试

在浏览器地址栏输入：localhost:8888/hello (opens new window)

7.打包部署

pom中添加打包插件

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

在命令行通过以下指令快速部署

java -jar [jar包名]

---

3.SpringBoot依赖管理特性

1.父项目做依赖管理

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

上面项目的父项目为
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.7.2</version>
</parent>
他几乎声明了所有开发中常用依赖的版本号，自动版本仲裁机制

2.自动仲裁机制

1）引入依赖可以不写版本

2）非仲裁版本的jar（同一个依赖的不同版本），要写版本号

比如：springboot2.7.2版本的mysql仲裁的版本为8.0.29，其他版本就是非仲裁版本，如果要使用其他版本，可以进行如下操作

<properties>
    <mysql.version>5.1.43</mysql.version>
</properties>

3.开发导入starter场景启动器

1）见到很多 spring-boot-starter-* ： *代表某种场景

2）只要有starter，我们需要的这个场景的依赖都自动引入

3）更多的场景Build Systems :: Spring Boot (opens new window)

4）见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。

---

4.SpringBoot自动配置特性

1.自动配好Tomcat

• 引入Tomcat依赖。
• 配置Tomcat

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.7.2</version>
      <scope>compile</scope>
    </dependency>

2.自动配好SpringMVC

• 引入SpringMVC全套组件
• 自动配好SpringMVC常用组件（功能）

3.自动配好Web常见功能，如：字符编码问题，dispatcher过滤器

• SpringBoot帮我们配置好了所有web开发的常见场景

4.默认包结构

• 启动器所在包及其下面的子包都会被自动扫描

• 无需以前的包扫描配置

若想改变扫描路径

//@SpringBootApplication //这是SpringBoot项目的启动类

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.demo.boot") //三个注解相当于上面的SpringBootApplication

5.各种配置都有默认值

• 默认配置最终都是映射到某个类上，如MultipartProperties

• 配置的值最终会绑定到某个类上，这个类会在容器中创建对象

6.按需加载所有自动配置项

• starter-*，引入了哪些场景这个场景的自动配置才会开启
• SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

7.自动配置流程

1）找到@SpringBootApplication 注解中的@EnableAutoConfiguration

2）加载自动配置类：AutoConfigurationImportSelector读取 Spring Boot中spring-boot-autoconfigure包的META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件

3）条件筛选：@Conditional 系列注解判断是否自动配置

4）注册 Bean 到容器

5）自定义配置覆盖默认值

组件 / 文件	作用
@EnableAutoConfiguration	开启自动配置的核心注解
AutoConfigurationImportSelector	加载自动配置类清单的核心类
META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports	自动配置类的清单文件（Spring Boot 2.7+ 替代旧的 spring.factories）
@Conditional 系列注解	条件筛选，控制自动配置类是否生效
spring-boot-autoconfigure 依赖	包含所有内置的自动配置类（如 WebMvcAutoConfiguration、DataSourceAutoConfiguration）

---

5.configuration注解

1.基本使用

• Full模式与Lite模式

示例

/* 1.配置类使用bean方法注册组件，默认是单实例
* 2.配置类本身也是组件
* 3.ProxyBeanMethods = true 默认是true，表示代理bean方法，
*   Full 模式，保证每次返回的组件都是单实例（默认）
*   Lite 模式，保证每次返回的组件都是新实例
* */
@Configuration(proxyBeanMethods = true)
public class myConfig {

    @Bean
    public User user01(){
        User zhangsan = new User("张三", 18);
        //user组件依赖了pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean
    public Pet tomcatPet() {
        return new Pet("tomcat");
    }
}

@Configuration测试代码如下:

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.demo.boot") //三个注解相当于上面的SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //获取所有组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for (String name : beanDefinitionNames) {
            System.out.println(name);
        }

        //获取组件
        Object tomcatPet = run.getBean("tomcatPet");
        Object tomcatPet1 = run.getBean("tomcatPet");
        System.out.println(tomcatPet == tomcatPet1);

        //从组件中获取一个User
        myConfig bean = run.getBean(myConfig.class);
        System.out.println(bean);

        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
        //保持组件单实例
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);

        User user01 = run.getBean("user01", User.class);
        Pet tomcatPet2 = run.getBean("tomcatPet", Pet.class);

        System.out.println(user01.getPet() == tomcatPet2);

    }
}

2.最佳实战

• 配置类组件无依赖关系，使用Lite模式，快速启动，减少判断

• 配置类组件有依赖关系，使用Full模式

---

6.底层注解

@Bean、@Component、@Controller、@Service、@Repository，它们是Spring的基本标签，在Spring Boot中并未改变它们原来的功能。

@Import({User.class,Pet.class})给容器中自动创建出两个类型的组件，名字默认为全类名

测试

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.demo.boot") //三个注解相当于上面的SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        String[] namesForType = run.getBeanNamesForType(User.class);
        for (String name : namesForType) {
            System.out.println(name);
        }

        String[] namesForType1 = run.getBeanNamesForType(Pet.class);
        for (String name : namesForType1) {
            System.out.println(name);
        }

    }
}

---

7.底层注解-@Conditional条件装配

条件装配：满足Conditional指定的条件，则进行组件注入

用@ConditionalOnMissingBean举例

@Import({User.class,Pet.class})
@Configuration(proxyBeanMethods = true)
public class myConfig {

    @Bean
    public User user01(){
        User zhangsan = new User("张三", 18);
        //user组件依赖了pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean
    @ConditionalOnBean(name = "user01")
    public Pet tomcatPet() {
        return new Pet("tomcat");
    }
}

测试

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.demo.boot") //三个注解相当于上面的SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        boolean b = run.containsBean("tomcatPet");
        System.out.println("容器中的tomcatPet组件"+ b);//true

        boolean b1 = run.containsBean("user01");
        System.out.println("容器中的user01组件"+ b1);//true

    }
}

---

8.底层注解-@ImportResource导入Spring配置文件

比如，公司使用bean.xml文件生成配置bean，然而你为了省事，想继续复用bean.xml，@ImportResource粉墨登场。

使用方法：

@ImportResource("classpath:beans.xml")
public class MyConfig {
...
}

---

9.@ConfigurationProperties配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用?

• 传统方法：

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

• Spring Boot一种配置配置绑定：@ConfigurationProperties + @Component

application.yml

mycar:
  name: BYDcar
  price: 10000

实体类中

@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
   ...
}

• Spring Boot另一种配置配置绑定：@EnableConfigurationProperties + @ConfigurationProperties 适用于外部第三方引入

@EnableConfigurationProperties(Car.class) //把这个Car这个组件自动注册到容器中
public class myConfig {
...   
}

@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

---