spring源碼核心:DefaultListableBeanFactory
核心建立方式
Class<?> ob = Class.forName("com.fxl.spring.test.SayServiceImpl");
//ob.getDeclaredConstructor(); 檢測構造器是不是公有
SayService say = (SayService) ob.newInstance();
say.getMessage();
結構圖
接口：
- AliasRegistry：註冊別名和具體的名稱接口
- SingletonBeanRegistry：註冊bean的接口
- BeanFactory：bean的實際調用接口
- HierarchicalBeanFactory：beanfactory的強化接口
- ConfigurableBeanFactory：beanfactory的調用接口
- AutowireCapableBeanFactory：beanfactory的強化接口
- ListableBeanFactory：beanfactory的強化接口，批量處理bean
- BeanDefinitionRegistry：bean的調用接口，包括接口別名
- ConfigurableListableBeanFactory：除了可配置beanfactory以外，它還提供了用於分析和修改bean定義的工具，以及預實例化單例
實現類
- SimpleAliasRegistry：存放別名和實際
public class SimpleAliasRegistry implements AliasRegistry {
/** Map from alias to canonical name */
private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
}
- DefaultSingletonBeanRegistry：存放具體的bean
- singletonObjects： 存放bean的名稱及實例
- singletonFactories： 存放bean的名稱及實例建立工廠
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/**
* Internal marker for a null singleton object:
* used as marker value for concurrent Maps (which don't support null values).
*/
protected static final Object NULL_OBJECT = new Object();
/** Logger available to subclasses */
protected final Log logger = LogFactory.getLog(getClass());
/** Cache of singleton objects: bean name --> bean instance */
// bean的名稱和實例
private final Map<String, Object> 'singletonObjects' = new ConcurrentHashMap<String, Object>(64);
/** Cache of singleton factories: bean name --> ObjectFactory */
// bean名稱和產生的工廠
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
/** Cache of early singleton objects: bean name --> bean instance */
// 早期存放bean的名稱和實例
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
/** Set of registered singletons, containing the bean names in registration order */
// bean的名稱
private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);
/** Names of beans that are currently in creation */
// 建立的類
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
/** Names of beans currently excluded from in creation checks */
// 當前建立時須要排除的名稱
private final Set<String> inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
/** List of suppressed Exceptions, available for associating related causes */
// 拋出的錯誤
private Set<Exception> suppressedExceptions;
/** Flag that indicates whether we're currently within destroySingletons */
// 銷燬時的狀態
private boolean singletonsCurrentlyInDestruction = false;
/** Disposable bean instances: bean name --> disposable instance */
// bean名稱
private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();
/** Map between containing bean names: bean name --> Set of bean names that the bean contains */
// 名稱
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);
/** Map between dependent bean names: bean name --> Set of dependent bean names */
// 依賴的名稱
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
// 依賴的名稱
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
}
- FactoryBeanRegistrySupport：bean緩存
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
/** Cache of singleton objects created by FactoryBeans: FactoryBean name --> object */
// 由FactoryBean建立的單例對象的緩存:FactoryBean名稱—對象
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
}
- AbstractBeanFactory：
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
/** Parent bean factory, for bean inheritance support */
// 父類 bean factory
private BeanFactory parentBeanFactory;
/** ClassLoader to resolve bean class names with, if necessary */
// 類加載器
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
/** ClassLoader to temporarily resolve bean class names with, if necessary */
// 類加載器在必要時臨時解析bean類名
private ClassLoader tempClassLoader;
/** Whether to cache bean metadata or rather reobtain it for every access */
// 是否緩存bean元數據，或者是否爲每一個訪問從新獲取它
private boolean cacheBeanMetadata = true;
/** Resolution strategy for expressions in bean definition values */
// bean定義值的表達式的解析策略
private BeanExpressionResolver beanExpressionResolver;
/** Spring ConversionService to use instead of PropertyEditors */
// 使用Spring ConversionService來代替屬性編輯器
private ConversionService conversionService;
/** Custom PropertyEditorRegistrars to apply to the beans of this factory */
// 自定義propertyeditorregistry應用到該工廠的bean
private final Set<PropertyEditorRegistrar> propertyEditorRegistrars =
new LinkedHashSet<PropertyEditorRegistrar>(4);
/** A custom TypeConverter to use, overriding the default PropertyEditor mechanism */
// 用於使用的自定義類型轉換，覆蓋默認的PropertyEditor機制
private TypeConverter typeConverter;
/** Custom PropertyEditors to apply to the beans of this factory */
// 自定義屬性編輯器應用到該工廠的bean
private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors =
new HashMap<Class<?>, Class<? extends PropertyEditor>>(4);
/** String resolvers to apply e.g. to annotation attribute values */
// 將字符串解析器應用於註釋屬性值
private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<StringValueResolver>();
/** BeanPostProcessors to apply in createBean */
// 用於在createBean中應用的beanpost處理器
private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();
/** Indicates whether any InstantiationAwareBeanPostProcessors have been registered */
// 代表InstantiationAwareBeanPostProcessors是否已經註冊
private boolean hasInstantiationAwareBeanPostProcessors;
/** Indicates whether any DestructionAwareBeanPostProcessors have been registered */
// 代表DestructionAwareBeanPostProcessors是否已經註冊
private boolean hasDestructionAwareBeanPostProcessors;
/** Map from scope identifier String to corresponding Scope */
// 從範圍標識符字符串映射到對應的範圍
private final Map<String, Scope> scopes = new HashMap<String, Scope>(8);
/** Security context used when running with a SecurityManager */
// 與安全管理器一塊兒運行時使用的安全上下文
private SecurityContextProvider securityContextProvider;
/** Map from bean name to merged RootBeanDefinition */
// 從bean名稱映射到合併的RootBeanDefinition
private final Map<String, RootBeanDefinition> mergedBeanDefinitions =
new ConcurrentHashMap<String, RootBeanDefinition>(64);
/** Names of beans that have already been created at least once */
// 已經至少建立過一次的bean的名稱
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(64));
/** Names of beans that are currently in creation */
// 當前正在建立的bean的名稱
private final ThreadLocal<Object> prototypesCurrentlyInCreation =
new NamedThreadLocal<Object>("Prototype beans currently in creation");
}
- AbstractAutowireCapableBeanFactory：抽象bean工廠超類，實現了默認bean的建立，具備由RootBeanDefinition類指定的所有功能
- 提供bean建立(使用構造函數解析)、屬性填充、鏈接(包括自動鏈接)和初始化。處理運行時bean引用、解析託管集合、調用初始化方法等。支持自動裝配構造函數、屬性名和屬性
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/** Strategy for creating bean instances */
// 建立bean實例的策略
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
/** Resolver strategy for method parameter names */
// 方法參數名的解析器策略
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
/** Whether to automatically try to resolve circular references between beans */
// 是否自動嘗試解析bean之間的循環引用
private boolean allowCircularReferences = true;
/**
* Whether to resort to injecting a raw bean instance in case of circular reference, even if the injected bean eventually got wrapped.
*/
// 是否在循環引用的狀況下使用原始bean實例，即便注入的bean最終被包裝了
private boolean allowRawInjectionDespiteWrapping = false;
/**
* Dependency types to ignore on dependency check and autowire, as Set of Class objects: for example, String. Default is none.
*/
// 依賴類型忽略依賴檢查和自動鏈接，這是類對象的集合:例如，String。默認是沒有的。
private final Set<Class<?>> ignoredDependencyTypes = new HashSet<Class<?>>();
/**
* Dependency interfaces to ignore on dependency check and autowire, as Set of Class objects. By default, only the BeanFactory interface is ignored.
*/
// 依賴接口忽略依賴檢查和自動鏈接，這是類對象的集合。默認狀況下，只會忽略BeanFactory接口。
private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<Class<?>>();
/** Cache of unfinished FactoryBean instances: FactoryBean name --> BeanWrapper */
// 未完成的FactoryBean實例的緩存:FactoryBean的名稱—bean包裝器
private final Map<String, BeanWrapper> factoryBeanInstanceCache =
new ConcurrentHashMap<String, BeanWrapper>(16);
/** Cache of filtered PropertyDescriptors: bean Class -> PropertyDescriptor array */
// 過濾的屬性描述符的緩存:bean類-屬性描述符數組
private final Map<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
new ConcurrentHashMap<Class<?>, PropertyDescriptor[]>(64);
}
- DefaultListableBeanFactory：在訪問bean以前，典型的用法是先註冊全部的bean定義(多是從bean定義文件中讀取)。所以，Bean定義查找在本地Bean定義表中是一種廉價的操做，在預先構建的Bean定義元數據對象上運行。
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
private static Class<?> javaxInjectProviderClass = null;
/** Map from serialized id to factory instance */
// 序列化的工程id
private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);
/** Optional id for this factory, for serialization purposes */
//這個工廠的可選id，用於序列化
private String serializationId;
/** Whether to allow re-registration of a different definition with the same name */
// 是否容許用相同的名稱從新註冊一個不一樣的定義
private boolean allowBeanDefinitionOverriding = true;
/** Whether to allow eager class loading even for lazy-init beans */
// 是否容許熱加載即便是 懶加載設置
private boolean allowEagerClassLoading = true;
/** Optional OrderComparator for dependency Lists and arrays */
// 用於依賴列表和數組的可選的OrderComparator
private Comparator<Object> dependencyComparator;
/** Resolver to use for checking if a bean definition is an autowire candidate */
// 解析器用於檢查bean定義是否爲自動鏈接的候選
private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
/** Map from dependency type to corresponding autowired value */
// 從依賴類型映射到對應的自動鏈接值
private final Map<Class<?>, Object> resolvableDependencies = new HashMap<Class<?>, Object>(16);
/** Map of bean definition objects, keyed by bean name */
// bean定義對象的映射，以bean名稱爲鍵
private final Map<String, BeanDefinition> 'beanDefinitionMap' = new ConcurrentHashMap<String, BeanDefinition>(64);
/** Map of singleton and non-singleton bean names keyed by dependency type */
// 單例和非單例bean的映射，依賴於依賴類型
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
/** Map of singleton-only bean names keyed by dependency type */
// 依賴類型的名稱
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);
/** List of bean definition names, in registration order */
// 默認的名稱列表
private final List<String> beanDefinitionNames = new ArrayList<String>();
/** Whether bean definition metadata may be cached for all beans */
// 是否爲全部bean緩存bean定義元數據
private boolean configurationFrozen = false;
/** Cached array of bean definition names in case of frozen configuration */
// 在凍結配置的狀況下，緩存的bean定義名稱
private String[] frozenBeanDefinitionNames;
}
beanfactory：bean的建立工廠
- 流程：
- 從AbstractApplicationContext->refresh()->finishBeanFactoryInitialization()：實例化bean的時候，會調用beanFactory.preInstantiateSingletons()
- 接着在 DefaultListableBeanFactory->preInstantiateSingletons() 實例化bean的時候，調用AbstractBeanFactory->getBean()
- 接着在AbstractBeanFactory->doGetBean()中使用getSingleton()回調一個beanfactory
- 最後調用 SimpleInstantiationStrategy->instantiate()的來實例化bean
1. DefaultListableBeanFactory->preInstantiateSingletons()：
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames;
synchronized (this.beanDefinitionMap) {
beanNames = new ArrayList<String>(this.beanDefinitionNames);
}
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
getBean(beanName);
}
}
}
2. AbstractBeanFactory->getBean(String beanName);
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
3.AbstractBeanFactory->doGetBean(String beanName);一個回調用來生成 bean
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
...
...
'getSingleton回調一個ObjectFactory'
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}catch (BeansException ex) {
destroySingleton(beanName);
}
}
});
...
...
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
return (T) bean;
}
4. DefaultSingletonBeanRegistry.class->getSingleton：調用singletonFactory的回調來實現bean的建立
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject null) {
...
...
try {
singletonObject = singletonFactory.getObject();
}
...
...
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
5. SimpleInstantiationStrategy->instantiate()
BeanDefinition: spring的bean默認映射對象
- 建立流程：
- 從AbstractApplicationContext->refresh()：刷新context的信息。
- obtainFreshBeanFactory()：建立beanfactory，並將xml裏面的bean解析成BeanDefinition,存放到beanDefinitionMap中。
- 先從XmlReaderContext中讀取配置，而後在根據配置BeanDefinitionDocumentReader 將BeanDefinition加載進去
- 分析bean
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate); //加載bean
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
- BeanDefinitionReaderUtils工具類中的createBeanDefinition建立bean
public static AbstractBeanDefinition createBeanDefinition(
String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
- BeanDefinition的建立組成：
1. '屬性'
public abstract class AttributeAccessorSupport implements AttributeAccessor, Serializable {
/** Map with String keys and Object values */
private final Map<String, Object> attributes = new LinkedHashMap<String, Object>(0);
}
2. '資源'
public class BeanMetadataAttributeAccessor extends AttributeAccessorSupport implements BeanMetadataElement {
private Object source;
}
3. '對象信息'
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
public static final String SCOPE_DEFAULT = "";
public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;
public static final int DEPENDENCY_CHECK_NONE = 0;
public static final int DEPENDENCY_CHECK_OBJECTS = 1;
public static final int DEPENDENCY_CHECK_SIMPLE = 2;
public static final int DEPENDENCY_CHECK_ALL = 3;
public static final String INFER_METHOD = "(inferred)";
private volatile Object beanClass;
private String scope = SCOPE_DEFAULT;
private boolean abstractFlag = false;
private boolean lazyInit = false;
private int autowireMode = AUTOWIRE_NO;
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
private String[] dependsOn;
private boolean autowireCandidate = true;
private boolean primary = false;
private final Map<String, AutowireCandidateQualifier> qualifiers =
new LinkedHashMap<String, AutowireCandidateQualifier>(0);
private boolean nonPublicAccessAllowed = true;
private boolean lenientConstructorResolution = true;
private ConstructorArgumentValues constructorArgumentValues;
private MutablePropertyValues propertyValues;
private MethodOverrides methodOverrides = new MethodOverrides();
private String factoryBeanName;
private String factoryMethodName;
private String initMethodName;
private String destroyMethodName;
private boolean enforceInitMethod = true;
private boolean enforceDestroyMethod = true;
private boolean synthetic = false;
private int role = BeanDefinition.ROLE_APPLICATION;
private String description;
private Resource resource;
}
4. 建立:bean建立的信息
public class GenericBeanDefinition extends AbstractBeanDefinition {
private String parentName;
}
- BeanDefinition的使用
- 經過SimpleInstantiationStrategy的instantiate，來建立bean對象。
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
if (beanDefinition.getMethodOverrides().isEmpty()) {
Constructor<?> constructorToUse;
synchronized (beanDefinition.constructorArgumentLock) {
constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
if (constructorToUse null) {
final Class<?> clazz = beanDefinition.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
@Override
public Constructor<?> run() throws Exception {
return clazz.getDeclaredConstructor((Class[]) null);
}
});
}
else {
'獲取構造器'
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
}
beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Exception ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
'實例化對象'
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
return instantiateWithMethodInjection(beanDefinition, beanName, owner);
}
}
2. 'BeanUtils.instantiateClass(constructorToUse)'：用構造器實例化
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(args);
}
....
}
相關文章
- 1. spring核心類之DefaultListableBeanFactory
- 2. Spring5源碼深度解析（二）——Spring中的核心類之DefaultListableBeanFactory
- 3. spring源碼解析之（DefaultListableBeanFactory）
- 4. Spring核心源碼：ApplicationContext
- 5. DefaultListableBeanFactory 源碼 分析
- 6. Spring 5.0源碼解讀：Bean容器DefaultListableBeanFactory
- 7. 一、spring 源碼第一篇DefaultListableBeanFactory
- 8. spring學習之源碼分析--DefaultListableBeanFactory
- 9. Spring源碼解析 - springMVC核心代碼
- 10. Spring的DefaultListableBeanFactory
- 更多相關文章...
- • Hibernate的核心接口 - Hibernate教程
- • MyBatis的核心組件 - MyBatis教程
- • Java Agent入門實戰（二）-Instrumentation源碼概述
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. spring核心類之DefaultListableBeanFactory
- 2. Spring5源碼深度解析（二）——Spring中的核心類之DefaultListableBeanFactory
- 3. spring源碼解析之（DefaultListableBeanFactory）
- 4. Spring核心源碼：ApplicationContext
- 5. DefaultListableBeanFactory 源碼 分析
- 6. Spring 5.0源碼解讀：Bean容器DefaultListableBeanFactory
- 7. 一、spring 源碼第一篇DefaultListableBeanFactory
- 8. spring學習之源碼分析--DefaultListableBeanFactory
- 9. Spring源碼解析 - springMVC核心代碼
- 10. Spring的DefaultListableBeanFactory