spring-core-3-24 | Spring IoC依赖来源：依赖注入和查找的对象来自于哪里？

Spring IoC 依赖来源

自定义Bean

如 xml中定义的Bean, 是用户自定义的
可以通过beanFactory.getBean()的方式能够依赖查找出来

容器內建Bean 对象

容器内部的Bean对象, 是spring给实例化的
可以通过beanFactory.getBean()的方式能够依赖查找出来

容器內建依赖

非spring的bean, 如 beanFactory, 是spring启动必须的组件, 基础环境
不能通过beanFactory.getBean()的方式依赖查找出来

代码示例

/*
 * 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);

   }

}