Spring Framework example source code file (GenericBeanFactoryAccessor.java)

This example Spring Framework source code file (GenericBeanFactoryAccessor.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Spring Framework tags/keywords

annotation, annotation, beansexception, beansexception, class, genericbeanfactoryaccessor, hashmap, listablebeanfactory, map, map, object, object, string, t, t, util

The Spring Framework GenericBeanFactoryAccessor.java source code

/*
 * Copyright 2002-2008 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.beans.factory.generic;

import java.lang.annotation.Annotation;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.util.Assert;

/**
 * Simple wrapper around a {@link ListableBeanFactory} that provides typed, generics-based
 * access to key methods. This removes the need for casting in many cases and should
 * increase compile-time type safety.
 *
 * <p>Provides a simple mechanism for accessing all beans with a particular {@link Annotation}.
 *
 * @author Rob Harrop
 * @author Juergen Hoeller
 * @since 2.0
 */
public class GenericBeanFactoryAccessor {

	/**
	 * The {@link ListableBeanFactory} being wrapped.
	 */
	private final ListableBeanFactory beanFactory;


	/**
	 * Constructs a <code>GenericBeanFactoryAccessor that wraps the supplied {@link ListableBeanFactory}.
	 */
	public GenericBeanFactoryAccessor(ListableBeanFactory beanFactory) {
		Assert.notNull(beanFactory, "Bean factory must not be null");
		this.beanFactory = beanFactory;
	}

	/**
	 * Return the wrapped {@link ListableBeanFactory}.
	 */
	public final ListableBeanFactory getBeanFactory() {
		return this.beanFactory;
	}


	/**
	 * @see org.springframework.beans.factory.BeanFactory#getBean(String)
	 */
	public <T> T getBean(String name) throws BeansException {
		return (T) getBeanFactory().getBean(name);
	}

	/**
	 * @see org.springframework.beans.factory.BeanFactory#getBean(String, Class)
	 */
	public <T> T getBean(String name, Class requiredType) throws BeansException {
		return (T) getBeanFactory().getBean(name, requiredType);
	}

	/**
	 * @see ListableBeanFactory#getBeansOfType(Class)
	 */
	public <T> Map getBeansOfType(Class type) throws BeansException {
		return getBeanFactory().getBeansOfType(type);
	}

	/**
	 * @see ListableBeanFactory#getBeansOfType(Class, boolean, boolean)
	 */
	public <T> Map getBeansOfType(Class type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException {

		return getBeanFactory().getBeansOfType(type, includeNonSingletons, allowEagerInit);
	}

	/**
	 * Find all beans whose <code>Class has the supplied {@link Annotation} type.
	 * @param annotationType the type of annotation to look for
	 * @return a Map with the matching beans, containing the bean names as
	 * keys and the corresponding bean instances as values
	 */
	public Map<String, Object> getBeansWithAnnotation(Class annotationType) {
		Map<String, Object> results = new HashMap();
		for (String beanName : getBeanFactory().getBeanNamesForType(null)) {
			Class beanType = getBeanFactory().getType(beanName);
			if (beanType.getAnnotation(annotationType) != null) {
				results.put(beanName, getBeanFactory().getBean(beanName));
			}
		}
		return results;
	}

}