SpringBoot——SpringBoot入门SpringBoot的自动配置配置文件和开发小技巧

Posted AC_Jobim

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot——SpringBoot入门SpringBoot的自动配置配置文件和开发小技巧相关的知识，希望对你有一定的参考价值。

SpringBoot——SpringBoot入门、SpringBoot的自动配置、配置文件和开发小技巧

一、简介

Spring Boot基于Spring开发，Spimg Boot本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。Spring Boot以约定大于配置的核心思想，默认帮我们进行了很多设置，多数Spring Boot应用只需要很少的Spring配置。同时它集成了大量常用的第三方库配置(例如Redis.MongoDB、Jpa、RabbitMQ、Quat等等)，Sping Boot应用中这些第三方库几乎可以零配置的开箱即用。

SpringBoot官网：https://spring.io/projects/spring-boot

官方文档架构：

在这里插入图片描述
在这里插入图片描述

二、hello world

方式一：创建Maven项目

1 创建Maven项目
2 导入SpringBoot起步依赖 
3 创建主程序
4 定义Controller
5 启动测试
6 部署

  1. 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zb</groupId>
    <artifactId>springboot-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>


    <!--springboot工程需要继承的父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <dependencies>
        <!--web开发的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    
</project>

  2. 创建主程序

    /**
 * 主程序类
 * @SpringBootApplication:这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

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

  3. 定义Controller

    //@Controller
//@ResponseBody
@RestController//相当于@Controller和@ResponseBody
public class HelloController {

    @RequestMapping("/hello")
    public String handle01() {
        return "Hello,Spring Boot";
    }
}

  4. 测试
    执行引导类中的main方法
    在这里插入图片描述

  5. 部署
    需要在pom.xml文件中导入插件：

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

    把项目打成jar包，直接在目标服务器执行即可

三、SpringBoot的自动配置（重点）

3.1 SpringBoot特点

3.1.1 依赖管理

  1. 父项目做依赖管理

    依赖管理
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

他的父项目
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

    父项目中所声明的版本号（等等）
    在这里插入图片描述

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

    1、见到很多 spring-boot-starter-* ： *就某种场景
    2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
    3、SpringBoot所有支持的场景
    https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
    4、见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。

    所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

  3. 无需关注版本号，自动版本仲裁

    1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号。

  4. 修改默认依赖版本号

    1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
    2、在当前项目里面重写配置

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

3.1.2 自动配置

  1. 自动配好Tomcat（自动引入了Tomcat依赖）

    在spring-boot-starter-web下存在
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
  <version>2.5.2</version>
  <scope>compile</scope>
</dependency>

  2. 自动配好SpringMVC

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

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

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

    public static void main(String[] args) {
    //1、返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    //2、查看容器里面的组件
    String[] names = run.getBeanDefinitionNames();
    for (String name : names) {
        System.out.println(name);
    }
}

  4. 默认的包结构

    • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来（无需以前的包扫描配置）

    • 想要改变扫描路径，

      • @SpringBootApplication(scanBasePackages=**"com.atguigu"**)

      • 或者@ComponentScan指定扫描路径

      @SpringBootApplication
//等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")

  5. 各种配置拥有默认值

    • 默认配置最终都是映射到某个类上，如：MultipartProperties
    • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

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

    • 非常多的starter

    • 引入了哪些场景这个场景的自动配置才会开启

    • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

3.2 容器功能

3.2.1 组件添加

3.2.1.1 @Configuration、@Bean

@Configuration的作用：标注在类上，配置spring容器(应用上下文)。相当于把该类作为spring的xml配置文件中的<beans>。

@Configuration注解的类中，使用@Bean注解标注的方法，返回的类型都会直接注册为bean

Full模式与Lite模式：

  • 配置类组件之间无依赖关系，用Lite模式加速容器启动过程，减少判断
  • 配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式（默认）

@Configuration使用示例：

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
 */
@Configuration(proxyBeanMethods = true) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom") //指定tom为组件的id
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
    
}

@Configuration测试代码:

/**
 * 主程序类
 * @SpringBootApplication:这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
//        String[] names = run.getBeanDefinitionNames();
//        for (String name : names) {
//            System.out.println(name);
//        }

        //从容器中获取组件
        Pet tom1 = run.getBean("tom", Pet.class);
        Pet tom2 = run.getBean("tom", Pet.class);
        System.out.println(tom1 == tom2);//true


        MyConfig bean = run.getBean(MyConfig.class);
        //当proxyBeanMethods = true时，com.zb.boot.config.MyConfig$$EnhancerBySpringCGLIB$$de8f3ffa@5328a9c1
        //当proxyBeanMethods = false时，输出com.zb.boot.config.MyConfig@3e134896
        System.out.println(bean);

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

        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);
        System.out.println("用户的宠物："+(user01.getPet() == tom));//用户的宠物：true

    }

}

3.2.1.2 @Component、@Controller、@Service、@Repository

它们是Spring的基本标签，在Spring Boot中并未改变它们原来的功能。只要该注解标记的类写在包扫描的范围呢，就会在容器内注册bean。

3.2.1.3 @ComponentScan和@Import导入组件

@ComponentScan对应xml时代的<context:component-scan>，用来告诉Spring从哪里找到bean。定义哪些包需要被扫描。Spring将会将在被指定的包及其下级的包(sub packages)中bean加入到容器中。

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.zb.boot") //自动扫描com.zb.boot包下的组件
public class MainApplication {
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
	}
}

@Import引入普通的类可以帮助我们把普通的类定义为Bean。@Import可以添加在@SpringBootApplication(启动类)、@Configuration(配置类)、@Component(组件类)对应的类上。

/**
 * @Import({User.class, DBHelper.class})
 *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
 */
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

获取组件：

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        //返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //从容器中获取组件
        User user = (User) run.getBean("com.zb.boot.bean.User");
        DBHelper dbHelper = run.getBean(DBHelper.class);
        System.out.println(user);
        System.out.println(dbHelper);
    }
}

3.2.1.4 @Conditional

条件装配：Conditional指定按照一定的条件进行判断，满足条件给容器注册bean
在这里插入图片描述

标注在方法上：

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false)
public class MyConfig {

    @ConditionalOnBean(name = "tomcatPet") //当容器中有tomcatPet的实例时，@Bean才生效
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

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

}

/**
 * 主程序类
 * @SpringBootApplication:这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        //返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        boolean tomcatPet = run.containsBean("tomcatPet");
        System.out.println("容器中Tom组件："+tomcatPet);//容器中Tom组件：false

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);//容器中user01组件：false
    }
}

标注在类上： 一个类中可以注入很多实例，@Conditional标注在类上就决定了一批bean是否注入。

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = "tom")//没有tom名字的Bean时，MyConfig类的Bean才能生效。
public class MyConfig {

    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

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

public static void main(String[] args) {
    //返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    boolean tom = run.containsBean("tom");
    System.out.println("容器中Tom组件："+tom);//false

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

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

}

3.2.2 原生配置文件引入

3.2.2.1 @ImportResource

@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效。即实现xml配置的装载

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="haha" class="com.zb.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>

    <bean id="hehe" class="com.zb.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>

使用@ImportResource实现xml配置的装载

@Configuration(proxyBeanMethods = false)
@ImportResource("classpath:beans.xml")
public class MyConfig {
...
}

//测试代码：
@SpringBootApplication
public class MainApplication {

    SpringBoot 入门介绍


 springboot 入门


 SpringBoot入门——开箱即用


 小D课堂 - 零基础入门SpringBoot2.X到实战_汇总


 （百度云）2021版SpringBoot2零基础入门springboot全套完整版


 SpringBoot简介及入门