简介： SpringBoot--常见注解

2.1 SpringBoot特点


2.1.1 依赖管理


父项目是用来解决依赖管理的

标签是maven中的继承，是用来做依赖管理的

spring-boot-dependencies是spring-boot-starter-parent的父项目。它几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

spring-boot-starter-* ： *就某种场景

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


<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>

修改默认版本号

在pom里直接写    这个标签，写你想要的版本即可


1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
2、在当前项目里面重写配置
    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>


2.1.2 自动配置


  • 自动配好SpringMVC
  • 引入SpringMVC全套组件
  • 自动配好SpringMVC常用组件（功能）
  • 自动配好Web常见功能，如：字符编码问题
  • SpringBoot帮我们配置好了所有web开发的常见场景
  • 默认的包结构
  • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
  • 无需以前的包扫描配置
  • 想要改变扫描路径，@SpringBootApplication(scanBasePackages="com.example")


@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.caq.boot")
  • @EnableAutoConfiguration帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。
  • 各种配置拥有默认值
  • 默认配置最终都是映射到某个类上，如：MultipartProperties
  • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
  • 按需加载所有自动配置项
  • 非常多的starter
  • 引入了哪些场景这个场景的自动配置才会开启
  • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

那么它是如何自动配置的呢？

我们需要先了解下SpringBoot底层的相关注解


2.2 常见注解


2.2.1 @Bean


==@Bean给容器中添加组件。==以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例

组件的概念在上面提到了就是符合某种规范的类，可以理解为给容器中添加对象

复制代码

/**
User类和Pet要提前写好
*/
@Bean
public User user01(){
    return new User("zs",12);
}
////这个我们自定义一个名字，不用方法名作为实例的名字了
@Bean("tiger")
public Pet animal01(){
    return new Pet("li");
}

如下，SpringApplication.run（）返回值是把IOC容器返回给我们了


ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

我们用返回的IOC容器进行测试看看通过@Bean添加的组件有没有添加成功


@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
//        1.返回值是IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        boolean tiger1 = run.containsBean("tiger");
        System.out.println(tiger1);
        boolean user01 = run.containsBean("user01");
        System.out.println(user01);
    }
}


2.2.2 @Configuration


组件(component):

组件也是抽象的概念,可以理解为一些符合某种规范的类组合在一起就构成了组件。他可以提供某些特定的功能。J2EE来说，有什么servlet，jsp, javabean，ejb都是组件。但实际他们都是类，只不过有他们特殊的规定。组件和类的关系:符合某种规范的类的组合构成组件

@Configuration作用是==告诉SpringBoot这是一个配置类 == 配置文件==

之前的Spring学习中，我们通过XML配置文件进行管理bean

通过@Configuration注解可以不用写XML配置文件，将它写在类上面可以把这个类当成配置类来用。对象的管理在这个配置类中进行


@Configuration
public class Myconfig {
}

@Configuration(proxyBeanMethods = true)，默认值是true的。那么它有什么用呢？

Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】

Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】

组件依赖必须使用Full模式默认。其他默认是否Lite模式

我们打印Myconfig对象可以看到是EnhancerBySpringCGLIB，这个就代表它是一个被SpringCGLIB增强了的代理对象

com.caq.boot.config.MyconfigEnhancerBySpringCGLIBEnhancerBySpringCGLIBEnhancerBySpringCGLIBdfb5b12f@55f45b92

==如果代理对象调用配置类中注册组件使用的方法返回值一定是单实例==


********配置类********
@Configuration(proxyBeanMethods = true)
public class Myconfig {
    @Bean
    public User user01(){
        return new User("zs",12);
    }
    @Bean("tiger")  //这个我们自定义一个名字，不用方法名作为实例的名字了
    public Pet animal01(){
        return new Pet("li");
    }
}
   
********主程序类********
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
    //1.返回值是IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
    
    Myconfig myconfig = run.getBean(Myconfig.class);
    System.out.println("对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象");
    User user02 = myconfig.user01();
    User user03 = myconfig.user01();
    System.out.println(user02==user03);
    }
}
********测试结果*******
...
com.caq.boot.config.Myconfig$$EnhancerBySpringCGLIB$$3ea98f23@1d81e101
对配置类中的这个组件注册方法调用看获取到的对象是不是同一对象
true


2.2.3 @Import


==和@Bean功能类似，都是注册组件的==

@Import({User.class, DBHelper.class})作用是给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名


@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String s : beanNamesForType) {
            System.out.println(s);
        }
    }
}
*************打印结果************
com.caq.boot.bean.User
user01


2.2.4 @Conditional


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

@ConditionalOnBean(name = "tiger")如果容器中有tiger这个组件才会执行下面的配置

@ConditionalOnMissingBean(name = "tiger")如果容器中没有tiger这个组件才会执行下面的配置


@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
@ConditionalOnBean(name = "tiger")
//@ConditionalOnMissingBean(name = "tiger")
public class Myconfig {
    @Bean
    public User user01(){
        return new User("zs",12);
    }
//    @Bean("tiger")
    public Pet animal01(){
        return new Pet("li");
    }
}


2.2.5 @ImportResource


可以引入xml配置文件中的bean


======================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="zs" class="com.caq.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>
    <bean id="dog" class="com.caq.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>
@ImportResource("classpath:beans.xml")
public class MyConfig {}


2.2.6 @ConfigurationProperties


==将我们的类和配置文件进行绑定== @ConfigurationProperties(prefix = "mycar")和配置文件绑定，prefix是和配置文件中的前缀对应

配置绑定可以理解为字面意思，将要配置给对象的属性写在配置文件中。通过@ConfigurationProperties注解来实现赋值


**************************car的实体类*******************
//只有在容器中的组件才有SpringBoot提供的功能
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private String price;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getPrice() {
        return price;
    }
    public void setPrice(String price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}
**********************web层代码***************************
@RestController
//@RestController是@ResponseBody的结合@Controller
public class Controller {
    @RequestMapping("/hello")
    public String handle01() {
        return "Hello SpringBoot 2 !" + "你好";
    }
    @Autowired
    Car car;
    @RequestMapping("/car")
    public Car car() {
        return car;
    }
}

运行springboot程序，访问可以发现成功把配置文件中的值注入到对象里了，绑定成功了

第二种配置文件绑定的方式

@Component+@ConfigurationProperties这种方式需要手动的把要绑定的类注册到容器中，如果是外部的类的话很不方便

@EnableConfigurationProperties(Car.class)+@ConfigurationProperties

其中@EnableConfigurationProperties(Car.class)能实现

1.开启car配置绑定功能

2.把这个car组件自动注册到容器中


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