• 0

  • 469

  • 收藏

[Spring]Bean的定义-BeanDefinition

智能的司机

我是老司机

2星期前

IOC容器

IOC容器主要的职责有:

  • Spring IOC 可以从配置文件或者注解中根据每个Bean的定义,将这些Java对象解析成BeanDefinition,最后注册到IOC容器
  • 依赖注入(DI),构造一个对象可以通过构造函数、静态工厂方法、工厂方法。日常开发中在Controller中使用@Autowired注入Service就是依赖注入的过程。
  • 管理Bean的生命周期,Spring可以管理Bean的作用域、加载时机等信息。
  • 日常使用中,ApplicationContext接口代表Spring IOC 容器

Spring官网对容器的概述图,业务Java对象加上元数据的配置,被Spring IOC进行读取、解析、注册到IOC容器后,对外界提供使用。

IOC

Bean

  • 交由Spring IOC容器管理的Java对象称为Bean
  • Bean的本质还是Java对象,只不过在此基础上,IOC负责了这个Java对象的生命周期。
  • 除了本身的Java对象内容外,Spring提供了一系列的配置项让开发者更好的去定义Bean,比如一个配置项,你希望它是单例的,那么你可以在xml中配置成scope="singleton"
  • 命名Bean可以在xml中指定id或者name,如果不提供,则默认按首字母小写的驼峰规则生成
  • 别名alias: 除了name之外,你可以指定Bean的别名,即你可以通过其他的命名来从容器中获取这个Bean.
  1. PersonFactory
@Component
public class PersonFactory {

	/**
	 * 这个Bean即可以为personC,也可以为Kobe
	 */
	@Bean({"personC", "Kobe"})
	public Person getPerson() {
		return new Person("I am Kobe who created by PersonFactory");
	}
}
复制代码
  1. Demo
@Configuration
@ComponentScan(value = "com.xjm")
public class BeanDefinitionDemoByAnnotation {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AnnotationContextDemo.class);
		Person kobe = (Person) applicationContext.getBean("Kobe");
		System.out.println(kobe.toString());
	}
}
复制代码

BeanDefinition

根据配置,用来描述Bean的BeanDefinition,它是一个接口,主要定义了一些Bean该有的方法,让下层实现类去实现这些功能,以下声明的属性均不在BeanDefinition中,只是便于理解,实际上Beandefinition只是定义了它们的getter和setter:

  • beanClassName:bean的类名称
  • scope:bean的作用域
  • lazyInit:是否懒加载
  • primary:如果存在多个实现类,优先以这个为首选实现类
  • factoryBeanName:指定要使用的工厂bean(如果有)。这是用于调用指定工厂方法的bean的名称
  • factoryMethod:指定工厂方法(如果有)。将使用构造函数参数调用此方法,如果未指定,则不使用任何参数。该方法将在指定的工厂bean(如果有)上被调用,否则将作为本地bean类上的静态方法被调用。
  • constructorArgumentValues:获取构造函数的参数,只读,内部用LinkedHashMap按照index存储参数。
  • propertyValues:Bean实例的属性值。可以在bean工厂后处理期间修改返回的实例。
  • dependsOn:设置该bean依赖于初始化的bean的名称。 Bean工厂将确保首先初始化这些Bean。
  • autowiredCandidate:设置此bean是否适合自动连接到其他bean,只影响基于type类型的自动装配,不影响基于name的自动装配。以及布尔方法:isAutowireCandidate()
  • initMethodName:初始化的函数名
  • destroyMethodName:销毁方法名
  • description:给bean添加可读性较友好的描述
  • parentName:bean的parent名称

Bean的作用域

Bean的作用域 ,可以指定值为:singletonprototyperequestsessionapplication

范围 描述
singleton 默认的作用域,单例
prototype 原型模式,也就是可以创建多个对象实例
request 生命周期为一个Http请求的Bean。即每个Http请求都会产生一个自己的Bean实例。仅在ApplicationContext中有效
session 生命周期为整个Http的Bean。仅在ApplicationContext中有效
application 作用域限定为ServletContext的生命周期

我们从xml或者注解中定义的内容都会被解析成BeanDefinition,再根据BeanDefinition产生Bean实例,这就跟Person.java->Person.class->Person是类似的。

实例化对象的几种方式

  • spring-config.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"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--1. 使用类的无参构造函数创建-->
	<bean id="personA" class="com.xjm.model.Person" scope="singleton" lazy-init="true" primary="true"></bean>
	<!--2. 通过静态工厂进行创建-->
	<bean id="personB" class="com.xjm.model.PersonStaticFactory" factory-method="getPerson" scope="singleton"></bean>
	<!--3. 使用实例工厂进行创建-->
	<bean id="personFactory" class="com.xjm.model.PersonFactory"></bean>
	<bean id="personC" factory-bean="personFactory" factory-method="getPerson" scope="singleton"></bean>
</beans>
复制代码
  • Person
public class Person {

	private String name;

	private Integer age;

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

	public Person() {
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person{" +
				"name='" + name + '\'' +
				", age=" + age +
				'}';
	}
}
复制代码
  • PersonFactory
public class PersonFactory {

	public Person getPerson() {
		return new Person("I am Kobe who created by PeronFactory");
	}
}
复制代码
  • PersonStaticFactory
public class PersonStaticFactory {

	public static Person getPerson() {
		return new Person("I am James who created by PersonStaticFactory");
	}
}
复制代码
  • demo
@SuppressWarnings("all")
public class BeanDefinitionDemo {
	public static void main(String[] args) {
		// 1. 声明配置类路径
		String xmlPath = "D:\\Spring\\spring-framework-5.1.x\\spring-demo\\src\\main\\resources\\spring\\spring-config.xml";
		// 2. 加载xml配置类
		ApplicationContext applicationContext = new FileSystemXmlApplicationContext(xmlPath);
		System.out.println("****************Before Spring********************");
		// 默认的构造函数
		Person person = new Person();
		System.out.println(person.toString());
		// 使用静态方法创建Person
		Person kobe = PersonStaticFactory.getPerson();
		System.out.println(kobe.toString());
		// 使用工厂创建Person
		PersonFactory personFactory = new PersonFactory();
		System.out.println(personFactory.getPerson().toString());
		System.out.println("****************Using Spring********************");
		// 默认构造函数创建Bean
		Person personA = (Person) applicationContext.getBean("personA");
		// 通过静态工厂方法创建Bean
		Person personB = (Person) applicationContext.getBean("personB");
		// 通过工厂方法创建Bean
		Person personC = (Person) applicationContext.getBean("personC");
		System.out.println(personA.toString()+"hashcode:"+personA.hashCode());
		System.out.println(personB.toString()+"hashcode:"+personB.hashCode());
		System.out.println(personC.toString()+"hashcode:"+personC.hashCode());
		System.out.println("************Singleton*********************");
		Person personAA = (Person) applicationContext.getBean("personA");
		Person personBB = (Person) applicationContext.getBean("personB");
		Person personCC = (Person) applicationContext.getBean("personC");
		System.out.println(personAA.toString()+"hashcode:"+personAA.hashCode());
		System.out.println(personBB.toString()+"hashcode:"+personBB.hashCode());
		System.out.println(personCC.toString()+"hashcode:"+personCC.hashCode());
	}
}
复制代码

可以看到,在xml配置好对应的初始化方式后,Spring就会根据配置的方式对对象实例进行初始化。

demo

AbstractBeanDefinition

AbstractBeanDefinition是BeanDefinition接口的抽象实现,也就是说它负责定义下层子类可以复用的代码,提供一些公共参数。

  • Class:beanClass,Bean的class对象或是类的全限定名,用来实例化Bean
  • Name: Bean的命名
  • Scope:scope,Bean的作用域
  • Constructor arguments: constructorArgumentValues,构造器参数,在依赖注入的时候用到
  • Properties:propertyValues,属性,在依赖注入的时候用到
  • Autowiring mode:AUTOWIRE_NOAUTOWIRE_BY_NAMEAUTOWIRE_BY_TYPEAUTOWIRE_CONSTRUCTOR,自动装配方式,byName,byType,byConstructor
  • Lazy initialization modelazyInit,懒加载方式
  • Initialization method:initMethodName,实例化方法,在实例化时的钩子函数
  • Destruction method:destroyMethodName,销毁方法,在销毁时的钩子函数
  • Autowire candidate: autowireCandidate,声明该bean是否可以作为被自动装配的目标
  • primary(@Primary):primary,设置为true的bean会是优先的实现类,用在一个Bean有多个实现类的场景
  • Factory bean name:factoryBeanName,工厂类名
  • Factory method:factoryMethodName, 指定工厂方法(如果有)。将使用构造函数参数调用此方法,如果未指定,则不使用任何参数。该方法将在指定的工厂bean(如果有)上被调用,否则将作为本地bean类上的静态方法被调用。

以下是AbstractBeanDefinition中定义的一些属性

BeanDefinition XML
scope
lazyInit
beanClass
autowireCandidate
primary
factoryMethodName 单独使用getPerson需要为static
factoryBeanName

可以理解为先创建personFactory,实现FactoryBean的接口,然后根据getObject再调用里面的getPerson方法

BeanDefinition的UML图

UML

OK,我们看到AbstractBeanDefinition是在Beandefinition上做了一些简单的属性声明与构造器,具体的实现还是由GenericBeanDefinition、RootBeanDefinition、ChildBeanDefinition去实现的,那么这三者之间有什么联系呢?下章见分晓

总结

  • Spring为了管理Java对象,创造了Bean和Beandefinition,然后提供了xml和注解的方式来读取这些配置信息,解析成Beandefinition,最后生成Bean注册到IOC容器中。
  • 实例化bean的方式可以为:构造函数、静态工厂方法、工厂实例方法(先创建工厂再调用方法)
  • 自动装配的方式有:byName、byType、byConstructor
  • Bean的生命周期可以是:singleton、prototype、request、session、application等
  • IOC容器中默认的Bean命名方式为首字母的驼峰规则,可以通过指定别名来获取你的Bean
免责声明:文章版权归原作者所有,其内容与观点不代表Unitimes立场,亦不构成任何投资意见或建议。

469

相关文章推荐

未登录头像

暂无评论