public PropertiesBeanDefinitionReader(BeanDefinitionRegistry registry) 
{
	                       	 
		super(registry);
}

Create new PropertiesBeanDefinitionReader for the given bean factory.

Parameters:

registry - the BeanFactory to load bean definitions into, in the form of a BeanDefinitionRegistry

 public String getDefaultParentBean() 
{
		return this.defaultParentBean;
}

Return the default parent bean for this bean factory.

 public PropertiesPersister getPropertiesPersister() 
{
		return this.propertiesPersister;
}

Return the PropertiesPersister to use for parsing properties files.

 public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException 
{
		return loadBeanDefinitions(new EncodedResource(resource), null);
}

Load bean definitions from the specified properties file, using all property keys (i.e. not filtering by prefix).

 public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException 
{
		return loadBeanDefinitions(encodedResource, null);
}

Load bean definitions from the specified properties file.

 public int loadBeanDefinitions(Resource resource,
    String prefix) throws BeanDefinitionStoreException 
{
		return loadBeanDefinitions(new EncodedResource(resource), prefix);
}

Load bean definitions from the specified properties file.

 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);
		}
}

Load bean definitions from the specified properties file.

 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 (Iterator it = map.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			String key = StringUtils.trimWhitespace((String) entry.getKey());
			if (key.startsWith(prefix + SEPARATOR)) {
				String property = key.substring(prefix.length() + SEPARATOR.length());
				if (isClassKey(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 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 = ((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.addPropertyValue(property, val);
				}
				else{
					// It's a normal bean property.
					pvs.addPropertyValue(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);
		}
}

Get all property values, given a prefix (which will be stripped) and add the bean they define to the factory with the given name

 public int registerBeanDefinitions(ResourceBundle rb) throws BeanDefinitionStoreException 
{
		return registerBeanDefinitions(rb, null);
}

Register bean definitions contained in a resource bundle, using all property keys (i.e. not filtering by prefix).

 public int registerBeanDefinitions(Map map) throws BeansException 
{
		return registerBeanDefinitions(map, null);
}

Register bean definitions contained in a Map, using all property keys (i.e. not filtering by prefix).

 public int registerBeanDefinitions(ResourceBundle rb,
    String prefix) throws BeanDefinitionStoreException 
{
		// Simply create a map and call overloaded method.
		Map map = new HashMap();
		Enumeration keys = rb.getKeys();
		while (keys.hasMoreElements()) {
			String key = (String) keys.nextElement();
			map.put(key, rb.getObject(key));
		}
		return registerBeanDefinitions(map, prefix);
}

Register bean definitions contained in a ResourceBundle.

Similar syntax as for a Map. This method is useful to enable standard Java internationalization support.

 public int registerBeanDefinitions(Map map,
    String prefix) throws BeansException 
{
		return registerBeanDefinitions(map, prefix, "Map " + map);
}

Register bean definitions contained in a Map. Ignore ineligible properties.

 public int registerBeanDefinitions(Map map,
    String prefix,
    String resourceDescription) throws BeansException 
{
		if (prefix == null) {
			prefix = "";
		}
		int beanCount = 0;
		for (Iterator it = map.keySet().iterator(); it.hasNext();) {
			Object key = it.next();
			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 = -1;
				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.isDebugEnabled()) {
						logger.debug("Found bean name '" + beanName + "'");
					}
					if (!getRegistry().containsBeanDefinition(beanName)) {
						// If we haven't already registered it...
						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;
}

Register bean definitions contained in a Map. Ignore ineligible properties.

 public  void setDefaultParentBean(String defaultParentBean) 
{
		this.defaultParentBean = defaultParentBean;
}

Set the default parent bean for this bean factory. If a child bean definition handled by this factory provides neither a parent nor a class attribute, this default value gets used.

Can be used e.g. for view definition files, to define a parent with a default view class and common attributes for all views. View definitions that define their own parent or carry their own class can still override this.

Strictly speaking, the rule that a default parent setting does not apply to a bean definition that carries a class is there for backwards compatiblity reasons. It still matches the typical use case.

 public  void setPropertiesPersister(PropertiesPersister propertiesPersister) 
{
		this.propertiesPersister =
				(propertiesPersister != null ? propertiesPersister : new DefaultPropertiesPersister());
}

Set the PropertiesPersister to use for parsing properties files. The default is DefaultPropertiesPersister.