IoC，Inversion of Control，控制反转，是面向对象编程中的一种设计原则，用来降低代码的耦合度。最通俗易懂的理解就是，本来由程序员写代码创建和组装类及依赖对象的控制权，反转交给容器去控制。
IoC 并非 Spring framework 特有，也有一些其他的 IoC 开源框架如 Apache Avalon、PicoContainer、Google Guice；只是 Spring 被大量使用，其 IoC 的功能也被熟知。
IoC 的实现策略有很多，但最主要的两种方式就是依赖查找和依赖注入。依赖查找是主动或手动的依赖查找方式，通常需要依赖容器或标准 API 实现；而依赖注入则是手动或自动依赖绑定的方式，无需依赖特定的容器和 API。这两种实现方式在 Spring 中都有体现。
谈到 IoC，就很自然的想到 IoC 容器，被提到也特别多。那什么是 IoC 容器？
首先容器是指，为某种特定组件的运行提供必要支持的一个软件环境。该环境为上层使用提供了许多底层服务。
比如几乎每天都在用的 Tomcat，就是一个 Servlet 容器，实现了 TCP 连接，解析 HTTP 等协议，提供了非常复杂的服务。如果没有容器提供这些服务，我们去实现 Servlet 规范就会非常麻烦；在 tomcat 上开发 servlet 服务，就非常容易。
为了方便我们快速实现 IoC，IoC 容器帮我们完成了对象的依赖处理、资源的生命周期管理和配置管理。它的主要实现有 Java Beans、Java ServiceLoader SPI、JNDI(Java Naming and Directory Interface)、EJB(Enterprise Java Beans)、Servlet，这些都是我们日常工作中天天在用的。
Spring 的 IoC 容器，包含了依赖查找和依赖注入，对 AOP、JDBC、事务、事件的抽象和封装，对 SPI 的扩展、对第三方功能的整合、对测试能力的封装等，提供了非常多的基础功能，可以让我们在容器上进行快速开发。如果没有这些容器的基础功能，试想一下自己去实现一个 AOP，会多出多少工作量与开发难度。
依赖查找Spring bean 的依赖查找，可以
- 根据名称查找
- 根据类型查找单个和所有 bean
- 根据 名称 + 类型 查找
- 根据注解查找
- 延迟查找
pom.xml
ssm com.fengx 1.0-SNAPSHOT 4.0.0 spring_01 8 8 org.springframework spring-beans ${spring.version}
配置文件
自定义注解，为演示可以通过注解查找到 bean 而创建
package com.fengx.spring_01;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Fengx {
}
bean 类
package com.fengx.spring_01;
@Fengx
public class User {
private Integer id = 1;
private String name = "Fengx";
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
// json字符串
return "User{" +
"id=" + id +
", name='" + name + ''' +
'}';
}
}
测试代码
package com.fengx.spring_01;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import java.util.Arrays;
import java.util.Map;
@SuppressWarnings("deprecation")
public class Test {
public static void main(String[] args) {
// XmlBeanFactory 已经是一个废弃的类
XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));
findByName(factory);
findPrimaryByType(factory);
findAllByType(factory);
findByNameAndType(factory);
findByAnnotation(factory);
findInLazy(factory);
findWithObjectProvider(factory);
findBeanNames(factory);
}
public static void findByName(BeanFactory factory) {
User user = (User)factory.getBean("user1");
System.out.println("根据名称查找: " + user);
}
private static void findPrimaryByType(BeanFactory factory) {
// 根据类型查找如何存在多个同一类型的bean，需要制定 primary 属性为 true
User user = factory.getBean(User.class);
System.out.println("根据类型查找 priary: " + user);
}
private static void findAllByType(ListableBeanFactory factory) {
// ListableBeanFactory，具有查询所有类型的能力
Map beans = (factory).getBeansOfType(User.class);
System.out.println("根据类型查找所有: " + beans);
System.out.println(BeanFactoryUtils.beansOfTypeIncludingAncestors(factory, User.class));
}
private static void findByNameAndType(BeanFactory factory) {
User user = factory.getBean("user1", User.class);
System.out.println("根据 名称 + 类型 查找: " + user);
}
private static void findByAnnotation(ListableBeanFactory factory) {
// ListableBeanFactory，具有根据注解查找 bean 的能力、查询同一类型多个 bean 的能力
Map beans = (factory).getBeansWithAnnotation(Fengx.class);
System.out.println("根据注解查找: " + beans);
}
private static void findInLazy(BeanFactory factory) {
ObjectFactory objectFactory = (ObjectFactory)factory.getBean("lazyUser");
User user = objectFactory.getObject();
System.out.println("延迟查找: " + user);
}
private static void findWithObjectProvider(BeanFactory factory) {
ObjectProvider beanProvider = factory.getBeanProvider(User.class);
User user = beanProvider.getIfAvailable(User::new);
System.out.println("bean provider: " + user);
}
private static void findBeanNames(ListableBeanFactory factory) {
System.out.println(Arrays.asList((factory).getBeanNamesForType(User.class)));
System.out.println(Arrays.asList((factory).getBeanNamesForAnnotation(Fengx.class)));
System.out.println(Arrays.asList(BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(factory, Fengx.class)));
}
}
打印结果
根据名称查找: User{id=1, name='Fengx'}
根据类型查找 priary: User{id=2, name='user2'}
根据类型查找所有: {user1=User{id=1, name='Fengx'}, user2=User{id=2, name='user2'}}
{user1=User{id=1, name='Fengx'}, user2=User{id=2, name='user2'}}
根据 名称 + 类型 查找: User{id=1, name='Fengx'}
根据注解查找: {user1=User{id=1, name='Fengx'}, user2=User{id=2, name='user2'}}
延迟查找: User{id=1, name='Fengx'}
bean provider: User{id=2, name='user2'}
[user1, user2]
[user1, user2]
[user1, user2]
- XmlBeanFactory 已经是一个废弃的类，但这个示例不想引入 spring-context、XmlBeanFactory 加载 xml 的代码比较直接，所以仍使用了
- 根据类型查到单个 bean 时，如果存在多个同类型的 bean，需要给 bean 设置 primary 属性
- ListableBeanFactory 具有根据注解查找 bean、查询同一类型多个 bean 的能力
- 延迟查找可以借助 ObjectFactoryCreatingFactoryBean 类实现
