Spring笔记-创建Bean

创建bean:

1.默认构造函数

spring.xml <bean class="com.test.spring.HelloSpring"></bean>

HelloSpring.java HelloSpring() {}

2.指定构造函数

<constructor-arg index="0" value="zhangsan"></constructor-arg>

<constructor-arg name="age" value="1"></constructor-arg>

</bean>

public HelloSpring(String name, int age) {}

3.静态工厂方法 factory-method="build"。场景：A/B测试

spring.xml

<constructor-arg name="type" value="A"></constructor-arg>

</bean>

HelloSpring.java

public static HelloSpring build(String type) {

if("A".equals(type)) {

return new HelloSpring("张三",1);

}else if("B".equals(type)){

return new HelloSpring("李四",2);

}else {

throw new IllegalArgumentException("type must be A OR B");

}

4.FactoryBean创建。创建的可能并不是类本身的对象，场景：SqlSessionFactory。

</bean>

class FactoryBeanSpring implements FactoryBean{

private String jdbcUrl;

public Object getObject() throws Exception {

return DriverManager.getDriver(jdbcUrl);

}

public Class getObjectType() {

return java.sql.Driver.class;

}

public boolean isSingleton() {

return true;

}

依赖注入：

HelloSpring的成员变量：WorldSpring

1.set方法注入

</bean>

2.构造方法注入

<constructor-arg name="worldSpring">

</constructor-arg>

</bean>

3.自动注入：byName、byType。默认是byName

4.方法注入: lookup-method。场景：一个单例bean依赖一个多例bean.该操作基于动态代理技术。也可以通过实现BeanFactoryAware接口来获取BeanFactory实例，从而直接调用getBean()方法获取新实例.

<lookup-method name="getHello" ></lookup-method>

</bean>

public abstract class LookupMethodSpring {

public abstract HelloSpring getHello();

public void sayHello() {

getHello().sayHello();

}

基本特性：

1.作用范围

scope=prototype多例

scope=singleton 单例。单例对象会缓存于IOC容器，在DefaultSingletonBeanRegistry对象中。

2.生命周期

创建

初始化 init-method

销毁 destory-method applicationContext关闭时会进行销毁

3.加载机制

设置lazy-init，默认为false。

true 懒加载，延迟加载。容器启动会很快

false 非懒加载，创建即加载。容器启动时能更快的发现错误。

创建、读取bean：

1.关键类

BeanDefinition：bean定义类。bean信息都保存在该类对象中，与xml bean一对一关系

继承 AttributeAccessor、BeanMetadataElement。AttributeAccessor.getAttribute()、BeanMetadataElement.getSource()

BeanDefinitionRegistry：Bean注册器类，id注册，name是设置别名。

id作为当前bean的存储key注册到BeanDefinitionRegistry注册器中

name作为别名key注册到AliasRegistry注册器

BeanDefinitionReader：Bean定义读取类。

BeanDefinitionReader读取xml，load BeanDefinition装载bean定义，注册到BeanDefinitionRegistry

BeanFactory：bean工厂，创建bean。

getBean(String)

基于ID或name 获取一个Bean

<T> T getBean(Class<T> requiredType)

基于Bean的类别获取一个Bean（如果出现多个该类的实例，将会报错。但可以指定 primary=“true” 调整优先级来解决该错误）

Object getBean(String name, Object... args)

基于名称获取一个Bean，并覆盖默认的构造参数

boolean isTypeMatch(String name, Class<?> typeToMatch)

指定Bean与指定Class 是否匹配

BeanFactory

BeanFactory是最顶层的一个接口类，它定义了IOC容器的基本功能规范。

子类ListableBeanFactory：表示这些 Bean 是可列表的，定义了 Bean 的集合；

子类HierarchicalBeanFactory：表示的是这些 Bean 是有继承关系，定义了Bean 之间的关系；

子类AutowireCapableBeanFactory：定义 Bean 的自动装配规则，定义了Bean 行为。

最终的默认实现类是 DefaultListableBeanFactory，实现了以上所有的接口。

BeanDefinition

Bean对象在Spring实现中是以BeanDefinition来描述的

BeanDefinitionReader

Bean 的解析主要就是对 Spring 配置文件的解析

2.模拟BeanDefinitionRegistry装载过程

//创建一个简单注册器

BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();

//创建bean定义读取器

BeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);

// 创建资源读取器、获取资源

DefaultResourceLoader loader = new DefaultResourceLoader();

Resource resource = loader.getResource("spring.xml");

// 装载Bean的定义

reader.loadBeanDefinitions(resource);

//通过别名获取

registry.getAliases("h1");

//通过id获取

registry.getBeanDefinition("h1");

System.out.println(Arrays.toString(registry.getBeanDefinitionNames()));

3.模拟

代码：

//注册中心

DefaultListableBeanFactory registry = new DefaultListableBeanFactory();

//读取器

XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);

//读取资源

//装载构建bean的定义

reader.loadBeanDefinitions("spring.xml");

registry.getBean("h1");

System.out.println(Arrays.toString(registry.getBeanDefinitionNames()));


分析：

1.DefaultListableBeanFactory既实现了BeanDefinitionRegistry，又实现了BeanFactory。

2.构造函数处打断点，查看调用过程：从下往上看

	at com.test.spring.HelloSpring.<init>(HelloSpring.java:12)

	  at sun.reflect.NativeConstructorAccessorImpl.newInstance0(NativeConstructorAccessorImpl.java:-1)

	  at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)

	  at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)

	  at java.lang.reflect.Constructor.newInstance(Constructor.java:423)

	  BeanUtils.instantiateClass(BeanUtils.java:200)

	  SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:87)

	  AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1312)

	  AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1214)

	  AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:557)

	  AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:517)

	  AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:323)

	  AbstractBeanFactory$$Lambda$5.1846406218.getObject(Unknown Source:-1)

	  DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:222)

	  - locked <0x58a> (a java.util.concurrent.ConcurrentHashMap)

	  AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:321)

			//先从单例缓存中获取。DefaultListableBeanFactory实现了BeanDefinitionRegistry，所以这里调用的是DefaultSingletonBeanRegistry的getSingleton(String beanName)方法

			Object sharedInstance = this.getSingleton(beanName); //DefaultSingletonBeanRegistry.getSingleton(beanName);

				//如果值不为空，进入下面

					bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);//查看是不是FactoryBean创建自定义bean

				//如果为空，进入下面，从parentBeanFactory里去获取，类似于classLoader里的双亲委派？

					 BeanFactory parentBeanFactory = this.getParentBeanFactory();

					 parentBeanFactory.getBean(nameToLookup, args);

					//如果还是为空

						//如果是单例

						if (mbd.isSingleton()){sharedInstance = this.getSingleton(beanName, objectFactory);} //DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory objectFactory)

							//DefaultSingletonBeanRegistry.getSingleton(String beanName, ObjectFactory objectFactory)

							//第一步 加锁

							//判断是否为空，双重检测

							this.beforeSingletonCreation(beanName);//检测这个bean是否正在被创建

							singletonFactory.getObject();//这个地方往回调，实际上调用的是AbstractBeanFactory.doGetBean的189行，这里传过来objectFactory。

								//AbstractBeanFactory.doGetBean的189行

								this.createBean(beanName, mbd, args);//AbstractAutowireCapableBeanFactory.doCreateBean();

							this.afterSingletonCreation(beanName);

							this.addSingleton(beanName, singletonObject);

						//如果是多例

						if (mbd.isPrototype()) {

							this.beforePrototypeCreation(beanName); //写锁

							prototypeInstance = this.createBean(beanName, mbd, args);

							this.afterPrototypeCreation(beanName);//去锁

						}

	  AbstractBeanFactory.getBean(AbstractBeanFactory.java:202)

	  at com.test.spring.BeanFactoryTest.main(BeanFactoryTest.java:23)

Tips:

1.ctrl+alt+u查看类和子类（实现类）的结构图