spring注解解析、IOC装配机制及IOC注入bean的五种方式

最新推荐文章于 2023-05-07 16:52:26 发布

RogerKan

最新推荐文章于 2023-05-07 16:52:26 发布

阅读量375

点赞数

分类专栏： # 源码解读

本文链接：https://blog.csdn.net/Kanmeijie/article/details/111570182

版权

源码解读专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. 注解解析

@Autowired和@Resource等注解是将Spring容器中的bean注入到属性，而@Component等注解是将bean放入Spring容器中管理。

@Autowired

spring2.1中允许用户通过@Autowired注解对Bean的属性变量.属性Setter方法以及构造函数进行标注,配合AutowiredAnnotationBeanProcessor完成Bean的自动配置。使用@Autowired注释进行byType注入。

在applicationContext.xml中加入：

<!-- 该 BeanPostProcessor 将自动对标注 @Autowired 的 Bean 进行注入 -->  
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>

通过 @Autowired的使用来消除 set ，get方法。

@Autowired  
private UserDao userdao;

这样就可以删除set ，get方法和spring中的相关配制了。

<bean id="userDao" class="..."/>  
<bean id="userService" class="...">  
    <property name="userDao">  
      <ref bean="userDao"/>  
    </property>  
</bean>

通过@Autowired属的Setter方法给父类中的属性注入值。

@Autowired  
public void setDataSource(DataSource dataSource)  
{  
    super.setDataSource(dataSource);  
}

@Autowired(required = false)
当不能确定 Spring 容器中一定拥有某个类的 Bean 时，可以在需要自动注入该类 Bean 的地方可以使用 @Autowired(required = false) ，这等于告诉 Spring：在找不到匹配 Bean 时也不报错。

当然，一般情况下，使用 @Autowired 的地方都是需要注入 Bean 的，使用了自动注入而又允许不注入的情况一般仅会在开发期或测试期碰到（如为了快速启动 Spring 容器，仅引入一些模块的 Spring 配置文件），所以 @Autowired(required = false) 会很少用到。

@Qualifier
使用@Autowired注释进行byType注入，如果需要byName（byName就是通过id去标识）注入，增加@Qualifier注释。一般在候选Bean数目不为1时应该加@Qualifier注释。

在默认情况下使用 @Autowired 注释进行自动注入时，Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时，Spring 容器将抛出

BeanCreationException 异常，并指出必须至少拥有一个匹配的 Bean。

和找不到一个类型匹配 Bean 相反的一个错误是：如果 Spring 容器中拥有多个候选 Bean，Spring 容器在启动时也会抛出 BeanCreationException 异常。

Spring 允许我们通过 @Qualifier 注释指定注入 Bean 的名称，这样歧义就消除了，可以通过下面的方法解决异常：

@Autowired  
public void setOffice(@Qualifier("office")Office office)  
{  
    this.office =office;  
}

也可以直接注入到属性:

@Autowired   
@Qualifier("office")   
private Office office;

@Qualifier(“office”)中的office是Bean的名称，所以@Autowired和@Qualifier结合使用时，自动注入的策略就从byType转变成byName了。

@Autowired可以对成员变量、方法以及构造函数进行注释，而@Qualifier的标注对象是成员变量、方法入参、构造函数入参。正是由于注释对象的不同，所以Spring不将 @Autowired和@Qualifier统一成一个注释类。

@Qualifier 只能和@Autowired 结合使用，是对@Autowired有益的补充。

一般来讲，@Qualifier对方法签名中入参进行注释会降低代码的可读性，而对成员变量注释则相对好一些。

@Resource
Spring不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。

@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。

@Resource装配顺序

如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

@Component、@Repository、@Service、@Controller
Spring 2.5 中除了提供 @Component 注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service 和 @Controller。

在目前的 Spring 版本中，这 3 个注释和 @Component 是等效的，但是从注释类的命名上，很容易看出这 3 个注释分别和持久层、业务层和控制层（Web 层）相对应。

虽然目前这3 个注释和 @Component 相比没有什么新意，但 Spring 将在以后的版本中为它们添加特殊的功能。

所以，如果 Web 应用程序采用了经典的三层分层结构的话，最好在持久层、业务层和控制层分别采用上述注解对分层中的类进行注释。

@Service用于标注业务层组件

@Controller用于标注控制层组件（如struts中的action）

@Repository用于标注数据访问组件，即DAO组件

@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@Service  
public class VentorServiceImpl implements iVentorService {     
}  
@Repository  
public class VentorDaoImpl implements iVentorDao {   
}

在一个稍大的项目中，如果组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。

Spring2.5为我们引入了组件自动扫描机制，他在类路径下寻找标注了上述注解的类，并把这些类纳入进spring容器中管理。

它的作用和在xml文件中使用bean节点配置组件时一样的。要使用自动扫描机制，我们需要打开以下配置信息：

<?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-2.5.xsd  
  
  
http://www.springframework.org/schema/context  
  
        http://www.springframework.org/schema/context/spring-context-2.5.xsd">   
  
    <context:annotation-config />  
    <context:component-scan base-package=”com.iteedu.spring”>     
</beans>

annotation-config是对标记了@Required、@Autowired、@PostConstruct（实例化bean后执行的方法（init（）））、@PreDestroy（关闭资源后执行的方法（ destroy（）））、@Resource、@WebServiceRef、@EJB、@PersistenceContext、@PersistenceUnit等注解的类进行对应的操作使注解生效。

base-package为需要扫描的包（含所有子包），负责扫描那些有@Component、@Repository、@Service 和 @Controller注解的类。

annotation-config是对标记了@Required、@Autowired、@PostConstruct（实例化bean后执行的方法（init（）））、@PreDestroy（关闭资源后执行的方法（ destroy（）））、@Resource、@WebServiceRef、@EJB、@PersistenceContext、@PersistenceUnit等注解的类进行对应的操作使注解生效。base-package为需要扫描的包（含所有子包），负责扫描那些有@Component、@Repository、@Service 和 @Controller注解的类。

可以使用以下方式指定初始化方法和销毁方法：

@PostConstruct  
public void init() {   
}   
@PreDestroy  
public void destory() {   
}

@Configuration 是spring boot 提供的自动装配，表示你这个类是个配置类

@Bean 作用在方法上是将方法的返回值注入到spring上下文中，作用在类上表示加入到IOC容器。

2. 三种装配机制

Spring中提供了三种主要的装配机制
1.在xml中进行显式配置
2.在java中进行显式配置
3.隐式bean发现机制和自动装配
第一种就是在xml配置文件中使用bean标签声明。
而上面的使用的是就是就是第二种。
第三种的隐式bean发现机制就是Spring支持扫描使用@Service、@Compent、@Repository、@Controller的类，并注册成Bean。
自动装配指的就是Spring会尝试满足在使用@Autowired的属性值和方法相对应的依赖(属性值就是本身的实体，方法就是参数中的依赖)，并将符合的bean填充过来。

3. IOC注入bean的五种方式

3.1 @Import导入组件，id默认是组件的全类名

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；
@Conditional({WindowsCondition.class})
@Configuration
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})
//@Import导入组件，id默认是组件的全类名
public class MainConfig2 {
//默认是单实例的
/**
* ConfigurableBeanFactory#SCOPE_PROTOTYPE
* @see ConfigurableBeanFactory#SCOPE_SINGLETON
* @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST request
* @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION sesssion
* @return\
* @Scope:调整作用域
* prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
* 每次获取的时候才会调用方法创建对象；
* singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
* 以后每次获取就是直接从容器（map.get()）中拿，
* request：同一次请求创建一个实例
* session：同一个session创建一个实例
*
* 懒加载：
* 单实例bean：默认在容器启动的时候创建对象；
* 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
*
*/
// @Scope("prototype")
@Lazy
@Bean("person")
public Person person(){
System.out.println("给容器中添加Person....");
return new Person("张三", 25);
}
/**
* @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean
*
* 如果系统是windows，给容器中注册("bill")
* 如果是linux系统，给容器中注册("linus")
*/
@Bean("bill")
public Person person01(){
return new Person("Bill Gates",62);
}
@Conditional(LinuxCondition.class)
@Bean("linus")
public Person person02(){
return new Person("linus", 48);
}
/**
* 给容器中注册组件；
* 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类]
* 2）、@Bean[导入的第三方包里面的组件]
* 3）、@Import[快速给容器中导入一个组件]
* 1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名
* 2）、ImportSelector:返回需要导入的组件的全类名数组；
* 3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中
* 4）、使用Spring提供的 FactoryBean（工厂Bean）;
* 1）、默认获取到的是工厂bean调用getObject创建的对象
* 2）、要获取工厂Bean本身，我们需要给id前面加一个&
* &colorFactoryBean
*/
@Bean
public ColorFactoryBean colorFactoryBean(){
return new ColorFactoryBean();
}

3.2 实现Condition进行注入

Springboot有大量的@ConditionXXXX注解

public class LinuxCondition implements Condition {

/**
* ConditionContext：判断条件能使用的上下文（环境）
* AnnotatedTypeMetadata：注释信息
*/
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// TODO是否linux系统
//1、能获取到ioc使用的beanfactory
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//2、获取类加载器
ClassLoader classLoader = context.getClassLoader();
//3、获取当前环境信息
Environment environment = context.getEnvironment();
//4、获取到bean定义的注册类
BeanDefinitionRegistry registry = context.getRegistry();

String property = environment.getProperty("os.name");

//可以判断容器中的bean注册情况，也可以给容器中注册bean
boolean definition = registry.containsBeanDefinition("person");
if(property.contains("linux")){
return true;
}
return false;
}
}

3.3 实现ImportSelector

public class MyImportSelector implements ImportSelector {

//返回值，就是到导入到容器中的组件全类名
//AnnotationMetadata:当前标注@Import注解的类的所有注解信息
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
// TODO Auto-generated method stub
//importingClassMetadata
//方法不要返回null值
return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
}

}

3.4 实现ImportBeanDefinitionRegistrar

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

/**
* AnnotationMetadata：当前类的注解信息
* BeanDefinitionRegistry:BeanDefinition注册类；
* 把所有需要添加到容器中的bean；调用
* BeanDefinitionRegistry.registerBeanDefinition手工注册进来
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
if(definition && definition2){
//指定Bean定义信息；（Bean的类型，Bean。。。）
RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
//注册一个Bean，指定bean名
registry.registerBeanDefinition("rainBow", beanDefinition);
}
}
}

3.5 实现 FactoryBean

/ /创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color> {

//返回一个Color对象，这个对象会添加到容器中
@Override
public Color getObject() throws Exception {
// TODO Auto-generated method stub
System.out.println("ColorFactoryBean...getObject...");
return new Color();
}

@Override
public Class<?> getObjectType() {
// TODO Auto-generated method stub
return Color.class;
}

//是单例？
//true：这个bean是单实例，在容器中保存一份
//false：多实例，每次获取都会创建一个新的bean；
@Override
public boolean isSingleton() {
// TODO Auto-generated method stub
return false;
}
}