Spring（5）-使用properties文件去获取BeanDefinition
本次我们使用properties文件在spring里面去读取Bean，当然这次不用我们手写BeanDefinitionReader，properties的解析器之前就有了
就是PropertiesBeanDefinitionReader，这个大佬就是去解析properties文件，从里面去创建GenericBeanDefinition，注册到spring工厂里面。
先看看这个Reader对properties文件格式的要求：
employee.(class)=MyClass // bean is of class MyClass employee.(abstract)=true // this bean can't be instantiated directly 如果是abstract的bean，不能直接被实例化 employee.group=Insurance // real property 真实属性 employee.usesDialUp=false // real property (potentially overridden) 真实属性（可能被覆盖） * 定义一个非抽象的bean，parent为抽象的employee， department属性为Sales salesrep.(parent)=employee // derives from "employee" bean definition 他的父类是employee salesrep.(lazy-init)=true // lazily initialize this singleton bean 懒加载初始化bean salesrep.manager(ref)=tony // reference to another bean 引用另外一个bean salesrep.department=Sales // real property 真实属性 techie.(parent)=employee // derives from "employee" bean definition techie.(scope)=prototype // bean is a prototype (not a shared instance) 这个bean是scope作用是多例，不共享 techie.manager(ref)=jeff // reference to another bean techie.department=Engineering // real property techie.usesDialUp=true // real property (overriding parent value) ceo.$0(ref)=secretary // inject 'secretary' bean as 0th constructor arg 注入ceo这个构造器的第一个参数 ceo.$1=1000000 // inject value '1000000' at 1st constructor arg 注入ceo这个构造器的第二个参数
看看BeanDefinitionReader这个接口，里面的代码
public interface BeanDefinitionReader { /** * Return the bean factory to register the bean definitions with. * <p>The factory is exposed through the BeanDefinitionRegistry interface, * encapsulating the methods that are relevant for bean definition handling. * * 获取beanDefinition的注册中心， * 为什么需要这个，因为读取到Bean definition后，需要存到这个里面去； * 如果不提供这个，我读了在哪放 */ BeanDefinitionRegistry getRegistry(); /** * @see org.springframework.core.io.support.ResourcePatternResolver * * 获取资源加载器 * 加载xml之类，当然作为一个接口，资源是可以来自于任何地方 */ @Nullable ResourceLoader getResourceLoader(); /** * 获取classloader */ @Nullable ClassLoader getBeanClassLoader(); /** * Return the BeanNameGenerator to use for anonymous beans * (without explicit bean name specified). * 获取bean名称生成器 */ BeanNameGenerator getBeanNameGenerator(); /** * 从指定的资源，加载bean definition * 从资源load bean definition */ int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(String location) throws BeanDefinitionStoreException; /** * 重载 */ int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException; }
看下这个Reader，他就是使用指定的classloader，从指定的resource，读取，去注入对应BeanDefinition，
加载BeanDefinition
看下PropertiesBeanDefinitionReader的构造方法
/** * Create new PropertiesBeanDefinitionReader for the given bean factory. * @param registry the BeanFactory to load bean definitions into, * in the form of a BeanDefinitionRegistry * 调用父类，参数传入了bean definition 注册表调用父类，参数传入了bean definition 注册表 */ public PropertiesBeanDefinitionReader(BeanDefinitionRegistry registry) { super(registry); } protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); this.registry = registry; // Determine ResourceLoader to use. if (this.registry instanceof ResourceLoader) { this.resourceLoader = (ResourceLoader) this.registry; } else { this.resourceLoader = new PathMatchingResourcePatternResolver(); } // Inherit Environment if possible if (this.registry instanceof EnvironmentCapable) { this.environment = ((EnvironmentCapable) this.registry).getEnvironment(); } else { this.environment = new StandardEnvironment(); } }
再看看loadBeanDefinitions是怎么实现的
@Override public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { return loadBeanDefinitions(new EncodedResource(resource), null); } public int loadBeanDefinitions(EncodedResource encodedResource, @Nullable String prefix) throws BeanDefinitionStoreException { if (logger.isTraceEnabled()) { logger.trace("Loading properties bean definitions from " + encodedResource); } //读取properties文件内容到props变量 Properties props = new Properties(); try { try (InputStream is = encodedResource.getResource().getInputStream()) { if (encodedResource.getEncoding() != null) { getPropertiesPersister().load(props, new InputStreamReader(is, encodedResource.getEncoding())); } else { getPropertiesPersister().load(props, is); } } //注册bean definition int count = registerBeanDefinitions(props, prefix, encodedResource.getResource().getDescription()); if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " bean definitions from " + encodedResource); } return count; } catch (IOException ex) { throw new BeanDefinitionStoreException("Could not parse properties from " + encodedResource.getResource(), ex); } }
再看看registerBeanDefinitions()这个方法
public int registerBeanDefinitions(Map<?, ?> map, @Nullable String prefix, String resourceDescription) throws BeansException { if (prefix == null) { prefix = ""; } int beanCount = 0; for (Object key : map.keySet()) { if (!(key instanceof String)) { throw new IllegalArgumentException("Illegal key [" + key + "]: only Strings allowed"); } String keyString = (String) key; if (keyString.startsWith(prefix)) { // Key is of form: prefix<name>.property String nameAndProperty = keyString.substring(prefix.length()); // Find dot before property name, ignoring dots in property keys. int sepIdx ; int propKeyIdx = nameAndProperty.indexOf(PropertyAccessor.PROPERTY_KEY_PREFIX); if (propKeyIdx != -1) { sepIdx = nameAndProperty.lastIndexOf(SEPARATOR, propKeyIdx); } else { //用 . 做分割 sepIdx = nameAndProperty.lastIndexOf(SEPARATOR); } if (sepIdx != -1) { String beanName = nameAndProperty.substring(0, sepIdx); if (logger.isTraceEnabled()) { logger.trace("Found bean name '" + beanName + "'"); } if (!getRegistry().containsBeanDefinition(beanName)) { // If we haven't already registered it... // 如果之前没注册这个bean，则注册之，这里的prefix：prefix+beanName // ，其实就是从properties文件中筛选出beanName一致的key-value registerBeanDefinition(beanName, map, prefix + beanName, resourceDescription); ++beanCount; } } else { // Ignore it: It wasn't a valid bean name and property, // although it did start with the required prefix. if (logger.isDebugEnabled()) { logger.debug("Invalid bean name and property [" + nameAndProperty + "]"); } } } } return beanCount; }
再看看registerBeanDefinition()方法
这里面就是去校验properties文件里面那些 . () 包起来的值
主要是去遍历map，把property的key用.分割，前面的就是beanName，用beanName作为前缀
protected void registerBeanDefinition(String beanName, Map<?, ?> map, String prefix, String resourceDescription) throws BeansException { String className = null; String parent = null; String scope = BeanDefinition.SCOPE_SINGLETON; boolean isAbstract = false; boolean lazyInit = false; ConstructorArgumentValues cas = new ConstructorArgumentValues(); MutablePropertyValues pvs = new MutablePropertyValues(); String prefixWithSep = prefix + SEPARATOR; int beginIndex = prefixWithSep.length(); for (Map.Entry<?, ?> entry : map.entrySet()) { String key = StringUtils.trimWhitespace((String) entry.getKey()); if (key.startsWith(prefixWithSep)) { String property = key.substring(beginIndex); //核心属性，bean的ClassName if (CLASS_KEY.equals(property)) { className = StringUtils.trimWhitespace((String) entry.getValue()); } //parent属性 else if (PARENT_KEY.equals(property)) { parent = StringUtils.trimWhitespace((String) entry.getValue()); } //是否抽象bean definition else if (ABSTRACT_KEY.equals(property)) { String val = StringUtils.trimWhitespace((String) entry.getValue()); isAbstract = TRUE_VALUE.equals(val); } //scope else if (SCOPE_KEY.equals(property)) { // Spring 2.0 style scope = StringUtils.trimWhitespace((String) entry.getValue()); } else if (SINGLETON_KEY.equals(property)) { // Spring 1.2 style String val = StringUtils.trimWhitespace((String) entry.getValue()); scope = ("".equals(val) || TRUE_VALUE.equals(val) ? BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE); } else if (LAZY_INIT_KEY.equals(property)) { String val = StringUtils.trimWhitespace((String) entry.getValue()); lazyInit = TRUE_VALUE.equals(val); } ................
try {
//构造一个bean definition
AbstractBeanDefinition bd = BeanDefinitionReaderUtils.createBeanDefinition(
parent, className, getBeanClassLoader());
bd.setScope(scope);
bd.setAbstract(isAbstract);
bd.setLazyInit(lazyInit);
//下面这两行，进行构造器注入和属性注入
bd.setConstructorArgumentValues(cas);
bd.setPropertyValues(pvs);
//注册
getRegistry().registerBeanDefinition(beanName, bd);
}
catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(resourceDescription, beanName, className, ex);
}
catch (LinkageError err) {
throw new CannotLoadBeanClassException(resourceDescription, beanName, className, err);
}
--看看createBeanDefinition这个方法，就是返回GenericBeanDefinition这个BeanDefinition的实现类
public static AbstractBeanDefinition createBeanDefinition(
@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
//parentName可能为空
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
//如果classLoader不为空，则使用以传入的classLoader
//同一虚拟机加载类对象，否则只是记录className
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
看下ProeprtiesBeanDefinitionReader里面定义的常量值
/** * Value of a T/F attribute that represents true. * Anything else represents false. Case seNsItive. */ public static final String TRUE_VALUE = "true"; /** * Separator between bean name and property name. * We follow normal Java conventions. */ public static final String SEPARATOR = "."; /** * Special key to distinguish {@code owner.(class)=com.myapp.MyClass}. */ public static final String CLASS_KEY = "(class)"; /** * Special key to distinguish {@code owner.(parent)=parentBeanName}. */ public static final String PARENT_KEY = "(parent)"; /** * Special key to distinguish {@code owner.(scope)=prototype}. * Default is "true". */ public static final String SCOPE_KEY = "(scope)"; /** * Special key to distinguish {@code owner.(singleton)=false}. * Default is "true". */ public static final String SINGLETON_KEY = "(singleton)"; /** * Special key to distinguish {@code owner.(abstract)=true} * Default is "false". */ public static final String ABSTRACT_KEY = "(abstract)"; /** * Special key to distinguish {@code owner.(lazy-init)=true} * Default is "false". */ public static final String LAZY_INIT_KEY = "(lazy-init)"; /** * Property suffix for references to other beans in the current * BeanFactory: e.g. {@code owner.dog(ref)=fido}. * Whether this is a reference to a singleton or a prototype * will depend on the definition of the target bean. */ public static final String REF_SUFFIX = "(ref)"; /** * Prefix before values referencing other beans. */ public static final String REF_PREFIX = "*"; /** * Prefix used to denote a constructor argument definition. */ public static final String CONSTRUCTOR_ARG_PREFIX = "$";
然后直接去，构造一个context继承AbstractRefreshableConfigApplicationContext，里面的loadBeanDefinitions这个方法，就行了，
public class PropertyContext extends AbstractRefreshableConfigApplicationContext { public PropertyContext() { } @Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { PropertiesBeanDefinitionReader beanDefinitionReader = new PropertiesBeanDefinitionReader(beanFactory); beanDefinitionReader.setEnvironment(this.getEnvironment()); beanDefinitionReader.setResourceLoader(this); String[] configResources = getConfigLocations(); beanDefinitionReader.loadBeanDefinitions(configResources); } public PropertyContext(ApplicationContext parent) { super(parent); } public PropertyContext(String configuration) { this(new String[]{configuration},true,null); } public PropertyContext(String[] configurations,Boolean refresh,@Nullable ApplicationContext parent) { super(parent); setConfigLocations(configurations); if (refresh){ refresh(); } } }
看看运行结果
但是呢，我刚才产生新的问题了，就是new PropertyContext的过程里，是在哪里去调用了loadBeanDefinitons这个方法啊，debug没找到，
这个疑问先放着，留着下次找到再来补下把
刚才百度，翻别人博客找到了，哈哈 https://blog.csdn.net/qq_41377914/article/details/107843774
1、第一步初始化用户使用的上下文类
{ public static void main( String[] args ) { PropertyContext propertyContext = new PropertyContext("beanDefinition.properties"); Map<String, Employee> result = propertyContext.getBeansOfType(Employee.class); System.out.println(result.size()); } }
2、在new的时候，会refresh一下，会调用抽象父类AbstractApplicationContext
public PropertyContext(String[] configurations,Boolean refresh,@Nullable ApplicationContext parent) { super(parent); setConfigLocations(configurations); if (refresh){ refresh(); } }
3、在refresh的抽象父类模板里，在创建beanFactory的时候，这个方法obtainFreshBeanFactory，方法里面去执行了loadBeanDefinitions方法
public void refresh() throws BeansException, IllegalStateException { synchronized(this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); this.prepareRefresh();
//就是这里 ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); this.prepareBeanFactory(beanFactory); try { this.postProcessBeanFactory(beanFactory); StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); this.invokeBeanFactoryPostProcessors(beanFactory); this.registerBeanPostProcessors(beanFactory); beanPostProcess.end(); this.initMessageSource(); this.initApplicationEventMulticaster(); this.onRefresh(); this.registerListeners(); this.finishBeanFactoryInitialization(beanFactory); this.finishRefresh(); } catch (BeansException var10) { if (this.logger.isWarnEnabled()) { this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10); } this.destroyBeans(); this.cancelRefresh(var10); throw var10; } finally { this.resetCommonCaches(); contextRefresh.end(); } } }
继续看这个创建DefaultListableBeanFactory里面的方法
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { this.refreshBeanFactory(); return this.getBeanFactory(); } protected final void refreshBeanFactory() throws BeansException { if (this.hasBeanFactory()) { this.destroyBeans(); this.closeBeanFactory(); } try { DefaultListableBeanFactory beanFactory = this.createBeanFactory(); beanFactory.setSerializationId(this.getId()); this.customizeBeanFactory(beanFactory); this.loadBeanDefinitions(beanFactory); this.beanFactory = beanFactory; } catch (IOException var2) { throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2); } }
在refreshBeanFactory的过程中，执行了子类实现的loadBeanDefinitions方法。
原大佬博客地址：https://www.cnblogs.com/grey-wolf/p/12093929.html
