首页 > 其他分享> > day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告，@Resource注解 )

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告，@Resource注解 )

2022-05-25 14:04:54 作者：互联网

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告，@Resource注解 )

1.关于框架

1.概念：

框架（Framework）一个框架是一个可复用的设计构件，它规定了应用的体系结构，阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程，表现为一组抽象类以及其实例之间协作的方法，它为构件复用提供了上下文(Context)关系。
应用框架指的是实现了某应用领域通用完备功能（除去特殊应用的部分）的底层服务。使用这种框架的编程人员可以在一个通用功能已经实现的基础上开始具体的系统开发。框架提供了所有应用期望的默认行为的类集合。具体的应用通过重写子类（该子类属于框架的默认行为）或组装对象来支持应用专用的行为。
你可以将框架理解为现实生活中的“毛胚房”，它已经完成了住房最基础部分的设计，例如打地基、设计住房的基本格局、预留电路、水路的线路接入等……当你使用一个框架时，就相当于得到了一间毛胚房，如果你想住进去，你需要做的事情主要是“装修”，把这个毛胚房加工成你希望的样子。

2.关于Spring框架

1.作用

Spring框架主要解决了创建对象、管理对象的问题。
在开发实践中，Spring框架的核心价值在于：开发者可以通过Spring框架提供的机制，将创建对象、管理对象的任务交给Spring来完成，以至于开发者不必再关心这些过程，当需要某个对象时，只需要通过Spring获取对象即可。
- Spring框架也经常被称之为：Spring容器， Spring框架还很好的支持了AOP

2.创建对象

其实，创建对象并不是一个复杂的任务，假设项目中存在类：

public class UserMapper {
public void insert() {
// 向数据表中的“用户表”中插入数据
}
}

创建对象的语法是极为简单的，例如：
```
UserMapper userMapper = new UserMapper();
```
但是，在开发实践中，类与类之间是存在依赖关系的，例如： UserController依赖UserMapper
```
public class UserController {
public UserMapper userMapper;
public void reg() {
userMapper.insert();
}
}
```
- 以上userMapper属性如果不赋值，则程序将无法正确运行;
- 在整个项目运行过程中，UserMapper对象只需要1个且始终存在即可；
- 如果自行创建对象，当多个类都依赖UserMapper时，各自创建UserMapper对象，违背了以上“只需要1个”的思想。
在开发实践中，有许多类型的对象、配置值都需要常驻内存、需要有唯一性，或都需要多处使用，自行维护这些对象或值是非常繁琐的，通过Spring框架可以极大的简化这些操作。

3. 在Maven工程中使用Spring

当某个项目需要使用Spring框架时，推荐使用Maven工程。

使用Spring框架所需的依赖项是 spring-context，依赖代码为：代码中版本号可按需调整

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.14</version>
</dependency>

3.通过Spring管理对象

1.创建对象的方式

如果需要Spring管理对象，就必须先创建对象，然后Spring获取到对象才可以进行管理
被Spring管理的对象，通常也称之为Spring Bean
创建对象的方式有2种：
- 通过@Bean方法
- 通过组件扫描

2.通过@Bean方法

编码步骤：
- 创建cn.tedu.spring.SpringBeanFactory类
- 在类中添加方法，方法的返回值类型就是你希望Spring创建并管理的对象的类型，并在此方法中自行编写返回有效对象的代码 – 在此类上添加@Configuration注解
- 在此方法上添加@Bean注解
- 示例代码：
```
package cn.tedu.spring;
@Configuration
public class SpringBeanFactory {
@Bean
public Random random() {
return new Random();
}
}
```
- 测试运行的编码步骤：
  - 创建任意类，在类中添加main()方法，将通过此方法测试运行，以观察运行效果–
    - 如果你已经掌握JUnit的用法，且添加了JUnit依赖，也可以使用JUnit测试
  - 创建AnnotationConfigApplicationContext类型的对象，并使用添加了@Configuration注解的类作为构造方法参数
    - 这是ApplicationContext接口的实现，通常称之为Spring的应用程序上下文
  - 调用AnnotationConfigApplicationContext对象的getBean()方法，以获取@Bean注解方法返回的对象
  - 自行测试获取的对象
  - 调用AnnotationConfigApplicationContext对象的close()方法，以关闭
- 测试运行：
```
public class SpringRunner {
public static void main(String[] args) {
// 1. 加载Spring
AnnotationConfigApplicationContext ac
= new AnnotationConfigApplicationContext(SpringBeanFactory.class);
// 2. 从Spring中获取对象
Random random = (Random) ac.getBean("random");
// 3. 测试使用对象，以便于观察是否获取到了有效的对象
System.out.println("random > " + random);
// 4. 关闭
ac.close();
}
}
```
- 关于以上代码，你需要知道
- 在AnnotationConfigApplicationContext的构造方法中，应该将SpringBeanFactory.class作为参数传入，否则就不会加载SpringBeanFactory类中内容
  - 实际上，在以上案例中，SpringBeanFactory类上的@Configuration注解并不是必须的，但@Bean方法的使用规范是将其声明在@Configuration类中
- 在getBean()时，传入的字符串参数"random"是SpringBeanFactory类中的@Bean方法的名称
- 在SpringBeanFactory类中的方法必须添加@Bean注解，其作用是使得Spring框架自动调用此方法，并管理此方法返回的结果
- 关于getBean()方法，此方法被重载了多次，典型的有：
  - Object getBean(String beanName)
    - 通过此方法，传入的beanName必须是有效的，否则将导致NoSuchBeanDefinitionException –
- T getBean(Class beanClass);
  - 使用此方法时，传入的类型在Spring中必须有且仅有1个对象，如果Spring容器中没有匹配类型的对象，将导致NoSuchBeanDefinitionException，如果有2个或更多，将导致NoUniqueBeanDefinitionException
- T getBean(String beanName, Class beanClass)
  - 此方法仍是根据传入的beanName获取对象，并且根据传入的beanClass进行类型转换
- 使用的@Bean注解可以传入String类型的参数，如果传入，则此注解对应的方法的返回结果的beanName就是@Bean注解中传入的String参数值，后续调用getBean()方法时，如果需要传入beanName，就应该传入在@Bean注解中配置的String参数值
示例：配置@Bean注解参数以指定beanName :获取对象时，需使用random作为beanName，而不是 xxx 作为beanName
```
package cn.tedu.spring;
@Configuration
public class SpringBeanFactory {
@Bean("random")
public Random xxx() {
return new Random();
}
}
```

3.通过组件扫描创建对象

编码步骤：
- 自行创建某个类，例如创建cn.tedu.spring.UserMapper类，并在类的声明之前添加@Component注解
  - 示例代码：
```
package cn.tedu.spring;
@Component
public class UserMapper {
}
```
- 自行创建某个类，例如创建cn.tedu.spring.SpringConfig类，并在类的声明之前添加2个注解：
  - @Configuration
  - @ComponentScan，且在注解参数指定包名为cn.tedu.spring
  - 示例代码：
```
package cn.tedu.spring;
@Configuration
@ComponentScan("cn.tedu.spring")
public class SpringConfig {
}
```
测试运行的编码步骤：
- 与前序编写测试运行代码的方式相同
  - 调用getBean()获取对象时，传入的beanName是：将UserMapper的类名首字母改为小写，即userMappe

测试运行：

public class SpringRunner {
public static void main(String[] args) {
// 1. 加载Spring
AnnotationConfigApplicationContext ac
= new AnnotationConfigApplicationContext(SpringConfig.class);
// 2. 从Spring中获取对象
UserMapper userMapper = ac.getBean("userMapper", UserMapper.class);
// 3. 测试使用对象，以便于观察是否获取到了有效的对象
System.out.println("userMapper > " + userMapper);
// 4. 关闭
ac.close();
}
}

关于以上代码，你需要知道
- 使用@ComponentScan配置的是执行组件扫描的根包，当创建AnnotationConfigApplicationContext对象时，由于传的SpringConfig添加了此注解，则Spring框架会扫描所配置的包，如果包中有组件类，Spring框架就会创建组件类的对象并管理
- UserMapper类必须在@ComponentScan注解配置的包中，否则Spring框架不会知道此类的存在
- 在UserMapper上的@Component表示此类是个“组件”，如果无此注解，Spring框架不会创建此类的对象
- 在@ComponentScan中配置的包是执行组件扫描的“根包（basePackage）”，在执行时，会扫描此包及其下所有子孙包，例如配置为cn.tedu时，如果存在cn.tedu.spring、cn.tedu.mybatis、cn.tedu.boot、cn.tedu.boot.mapper、cn.tedu.boot.controller等包，则这些包都会被扫描
  - 你甚至可以把根包配置为cn，也可以完全扫描到以上列举的包，但并不推荐这么做，毕竟你的开发环境中的其它库中的类也是项目的一部分，例如依赖的第三方框架或工具等，如果这些框架或工具的包名的第1级也是cn，也会被扫描到，尽管不确实是否会导致意外的问题，但这种做法肯定是不对的
- 当getBean()时，由Spring创建的组件类的对象，默认的beanName都是将首字母改为小写
  - 以上规则仅适用于：类名中的第1个字母是大写，且第2个字母是小写的情况，如果类名不符合这种情况，则getBean()时传入的名称就是类名（与类名完全相同的字符串）
- 你可以配置@Component注解的参数以指定beanName
  - 示例：配置@Component注解参数以指定beanName :
    - 获取对象时，需使用 userMapperBean 作为beanName，而不是 userMapper 作为beanName
```
package cn.tedu.spring;
@Component("userMapperBean")
public class UserMapper {
}
```
- 在创建对象的过程中，Spring会自动调用构造方法来创建对象，其中用到了反射机制，即使构造方法是私有的，也不影响调用
  - Spring在许多实现上都使用了反射机制，基本上不会受到访问权限修饰符的影响
  - 如果类中有多个构造方法，Spring的选取构造方法的规则请参见《课后阅读》

4.配置注解属性

关于@ComponentScan，其源代码片段有：
关于注解的配置语法：
关于注解的配置语法：
在配置注解属性时，value是默认的属性，当注解只需要配置value这1个属性的值时，可以缺省，例如以下2种语法是完全等效的：
```
@ComponentScan("cn.tedu.spring")
```
```
@ComponentScan(value = "cn.tedu.spring")
```
注意：如果注解需要配置更多属性，则配置value属性时必须显式的指定属性名为value
在配置注解属性时，如果属性类型是数组类型的，却只需要配置1个值，可以不使用大括号框住属性值，例如以下2种语法是完全等效的：
```
@ComponentScan("cn.tedu.spring")
```
```
@ComponentScan({"cn.tedu.spring"})
```
提示：如果数组类型的属性需要配置多个值，则必须使用大括号框住所有值，各值之间使用逗号分隔

5.配件注解

除了@Component以外，在Spring框架中还可以使用@Repository、@Service、@Controller表示某个类是组件类

这4个注解选择其中1个使用即可，例如以下2个代码片段是等效的：

package cn.tedu.spring;
@Component
public class UserMapper {
}

package cn.tedu.spring;
@Repository
public class UserMapper {}

@Repository、@Service、@Controller使用@Component作为元注解（Meta Annotation），并且，这3个注解的value属性都等效于@Component的value属性，通过源代码可以看出这些特点，以@Repository为例 :
在Spring框架的解释范围内，组件注解的用法及作用表现是完全相同的，但字面语义不同，在开发实践中，应该根据类的定位进行选取：–
- @Repository：用于实现数据访问的类 –
- @Service：用于处理业务逻辑的类 –
- @Controller：用于控制器类 –
- @Component：通用组件注解，即：不适合使用以上注解的组件类则添加此注解
- @Configuration也使用了@Component作为元注解，所以，此注解也可以视为“组件注解” ，但是Spring框架对其处理方式更为特殊（使用了代理模式），所以，仅当某个类的作用是编写各种配置代码时，才会使用@Configuration。

6.选择创建对象的方式

通过@Bean方法：需要在配置类中添加@Bean方法，需要Spring管理的对象越多，则需要添加的@Bean方法就越多，虽然每个方法的代码并不复杂，但是当方法的数量到一定程度后也比较繁琐，不易于管理，这种做法的优点是可以完全自定义对象的创建过程，在@Bean方法内部仍是传统的创建对象的语句–
通过组件扫描：只需要配置1次组件扫描，然后各组件类添加组件即可，且各组件类添加组件注解后也可增强语义，所以，无论编码成本还是代码的可读性都更好，这种做法的不足在于“只能适用于自定义的类” ，毕竟你不可以在引用的库中的类上添加组件注解

7.Spring Bean的作用域

在默认情况下，由Spring Bean的作用域是单例的
单例的表现为：实例唯一，即在任意时刻每个类的对象最多只有1个，并且，当对象创建出来之后，将常驻内存，直至Spring将其销毁（通常是ApplicationContext调用了销毁方法，或程序运行结束）
注意：这与设计模式中的单例模式无关，只是作用域的表现完全相同
可以通过@Scope注解修改作用域
- 当通过@Bean方法创建对象时，在方法的声明之前添加@Scope注解
```
@Configuration
public class SpringBeanFactory {
@Scope
@Bean
public Random random() {
return new Random();
}
}
```
- 当通过组件扫描创建对象时，在组件类的声明之前添加@Scope注解
```
@Scope
@Repository
public class UserMapper {
}
```
@Scope注解的scopeName属性决定了作用域，此属性与value是互相等效的，所以，通常配置为value属性即可
@Scope注解的scopeName属性的常见取值有：–
- singleton：单例的
  - 事实上这是默认值，在scopeName属性的源码上明确的说明了：Defaults toanemptystring "" which implies ConfigurableBeanFactory.SCOPE_SINGLETON，且以上常量的值就是singleton –
- prototype：原型，是非单例的

当需要将Spring Bean的作用域改为“非单例的”，可以：

@Configuration
public class SpringBeanFactory {
@Scope("prototype")
@Bean
public Random random() {
return new Random();
}
}

@Scope("prototype")
@Repository
public class UserMapper {
}

你可以反复通过getBean()获取对象，会发现各对象的hashCode()返回的结果都不相同
- 如果hashCode()没有被恶意重写，不同对象的hashCode()必然不同
由于不配置@Scope，与配置为@Scope("singleton")是等效的，所以，仅当需要将Spring Bean的作用域改为“非单例的”，才会添加配置为@Scope("prototype")
在默认情况下，单例的Spring Bean是预加载的，必要的话，也可以将其配置为懒加载的
- 如果某个对象本身不是单例的，则不在此讨论范围之内
预加载的表现为：加载Spring环境时就会创建对象，即加载Spring配置的环节，会创建对象
懒加载的表现为：加载Spring环境时并不会创建对象，而是在第1次获取对象的那一刻再创建对象
可以通过@Lazy注解来配置懒加载 –
- 当通过@Bean方法创建对象时，在方法的声明之前添加@Lazy注解
```
@Configuration
public class SpringBeanFactory {
@Lazy
@Bean
public Random random() {
return new Random();
}
}
```
- 当通过组件扫描创建对象时，在组件类的声明之前添加 @Lazy注解
```
@Lazy
@Repository
public class UserMapper {
}
```

@Lazy注解的value属性是boolean类型的，表示“是否懒加载

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.PARAMETER, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lazy {
    boolean value() default true;
}

@Lazy注解的参数是不需要关心的，因为：
- 单例的Spring Bean默认就是预加载的，不是懒加载的，所以，保持默认状态时，不使用@Lazy注解即可，并不需要配置为@Lazy(false)
- @Lazy注解的value属性默认为true，所以，当需要将单例的Spring Bean配置为懒加载时，只需要添加@Lazy注解即可，并不需要配置为@Lazy(true)

两种加载优点：
- 预加载的优点在于：事先创建好对象，无论何时需要获取对象，都可以直接获取，缺点在于：相当于启动程序时就会创建对象，这样的对象越多，启动过程就越慢，并且，如果某个对象创建出来以后，在接下来的很长一段时间都不需要使用，而此对象却一直存在于内存中，则是一种浪费
- 懒加载的优点在于：仅当需要对象时才会创建对象，不会形成浪费，缺点在于：如果当前系统已经负荷较重，需要的对象仍未加载，则会增加系统负担
- 相比而言，在开发实践中，通常认为预加载是更合理的配置

8. 创建对象的小结

Spring可以将创建出来的对象管理起来，对于开发者而言，当需要某个类的对象时，只需要从Spring容器中获取即可
创建对象的方式有2种：
1. 通过@Bean方法：在配置类中自定义方法，返回需要Spring管理的对象，此方法必须添加@Bean注解
2. 通过组件扫描：在配置类中使用@ComponentScan指定需要扫描的包，并确保需要Spring管理对象的类都在此包或其子孙包下，且这些类必须添加@Component、@Repository、@Service、@Controller中的其中某1个注解
3. 如果需要Spring管理的是自定义的类的对象，应该使用组件扫描的做法，如果需要Spring管理的对象的类型不是自定义的，只能使用@Bean方法的做法
使用组件扫描时，在@ComponentScan中指定的包是扫描的根包，其子孙包中的类都会被扫描，通常，指定的包不需要特别精准，但也不宜过于粗糙，你应该事先规划出项目的根包并配置在组件扫描中，且保证自定义的每个组件类都在此包或其子孙包中
在Spring框架的解释范围内，@Component、@Repository、@Service、@Controller的作用是完全相同的，但语义不同，应该根据类的定位进行选取
@Configuration是特殊的组件注解，Spring会通过代理模式来处理，此注解应该仅用于配置类
使用@Bean方法时，beanName默认是方法名，也可以在@Bean注解中配置参数来指定beanName
使用组件扫描时，beanName默认是将类名首字母改为小写的名称（除非类名不符合首字母大写、第2字母小写的规律），也可以在@Component或其它组件注解中配置参数来指定beanName
Spring Bean的作用域默认是预加载的单例的，可以通过@Scope("prototype")配置为“非单例的”，在单例的前提下，可以通过@Lazy配置为“懒加载的” ，通常，保持为默认即可
关于配置注解参数：
1. 如果你需要配置的只是注解的value这1个属性，不需要显式的写出属性名称
2. 如果你需要配置注解中的多个属性，每个属性都必须显式写出属性名称，包括value属性
3. 如果你需要配置的注解属性的值是数组类型，当只指定1个值时，可以不使用大括号将值框住，当指定多个值时，多个值必须使用大括号框住，且各值之间使用逗号分隔
4. 你可以通过查看注解的源代码来了解注解可以配置哪些属性、属性的值类型、默认值
5. 在注解的源代码中，@AliasFor可理解为“等效于”

4.自动装配

1.自动装配机制

Spring的自动装配机制表现为：当某个量需要被赋值时，可以使用特定的语法，使得Spring尝试从容器找到合适的值，并自动完成赋值
最典型的表现就是在类的属性上添加@Autowired注解，Spring就会尝试从容器中找到合适的值为这个属性赋值

代码：

SpringConfig

package cn.tedu.spring;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("cn.tedu.spring")
public class SpringConfig {
}

UserMapper

package cn.tedu.spring;
import org.springframework.stereotype.Repository;
@Repository
public class UserMapper {
public void insert() {
System.out.println("UserMapper.insert() >> 将用户数据写入到数据库中……");
}
}

UserController

package cn.tedu.spring;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class UserController {
@Autowired // 注意：此处使用了自动装配的注解
private UserMapper userMapper;
public void reg() {
System.out.println("UserController.reg() >> 控制器即将执行用户注册……");
userMapper.insert(); // 注意：此处调用了userMapper属性的方法
}
}

SpringRunner

public class SpringRunner {
public static void main(String[] args) {
AnnotationConfigApplicationContext ac
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserController userController = ac.getBean("userController", UserController.class);userController.reg();
ac.close();
}
}

代码解析：
- – 在main()方法中，由于加载了SpringConfig类，根据SpringConfig上配置的@ComponentScan，将执行组件扫描
- 由于UserMapper和UserController都在组件扫描的包范围内，所以Spring框架会自动调用它们的构造方法以创建对象，并把对象保管在Spring容器中
- 由于UserController中的userMapper属性添加了@Autowired注解，所以Spring框架会尝试为此属性注入值，且由于在Spring容器中存在UserMapper对象，则可以成功注入，使得userMapper属性是有值的
- 最终userController调用reg()方法时，实现过程中还通过userMapper调用了insert()方法，整个执行过程中不会出错，在控制台可以看到对应的输出文本
除了对属性装配以外，Spring的自动装配机制还可以表现为：如果某个方法是由Spring框架自动调用的（通常是构造方法，或@Bean方法），当这个方法被声明了参数时，Spring框架也会自动的尝试从容器找到匹配的对象，用于调用此方法
对方法的参数自动装配时，如果方法有多个参数，各参数的先后顺序是不重要的

代码：

@Configuration
public class SpringConfig {
@Bean
public UserMapper userMapper() {
return new UserMapper();
}
@Bean
public UserController userController(UserMapper userMapper) {
UserController userController = new UserController();
userController.userMapper = userMapper;
return userController;
}
}

2.@Autowired的装配机制

关于@Autowired的装配机制，首先，会根据需要装配的数据的类型在Spring容器中统计匹配的Bean（对象）的数量
当匹配的Bean数量为0个时，判断@Autowired注解的required属性值
1. true（默认）：装配失败，启动项目时即抛出NoSuchBeanDefinitionException
2. false：放弃自动装配，不会报告异常，后续直接使用此属性时，会出现NPE (空指针异常)
当匹配的Bean数量为1个时，将直接装配，且装配成功
当匹配的Bean数量为多个时：自动尝试按照名称实现装配（即：要求属性名称与beanName相同）
1. 存在与属性名称匹配的Spring Bean：装配成功
2. 不存在与属性名称匹配的Spring Bean：装配失败，启动项目时即抛出NoUniqueBeanDefinitionException

3.小结

※ 当某个属性需要被注入值，且你肯定此值存在于Spring容器中，你可以在属性上添加@Autowired注解，则Spring框架会自动为此属性注入值
※ 如果某个方法是由Spring调用的，当方法体中需要某个值，且你肯定此值存在于Spring容器中，你可以将其声明为方法的参数，则Spring框架会自动从容器中找到此值并且于调用此方法，如果声明了多个这样的参数，各参数的先后顺序是不重要的
自动装配的前提是Spring会自动创建此类的对象，否则，Spring不可能为属性赋值，也不可能调用类中的方法
@Autowired的装配机制的表现是可以根据类型实现装配，并且，当匹配类型的Bean有多个时，还可以根据名称进行匹配，从而实现装配，你需要熟记具体装配机制

5.其它

仍有一些与Spring框架相关的内容并未在本课提及，主要包括：
1. Spring Bean的生命周期
2. 读取properties配置文件
3. @Value注解
4. Spring AOP

6.课后阅读

1. IoC

IoC（Inversion of Control：控制反转）是Spring框架的核心，在传统的开发模式下，是由开发者创建对象、为对象的属性赋值、管理对象的作用域和生命周期等，所以，是开发者拥有“控制权”，当使用了Spring之后，这些都交给Spring框架去完成了，开发者不必关心这些操作的具体实现，所以，称之为“控制反转
无论是创建对象，还是自动装配等等，只要是Spring创建并管理对象的操作，都可以称之为Spring IoC的过程

2.DI

DI（Dependency Injection：依赖注入）是Spring框架实现IoC的核心实现，当某个类中声明了另一个类的属性（例如在UserController类中声明了UserMapper类型的属性），则称之为依赖（即UserController依赖了UserMapper），Spring框架会帮你完成依赖项的赋值，只是你在你的代码中看不到赋值过程或赋值符号，所以称之为注入

3.Ioc与DI关系

Spring通过DI实现了IoC，所以，IoC是一种目标，而DI是实现此目标的重要手段

4. 关于@Qualifier

@Qualifier注解是在自动装配机制中，用于指定beanName的注解
通常是因为存在多个类型匹配的Bean，但是所有Bean的beanName与被装配的属性名称/参数名称都不匹配，且不想修改beanName也不想修改属性名称/参数名称，则可以通过@Qualifier指定beanName
1. 这种现象在开发实践中并不多见

在自动装配属性时指定beanName

@Controller
public class UserController {
@Autowired
@Qualifier("userMapper")
private UserMapper xxx;
public void reg() {
System.out.println("UserController.reg() >> 控制器即将执行用户注册……");
xxx.insert();
}
}

在自动装配方法参数时指定beanName

@Configuration
public class SpringConfig {
@Bean
public UserMapper userMapper() {
return new UserMapper();
}
@Bean
public UserController userController(@Qualifier("userMapper") UserMapper xxx) {
UserController userController = new UserController();
userController.userMapper = xxx;
return userController;
}
}

5. 关于构造方法

当通过组件扫描创建对象时，Spring会自动调用组件类的构造方法，此过程中会使用到反射，所以可以无视构造方法的访问权限
如果类中仅有1个构造方法，Spring会自动调用这个构造方法
如果类中没有显式的添加构造方法，根据Java的机制，会由编译器添加默认构造方法，相当于有1个构造方法
如果类中有多个构造方法，默认情况下，Spring会自动调用无参数构造方法（如果存在的话），如果某个构造方法添加了@Autowired，则Spring会自动调用添加了此注解的构造方法
被Spring调用的构造方法是允许有参数的，作为开发者，你需要保证Spring可以利用自动装配机制为参数注入值（你需要保证Spring容器中存在匹配的值），否则会导致NoSuchBeanDefinitionException

6. 关于@Resource注解

@Resource注解是javax.annotation包中的

如果某属性添加了@Resource注解，Spring也可以实现自动装配

@Controller
public class UserController {
@Resource
private UserMapper userMapper;
public void reg() {
System.out.println("UserController.reg() >> 控制器即将执行用户注册……");
userMapper.insert();
}
}

@Resource注解的装配机制是：先尝试根据名称进行装配（即：要求属性名称与beanName相同），如果失败，则尝试根据类型装配，如果不存在类型的Bean，则抛出NoSuchBeanDefinitionException，如果只有1个匹配类型的Bean，则装配成功，如果匹配类型的Bean超过1个，则抛出NoUniqueBeanDefinitionException
在开发实践中，绝大部分类型的Bean都只有1个，无论是@Autowired还是@Resource，当匹配类型的Bean有且仅有1个时，都可以成功装配，所以，在绝大部分情况下，这2个注解的装配机制的差异对于开发人员来说是无感的
当需要讨论@Autowired与@Resource的区别时，除了这2个注解所在的包不同、装配机制不同以外，还存在以下区别：
1. @Autowired可以添加在构造方法的声明之前，@Resource不可以
2. @Resource可以添加在类的声明之前（但不会装配属性的值），@Autowired不可以
3. 当存在多个同类型的Bean时
  1. 当装配属性时，@Autowired需要通过@Qualifier指定beanName，而@Resource可以直接配置name属性以指定beanName
  2. 当装配方法的参数时（例如添加了@Autowired的构造方法的参数），@Autowired仍可以使用@Qualifier指定beanName，而@Resource无法解决此问题
综合来看，由于@Autowired是Spring框架专门定制的注解，且@Autowired可以添加在构造方法上，相比@Resource有更多的应用场景（虽然不一定真的需要这样用），所以，在开发实践中，当需要使用注解显式的表示自动装配时，推荐优先使用@Autowired

7. 关于@Autowired的警告

当你在属性上添加@Autowired时，在IntelliJ IDEA中会有浅灰色的下划线提示警告
1. 此警告内容为：Field Injection is not recommended，可译为：字段（类的属性）注入是不推荐的
2. 假设某开发人员不是通过Spring容器获取UserController的对象，而是通过传统方式，使用new关键字自行创建对象，且忽略了为userMapper属性赋值（此属性是private的，对外不可见，忽略了很常见），则会导致userMapper一直是默认的null值，后续调用userMapper的方法时就会出现NPE，这被视为字段注入的不足之处
建议的解决方案是这样的：
```
@Controller
public class UserController {
private UserMapper userMapper;
public UserController(UserMapper userMapper) {
this.userMapper = userMapper;
}
public void reg() {
System.out.println("UserController.reg() >> 控制器即将执行用户注册……");
System.out.println(userMapper.getClass().getName());
userMapper.insert();
}
}
```
1. Spring有非常完善的调用构造方法的机制，并且也可以对构造方法中的参数注入值，甚至存在多个匹配类型对象时还可以使用@Qualifier指定beanName，所以，只要构造方法中的代码能够对属性赋值，就可以实现和属性上自动装配完全相同的效果
2. 只要将必要的值声明为构造方法的参数，无论是Spring创建对象，还是人为创建对象，都需要提供此参数值，除非恶意的传入null值，否则，不会出现NPE问题，所以，此做法是被推荐的
使用构造方法虽然安全，不会出现NPE，但是，当需要被赋值的属性的数量出现增或减时，都需要调整构造方法，当属性数量较多时，构造方法的参数也会变多，这些都是在开发实践中非常现实的问题
由于字段注入的NPE问题只是开发阶段人为错误使用导致的，出现概率非常低、可控、容易解决，且字段注入的语法简洁、直观，所以，在开发实践中，字段注入仍是最常见的用法

标签：框架,构造方法,对象,Spring,UserMapper,Bean,注解,属性
来源： https://www.cnblogs.com/xiaoyezilei/p/16309032.html

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告 ，@Resource注解 )

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告 ，@Resource注解 )

1.关于框架

1.概念：

2.关于Spring框架

1.作用

2.创建对象

3. 在Maven工程中使用Spring

3.通过Spring管理对象

1.创建对象的方式

2.通过@Bean方法

3.通过组件扫描创建对象

4.配置注解属性

5.配件注解

6.选择创建对象的方式

7.Spring Bean的作用域

8. 创建对象的小结

4.自动装配

1.自动装配机制

2.@Autowired的装配机制

3.小结

5.其它

6.课后阅读

1. IoC

2.DI

3.Ioc与DI关系

4. 关于@Qualifier

5. 关于构造方法

6. 关于@Resource注解

7. 关于@Autowired的警告

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告，@Resource注解 )

day60( 关于框架 , 关于Spring框架,通过Spring管理对象,自动装配, Ioc与DI,@Qualifier ,构造方法，@Autowired的警告，@Resource注解 )