1.SpringBoot特点

1.1 依赖管理

• 父项目做依赖管理
  
  
  几乎包含所有开发需要的依赖。

• 无需关注版本号，自动版本仲裁
  1、引入依赖默认都可以不写版本
  2、引入非版本仲裁的jar，要写版本号。

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

• 可以修改默认版本号

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

• 开发导入starter场景启动器
  （1）
  spring-boot-starter-* ： *就某种场景
  只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
  (2)
  见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
  

我们可以看到我们只是引入spring-boot-starter-web，但是实际上是引入了不止一个的依赖

1.2 自动配置

自动配置	详解
自动配好Tomcat	（1）引入Tomcat依赖。（2）配置Tomcat
自动配好SpringMVC	（1）引入SpringMVC全套组件（2） 自动配好SpringMVC常用组件（功能）
自动配好Web常见功能，如：字符编码问题	SpringBoot帮我们配置好了所有web开发的常见场景
默认的包结构	（1）主程序所在包及其下面的所有子包里面的组件都会被默认扫描进（2）无需以前的包扫描配置（3）想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.xxxx”)或者@ComponentScan 指定扫描路径【注：@SpringBootApplication等同于@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(“com.xxxx.boot”)】
各种配置拥有默认值	(1)默认配置最终都是映射到某个类上，如：MultipartProperties(2)配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
按需加载所有自动配置项	(1)非常多的starter(2)引入了哪些场景这个场景的自动配置才会开启(3)SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

2.容器功能

2.1 组件添加

2.1.1@Configuration

两个Bean
【Pet.java】

package com.sdnu.boot.bean;

public class Pet {
    private String name;

    public Pet() {
    }

    public Pet(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

【User.java】

package com.sdnu.boot.bean;

public class User {
    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

原来注册方式：
【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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user1" class="com.sdnu.boot.bean.User">
        <property name="name" value="xiaoming"/>
        <property name="age" value="20"/>
    </bean>
    <bean id="dog" class="com.sdnu.boot.bean.Pet">
        <property name="name" value="zhangao"/>
    </bean>
</beans>

我们使用springboot后就不需要写xml文件了，我们只需要定义一个类用@Configuration标注。

【MyConfig.java】

package com.sdnu.boot.config;

import com.sdnu.boot.bean.Pet;
import com.sdnu.boot.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@Bean标注在类上给容器注册组件， 配置类本身也是组件
//告诉springboot这是一个配置类
@Configuration(proxyBeanMethods = true)
public class MyConfig {
    //返回类型是组件类型
    //方法名是组件id
    //返回的值，就是组件在容器中的实例
    @Bean
    public User User1(){
        return new User("xiaoming", 20);
    }
    //组件id为指定的tom
    @Bean("tom")
    public Pet myPet(){
        return new Pet("zhangao");
    }
}

【测试】

package com.sdnu.boot;

import com.sdnu.boot.bean.Pet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * [@SpringBootApplication 表示这是一个启动类
 */
@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);
        }
        Pet tom1 = run.getBean("tom", Pet.class);
        Pet tom2 = run.getBean("tom", Pet.class);
        System.out.println("组件1：" + tom1);
        System.out.println("组件2：" + tom2);
    }
}

我们通过结果还可以看出配置类里面使用@Bean标注在方法上给容器注册组件，默认是单实例的.

• 注释proxyBeanMethods是为了让使用@Bean注解的方法被代理而实现bean的生命周期的行为。
• Full模式
  设置为true，那么直接调用方法获取bean，不会创建新的bean，而是会走bean的生命周期的行为。（保证每个@Bean方法被调用多少次返回的组件都是单实例的）
• Lite模式
  设置为false, 那么直接调用方法获取bean，会创建新的bean，且不会走bean的生命周期的行为。（每个@Bean方法被调用多少次返回的组件都是新创建的）
• 组件依赖必须使用Full模式默认。其他默认是否Lite模式

2.1.2 @Bean、@Component、@Controller、@Service、@Repository

@Component , @Repository , @ Controller , @Service 这些注解只局限于自己编写的类，而@Bean注解能把第三方库中的类实例加入IOC容器中并交给spring管理。

2.1.3 @ComponentScan、@Import

给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名

@Import({User.class, DBHelper.class})
public class MyConfig {
}

2.1.4 @Conditional

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

2.2 原生配置引入@ImportResource

可以导入之前我们spring使用的xml方式注册的组件。

2.3 配置绑定

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

2.3.1 @Component + @ConfigurationProperties

【car.java】

package com.sdnu.boot.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 只有在spring容器中的组件才会有这个功能，所有要使用@Component去注册组件
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;

    public Car() {
    }

    public Car(String brand, Integer price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

2.3.2 @EnableConfigurationProperties + @ConfigurationProperties

@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
public class MyConfig {
}