创建bean:
1.默认构造函数
spring.xml <bean class="com.test.spring.HelloSpring"></bean>
HelloSpring.java HelloSpring() {}
2.指定构造函数
<bean class="com.test.spring.HelloSpring">
<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
<bean class="com.test.spring.HelloSpring" factory-method="build">
<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 id="driver" class="com.test.spring.FactoryBeanSpring">
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306"></property>
</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 class="com.test.spring.HelloSpring" >
<property name="worldSpring" ref="world" />
</bean>
<bean id="world" class="com.test.spring.WorldSpring" ></bean>
2.构造方法注入
<bean class="com.test.spring.HelloSpring" >
<constructor-arg name="worldSpring">
<bean class="com.test.spring.WorldSpring" />
</constructor-arg>
</bean>
3.自动注入：byName、byType。默认是byName
<bean class="com.test.spring.HelloSpring" autowire="byName" />
<bean id="worldSpring" class="com.test.spring.WorldSpring" />
4.方法注入: lookup-method。场景：一个单例bean依赖一个多例bean.该操作基于动态代理技术。也可以通过实现BeanFactoryAware接口来获取BeanFactory实例，从而直接调用getBean()方法获取新实例.
<bean class="com.test.spring.LookupMethodSpring" >
<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查看类和子类（实现类）的结构图