Spring Freamwork IoC 容器概述

Spring IoC 容器概述

1、Spring IoC 依赖查找

• 根据 Bean 名称查找
• 根据 Bean 类型查找
• 根据 Bean 名称 + 类型查找
• 根据Java 注解查找

dependency-lookup-context.xml

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.lvt.thinking.in.spring.ioc.overview.domain.User">
        <property name="id" value="1"></property>
        <property name="name" value="张三"></property>
    </bean>

    <bean id="superUser" class="com.lvt.thinking.in.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>

DependencyLookupDemo.java

public class DependencyLookupDemo {

    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INFO/dependency-lookup-context.xml");
        // 根据名称查找
        lookupRealTime(beanFactory);
        lookupLazy(beanFactory);
        // 根据类型查找
        lookupByType(beanFactory);
        lookupCollectionByType(beanFactory);
        // 根据名称和类型查找
        lookupByTypeAndName(beanFactory);
        // 根据 Java 注解查找
        lookupByAnnotation(beanFactory);
    }

    private static void lookupByAnnotation(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, User> users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);
            System.out.println("根据@super注解查找："+users);
        }
    }

    private static void lookupByTypeAndName(BeanFactory beanFactory) {
        User user = beanFactory.getBean("user", User.class);
        System.out.println("根据名称和类型查找："+user);
    }

    private static void lookupCollectionByType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
            System.out.println("查找到的所有的 User 集合对象：" + users);
        }
    }

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

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

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

2、Spring IoC 依赖注入

• 根据 Bean 名称注入
• 根据 Bean 类型注入
• 注入容器内建 Bean 对象
• 注入 非 Bean 对象

3、Spring IoC 依赖来源

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

dependency-injection-context.xml

<?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">

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

    <!--自动注入-->
<!--    <bean id="userRepository" class="com.lvt.thinking.in.spring.ioc.overview.repository.UserRepository" autowire="byType">-->
    <bean id="userRepository" class="com.lvt.thinking.in.spring.ioc.overview.repository.UserRepository">
        <!--手动配置-->
        <property name="users">
            <util:list>
                <ref bean="superUser"></ref>
                <ref bean="user"></ref>
            </util:list>
        </property>
    </bean>
</beans>

DependencyInjectionDemo.java

public class DependencyInjectionDemo {

    public static void main(String[] args) {
//        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INFO/dependency-injection-context.xml");
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:META-INFO/dependency-injection-context.xml");

        // 依赖来源一：自定义 Bean
        UserRepository userRepository = applicationContext.getBean("userRepository", UserRepository.class);
        System.out.println(userRepository.getUsers());

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

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

}

4、Spring IoC 配置元信息

• 基于XML 文件
• 基于 Properties 文件
• 基于 Java 注解
• 基于 Java API

5、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();
    }

6、面试题精选

6.1、 什么是 Spring IoC 容器？

Spring IoC 容器负责创建对象、管理对象，装配对象、配置对象、并且管理这些对象的生命周期。

6.2、Bean Factory 与 FactoryBean 区别?

• 两个都是个工厂，但FactoryBean本质上还是一个Bean，也归BeanFactory管理
• BeanFactory是Spring容器的顶层接口，FactoryBean更类似于用户自定义的工厂接口。FactoryBean在Spring中最为典型的一个应用就是用来创建AOP的代理对象

6.3、Spring IoC 容器启动时做了哪些准备？

IoC 配置元信息读取和解析、IoC 容器生命周期、Spring 事件发布、国际化等。

更多精选好文请关注个人公众号：