BeanFactory和FactoryBean的联系和区别
BeanFactory是整个Spring容器的根容器，里面描述了在所有的子类或子接口当中对容器的处理原则和职责，包括生命周期的一些约定。
FactoryBean本身存活在BeanFactory当中，也是一种工厂。这个工厂的作用是用于获取FactoryBean所创建的对象。在创建的对象的时候，对象中的某些方法的前面和后面额外执行一些操作，实现AOP。
BeanFactory接口所在的位置：
BeanFactory源码
1 /* 2 * Copyright 2002-2011 the original author or authors. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package org.springframework.beans.factory; 18 19 import org.springframework.beans.BeansException; 20 21 /** 22 * The root interface for accessing a Spring bean container. 23 * This is the basic client view of a bean container; 24 * further interfaces such as {@link ListableBeanFactory} and 25 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory} 26 * are available for specific purposes. 27 * 28 * <p>This interface is implemented by objects that hold a number of bean definitions, 29 * each uniquely identified by a String name. Depending on the bean definition, 30 * the factory will return either an independent instance of a contained object 31 * (the Prototype design pattern), or a single shared instance (a superior 32 * alternative to the Singleton design pattern, in which the instance is a 33 * singleton in the scope of the factory). Which type of instance will be returned 34 * depends on the bean factory configuration: the API is the same. Since Spring 35 * 2.0, further scopes are available depending on the concrete application 36 * context (e.g. "request" and "session" scopes in a web environment). 37 * 38 * <p>The point of this approach is that the BeanFactory is a central registry 39 * of application components, and centralizes configuration of application 40 * components (no more do individual objects need to read properties files, 41 * for example). See chapters 4 and 11 of "Expert One-on-One J2EE Design and 42 * Development" for a discussion of the benefits of this approach. 43 * 44 * <p>Note that it is generally better to rely on Dependency Injection 45 * ("push" configuration) to configure application objects through setters 46 * or constructors, rather than use any form of "pull" configuration like a 47 * BeanFactory lookup. Spring's Dependency Injection functionality is 48 * implemented using this BeanFactory interface and its subinterfaces. 49 * 50 * <p>Normally a BeanFactory will load bean definitions stored in a configuration 51 * source (such as an XML document), and use the <code>org.springframework.beans</code> 52 * package to configure the beans. However, an implementation could simply return 53 * Java objects it creates as necessary directly in Java code. There are no 54 * constraints on how the definitions could be stored: LDAP, RDBMS, XML, 55 * properties file, etc. Implementations are encouraged to support references 56 * amongst beans (Dependency Injection). 57 * 58 * <p>In contrast to the methods in {@link ListableBeanFactory}, all of the 59 * operations in this interface will also check parent factories if this is a 60 * {@link HierarchicalBeanFactory}. If a bean is not found in this factory instance, 61 * the immediate parent factory will be asked. Beans in this factory instance 62 * are supposed to override beans of the same name in any parent factory. 63 * 64 * <p>Bean factory implementations should support the standard bean lifecycle interfaces 65 * as far as possible. The full set of initialization methods and their standard order is:<br> 66 * 1. BeanNameAware's <code>setBeanName</code><br> 67 * 2. BeanClassLoaderAware's <code>setBeanClassLoader</code><br> 68 * 3. BeanFactoryAware's <code>setBeanFactory</code><br> 69 * 4. ResourceLoaderAware's <code>setResourceLoader</code> 70 * (only applicable when running in an application context)<br> 71 * 5. ApplicationEventPublisherAware's <code>setApplicationEventPublisher</code> 72 * (only applicable when running in an application context)<br> 73 * 6. MessageSourceAware's <code>setMessageSource</code> 74 * (only applicable when running in an application context)<br> 75 * 7. ApplicationContextAware's <code>setApplicationContext</code> 76 * (only applicable when running in an application context)<br> 77 * 8. ServletContextAware's <code>setServletContext</code> 78 * (only applicable when running in a web application context)<br> 79 * 9. <code>postProcessBeforeInitialization</code> methods of BeanPostProcessors<br> 80 * 10. InitializingBean's <code>afterPropertiesSet</code><br> 81 * 11. a custom init-method definition<br> 82 * 12. <code>postProcessAfterInitialization</code> methods of BeanPostProcessors 83 * 84 * <p>On shutdown of a bean factory, the following lifecycle methods apply:<br> 85 * 1. DisposableBean's <code>destroy</code><br> 86 * 2. a custom destroy-method definition 87 * 88 * @author Rod Johnson 89 * @author Juergen Hoeller 90 * @author Chris Beams 91 * @since 13 April 2001 92 * @see BeanNameAware#setBeanName 93 * @see BeanClassLoaderAware#setBeanClassLoader 94 * @see BeanFactoryAware#setBeanFactory 95 * @see org.springframework.context.ResourceLoaderAware#setResourceLoader 96 * @see org.springframework.context.ApplicationEventPublisherAware#setApplicationEventPublisher 97 * @see org.springframework.context.MessageSourceAware#setMessageSource 98 * @see org.springframework.context.ApplicationContextAware#setApplicationContext 99 * @see org.springframework.web.context.ServletContextAware#setServletContext 100 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization 101 * @see InitializingBean#afterPropertiesSet 102 * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName 103 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization 104 * @see DisposableBean#destroy 105 * @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName 106 */ 107 public interface BeanFactory { 108 109 /** 110 * Used to dereference a {@link FactoryBean} instance and distinguish it from 111 * beans <i>created</i> by the FactoryBean. For example, if the bean named 112 * <code>myJndiObject</code> is a FactoryBean, getting <code>&myJndiObject</code> 113 * will return the factory, not the instance returned by the factory. 114 */ 115 String FACTORY_BEAN_PREFIX = "&"; 116 117 /** 118 * Return an instance, which may be shared or independent, of the specified bean. 119 * <p>This method allows a Spring BeanFactory to be used as a replacement for the 120 * Singleton or Prototype design pattern. Callers may retain references to 121 * returned objects in the case of Singleton beans. 122 * <p>Translates aliases back to the corresponding canonical bean name. 123 * Will ask the parent factory if the bean cannot be found in this factory instance. 124 * @param name the name of the bean to retrieve 125 * @return an instance of the bean 126 * @throws NoSuchBeanDefinitionException if there is no bean definition 127 * with the specified name 128 * @throws BeansException if the bean could not be obtained 129 */ 130 Object getBean(String name) throws BeansException; 131 132 /** 133 * Return an instance, which may be shared or independent, of the specified bean. 134 * <p>Behaves the same as {@link #getBean(String)}, but provides a measure of type 135 * safety by throwing a BeanNotOfRequiredTypeException if the bean is not of the 136 * required type. This means that ClassCastException can't be thrown on casting 137 * the result correctly, as can happen with {@link #getBean(String)}. 138 * <p>Translates aliases back to the corresponding canonical bean name. 139 * Will ask the parent factory if the bean cannot be found in this factory instance. 140 * @param name the name of the bean to retrieve 141 * @param requiredType type the bean must match. Can be an interface or superclass 142 * of the actual class, or <code>null</code> for any match. For example, if the value 143 * is <code>Object.class</code>, this method will succeed whatever the class of the 144 * returned instance. 145 * @return an instance of the bean 146 * @throws NoSuchBeanDefinitionException if there's no such bean definition 147 * @throws BeanNotOfRequiredTypeException if the bean is not of the required type 148 * @throws BeansException if the bean could not be created 149 */ 150 <T> T getBean(String name, Class<T> requiredType) throws BeansException; 151 152 /** 153 * Return the bean instance that uniquely matches the given object type, if any. 154 * @param requiredType type the bean must match; can be an interface or superclass. 155 * {@code null} is disallowed. 156 * <p>This method goes into {@link ListableBeanFactory} by-type lookup territory 157 * but may also be translated into a conventional by-name lookup based on the name 158 * of the given type. For more extensive retrieval operations across sets of beans, 159 * use {@link ListableBeanFactory} and/or {@link BeanFactoryUtils}. 160 * @return an instance of the single bean matching the required type 161 * @throws NoSuchBeanDefinitionException if there is not exactly one matching bean found 162 * @since 3.0 163 * @see ListableBeanFactory 164 */ 165 <T> T getBean(Class<T> requiredType) throws BeansException; 166 167 /** 168 * Return an instance, which may be shared or independent, of the specified bean. 169 * <p>Allows for specifying explicit constructor arguments / factory method arguments, 170 * overriding the specified default arguments (if any) in the bean definition. 171 * @param name the name of the bean to retrieve 172 * @param args arguments to use if creating a prototype using explicit arguments to a 173 * static factory method. It is invalid to use a non-null args value in any other case. 174 * @return an instance of the bean 175 * @throws NoSuchBeanDefinitionException if there's no such bean definition 176 * @throws BeanDefinitionStoreException if arguments have been given but 177 * the affected bean isn't a prototype 178 * @throws BeansException if the bean could not be created 179 * @since 2.5 180 */ 181 Object getBean(String name, Object... args) throws BeansException; 182 183 /** 184 * Does this bean factory contain a bean definition or externally registered singleton 185 * instance with the given name? 186 * <p>If the given name is an alias, it will be translated back to the corresponding 187 * canonical bean name. 188 * <p>If this factory is hierarchical, will ask any parent factory if the bean cannot 189 * be found in this factory instance. 190 * <p>If a bean definition or singleton instance matching the given name is found, 191 * this method will return {@code true} whether the named bean definition is concrete 192 * or abstract, lazy or eager, in scope or not. Therefore, note that a {@code true} 193 * return value from this method does not necessarily indicate that {@link #getBean} 194 * will be able to obtain an instance for the same name. 195 * @param name the name of the bean to query 196 * @return whether a bean with the given name is present 197 */ 198 boolean containsBean(String name); 199 200 /** 201 * Is this bean a shared singleton? That is, will {@link #getBean} always 202 * return the same instance? 203 * <p>Note: This method returning <code>false</code> does not clearly indicate 204 * independent instances. It indicates non-singleton instances, which may correspond 205 * to a scoped bean as well. Use the {@link #isPrototype} operation to explicitly 206 * check for independent instances. 207 * <p>Translates aliases back to the corresponding canonical bean name. 208 * Will ask the parent factory if the bean cannot be found in this factory instance. 209 * @param name the name of the bean to query 210 * @return whether this bean corresponds to a singleton instance 211 * @throws NoSuchBeanDefinitionException if there is no bean with the given name 212 * @see #getBean 213 * @see #isPrototype 214 */ 215 boolean isSingleton(String name) throws NoSuchBeanDefinitionException; 216 217 /** 218 * Is this bean a prototype? That is, will {@link #getBean} always return 219 * independent instances? 220 * <p>Note: This method returning <code>false</code> does not clearly indicate 221 * a singleton object. It indicates non-independent instances, which may correspond 222 * to a scoped bean as well. Use the {@link #isSingleton} operation to explicitly 223 * check for a shared singleton instance. 224 * <p>Translates aliases back to the corresponding canonical bean name. 225 * Will ask the parent factory if the bean cannot be found in this factory instance. 226 * @param name the name of the bean to query 227 * @return whether this bean will always deliver independent instances 228 * @throws NoSuchBeanDefinitionException if there is no bean with the given name 229 * @since 2.0.3 230 * @see #getBean 231 * @see #isSingleton 232 */ 233 boolean isPrototype(String name) throws NoSuchBeanDefinitionException; 234 235 /** 236 * Check whether the bean with the given name matches the specified type. 237 * More specifically, check whether a {@link #getBean} call for the given name 238 * would return an object that is assignable to the specified target type. 239 * <p>Translates aliases back to the corresponding canonical bean name. 240 * Will ask the parent factory if the bean cannot be found in this factory instance. 241 * @param name the name of the bean to query 242 * @param targetType the type to match against 243 * @return <code>true</code> if the bean type matches, 244 * <code>false</code> if it doesn't match or cannot be determined yet 245 * @throws NoSuchBeanDefinitionException if there is no bean with the given name 246 * @since 2.0.1 247 * @see #getBean 248 * @see #getType 249 */ 250 boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException; 251 252 /** 253 * Determine the type of the bean with the given name. More specifically, 254 * determine the type of object that {@link #getBean} would return for the given name. 255 * <p>For a {@link FactoryBean}, return the type of object that the FactoryBean creates, 256 * as exposed by {@link FactoryBean#getObjectType()}. 257 * <p>Translates aliases back to the corresponding canonical bean name. 258 * Will ask the parent factory if the bean cannot be found in this factory instance. 259 * @param name the name of the bean to query 260 * @return the type of the bean, or <code>null</code> if not determinable 261 * @throws NoSuchBeanDefinitionException if there is no bean with the given name 262 * @since 1.1.2 263 * @see #getBean 264 * @see #isTypeMatch 265 */ 266 Class<?> getType(String name) throws NoSuchBeanDefinitionException; 267 268 /** 269 * Return the aliases for the given bean name, if any. 270 * All of those aliases point to the same bean when used in a {@link #getBean} call. 271 * <p>If the given name is an alias, the corresponding original bean name 272 * and other aliases (if any) will be returned, with the original bean name 273 * being the first element in the array. 274 * <p>Will ask the parent factory if the bean cannot be found in this factory instance. 275 * @param name the bean name to check for aliases 276 * @return the aliases, or an empty array if none 277 * @see #getBean 278 */ 279 String[] getAliases(String name); 280 281 }