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.
- PersonFactory
@Component
public class PersonFactory {
/**
* 这个Bean即可以为personC,也可以为Kobe
*/
@Bean({"personC", "Kobe"})
public Person getPerson() {
return new Person("I am Kobe who created by PersonFactory");
}
}
- 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的作用域 ,可以指定值为:singleton、prototype、request、session、application。
| 范围 | 描述 |
|---|---|
| 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_NO、AUTOWIRE_BY_NAME、AUTOWIRE_BY_TYPE、AUTOWIRE_CONSTRUCTOR,自动装配方式,byName,byType,byConstructor -
Lazy initialization mode：
lazyInit,懒加载方式 -
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 | <bean scope="xxx" /> |
| lazyInit | <bean lazy-init="true" /> |
| beanClass | <bean class="xxx" /> |
| autowireCandidate | <bean autowire-candidate="true" /> |
| primary | <bean primary="true" /> |
| factoryMethodName | <bean factory-method="getPerson"> 单独使用getPerson需要为static |
| factoryBeanName | <bean id="personFactory" class="com.xjm.model.PersonFactory"></bean> <bean id="personC" factory-bean="personFactory" factory-method="getPerson"> 可以理解为先创建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
网友评论