IOC
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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>ssm</artifactId>
<groupId>com.fengx</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<!--Spring依赖查找-->
<artifactId>spring_01</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<build>
</build>
</project>
配置文件
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user1" class="com.fengx.spring_01.User"/>
<!--根据类型查到单个 bean 时,如果存在多个同类型的 bean,需要给 bean 设置 primary 属性-->
<bean id="user2" class="com.fengx.spring_01.User" primary="true">
<property name="id" value="2" />
<property name="name" value="user2" />
</bean>
<bean id="lazyUser" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
<property name="targetBeanName" value="user1"/>
</bean>
</beans>
自定义注解,为演示可以通过注解查找到 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;
/**
* @author: Fengx
* @date: 2021-10-19
* @description: 自定义注解:为演示可以通过注解查找到 bean 而创建
**/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Fengx {
}
bean 类
package com.fengx.spring_01;
/**
* @author: Fengx
* @date: 2021-10-19
* @description: 实体类
**/
@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;
/**
* @author: Fengx
* @date: 2021-10-19
* @description: 依赖查找,测试类
**/
@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);
}
/**
* 根据名称查找
* @param factory
*/
public static void findByName(BeanFactory factory) {
User user = (User)factory.getBean("user1");
System.out.println("根据名称查找: " + user);
}
/**
* 根据类型查找 primary
* @param factory
*/
private static void findPrimaryByType(BeanFactory factory) {
// 根据类型查找如何存在多个同一类型的bean,需要制定 primary 属性为 true
User user = factory.getBean(User.class);
System.out.println("根据类型查找 priary: " + user);
}
/**
* 根据类型查找所有
* @param factory
*/
private static void findAllByType(ListableBeanFactory factory) {
// ListableBeanFactory,具有查询所有类型的能力
Map<String, User> beans = (factory).getBeansOfType(User.class);
System.out.println("根据类型查找所有: " + beans);
System.out.println(BeanFactoryUtils.beansOfTypeIncludingAncestors(factory, User.class));
}
/**
* 根据 名称 + 类型 查找
* @param factory
*/
private static void findByNameAndType(BeanFactory factory) {
User user = factory.getBean("user1", User.class);
System.out.println("根据 名称 + 类型 查找: " + user);
}
/**
* 根据注解查找
* @param factory
*/
private static void findByAnnotation(ListableBeanFactory factory) {
// ListableBeanFactory,具有根据注解查找 bean 的能力、查询同一类型多个 bean 的能力
Map<String, Object> beans = (factory).getBeansWithAnnotation(Fengx.class);
System.out.println("根据注解查找: " + beans);
}
/**
* 延迟查找
* @param factory
*/
private static void findInLazy(BeanFactory factory) {
ObjectFactory<User> objectFactory = (ObjectFactory<User>)factory.getBean("lazyUser");
User user = objectFactory.getObject();
System.out.println("延迟查找: " + user);
}
/**
* 使用 getBeanProvider 查找
* @param factory
*/
private static void findWithObjectProvider(BeanFactory factory) {
ObjectProvider<User> beanProvider = factory.getBeanProvider(User.class);
User user = beanProvider.getIfAvailable(User::new);
System.out.println("bean provider: " + user);
}
/**
* 查找 bean 名称
* @param factory
*/
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 类实现