Spring IOC容器的理解（五）-阿里云开发者社区

基于XML管理bean
实验十一给bean的属性赋值：集合属性

实验十二自动装配

实验十三集合类型的bean

实验十四 FactoryBean机制

实验十五 bean的作用域

实验十六 bean的生命周期

实验十一给bean的属性赋值：集合属性

1、给组件类添加属性

2、配置

3、测试

4、其他变化形式

实验十一给bean的属性赋值：集合属性
1、给组件类添加属性

2、配置

<property name="memberList">
    <list>
        <value>member01</value>
        <value>member02</value>
        <value>member03</value>
    </list>
</property>

3、测试
@Test
public void testExperiment13() {


HappyTeam happyTeam2 = (HappyTeam) iocContainer.getBean("happyTeam2");

List<String> memberList = happyTeam2.getMemberList();

for (String member : memberList) {
    System.out.println("member = " + member);
}

}
4、其他变化形式

<property name="memberNameList">
    <!-- list标签：准备一组集合类型的数据，给集合属性赋值 -->
    <!--<list>
        <value>member01</value>
        <value>member02</value>
        <value>member03</value>
    </list>-->
    <!-- 使用set标签也能实现相同效果，只是附带了去重功能 -->
    <!--<set>
        <value>member01</value>
        <value>member02</value>
        <value>member02</value>
    </set>-->
    <!-- array也同样兼容 -->
    <array>
        <value>member01</value>
        <value>member02</value>
        <value>member02</value>
    </array>
</property>
<property name="managerList">
    <!-- 给Map类型的属性赋值 -->
    <!--<map>
        <entry key="财务部" value="张三"/>
        <entry key="行政部" value="李四"/>
        <entry key="销售部" value="王五"/>
    </map>-->
    <!-- 也可以使用props标签 -->
    <props>
        <prop key="财务部">张三2</prop>
        <prop key="行政部">李四2</prop>
        <prop key="销售部">王五2</prop>
    </props>
</property>

实验十二自动装配

1、声明组件类

2、配置

3、测试

实验十二自动装配
1、声明组件类
其中HappyController需要用到HappyService。所谓自动装配就是一个组件需要其他组件时，由 IOC 容器负责找到那个需要的组件，并装配进去。

public class HappyController {

    
private HappyService happyService;

public HappyService getHappyService() {
    return happyService;
}

public void setHappyService(HappyService happyService) {
    this.happyService = happyService;
}

}

public class HappyService {
}
2、配置

<bean id="happyController"

  class="com.atguigu.ioc.component.HappyController"
  autowire="byName"

<!-- 手动装配：在property标签中使用ref属性明确指定要装配的bean -->
<!--<property name="happyService" ref="happyService"/>-->

3、测试
@Test
public void testExperiment12() {

HappyController happyController = iocContainer.getBean(HappyController.class);

HappyService happyService = happyController.getHappyService();

System.out.println("happyService = " + happyService);

}
实验十三集合类型的bean

1、配置

2、测试

实验十三集合类型的bean
1、配置

<util:list id="machineList">

<bean class="com.atguigu.ioc.component.HappyMachine">
    <property name="machineName" value="machineOne"/>
</bean>
<bean class="com.atguigu.ioc.component.HappyMachine">
    <property name="machineName" value="machineTwo"/>
</bean>
<bean class="com.atguigu.ioc.component.HappyMachine">
    <property name="machineName" value="machineThree"/>
</bean>

</util:list>
2、测试

@Test
public void testExperiment11() {

List<HappyMachine> machineList = (List<HappyMachine>) iocContainer.getBean("machineList");
for (HappyMachine happyMachine : machineList) {
    System.out.println("happyMachine = " + happyMachine);
}

}
实验十四 FactoryBean机制

1、简介

2、实现FactoryBean接口

3、配置bean

4、测试获取bean

实验十四 FactoryBean机制
1、简介
FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

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

https://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;

import org.springframework.lang.Nullable;

/**

Interface to be implemented by objects used within a {@link BeanFactory} which
are themselves factories for individual objects. If a bean implements this
interface, it is used as a factory for an object to expose, not directly as a
bean instance that will be exposed itself.

NB: A bean that implements this interface cannot be used as a normal bean.
A FactoryBean is defined in a bean style, but the object exposed for bean
references ({@link #getObject()}) is always the object that it creates.

FactoryBeans can support singletons and prototypes, and can either create
objects lazily on demand or eagerly on startup. The {@link SmartFactoryBean}
interface allows for exposing more fine-grained behavioral metadata.

This interface is heavily used within the framework itself, for example for
the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the
{@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for
custom components as well; however, this is only common for infrastructure code.

{@code FactoryBean} is a programmatic contract. Implementations are not
supposed to rely on annotation-driven injection or other reflective facilities.
{@link #getObjectType()} {@link #getObject()} invocations may arrive early in the
bootstrap process, even ahead of any post-processor setup. If you need access to
other beans, implement {@link BeanFactoryAware} and obtain them programmatically.

The container is only responsible for managing the lifecycle of the FactoryBean
instance, not the lifecycle of the objects created by the FactoryBean. Therefore,
a destroy method on an exposed bean object (such as {@link java.io.Closeable#close()}
will not be called automatically. Instead, a FactoryBean should implement
{@link DisposableBean} and delegate any such close call to the underlying object.

Finally, FactoryBean objects participate in the containing BeanFactory's
synchronization of bean creation. There is usually no need for internal
synchronization other than for purposes of lazy initialization within the
FactoryBean itself (or the like).

@author Rod Johnson
@author Juergen Hoeller
@since 08.03.2003
@param the bean type
@see org.springframework.beans.factory.BeanFactory
@see org.springframework.aop.framework.ProxyFactoryBean
@see org.springframework.jndi.JndiObjectFactoryBean

*/
public interface FactoryBean {

/**
 * The name of an attribute that can be
 * {@link org.springframework.core.AttributeAccessor#setAttribute set} on a
 * {@link org.springframework.beans.factory.config.BeanDefinition} so that
 * factory beans can signal their object type when it can't be deduced from
 * the factory bean class.
 * @since 5.2
 */
String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

/**
 * Return an instance (possibly shared or independent) of the object
 * managed by this factory.
 * <p>As with a {@link BeanFactory}, this allows support for both the
 * Singleton and Prototype design pattern.
 * <p>If this FactoryBean is not fully initialized yet at the time of
 * the call (for example because it is involved in a circular reference),
 * throw a corresponding {@link FactoryBeanNotInitializedException}.
 * <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}
 * objects. The factory will consider this as normal value to be used; it
 * will not throw a FactoryBeanNotInitializedException in this case anymore.
 * FactoryBean implementations are encouraged to throw
 * FactoryBeanNotInitializedException themselves now, as appropriate.
 * @return an instance of the bean (can be {@code null})
 * @throws Exception in case of creation errors
 * @see FactoryBeanNotInitializedException
 */
@Nullable
T getObject() throws Exception;

/**
 * Return the type of object that this FactoryBean creates,
 * or {@code null} if not known in advance.
 * <p>This allows one to check for specific types of beans without
 * instantiating objects, for example on autowiring.
 * <p>In the case of implementations that are creating a singleton object,
 * this method should try to avoid singleton creation as far as possible;
 * it should rather estimate the type in advance.
 * For prototypes, returning a meaningful type here is advisable too.
 * <p>This method can be called <i>before</i> this FactoryBean has
 * been fully initialized. It must not rely on state created during
 * initialization; of course, it can still use such state if available.
 * <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return
 * {@code null} here. Therefore it is highly recommended to implement
 * this method properly, using the current state of the FactoryBean.
 * @return the type of object that this FactoryBean creates,
 * or {@code null} if not known at the time of the call
 * @see ListableBeanFactory#getBeansOfType
 */
@Nullable
Class<?> getObjectType();

/**
 * Is the object managed by this factory a singleton? That is,
 * will {@link #getObject()} always return the same object
 * (a reference that can be cached)?
 * <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,
 * the object returned from {@code getObject()} might get cached
 * by the owning BeanFactory. Hence, do not return {@code true}
 * unless the FactoryBean always exposes the same reference.
 * <p>The singleton status of the FactoryBean itself will generally
 * be provided by the owning BeanFactory; usually, it has to be
 * defined as singleton there.
 * <p><b>NOTE:</b> This method returning {@code false} does not
 * necessarily indicate that returned objects are independent instances.
 * An implementation of the extended {@link SmartFactoryBean} interface
 * may explicitly indicate independent instances through its
 * {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}
 * implementations which do not implement this extended interface are
 * simply assumed to always return independent instances if the
 * {@code isSingleton()} implementation returns {@code false}.
 * <p>The default implementation returns {@code true}, since a
 * {@code FactoryBean} typically manages a singleton instance.
 * @return whether the exposed object is a singleton
 * @see #getObject()
 * @see SmartFactoryBean#isPrototype()
 */
default boolean isSingleton() {
    return true;
}

}

2、实现FactoryBean接口
3、配置bean
4、测试获取bean
实验十五 bean的作用域

1、概念

2、配置

3、测试

实验十五 bean的作用域
1、概念
在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值含义创建对象的时机
singleton 在IOC容器中，这个bean的对象始终为单实例 IOC容器初始化时
prototype 这个bean在IOC容器中有多个实例获取bean时
如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值含义
request 在一个请求范围内有效
session 在一个会话范围内有效
2、配置

<property name="machineName" value="iceCreamMachine"/>

3、测试
@Test
public void testExperiment15() {

HappyMachine happyMachine01 = (HappyMachine) iocContainer.getBean("happyMachine4");
HappyMachine happyMachine02 = (HappyMachine) iocContainer.getBean("happyMachine4");

System.out.println(happyMachine01 == happyMachine02);

System.out.println("happyMachine01.hashCode() = " + happyMachine01.hashCode());
System.out.println("happyMachine02.hashCode() = " + happyMachine02.hashCode());

}
更新有点慢望谅解多多点赞互相关注

IOC容器理解中的基于xml管理bean更新完了，后期会继续更新基于注解管理bean等等

Spring IOC容器的理解（五）

容器服务

热门文章

最新文章

相关课程

相关电子书

相关实验场景