Spring Framework（二）IOC和依赖查找

最新推荐文章于 2023-06-09 17:10:11 发布

爱听歌的Fengx

最新推荐文章于 2023-06-09 17:10:11 发布

阅读量206

点赞数

分类专栏： # Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_37651252/article/details/120885960

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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 类实现

爱听歌的Fengx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Framework（二）IOC和依赖查找

IOCIoC，Inversion of Control，控制反转，是面向对象编程中的一种设计原则，用来降低代码的耦合度。最通俗易懂的理解就是，本来由程序员写代码创建和组装类及依赖对象的控制权，反转交给容器去控制。IoC 并非 Spring Framework 特有，也有一些其他的 IoC 开源框架如 Apache Avalon、PicoContainer、Google Guice；只是 Spring 被大量使用，其 IoC 的功能也被熟知。IoC 的实现策略有很多，但最主要的两种方式就是依赖查找和依赖
复制链接

扫一扫