Spring 系列 | IOC及 Spring IOC 的具体表现形式

Dm同学

已于 2022-01-30 02:20:11 修改

阅读量749

点赞数 2

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

于 2022-01-29 23:52:48 首次发布

本文链接：https://blog.csdn.net/u010176014/article/details/122745818

版权

spring 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

今天的主要内容是IOC ，用不太严谨但好懂的大白话来说，IOC是一种设计思想，就是把原来由应用程序自己来主动创建查找管理对象的那部分，交给了框架处理。只要你告诉框架，你是那个对象，你需要哪个对象就可以了。不用在自己去找这个对象在哪里，也不用管怎么去找到并创建和销毁这个对象了。

本文重点聚焦两个问题，一个是IOC 是什么，另一个是IOC在spring中是怎么体现和应用的。

思路：
IOC是什么？
在一些开源框架里 IOC 都是怎么用的？
在Spring里 IOC是怎么用的？
更具体点，则是：包含怎么找，怎么注入，怎么配置，数据源是那些，对象的生命周期，以及谁控制的这些信息

IOC是什么

从定义和主要实现策略两个维度来展开

定义

IOC 在维基百科上的定义是这样写的

In software engineering, inversion of control (IoC) is a programming principle.

IOC 是 inversion of control 的缩写，即控制反转。它是一种编程的原则或风格。
说起IOC的简史，它最早是1983年，Richard E.Sweet 在《TheMesaProgrammingEnvironment》中提出的 “Hollywood Principle” ,即 “好莱坞原则”，主要表达的意思也是大家很熟悉的一句话“不要来打电话给我，我会打电话给你” ，也就是导演在会去联系演员，导演会打电话给演员，而不是演员主动联系导演。这里面其实就是控制反转的原则，在程序里对应则是：我们的依赖或是我们的数据是由其他方来提供的，而非自己去读取的。

实现策略

在维基百科中 Inversion_of_control 有这样的定义：

In object-oriented programming, there are several basic techniques to implement inversion of control. These are:
• Using a service locator pattern (注：服务定位模式)
• Using dependency injection (注：依赖注入), for example
• Constructor injection （注：构造器注入）
• Parameter injection （注：参数注入）
• Setter injection （注：setter注入）
• Interface injection （注：接口注入）
• Using a contextualized lookup （注：上下文的依赖查询例如 bean context ）
• Using template method design pattern (注：模板方法的设计模式)
• Using strategy design pattern （注：策略模式）

容器的职责

1 实现与任务的执行要解耦
2 关注设计上的最终目标而不是具体实现
3 对象生命周期的管理
4 配置

一些开源组件的主要实现

接下来看看IOC 容器在一些开源组件上的主要实现

Java SE : Java Beans,Java ServiceLoader SPI ,JNDI(Java Naming and Directory Interface)
Java EE :EJB(Enterprise Java Beans) Servlet
其他开源
• Apache Avalon(http://avalon.apache.org/closed.html)
• PicoContainer(http://picocontainer.com/)
• Google Guice(https://github.com/google/guice)
• Spring Framework(https://spring.io/projects/spring-framework)

从EJB 3.0 开始，就出现了所谓的依赖注入和依赖查找并存的情况，之前大部分都是依赖查找形式。这也算是一个小的分水岭了

接下来针对一个具体的框架来进行特性说明
Java Beans 作为IOC 容器特性

传统IOC容器的实现

特性：

依赖查找
生命周期
配置元信息
事件
自定义
资源管理
持久化

接下来重点聊下IOC 的依赖注入和依赖控制
在这里插入图片描述

Spring IoC 容器

IOC在spring中是怎么体现和应用的。包括怎么进行的依赖注入或查找，包括相关的配置，以及对象的源等。
IOC 是控制反转，这里再讲Spring IOC时，仍然是结合IOC 的特性来讲，在Spring里是如何做到的依赖查找和依赖注入，再依赖查找里具体是通过什么形式，再依赖注入里又是通过什么形式。将结合代码来看一下。这是这篇文章我最想详细介绍的内容

在这里插入图片描述

依次展示几个依赖查找和注入的案例：

依赖查找示例：

1 通过Bean名称的方式来查找

如：beanFactory.getBean(“user”);


/**
 * 依赖查找示例
 * 1. 通过名称的方式来查找
 *
 * @since
 */
public class DependencyLookupDemo {

    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        lookupInRealTime(beanFactory);
        lookupInLazy(beanFactory);
    }

    private static void lookupInLazy(BeanFactory beanFactory) {
        /**
         *  对应 xml :
         *   <bean id="user" class="org.geekbang.thinking.in.spring.ioc.overview.domain.User">
         *         <property name="id" value="1"/>
         *         <property name="name" value="小明"/>
         *      </bean>
         *
         *      <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
         *         <property name="targetBeanName" value="user"/>
         *     </bean>
         */
         //区别在这里！！
        ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
        User user = objectFactory.getObject();
        System.out.println("延迟查找：" + user);
    }

    private static void lookupInRealTime(BeanFactory beanFactory) {

      /* 对应 xml :
      <bean id="user" class="org.geekbang.thinking.in.spring.ioc.overview.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="小明"/>
      </bean>
      */
        //区别在这里！！
        User user = (User) beanFactory.getBean("user");
        System.out.println("实时查找：" + user);
    }
    }

2 通过类型查找

如：beanFactory.getBean(User.class);

 /**
 * 依赖查找示例
 * 按照类型查找
 *
 * @since
 */
public class DependencyLookupDemo {

    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        // 按照类型查找
        lookupByType(beanFactory);
        // 按照类型查找结合对象
        lookupCollectionByType(beanFactory);
    }

    private static void lookupByType(BeanFactory beanFactory) {
        //区别在这里！！
        User user = beanFactory.getBean(User.class);
        System.out.println("按照类型查找：" + user);
    }

    private static void lookupCollectionByType(BeanFactory beanFactory) {
         //区别在这里！！
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
            System.out.println("查找到的所有的 User 集合对象：" + users);
        }
    }
}

3 通过注解查找

前置工作：先写一个自定义注解，然后标注在一个新的类上，并在xml上声明好
a : 自定义注解：

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

b：标注在一个新的类上

@Super
public class SuperUser extends User {

    private String address;

    public String getAddress() {
        return address;
    }

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

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

c : 声明

 <bean id="superUser" class="org.geekbang.thinking.in.spring.ioc.overview.domain.SuperUser" parent="user"
          primary="true">
        <property name="address" value="杭州"/>
</bean>

d : 查找

/**
 * 依赖查找示例
 * 按照注解茶渣后
 *
 * @since
 */
public class DependencyLookupDemo {

    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        // 通过注解查找对象
        lookupByAnnotationType(beanFactory);
    }

    private static void lookupByAnnotationType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, User> users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);
            System.out.println("查找标注 @Super 所有的 User 集合对象：" + users);
        }
    }
}

依赖注入示例

手动方式

写在xml 配置里，不灵活

  <bean id="userRepository" class="org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository"  >  
     ` <!--  手动配置  -->
    <bean id="userRepository" class="org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository">
        <property name="users">
            <util:list>
                <ref bean="superUser"/>
                <ref bean="user"/>
            </util:list>
        </property>
    </bean>`
 </bean>

自动配置

主要是autowire 属性

  <bean id="userRepository" class="org.geekbang.thinking.in.spring.ioc.overview.repository.UserRepository"  autowire="byType"> <!-- Auto-Wiring -->
 </bean>

依赖注入和查找的对象来自于哪里

a : 自定义bean
b ：容器内建Bean 对象，例如
Environment environment =applicationContext.getBean(Environment.class);
c : 容器内建依赖

配置元信息

Bean 定义配置：（Bean 相关的配置）
基于XML文件，基于Propertiles文件，基于Java 注解，基于 Java API

IOC 容器的配置（容器相关的配置）
基于 XML 文件，基于Java 注解，基于 Java API

外部化的配置
基于Java 注解

Spring IOC 容器生命周期

待补充

总结

本文主要讲IOC ，以及在Spring 里 IOC 设计思想的具体体现。进而更具体的讲 Spring 代码里 IOC 是如何进行依赖注入，如果进行依赖查找的，是否可以通过配置方式进行调整（配置元信息），对象是哪里来的，对象是谁控制的，以及对象整个过程的声明周期是如何管理的。
按照这样的思路，IOC 的基本面应该都有所涉及了。接下来就是针对各个点去进行深入的立即和学习。

Dm同学

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring 系列 | IOC及 Spring IOC 的具体表现形式

Spring系列 | IOC 知多少今天的主要内容是IOC ，重点聚焦两个问题，一个是IOC 是什么，另一个是IOC在spring中是怎么体现和应用的。IOC是什么从定义和主要实现策略两个维度来展开定义IOC 在维基百科上的定义是这样写的In software engineering, inversion of control (IoC) is a programming principle.IOC 是 inversion of control 的缩写，即控制反转。它是一种编程的原则或风
复制链接

扫一扫