架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

Spring:IoC 容器与依赖注入

2019年1月1日 #后端开发 #Spring

系列文章:Spring:IoC、AOP 与事务 的第 1 篇。

Spring

  • Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架,目的是用于简化企业应用程序的开发,它使得开发者只需要关心业务需求。

Spring IOC = Spring Bean + Spring Context特性

  • 主要由以下几个模块组成:
    • Spring Core:核心类库,提供IOC服务
    • Spring Context:提供框架式的Bean访问方式,以及企业级功能(JNDI、定时任务等)
    • Spring AOP:AOP服务切面编程
    • Spring Type Conversion:类型转换
    • Spring Data Binding :数据绑定
    • Spring Express Language:Spring 表达式
    • Spring Resources:资源管理
    • Spring Events:事件
    • Spring i18n:国际化
    • Spring Validation:校验
    • Spring Data Access:数据存储
      • JDBC Java API:对JDBC的抽象,简化了数据访问异常的处理
      • Transactions:事务抽象 EJB简化版本
      • O/R Mapping:映射
      • DAO Support:对JDBC的抽象,简化了数据访问异常的处理
      • XML Marshalling 编列
    • Spring Integration
      • Remoting:远程调用
      • JMS:Java消息服务
      • JCA:Java连接架构
      • JMS:Java管理扩展
      • Email:Java 邮件客户端
      • Tasks:本地任务
      • Scheduling:本地调度
      • Caching:缓存抽象
      • Test : Spring 测试
        • Mock Objects:模拟对象框架
        • Test Context Framework:TestContext框架
        • Spring Mvc Test:Spring MVC 测试
        • WebTestClient :Web 测试客户端
    • Spring Web:提供了基本的面向Web的综合特性,例如多方文件上传
      • Spring Servlet Support
        • Spring MVC:提供面向Web应用的Model-View-Controller实现
        • WebSocket
        • SockJS
      • Spring Reactive
        • Spring WebFlux
        • WebClient
        • WebSocket

Spring 编程模型

  • 面向对象
    • 契约接口:Aware、BeanPostProcess
    • 设计模式:观察者、组合模式、模版模式
  • 面向切面
    • 动态代理:JdkDynamicAopProxy
    • 字节码提升:ASM、CGLib、AspectJ
  • 面向元编程
    • 注解:模式注解 @Component @Service
    • 配置:Environment抽象、PropertySources
    • 范型:GenericTypeResolver
  • 函数驱动
    • ApplicationEventPubilsher
    • Reactive Spring WebFlux
  • 模块驱动
    • Maven Artifacts
    • OSGI Bundles
    • Java 9 Automatic Modules
    • Spring @Enable*

Spring 设计思想

  • Object-Oriented Programming (OOP)
  • IOC / DI
  • Domain-DrivenDevelopment (DDD)
  • Test-DrivenDevelopment (TDD)
  • Event-DrivenPrograming (EDP)
  • Functional Programing (FP)

Spring IOC

IOC对于Spring框架来说,就是由Spring来负责控制对象的生命周期和对象间的关系。

所谓依赖注入,就是由IOC容器在运行期间,动态地将某种依赖关系注入到对象之中,所以,以来注入DI 和控制反转IOC 是从不同的角度描述的同一间事情,就是值通过引用IOC容器,利用以来关系注入的方式,实现对象之间的解耦。DI是IOC的实现。

  • IoC(Inversion of Control,翻译为“控制反转”)不是一个具体的技术,而是一种设计思想。与传统控制流相比,IoC 会颠倒控制流,在传统的编程中需要开发者自行创建并销毁对象,而在 IoC 中会把这些操作交给框架来处理,这样开发者就不用关注具体的实现细节了,拿来直接用就可以了,这就是控制反转。

    • IoC 很好的体现出了面向对象的设计法则之一——好莱坞法则:“别找我们,我们找你”。即由 IoC 容器帮对象找到相应的依赖对象并注入,而不是由对象主动去找。
    • DI(Dependency Injection,翻译为“依赖注入”)表示组件间的依赖关系交由容器在运行期自动生成,也就是说,由容器动态的将某个依赖关系注入到组件之中,这样就能提升组件的重用频率。通过依赖注入机制,我们只需要通过简单的配置,就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心资源来自哪里、由谁实现等问题。
    • IoC 和 DI 其实是同一个概念从不同角度的描述的,由于控制反转这个概念比较含糊(可能只理解成了容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以 2004 年被开发者尊称为“教父”的 Martin Fowler(世界顶级专家,敏捷开发方法的创始人之一)又给出了一个新的名字“依赖注入”,相对 IoC 而言,“依赖注入”明确描述了“被注入对象依赖 IoC 容器配置依赖对象”。
  • 平常的Java开发中,程序员在某个类中需要依赖其它类的方法。通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理。 Spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过Spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是"控制反转"。通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员。而控制反转是指new实例工作不由我们程序员来做而是交给Spring容器来做。

实现方式

  • JavaSE
    • Java Beans
    • Java ServiceLoader SPI

依赖查找

单属性查找、集合对象查找

  • 依赖查找是主动依赖查找方式,通常需要依赖容器API标准实现,而依赖注入是通过手动或者自动依赖绑定方式实现。

  • 实时查找

    • BeanFactory.getBean(String beanName) 根据名称查找
    • BeanFactory.getBean(Class<T>beanClazz) 根据Bean类型查找
  • 延迟查找

  • 查询条件

    • 单个Bean对象
    • 集合Bean对象
    • 条件查找(在查找过程中 Name 和 Id都是坚定Bean的条件,在一个上下文中只能存在一种)
      • Bean Name + Bean Type查找
      • Bean Id + Bean Type查找
    • Java 注解

演示代码

  • 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">
    <!-- more bean definitions go here -->
    <bean id="delayLookup" class="cn.z201.spring.domain.DelayLookup">
        <property name="name" value="spring"/>
    </bean>

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

    <!-- parent 继承等父类 primary 即使指定的 bean 标记为自动装配候选者。 -->
    <bean id="annotationDelayLookup" class="cn.z201.spring.domain.AnnotationDelayLookup"
          parent="delayLookup" primary="true">
        <property name="address" value="杭州"/>
    </bean>

</beans>
  • Java代码
/**
 * @author z201.coding@gmail.com
 * spring ioc 延时查找
 **/
public class DelayLookup {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "DelayLookup{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * @author z201.coding@gmail.com
 **/
@Point
public class AnnotationDelayLookup extends DelayLookup{
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "AnnotationDelayLookup{" +
                "address='" + address + '\'' +
                "} " + super.toString();
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Point {

}

public class IOCDelayLookupTest {

    @Test
    public void testLookup() {
        // 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
        // 启动 spring 上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-lookup-context.xml");
        lookup(beanFactory);
        lookupLazy(beanFactory);
        lookupType(beanFactory);
        lookupCollectionType(beanFactory);
        lookupAnnotationType(beanFactory);
    }


    /**
     * 实时查找
     *
     * @param beanFactory
     */
    private void lookup(BeanFactory beanFactory) {
        // 根据id 获取bean
        DelayLookup delayLookup = (DelayLookup) beanFactory.getBean("delayLookup");
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("实时查找 " + delayLookup);
    }

    /**
     * 延时查找
     *
     * @param beanFactory
     */
    private void lookupLazy(BeanFactory beanFactory) {
        // 根据id 获取bean
        ObjectFactory<DelayLookup> delayLookup = (ObjectFactory<DelayLookup>) beanFactory.getBean("objectFactory");
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("延时查找 " + delayLookup.getObject());
    }

    /**
     * 单一类型查找
     *
     * @param beanFactory
     */
    private void lookupType(BeanFactory beanFactory) {
        // 根据id 获取bean
        DelayLookup delayLookup = beanFactory.getBean(DelayLookup.class);
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("单一类型查找  " + delayLookup);
    }


    /**
     * 单一类型集合查找
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, DelayLookup> delayLookupMap = listableBeanFactory.getBeansOfType(DelayLookup.class);
            // getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("单一类型集合查找  " + key + " " + value);
            });
        }
    }

    /**
     * Java注解查找
     * 通过注解查找只需要
     *
     * @param beanFactory
     */
    private void lookupAnnotationType(BeanFactory beanFactory) {
        // Point
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, AnnotationDelayLookup> delayLookupMap = (Map) listableBeanFactory.getBeansWithAnnotation(Point.class);
            // getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("Java注解 @Point 查找  " + key + " " + value);
            });
        }

    }

}
  • Console
实时查找 DelayLookup{name='spring'}
延时查找 DelayLookup{name='spring'}
单一类型查找  AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}
单一类型集合查找  delayLookup DelayLookup{name='spring'}
单一类型集合查找  annotationDelayLookup AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}
Java注解 @Point 查找  annotationDelayLookup AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}

依赖注入

  • 自定义Bean注入。

    • 通过Bean注入。
    • 通过Bean集合注入。
  • 容器内部依赖注入。

  • 容器内部建立Bean注入。

  • 构造方法注入。

    • 构造器注入是不允许循环依赖的存在,日常开发推荐该方式,如果出现循环依赖应该考虑自身代码实现是否合理。
  • 工厂的方法注入。

  • 字段注入

    • 编码注入
      • Java注解注入
        • @Autowired
        • @Resource
        • @Inject
  • 方法注入

  • 回调注入

演示代码

  • 配置文件
<?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">
    <!-- more bean definitions go here -->
    <!--
    1.在注入集合类等时候,引入util配置信息
    xmlns:util="http://www.springframework.org/schema/util"
    http://www.springframework.org/schema/util
    https://www.springframework.org/schema/util/spring-util.xsd
    -->

    <bean id="injectionBean" class="cn.z201.spring.injection.domain.InjectionBean">
        <property name="name" value="spring"/>
    </bean>

    <bean id="superInjectionBean" class="cn.z201.spring.injection.domain.SuperInjectionBean"
          parent="injectionBean" primary="true">
        <property name="address" value="杭州"/>
    </bean>

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

    <!-- 自动配置 Auto-Wiring -->
    <bean id="injectionRepository" class="cn.z201.spring.injection.repository.InjectionRepository" autowire="byType">
        <!--     手动配置  -->
<!--        <property name="beans">-->
<!--            <util:list>-->
<!--                <ref bean="injectionBean"/>-->
<!--                <ref bean="superInjectionBean"/>-->
<!--            </util:list>-->
<!--        </property>-->
    </bean>

</beans>
  • java代码
/**
 * @author z201.coding@gmail.com
 **/
public class InjectionBean {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "InjectionBean{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * @author z201.coding@gmail.com
 **/
public class InjectionRepository {

    private Collection<InjectionBean> beans;

    public Collection<InjectionBean> getBeans() {
        return beans;
    }

    public void setBeans(Collection<InjectionBean> beans) {
        this.beans = beans;
    }

    @Override
    public String toString() {
        return "InjectionRepository{" +
                "beans=" + beans +
                '}';
    }
}


/**
 * @author z201.coding@gmail.com
 **/
public class IOCInjectionTest {

    @Test
    public void testInjection() {
        // 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
        // 启动 spring 上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-injection-context.xml");
        lookupType(beanFactory);
        lookupCollectionType(beanFactory);
    }

    /**
     * 单一对象注入
     *
     * @param beanFactory
     */
    private void lookupType(BeanFactory beanFactory) {
        // 根据id 获取bean
        InjectionBean injectionBean = beanFactory.getBean(InjectionBean.class);
        // 重写 DelayLookup.toString()方法成功输出 spring 。
        System.out.println("单一对象注入  " + injectionBean);
    }

    /**
     * 集合对象注入
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, InjectionRepository> delayLookupMap = listableBeanFactory.getBeansOfType(InjectionRepository.class);
            // getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("集合对象注入  " + key + " " + value);
            });
        }
    }
}

  • Console
单一类型查找  SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}
单一类型集合查找  injectionRepository InjectionRepository{beans=[InjectionBean{name='spring'}, SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}]}

Autowired和Resource关键字

  • @Resource和@Autowired都是做bean的注入时使用,其实@Resource并不是Spring的注解,它的包是javax.annotation.Resource,需要导入,但是Spring支持该注解的注入。
  • Autowired注解是按照类型(byType)装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配,可以结合@Qualififier注解一起使用:
public class TestServiceImpl { 
  // 下面两种@Autowired只要使用一种即可 
  @Autowired 
  private UserDao userDao; // 用于字段上 
  
  @Autowired  // 用于属性的方法上
  public void setUserDao(UserDao userDao) 
  {  
    this.userDao = userDao; 
  } 
}
// @Autowired注解是按照类型(byType)装配依赖对象,默认情况下它要求依赖对象必须存在,如果允
// 许null值,可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配,可以结
// 合@Qualifier注解一起使用。如下:
public class TestServiceImpl {
  @Autowired 
  @Qualifier("userDao") private UserDao userDao;
}
  • Resource默认按照ByName自动注入,由J2EE提供,需要导入包javax.annotation.Resource。@Resource有两个重要的属性:name和type,而Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以,如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性,这时将通过反射机制使用byName自动注入策略。
public class TestServiceImpl { 
  // 下面两种@Resource只要使用一种即可 
  
  // 用于字段上 
  @Resource(name="userDao") 
  private UserDao userDao; 
  
  // 用于属性的setter方法上 
  @Resource(name="userDao") 
  public void setUserDao(UserDao userDao) { 
    this.userDao = userDao;
  } 
}

BeanFactory与ApplicationContext

  • BeanFactory 是 Bean 容器,ApplicationContext通过组合BeanFactory提供依赖查找的能力。常用的 AOP、事务以及 事件等,这些都被 ApplicationContext 支持。

  • BeanFactory是Spring底层ioc容器,它维护存储了很多bean定义的信息、Bean配置、生命周期管理。

  • ApplicationContext是BeanFactory超子集。

BeanFactory与FactoryBean

BeanFactory与FactoryBean都是接口。

  • BeanFactory是IOC容器,就是一个Factory或者说IOC容器对象工厂。
  • BeanFactory是单一查找的核心

  • FactoryBean是创建Bean的一种方式。FactoryBean就是一个Bean。
    • 在Spring中,所有的Bean都是由BeanFactory管理。

ObjectFactory 与 BeanFactory

  • ObjectFactory 与 BeanFactory 均提供依赖查找的能力

  • ObjectFactory 仅关注一个或一种类型的 Bean 依赖查找,并

    且自身不具备依赖查找。

  • BeanFactory 则提供了单一类型、集合类型以及层次性等多种依赖查

    找方式。

生命周期

  • 容器
  • Java Beans

BeanDefinition

BeanDefinition是Spring Framework中定义Bean的配置元信息接口。

创建bean

  • 基于xml创建
  • 基于Java注解创建
    • @Bean
    • @Component
    • @Import
/**
 * @author z201.coding@gmail.com
 * 演示
 * DefaultListableBeanFactory 基于xml配置信息创建bean
 * AnnotationConfigApplicationContext 基于注解类创建bean
 **/
public class IocContainerTest {

    @Test
    public void setupXmlApplicationContext(){
        // 创建BeanFactory 容器
        DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
        String location = "classpath:META-INF/ioc-delay-injection-context.xml";
        // 加载 xml格式的配置文件,并获取bean的数量
        int beanDefinitionCount =  reader.loadBeanDefinitions(location);
        System.out.println("bean 定义加载的数量 " + beanDefinitionCount);
        lookupCollectionType(defaultListableBeanFactory);
    }

    @Test
    public void setupAnnotationConfigApplicationContext(){
        // 创建BeanFactory 容器
        AnnotationConfigApplicationContext config = new AnnotationConfigApplicationContext();
        // 加载 IocContainer 作为bean配置类,配置类需要添加@Configuration注解
        config.register(IocContainer.class);
        // 启动应用上下文
        config.refresh();
        lookupCollectionType(config);
        // 关闭上下文
        config.close();
    }

    /**
     * 集合对象注入
     *
     * @param beanFactory
     */
    private void lookupCollectionType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, SuperInjectionBean> delayLookupMap = listableBeanFactory.getBeansOfType(SuperInjectionBean.class);
            // getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
            delayLookupMap.forEach((key, value) -> {
                System.out.println("集合对象注入  " + key + " " + value);
            });
        }
    }
}

  • Console
# 运行setupXmlApplicationContext
bean 定义加载的数量 4
集合对象注入  superInjectionBean SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}
# 运行setupAnnotationConfigApplicationContext
集合对象注入  superInjectionBean SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}

配置元信息

可以通过Bean定义、IOC容器配置、外部属性配置。

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

实际作用

  • AOP抽象、事务抽象、事件机制、SPI机制、第三方集成。

小结

IoC 把对象创建与依赖装配交给容器,依赖查找按名称、类型、注解取实例;BeanFactory 延迟加载,ApplicationContext 启动时完成大部分准备工作。

最近更新: 2026/11/20 22:35
Contributors: 庆峰
Prev
MyBatis:执行流程与插件机制
Next
Spring:AOP 与自动装配