3-Spring IoC容器概述

参考：小马哥讲Spring核心编程思想

1. Spring IoC依赖查找

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.freedom.spring.ioc.overview.domain.User">
        <property name="id" value="1"></property>
        <property name="name" value="freedom"></property>
    </bean>

    <bean id="superUser" class="com.freedom.spring.ioc.overview.domain.SuperUser" parent="user" primary="true">
        <property name="address" value="深圳"></property>
    </bean>


    <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
        <property name="targetBeanName" value="user"></property>
    </bean>
</beans>

public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置XML配置文件
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("META-INF/dependency-lookup-context.xml");

        lookupByAnnotationType(beanFactory);

        lookupCollectionByType(beanFactory);

        lookupByType(beanFactory);

        lookupInLazy(beanFactory);

        lookupInRealTime(beanFactory);

    }

    private static void lookupByAnnotationType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, Object> map = listableBeanFactory.getBeansWithAnnotation(Super.class);
            System.out.println("根据注解查找" + map);
        }
    }

    private static void lookupCollectionByType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, User> map = listableBeanFactory.getBeansOfType(User.class);
            System.out.println("根据类型查找对象集合" + map);
        }
    }

    private static void lookupByType(BeanFactory beanFactory) {
        User user = beanFactory.getBean(User.class);
        System.out.println("根据类型查找:" + user);
    }

    private static void lookupInLazy(BeanFactory beanFactory) {
        ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
        User user = objectFactory.getObject();
        System.out.println("延迟查找:" + user);
    }

    private static void lookupInRealTime(BeanFactory beanFactory) {
        User user = (User) beanFactory.getBean("user");
        System.out.println("实时查找:" + user);
    }
}

2. Spring IoC 依赖注入

public class UserRepository {
    /**
     * 自定义 Bean
     */
    private Collection<User> users;
    /**
     * 內建非 Bean 对象（依赖）
     */
    private BeanFactory beanFactory;
    /**
     * 延迟
     */
    private ObjectFactory<ApplicationContext> objectFactory;
    gettter setter...
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <!-- 通过导入复用 dependency-lookup-context.xml -->
    <import resource="dependency-lookup-context.xml"/>

    <bean id="userRepository" class="com.freedom.spring.ioc.overview.repository.UserRepository"
          autowire="byType"><!--根据类型注入 -->
        <!-- 根据名称注入 -->
        <!--<property name="users">
            <util:list>
                <ref bean="superUser"/>
                <ref bean="user"/>
            </util:list>
        </property>-->
    </bean>
</beans>

public class DependencyInjectionDemo {
    public static void main(String[] args) {
        // 配置XML配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("META-INF/dependency-injection-context.xml");
        // 依赖来源一：自定义 Bean
        UserRepository userRepository = applicationContext.getBean("userRepository", UserRepository.class);
        Collection<User> users = userRepository.getUsers();
        System.out.println(users);

        // 依赖来源二：依赖注入（內建依赖）
        BeanFactory beanFactory = userRepository.getBeanFactory();
        System.out.println(beanFactory);

        ObjectFactory<ApplicationContext> objectFactory = userRepository.getObjectFactory();
        System.out.println(objectFactory.getObject() == applicationContext);

        // 依赖来源三：容器內建 Bean
        Environment environment = applicationContext.getBean(Environment.class);
        System.out.println("获取 Environment 类型的 Bean：" + environment);
    }
}

3. Spring IoC 依赖来源

• 自定义 Bean
• 容器內建 Bean 对象
• 容器內建依赖

4. Spring IoC配置元信息

5. Spring IoC 容器

BeanFactory 和 ApplicationContext 谁才是 Spring IoC 容器？

6. Spring 应用上下文

7. 使用 Spring IoC 容器

8. Spring IoC 容器生命周期

• 启动
• 运行
• 停止

 public static void main(String[] args) {
        // 创建 BeanFactory 容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 将当前类 AnnotationApplicationContextAsIoCContainerDemo 作为配置类（Configuration Class）
        applicationContext.register(AnnotationApplicationContextAsIoCContainerDemo.class);
        // 启动应用上下文
        applicationContext.refresh();
        // 依赖查找集合对象
        lookupCollectionByType(applicationContext);

        // 关闭应用上下文
        applicationContext.close();

    }