首页 > 试题广场 >

下面有关spring依赖注入说法错误的是？

[单选题]

IOC就是由spring来负责控制对象的生命周期和对象间的关系

BeanFactory是最简单的容器，提供了基础的依赖注入支持

ApplicationContext建立在BeanFactory之上，提供了系统构架服务

如果Bean的某一个属性没有注入，ApplicationContext加载后，直至第一次使用调用getBean方法才会抛出异常；而BeanFactory则在初始化自身时检验，这样有利于检查所依赖属性是否注入

推荐

MyGoodHelper

答案：D

ApplicationContext初始化时会检验，而BeanFactory在第一次使用时未注入，才会抛出异常

编辑于 2015-02-02 14:52:18 回复(3)

spring的IOC容器能够帮我们自动new对象，对象交给spring管之后我们不用自己手动去new对象了，也就是控制权的转让。

spring使用BeanFactory来实例化、配置和管理对象，但是它只是一个接口，里面有一个getBean()方法。

我们一般都不直接用BeanFactory，而是用它的实现类 ApplicationContext ，这个类会自动解析我们配置的applicationContext.xml

发表于 2015-09-09 09:37:20 回复(2)

………h

Factory这个单词从头错到尾，强迫症心里很不舒服

发表于 2017-04-09 15:07:41 回复(7)

嶷如秋山·令出不返

Spring的IoC容器就是一个实现了BeanFactory接口的可实例化类。事实上，Spring提供了两种不同的容器：一种是最基本的BeanFactory，另一种是扩展的ApplicationContext。BeanFactory 仅提供了最基本的依赖注入支持，而 ApplicationContext 则扩展了BeanFactory ,提供了更多的额外功能。二者对Bean的初始化也有很大区别。BeanFactory当需要调用时读取配置信息，生成某个类的实例。如果读入的Bean配置正确，则其他的配置中有错误也不会影响程序的运行。而ApplicationContext 在初始化时就把 xml 的配置信息读入内存，对 XML 文件进行检验，如果配置文件没有错误，就创建所有的Bean ,直接为应用程序服务。相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

发表于 2017-08-27 15:06:03 回复(1)

Linsanity

BeanFactory和ApplicationContext的异同点：

相同点：两者都是通过xml配置文件加载bean,ApplicationContext和BeanFacotry相比,提供了更多的扩

展功能。

不同点：BeanFactory是延迟加载,如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常；而ApplicationContext则在初始化自身是检验，这样有利于检查所依赖属性是否注入；所以通常情况下我们选择使用ApplicationContext

发表于 2017-05-15 21:20:31 回复(1)

薛定谔之喵

D项说反了

发表于 2016-03-28 10:13:09 回复(0)

peanut丶w

.BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化，而ApplicationContext则相反，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误。

发表于 2017-10-10 17:43:18 回复(1)

眉毛密过发

spring容器管理有俩中方式，一种是beanFactory（bean工厂）；另一种是应用上下文；

而bean工厂使用只具有是bean IOC注入使用，基本上不用这个方式；（但是该方式会在初始化时自身检测，有利于编译时发现错误）

应用上下文可以说是一种懒加载形式，只在第一次调用getbean方法是注入，这时候可能会有编译时忘记注入等情况发生。（有时候注入包名写错，忘记自动扫描开启会发现运行时才给你报错）

发表于 2019-09-29 15:56:23 回复(0)

头凉

applicationcontext在BeanFactory之上

发表于 2018-08-24 22:41:58 回复(0)

凌风123

发表于 2019-05-04 20:51:39 回复(0)

尼莫1997

发表于 2019-05-01 09:22:53 回复(0)

月薪起步1万2

这是说延迟加载问题。

发表于 2019-04-15 21:49:59 回复(0)

GavinRai

ApplicationContext初始化时会检验，而BeanFactory在第一次使用时未注入，才会抛出异常

发表于 2019-04-10 11:12:38 回复(0)

牛客6861837号

BeanFactory有延时加载机制，ApplacationContext自启动就会创建Bean

发表于 2018-09-30 13:02:34 回复(0)

karaysn

D选项说反了吧

发表于 2018-09-12 10:47:14 回复(0)

404Exception

Spring BeanFactory与FactoryBean的区别及其各自的详细介绍于用法

1. BeanFactory

BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，用于管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

Spring为我们提供了许多易用的BeanFactory实现，XmlBeanFactory就是常用的一个，该实现将以XML方式描述组成应用的对象及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。

实例化容器

1 Resource resource = new FileSystemResource("beans.xml"); 2 BeanFactory factory = new XmlBeanFactory(resource);

1 ClassPathResource resource = new ClassPathResource("beans.xml"); 2 BeanFactory factory = new XmlBeanFactory(resource);

1 ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml", "applicationContext-part2.xml"}); 3 BeanFactory factory = (BeanFactory) context;

基本就是这些了，接着使用getBean(String beanName)方法就可以取得bean的实例；BeanFactory提供的方法及其简单，仅提供了六种方法供客户调用：

boolean containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true
Object getBean(String) 返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常
Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型
Class getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常
boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式
String[] getAliases(String name) 返回给定bean名称的所有别名

2. FactoryBean

以Bean结尾，表示它是一个Bean，不同于普通Bean的是：它是实现了FactoryBean<T>接口的Bean，根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，请在id前面加一个&符号来获取。

例如自己实现一个FactoryBean，功能：用来***一个对象，对该对象的所有方法做一个拦截，在调用前后都输出一行LOG，模仿ProxyFactoryBean的功能。

 1 /**  2  * my factory bean<p>  3  * ***一个类，拦截该类的所有方法，在方法的调用前后进行日志的输出  4  * @author daniel.zhao  5  *  6 */  7 public class MyFactoryBean implements FactoryBean<Object>, InitializingBean, DisposableBean {  8  9 private static final Logger logger = LoggerFactory.getLogger(MyFactoryBean.class); 10 11 private String interfaceName; 12 13 private Object target; 14 15 private Object proxyObj; 16 17  @Override 18 public void destroy() throws Exception { 19 logger.debug("destroy......"); 20  } 21 22  @Override 23 public void afterPropertiesSet() throws Exception { 24 proxyObj = Proxy.newProxyInstance( 25 this.getClass().getClassLoader(), 26 new Class[] { Class.forName(interfaceName) }, 27 new InvocationHandler() { 28 29  @Override 30 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 31 logger.debug("invoke method......" + method.getName()); 32 logger.debug("invoke method before......" + System.currentTimeMillis()); 33 Object result = method.invoke(target, args); 34 logger.debug("invoke method after......" + System.currentTimeMillis()); 35 return result; 36  } 37 38  }); 39 logger.debug("afterPropertiesSet......"); 40  } 41 42  @Override 43 public Object getObject() throws Exception { 44 logger.debug("getObject......"); 45 return proxyObj; 46  } 47 48  @Override 49 public Class<?> getObjectType() { 50 return proxyObj == null ? Object.class : proxyObj.getClass(); 51  } 52 53  @Override 54 public boolean isSingleton() { 55 return true; 56  } 57 58 public String getInterfaceName() { 59 return interfaceName; 60  } 61 62 public void setInterfaceName(String interfaceName) { 63 this.interfaceName = interfaceName; 64  } 65 66 public Object getTarget() { 67 return target; 68  } 69 70 public void setTarget(Object target) { 71 this.target = target; 72  } 73 74 public Object getProxyObj() { 75 return proxyObj; 76  } 77 78 public void setProxyObj(Object proxyObj) { 79 this.proxyObj = proxyObj; 80  } 81 82 }

XML-Bean配置如下

1 <bean id="fbHelloWorldService" class="com.ebao.xxx.MyFactoryBean"> 2 <property name="interfaceName" value="com.ebao.xxx.HelloWorldService" /> 3 <property name="target" ref="helloWorldService" /> 4 </bean>

Junit Test class

 1 @RunWith(JUnit4ClassRunner.class)  2 @ContextConfiguration(classes = { MyFactoryBeanConfig.class })  3 public class MyFactoryBeanTest {  4  5  @Autowired  6 private ApplicationContext context;  7  8 /**  9  * 测试验证FactoryBean原理，***一个servcie在调用其方法的前后，打印日志亦可作其他处理 10  * 从ApplicationContext中获取自定义的FactoryBean 11  * context.getBean(String beanName) ---> 最终获取到的Object是FactoryBean.getObejct(), 12  * 使用Proxy.newInstance生成service的***类 13 */ 14  @Test 15 public void testFactoryBean() { 16 HelloWorldService helloWorldService = (HelloWorldService) context.getBean("fbHelloWorldService"); 17  helloWorldService.getBeanName(); 18  helloWorldService.sayHello(); 19  } 20 }

发表于 2018-08-21 23:37:56 回复(0)

泡泡糖大哥

       *                            1.首先本身BeanFactory创建的实例是多例的，即用时才创建Bean实例
       *                            2.我们的ApplicationContext是BeanFactory的子接口，其默认情况下是单例模式，即随着配置文件的解析就创建实例
       *                                但是在该子接口可以通过配置来实现指定Bean实例的创建时机，即使用作用域范围Scope指定，不仅仅限制于单例模式多例模式，
       *                                还涉及到request/session/application/websocket
       *
       * 单例模式下：1.加载配置文件解析配置文件的时候会触发init函数的执行，
       *                        2.在工厂容器销毁的时候会触发destroy方法的执行，
       * 多例模式下：1.加载配置文件解析配置文件的时候不会触发init的函数的执行，
       *                        2.在bean创建的时候，会触发init函数执行，并且在工厂容器销毁的时候并没有执行destroy方法
       * 总结：在单例模式下：在解析文件的时候就会创建bean的实例，并且其销毁伴随着容器的销毁，容器销毁会触发实例的销毁
       *            在多例模式下：在解析文件的时候不会创建bean的实例，而是在使用的时候采取创建，实例的销毁时机并不会伴随着容器的销毁而销毁，而是Java中的GC进行销毁

发表于 2018-05-07 22:02:26 回复(1)

doer3

ApplicationContext初始化时会检验，而BeanFactory在第一次使用时未注入，才会抛出异常

发表于 2017-08-25 16:49:05 回复(0)

牛客143068号

spring的IOC容器能够帮我们自动new对象，对象交给spring管之后我们不用自己手动去new对象了，也就是控制权的转让。

spring使用BeanFactory来实例化、配置和管理对象，但是它只是一个接口，里面有一个getBean()方法。

我们一般都不直接用BeanFactory，而是用它的实现类 ApplicationContext ，这个类会自动解析我们配置的applicationContext.

spring依赖注入：

IOC就是由spring来负责控制对象的生命周期和对象间的关系。

BeanFacotry是最简单的容器，提供了基础的依赖注入支持。 ApplicationContext建立在BeanFacotry之上，提供了系统构架服务。

发表于 2016-12-06 19:17:50 回复(1)

revivedSuN

ApplicationContext是在初始化，没找到注入目标时候会抛出异常。

stuImpl类中有一个 
	@Autowired
	private Stu stu;
但配置的xml中，扫描的包不包含Stu所在包，这样可以看到创建ClassPathXmlApplicationContext时候，并实现注入会抛出下面的异常。

 Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'stuImpl': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private quartz.Stu spring.scan.StuImpl.stu; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [quartz.Stu] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:298)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1148)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:519)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:458)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:293)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:290)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:191)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:636)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:938)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:479)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
	at spring.Main.main(Main.java:15)

发表于 2016-08-21 12:19:19 回复(0)

牛仔very的忙

看是否是懒加载情况而定

发表于 2015-07-19 23:57:28 回复(0)

提交观点

问题信息

百度 Spring

上传者：小小

难度：

21条回答 1320收藏 13342浏览

下面有关spring依赖注入说法错误的是？

Spring BeanFactory与FactoryBean的区别及其各自的详细介绍于用法

1. BeanFactory

2. FactoryBean

问题信息

热门推荐

相关试题