spring boot traceid 依赖 spring boot依赖管理

文章目录

• 一、依赖管理
• 二、自动配置

• 1.自动配置好tomcat
• 2.自动配置好SpringMVC
• 3.默认的包结构
• 4.各种配置拥有默认值
• 5.按需加载所有自动配置项

• 三、容器功能

• 1.@Configuration,@Import,@Conditional,@ImportResource
• 2.@ConfigurationProperties

• 2.1 使用@ConfigurationProperties和@Component注解到bean定义类上
• 2.2 在配置类上写@EnableConfigurationProperties,适用于无法标注@Component的类

---

一、依赖管理

• 父项目做依赖管理

在这依赖管理    
<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>

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

• 开发导入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： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

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

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

• 可以修改默认版本号

1、查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
    2、在当前项目里面重写配置
    <!--项目依赖版本管理-->
    <properties>
        <sdev.version>1.0.0</sdev.version>
        <!-- main version setting -->
        <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
        <java.version>1.8</java.version>
        <jsp-api.version>2.2</jsp-api.version>
        <druid.version>1.0.18</druid.version>
        <!-- tools version setting -->
        <slf4j.version>1.7.23</slf4j.version>
        <commons-lang3.version>3.5</commons-lang3.version>
        <fastjson.version>1.2.54</fastjson.version>
    </properties>

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、自动配置

1.自动配置好tomcat

• 引入tomcat依赖
• 配置tomcat

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
     <scope>provided</scope>
 </dependency>

2.自动配置好SpringMVC

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

我们打印出容器中的组件：

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

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

可以看到dispatcherServlet和解决中文乱码的组件characterEncodingFilter已经被添加到容器中

3.默认的包结构

• 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
• 无需以前的包扫描配置
• 想要改变包扫描路径，可以用@SpringBootApplication(scanBasePackages = “com.sdev”)或者@ComponentScan 指定扫描路径

@SpringBootApplication(scanBasePackages = "com.sdev")
// 等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(basePackages={"com.sdev"})

4.各种配置拥有默认值

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

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

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

三、容器功能

1.@Configuration,@Import,@Conditional,@ImportResource

package com.sdev.demo.config;

import com.sdev.demo.bean.Pet;
import com.sdev.demo.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import java.util.logging.Logger;


/**
 * 1.配置类里面使用@bean标注在方法上给容器注册组件，默认单例
 * 2.配置类本身也是组件
 * 3.proxyBeanMethods:代理bean的方法
 *      全配置Full(proxyBeanMethods = true)
 *      轻量级配置Lite(proxyBeanMethods = false)，配置类在容器中不会保存代理对象
 *      解决组件依赖场景的问题(不依赖调成false,不检查，启动快)
 * 4.@Import({User.class, Logger.class})在容器中自动创建出这个两个类型的组件,默认组件的名字是全类名
 * 5.@ImportResource("classpath:beans.xml")导入Spring的配置文件
 */
//@Import({User.class, Logger.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 ==  配置文件
public class MyConfig {
    /**
     * 外部无论对配置类中的这个组件注册方法调用多少次，获取的都是之前注册到容器中的单实例对象
     * @return
     */
    @Bean  // 给容器中添加组件。以方法名作为组件id,返回类型就是组件类型，返回的值就是组件在容器中的实例
    public User user01(){
        User user = new User("zhangsan",1);
        // proxyBeanMethods = true，User组件依赖了Pet组件
        user.setPet(dog());
        return user;
    }

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

}

package com.sdev;

import com.sdev.demo.bean.Pet;
import com.sdev.demo.bean.User;
import com.sdev.demo.config.MyConfig;
import com.sun.rowset.internal.Row;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Logger;
import java.util.stream.IntStream;


// @SpringBootApplication(scanBasePackages = "com.sdev")
@EnableCaching
@EnableAsync
@EnableConfigurationProperties({Pet.class})
//1、开启Pet配置绑定功能
//2、把这个Pet这个组件自动注册到容器中
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(basePackages={"com.sdev"})
public class SBootApplication extends SpringBootServletInitializer {

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

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

        // 3.从容器中获取组件
        Pet dog1 = run.getBean("dog",Pet.class);
        Pet dog2 = run.getBean("dog",Pet.class);
        System.out.println(dog1);
        System.out.println("单例：" + (dog1 == dog2));

        // 4.获取代理对象com.sdev.demo.config.MyConfig$$EnhancerBySpringCGLIB$$a682f5c0@57540fd0
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println("配置类本身也是组件" + bean);

        // 如果@Configuration(proxyBeanMethods = true)，代理对象调用方法，SpringBoot总会检查这个对象是否在容器中
        // 保持组件单实例
        User user1 = bean.user01();
        User user2 = bean.user01();
        System.out.println("多次调用组件注册方法，从容器中拿:"+ (user1==user2));

        User user01 = run.getBean("user01",User.class);
        Pet dog = run.getBean("dog",Pet.class);
        System.out.println("用户的宠物是否是容器中的宠物：" + (user01.getPet() == dog));

        //5.获取组件
        String[] beanNameForType = run.getBeanNamesForType(User.class);
        System.out.println("===================");
        for (String s : beanNameForType) {
            System.out.println(s);
        }
    }
 }

proxyBeanMethods = false执行结果如下：

===================
Pet{name=heihuang}
单例：true
配置类本身也是组件com.sdev.demo.config.MyConfig@5e8604bf
多次调用组件注册方法，从容器中拿:false
用户的宠物是否是容器中的宠物：false
===================
user01

proxyBeanMethods = true执行结果如下：

===================
Pet{name=heihuang}
单例：true
配置类本身也是组件com.sdev.demo.config.MyConfig$$EnhancerBySpringCGLIB$$d95b39ce@37c2eacb
多次调用组件注册方法，从容器中拿:true
用户的宠物是否是容器中的宠物：true
===================
user01

2.@ConfigurationProperties

2.1 使用@ConfigurationProperties和@Component注解到bean定义类上

package com.sdev.demo.bean;

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

@Data
@Component
@ConfigurationProperties("my.pet")
public class Pet {

    private String name;

    public Pet() {
    }

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

    @Override
    public String toString(){
        return "Pet{" + "name=" + name + "}";
    }

}

2.2 在配置类上写@EnableConfigurationProperties,适用于无法标注@Component的类

package com.sdev.demo.bean;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties("my.user")
public class User {

    private String name;

    private Integer age;

    private Pet pet;

    public User(){};

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", pet=" + pet +
                '}';
    }
}

package com.sdev.demo.config;

import com.sdev.demo.bean.Pet;
import com.sdev.demo.bean.User;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

import java.util.logging.Logger;


/**
 * 1.配置类里面使用@bean标注在方法上给容器注册组件，默认单例
 * 2.配置类本身也是组件
 * 3.proxyBeanMethods:代理bean的方法
 *      全配置Full(proxyBeanMethods = true)
 *      轻量级配置Lite(proxyBeanMethods = false)，配置类在容器中不会保存代理对象
 *      解决组件依赖场景的问题(不依赖调成false,不检查，启动快)
 * 4.@Import({User.class, Logger.class})在容器中自动创建出这个两个类型的组件,默认组件的名字是全类名
 * 5.@ImportResource("classpath:beans.xml")导入Spring的配置文件
 */
//@Import({User.class, Logger.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 ==  配置文件
@EnableConfigurationProperties({User.class}) //1.开启User配置绑定功能  2.把User这个组件自动注册到容器中
public class MyConfig {
    /**
     * 外部无论对配置类中的这个组件注册方法调用多少次，获取的都是之前注册到容器中的单实例对象
     * @return
     */
    @Bean  // 给容器中添加组件。以方法名作为组件id,返回类型就是组件类型，返回的值就是组件在容器中的实例
    public User user01(){
        User user = new User("zhangsan",1);
        // proxyBeanMethods = true，User组件依赖了Pet组件
        user.setPet(dog());
        return user;
    }

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

}

---