【SpringBoot 】组件管理 + 属性注入

旧城等待， 2023-02-20 07:45 32阅读 0赞

### 组件管理 + 属性注入 ###

*  组件管理
 *   *  @Component 管理单个组件
     *  @Configuration + @Bean 管理多个组件
 *  属性注入
 *   *  基本属性注入 @Value
     *  对象方式注入 @ConfigurationProperties
     *  两种注入方式比较
     *  注入细节
     *   *  配置文件注入值数据校验 @Validated
         *  加载指定的配置文件 @PropertySource
         *  导入 Spring 的配置文件 @ImportResource
         *  配置文件占位符

> [SpringBoot 核心知识点整理！][SpringBoot]

# 组件管理 #

## @Component 管理单个组件 ##

在 springboot 中可以管理自定义的 **简单组件** 对象的创建可以直接使用注解形式创建：

*  `@Component` 用来管理单个组件（包扫描形式）

1、使用 `@Repository`、`@Service`、`@Controller`、以及 `@Component` 管理不同简单对象；  
比如要通过工厂创建自定义 User 对象：`User.java`

@Component
    @Data
    public class User { 
        private String id;
        private String name;
        // ......
    }

2、通过工厂创建之后可以在使用处任意注入该对象；  
比如在控制器中使用自定义简单对象创建：

@Controller
    @RequestMapping("hello")
    public class HelloController { 
        @Autowired
        private User user;
      	// ......
    }

## @Configuration + @Bean 管理多个组件 ##

在 springboot 中如果要管理 `复杂对象` 必须使用 `@Configuration` \+ `@Bean` 注解进行管理；

*  `@Configuration` 主要用来生产多个组件交给工厂管理 (注册形式）

1、管理复杂对象的创建  
注意：这里的 `User` 不需要加 `@Component` 注解，与上面的管理单个对象区分开来。

@ToString
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class User { 
        private String id;
        private String name;
    }

@Configuration // @Component 也可以, 不推荐
    public class BeanConfigs { 
    
        @Bean   // @Bean 将当前返回值作为工厂中的一个对象进行管理
        public User getUser() { 
            return new User();
        }
    
        @Bean //(name = "aaa") // 用来将该方法的返回值交给springboot管理 在工厂中默认标识: 类名(首字母小写)
        @Scope("prototype") // prototype表示多例; 默认是singleton, 单例的
        public Calendar getCalendar() { 
            return Calendar.getInstance();
        }
    
    }

2、使用复杂对象

@RestController
    @RequestMapping("/hello")
    public class HelloController { 
        @Autowired
        private User user;
        
        @Autowired
        private Calendar calendar1;
    
        @Autowired
        private Calendar calendar2;
    
        @GetMapping("/hello")
        public String hello() { 
            System.out.println(user); // 管理单个对象
            // 管理多个对象, 默认是单例的, 需要设置 prototype
            System.out.println(calendar1.getTime()); // 成功创建出对象
            System.out.println(calendar1 == calendar2); // 默认是单例的, 需要设置 prototype 才为多例
            return "hello spring boot!!!";
        }

# 属性注入 #

SpringBoot 使用一个全局的配置文件，配置文件名是固定的：

*  application.properties
 *  application.yml

配置文件的作用：修改 SpringBoot 自动配置的默认值；SpringBoot 在底层都给我们自动配置好了；

springboot 中提供了两种注入方式：**基本属性注入**、**对象注入**

## 基本属性注入 @Value ##

基本属性包括：`int`、`String`、`Date`、`String[]`、`List`、`Map` 等。

**基本属性注入**：使用注解 `@Value("${xxx}")`

@RestController
    @RequestMapping("hello")
    public class HelloController { 
    	
        @Value("${server.port}") 
        private int port;
    
        @Value("${str}") 
        private String str;
        
        @Value("${bir}")
        private Date bir;
    
        @Value("${strs}")
        private String[] strs;
    
        @Value("${list}")
        private List<String> list;
    
        @Value("#{${maps}}") // map注入取值有点特殊
        private Map<String, String> maps;
        
         @GetMapping("hello")
        public String hello() { 
        
        	// port = 8989
            System.out.println("port = " + port);
            // str = zhenyu
            System.out.println("str= " + str);
            // time = Wed Dec 12 12:12:12 CST 2012
            System.out.println("time = " + bir);
            // aa
    		// bb
    		// cc
            for (String str : strs) { 
                System.out.println(str);
            }
            // zhangsan
    		// lisi
    		// wangwu
            list.forEach( v -> System.out.println(v));
            // k = aa, v = xiaoyi
    		// k = bb, v = xiaoer
    		// k = cc, v = xiaosan
            maps.forEach((k, v) -> { 
                System.out.println("k = " + k + ", v = " + v);
            });
            
            return "hello spring boot!";
            
        }
    }

`application.properties` 中配置：

server.port = 8989
    
    # 属性注入
    str = zhenyu
    bir = 2012/12/12 12:12:12
    
    strs = aa, bb, cc
    list = zhangsan, lisi, wangwu
    maps = { 'aa':'xiaoyi', 'bb':'xiaoer', 'cc':'xiaosan'}

## 对象方式注入 @ConfigurationProperties ##

对象方式注入使用注解：`@ConfigurationProperties(prefix="前缀")`

`@ConfigurationProperties` 告诉 SpringBoot 本类中的所有属性在配置文件中进行绑定；

*  只有这个组件是容器中的组件，才能容器提供的 `@ConfigurationProperties` 功能，所以需要 `@Component`

@ToString
    @Data // 必要
    @Component // @Configuration 也可以
    @ConfigurationProperties(prefix = "user") // 必要
    public class User { 
        private String id;
        private String name;
        private Integer age;
        private Date bir;
    }

控制器中使用：`@Autowired` 完成自动注入；

@RestController
    @RequestMapping("hello")
    public class HelloController { 
    
        @Autowired
        private User user;
    
        @GetMapping("hello")
        public String hello() { 
            System.out.println(user); 
            // User(id=1721, name=yusael, age=20, bir=Wed Dec 12 12:12:12 CST 2012)
            return "hello spring boot!";
        }
    }

`application.properties` 中配置：

# 自定义对象属性注入
    user.id = 1721
    user.name = zhenyu
    user.age = 20
    user.bir = 2012/12/12 12:12:12

--------------------

注：可以通过引入依赖 —— **配置文件处理器**，构建自定义注入元数据。

*  意思就是引入这个依赖后，在 配置文件中写注入对象会有提示，不引入也不影响什么。

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-configuration-processor</artifactId>
      <optional>true</optional>
    </dependency>

## 两种注入方式比较 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>@ConfigurationProperties</th> 
   <th>@Value</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>功能</td> 
   <td>批量注入配置文件中的属性</td> 
   <td>一个个指定</td> 
  </tr> 
  <tr> 
   <td>松散绑定（松散语法）</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>SpEL</td> 
   <td>不支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>JSR303 数据校验</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>复杂类型封装</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
 </tbody> 
</table>

如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用 `@Value`；

如果说，我们专门编写了一个 javaBean 来和配置文件进行映射，我们就直接使用`@ConfigurationProperties`；

## 注入细节 ##

### 配置文件注入值数据校验 @Validated ###

@Component
    @ConfigurationProperties(prefix = "person")
    @Validated // 配置文件注入值数据校验
    public class Person { 
    
        /** * <bean class="Person"> * <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property> * <bean/> */
    
       //lastName必须是邮箱格式
        @Email
        //@Value("${person.last-name}")
        private String lastName;
        //@Value("#{11*2}")
        private Integer age;
        //@Value("true")
        private Boolean boss;
    
        private Date birth;
        private Map<String,Object> maps;
        private List<Object> lists;
        private Dog dog;

### 加载指定的配置文件 @PropertySource ###

`@PropertySource` 加载指定的配置文件；

// 加载指定的配置文件
    @PropertySource(value = { "classpath:person.properties"})
    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person { 
    	private String lastName;
    	private Integer age;
    	private Boolean boss;
    }

### 导入 Spring 的配置文件 @ImportResource ###

`@ImportResource`：导入 Spring 的配置文件，让配置文件里面的内容生效；

*  Spring Boot 里面没有 Spring 的配置文件，我们自己编写的配置文件，也不能自动识别；  
    想让 Spring 的配置文件生效，加载进来；`@ImportResource` 标注在一个配置类上；

// 导入Spring的配置文件让其生效
    @ImportResource(locations = { "classpath:beans.xml"})

然后编写 Spring 的配置文件：

<?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="helloService" class="com.atguigu.springboot.service.HelloService"></bean>
    </beans>

### 配置文件占位符 ###

随机数：

${ random.uuid}
    ${ random.value}
    ${ random.int}
    ${ random.long}
    ${ random.int(10)}
    ${ random.int[1024,65536]}

`:` 指定占位符中的默认值：

person.last-name=张三${ random.uuid} # 随机数
    person.age=${ random.int} # 随机数
    person.birth=2017/12/15
    person.boss=false
    person.maps.k1=v1
    person.maps.k2=14
    person.lists=a,b,c
    person.dog.name=${ person.hello:hello}_dog # 指定默认值
    person.dog.age=15

[SpringBoot]: https://blog.csdn.net/weixin_43734095/article/details/106864711