spring-core-3-23 | Spring IoC依赖注入：Spring提供了哪些依赖注入模式和类型呢？

Spring IoC 依赖注入

根据Bean 名称注入

根据Bean 类型注入

单个Bean 对象

集合Bean 对象

注入容器內建Bean 对象

注入非Bean 对象

注入类型

实时注入

延迟注入

代码示例

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

    <!--23 | Spring IoC依赖注入：Spring提供了哪些依赖注入模式和类型呢？-->
    <!-- 通过导入复用 dependency-lookup-context.xml -->
    <import resource="dependency-lookup-context.xml"/>

    <bean id="userRepository" class="org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository"
          autowire="byType">
        <!-- Auto-Wiring, 自动注入, 这里用的是byType, 根据类型, 但是这种方式是不支持自定义类的加载顺序的 -->
        <!-- 手动配置, 那么这里就有问题, 如果user还有更多的上升文, 要不断手动配置, 我们更希望是自动注入的 -->
        <!--关于util标签见官方文档, 搜索 :util  :
            https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/spring-framework-reference/core.html#spring-core-->
        <!--        <property name="users">-->
        <!--            <util:list>-->
        <!--                <ref bean="superUser" />-->
        <!--                <ref bean="user" />-->
        <!--            </util:list>-->
        <!--        </property>-->

    </bean>
</beans>

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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
 *
 *     http://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.geekbang.thinking.in.spring.ioc.overview.repository;

import org.geekbang.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.ApplicationContext;

import java.util.Collection;

/**
 * 23 | Spring IoC依赖注入：Spring提供了哪些依赖注入模式和类型呢？
 * 用户信息仓库
 *
 * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
 * @since
 */
public class UserRepository {

    /**
     * 23.1 23.2
     * 注入自定义 Bean 对象
     * 自定义 Bean
      */
    private Collection<User> users;

    /**
     * 23.3 內建 Bean 对象(不是业务方构建的, 而是spring内部自己建的)
     * 23.4 內建非 Bean 对象（內建依赖）
     */
    private BeanFactory beanFactory;

    /**
     * 23.5 內建 Bean 对象(不是业务方构建的, 而是spring内部自己建的)
     * 这里解释了一个问题, 依赖查找和依赖注入, bean的来源不是同一个
     */
    private ObjectFactory<ApplicationContext> objectFactory;

    public Collection<User> getUsers() {
        return users;
    }

    public void setUsers(Collection<User> users) {
        this.users = users;
    }


    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }

    public ObjectFactory<ApplicationContext> getObjectFactory() {
        return objectFactory;
    }

    public void setObjectFactory(ObjectFactory<ApplicationContext> objectFactory) {
        this.objectFactory = objectFactory;
    }
}

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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
 *
 *     http://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.geekbang.thinking.in.spring.ioc.overview.dependency.injection;

import org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 注意 视频 23 讲的并不清楚, 一定要结合 视频24一块看
 * 23 | Spring IoC依赖注入：Spring提供了哪些依赖注入模式和类型呢？
 * 依赖注入示例
 * • 根据Bean 名称注入
 * • 根据Bean 类型注入
 * •    单个Bean 对象
 * •    集合Bean 对象
 * • 注入容器內建Bean 对象
 * • 注入非Bean 对象 (容器內建依赖)
 * • 注入类型
 * •    实时注入
 * •    延迟注入
 *
 *
 * 24 | Spring IoC依赖来源：依赖注入和查找的对象来自于哪里？
 * 自定义Bean
 *      如 xml中定义的Bean, 是用户自定义的
 *      可以通过beanFactory.getBean()的方式能够依赖查找出来
 * 容器內建Bean 对象
 *      容器内部的Bean对象, 是spring给实例化的
 *      可以通过beanFactory.getBean()的方式能够依赖查找出来
 * 容器內建依赖(內建非 Bean 对象)
 *      非spring的bean, 如 beanFactory, 是spring启动必须的组件, 基础环境
 *      不能通过beanFactory.getBean()的方式依赖查找出来
 * <p>
 *
 * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
 * @since
 */
public class DependencyInjectionDemo {

    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        // 配置文件是 dependency-injection-context.xml, 这个文件通过导入复用 dependency-lookup-context.xml
        // 因此存在了两个上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-injection-context.xml");

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-injection-context.xml");

        // 23.1 根据Bean 名称注入,
        // 23.2 根据Bean 类型注入 单个Bean 对象 单个Bean 对象
        // 24.1 依赖来源一：自定义 Bean,
        // 主要在配置文件 dependency-injection-context.xml 决定是查找还是注入
        //UserRepository userRepository =
        // applicationContext.getBean("userRepository", UserRepository.class);

        //System.out.println(userRepository.getUsers());


        // 23.3 注入容器內建Bean 对象 (不是业务方构建的, 而是spring内部自己建的)
        // 24.2 依赖来源二：容器內建 Bean 对象
        // 用依赖查找就是能获取到的
        //Environment environment = applicationContext.getBean(Environment.class);
        //System.out.println("获取 Environment 类型的 Bean：" + environment);


        // 23.4 內建非 Bean 对象（內建依赖）
        // 24.3 依赖来源三：容器內建依赖
        //System.out.println(userRepository.getBeanFactory());
        // 这里的结果是不相等的, 证明这俩不是一个beanFactory
        //System.out.println(userRepository.getBeanFactory() == applicationContext);

        // 依赖查找（报错）, 那么这个地方依赖的来源是怎么回事?
        // 这说明BeanFactory不是一个内建Bean对象, 而是内建的依赖
        //System.out.println(beanFactory.getBean(BeanFactory.class));


        // ObjectFactory是之前用于延迟加载的那个beanFactory
        // 这里用 依赖注入 获取的 ObjectFactory
        //ObjectFactory userFactory = userRepository.getObjectFactory();
        // 这里的结果是相等的? 这里的依赖来源是哪里?
        // 答案是applicationContext中的beanFactory, 和手工new 的 beanFactory, 在spring容器中并不是一个对象,
        // 依赖查找和依赖注入的依赖来源是不同的, 
        // 在视频 26 这个问题得到解答
        //System.out.println(userFactory.getObject() == applicationContext);

    }

}