employee.(class)=MyClass       // bean is of class MyClassemployee.(abstract)=true       // this bean can't be instantiated directlyemployee.group=Insurance       // real propertyemployee.usesDialUp=false      // real property (potentially overridden)
salesrep.(parent)=employee     // derives from "employee" bean definitionsalesrep.(lazy-init)=true      // lazily initialize this singleton beansalesrep.manager(ref)=tony     // reference to another beansalesrep.department=Sales      // real property
techie.(parent)=employee       // derives from "employee" bean definitiontechie.(scope)=prototype       // bean is a prototype (not a shared instance)techie.manager(ref)=jeff       // reference to another beantechie.department=Engineering  // real propertytechie.usesDialUp=true         // real property (overriding parent value)
ceo.$0(ref)=secretary          // inject 'secretary' bean as 0th constructor argceo.$1=1000000                 // inject value '1000000' at 1st constructor arg

public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader {
}public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader {
}

        // Inherit Environment if possibleif (this.registry instanceof EnvironmentCapable) {this.environment = ((EnvironmentCapable) this.registry).getEnvironment();}else {this.environment = new StandardEnvironment();}

        // Determine ResourceLoader to use.if (this.registry instanceof ResourceLoader) {this.resourceLoader = (ResourceLoader) this.registry;}else {this.resourceLoader = new PathMatchingResourcePatternResolver();}

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader == null) {throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");}if (resourceLoader instanceof ResourcePatternResolver) {// Resource pattern matching available.try {Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);int loadCount = loadBeanDefinitions(resources);if (actualResources != null) {for (Resource resource : resources) {actualResources.add(resource);}}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");}return loadCount;}catch (IOException ex) {throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", ex);}}else {// Can only load single resources by absolute URL.Resource resource = resourceLoader.getResource(location);int loadCount = loadBeanDefinitions(resource);if (actualResources != null) {actualResources.add(resource);}if (logger.isDebugEnabled()) {logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");}return loadCount;}}

public int loadBeanDefinitions(EncodedResource encodedResource, String prefix)throws BeanDefinitionStoreException {Properties props = new Properties();try {InputStream is = encodedResource.getResource().getInputStream();try {if (encodedResource.getEncoding() != null) {getPropertiesPersister().load(props, new InputStreamReader(is, encodedResource.getEncoding()));}else {getPropertiesPersister().load(props, is);}}finally {is.close();}return registerBeanDefinitions(props, prefix, encodedResource.getResource().getDescription());}catch (IOException ex) {throw new BeanDefinitionStoreException("Could not parse properties from " + encodedResource.getResource(), ex);}}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");if (logger.isInfoEnabled()) {logger.info("Loading XML bean definitions from " + encodedResource.getResource());}Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (currentResources == null) {currentResources = new HashSet<EncodedResource>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {InputStream inputStream = encodedResource.getResource().getInputStream();try {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}return doLoadBeanDefinitions(inputSource, encodedResource.getResource());}finally {inputStream.close();}}catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);}finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}}

protected void registerBeanDefinition(String beanName, Map<?, ?> map, String prefix, String resourceDescription)throws BeansException {String className = null;String parent = null;String scope = GenericBeanDefinition.SCOPE_SINGLETON;boolean isAbstract = false;boolean lazyInit = false;ConstructorArgumentValues cas = new ConstructorArgumentValues();MutablePropertyValues pvs = new MutablePropertyValues();for (Map.Entry<?, ?> entry : map.entrySet()) {String key = StringUtils.trimWhitespace((String) entry.getKey());if (key.startsWith(prefix + SEPARATOR)) {String property = key.substring(prefix.length() + SEPARATOR.length());if (CLASS_KEY.equals(property)) {className = StringUtils.trimWhitespace((String) entry.getValue());}else if (PARENT_KEY.equals(property)) {parent = StringUtils.trimWhitespace((String) entry.getValue());}else if (ABSTRACT_KEY.equals(property)) {String val = StringUtils.trimWhitespace((String) entry.getValue());isAbstract = TRUE_VALUE.equals(val);}else if (SCOPE_KEY.equals(property)) {// Spring 2.0 stylescope = StringUtils.trimWhitespace((String) entry.getValue());}else if (SINGLETON_KEY.equals(property)) {// Spring 1.2 styleString val = StringUtils.trimWhitespace((String) entry.getValue());scope = ((val == null || TRUE_VALUE.equals(val) ? GenericBeanDefinition.SCOPE_SINGLETON :GenericBeanDefinition.SCOPE_PROTOTYPE));}else if (LAZY_INIT_KEY.equals(property)) {String val = StringUtils.trimWhitespace((String) entry.getValue());lazyInit = TRUE_VALUE.equals(val);}else if (property.startsWith(CONSTRUCTOR_ARG_PREFIX)) {if (property.endsWith(REF_SUFFIX)) {int index = Integer.parseInt(property.substring(1, property.length() - REF_SUFFIX.length()));cas.addIndexedArgumentValue(index, new RuntimeBeanReference(entry.getValue().toString()));}else {int index = Integer.parseInt(property.substring(1));cas.addIndexedArgumentValue(index, readValue(entry));}}else if (property.endsWith(REF_SUFFIX)) {// This isn't a real property, but a reference to another prototype// Extract property name: property is of form dog(ref)property = property.substring(0, property.length() - REF_SUFFIX.length());String ref = StringUtils.trimWhitespace((String) entry.getValue());// It doesn't matter if the referenced bean hasn't yet been registered:// this will ensure that the reference is resolved at runtime.Object val = new RuntimeBeanReference(ref);pvs.add(property, val);}else {// It's a normal bean property.
                    pvs.add(property, readValue(entry));}}}if (logger.isDebugEnabled()) {logger.debug("Registering bean definition for bean name '" + beanName + "' with " + pvs);}// Just use default parent if we're not dealing with the parent itself,// and if there's no class name specified. The latter has to happen for// backwards compatibility reasons.if (parent == null && className == null && !beanName.equals(this.defaultParentBean)) {parent = this.defaultParentBean;}try {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);}}

/*** Register each bean definition within the given root {@code <beans/>} element.*/protected void doRegisterBeanDefinitions(Element root) {String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);if (StringUtils.hasText(profileSpec)) {String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);if (!getEnvironment().acceptsProfiles(specifiedProfiles)) {return;}}// Any nested <beans> elements will cause recursion in this method. In// order to propagate and preserve <beans> default-* attributes correctly,// keep track of the current (parent) delegate, which may be null. Create// the new (child) delegate with a reference to the parent for fallback purposes,// then ultimately reset this.delegate back to its original (parent) reference.// this behavior emulates a stack of delegates without actually necessitating one.BeanDefinitionParserDelegate parent = this.delegate;this.delegate = createDelegate(this.readerContext, root, parent);preProcessXml(root);parseBeanDefinitions(root, this.delegate);postProcessXml(root);this.delegate = parent;}