深入讲讲spring的IoC的实现方式

拼搏现实的明天。 2023-10-06 13:28 8阅读 0赞

## 什么是IoC ##

首先看看IoC的定义，什么IoC。网上有很多解释，这边就不一一甄别对错，我们直接上Spring的官方文档。

> IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern.

一长串英文，其内容大概说明以下几点：

> 1，IoC又被称为依赖注入（DI） 2，IoC描述了对象的定义和依赖的过程。 3，注入分为三种类型
> 
>  *  通过构造器参数注入
>  *  通过工厂方法参数注入
>  *  通过属性注入
> 
> 4，当对象实例化后依赖的对象才被创建，当创建bean后容器注入这些依赖对象。这个过程基本上是反向的，因此命名为控制反转（IoC）  
> 5，IoC是通过直接使用构造类来控制实例化，或者定义它们之间的依赖关系，或者类似于服务定位模式的一种机制。

以上的官方文档中，有一处是容易误导人的说法。IoC又被称为依赖注入（DI），这么说是因为，我们在讨论IoC的时候，大多数都是在讨论依赖注入的实现方式，所以，这里说IoC又被称为DI，然而实际上，IoC并不是DI，这是两个概念。IoC描述的是控制反转的机制，而DI描述的是IoC的一种实现方式。对，是一种实现方式。IoC的实现方式有两种：

*  依赖查找(Dependency lookup, DL)
 *  依赖注入(Dependency Injection, DI)

关于IoC，最好的比喻，就是业界所说的“好莱坞模式”，就是导演会跟演员说，“你不要来找我，我会去找你。”在IoC中，“我”指的是实例对象，“你”指的是需要注入到这个实例中的资源实例。那么，“我”如何去找到“你”呢？就是通过上述的两个方式去找。下面通过简单的示例，来说明IoC的两个实现原理和过程。

## 依赖查找 ##

依赖查找又分为以下方式：

*  按名称查找
 *  按类型查找
 *  按注解查找

首先我们定义一个资源，比如User类，类包含两个属性，名称和id。

public class User {
        
    
        private Long userId;
    
        private String name;
    
        public Long getUserId() {
        
            return userId;
        }
    
        public void setUserId(Long userId) {
        
            this.userId = userId;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "User{" +
                    "userId=" + userId +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

然后通过xml的方式来创建一个user实例。id指定为1231，名称为jeff\_rao。  
创建一个objectFactory用于延时查找。

dependency-lookup-context.xml，放在原信息包（META-INFO）中

### 按名称查找 ###

按名称查找又分为实时查找和延迟查找。

public class DependencyLookupDemo {
        
    
        public static void main(String[] args){
        
    
            // 创建一个上下文
            // ApplicationContext是BeanFactory的一个子实现
            // 所以可以通过ApplicationContext上下文来创建一个BeanFactory
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("/META-INFO/dependency-lookup-context.xml");
    
            // 按名称查找
            // 实时查找
            lookupBeanInRealTime(beanFactory);
            // 延时查找
            lookupBeanInLazy(beanFactory);
    
        }
    
        /**
        * 延时查找
        */
        private static void lookupBeanInLazy(BeanFactory beanFactory) {
        
    
            // 通过beanFactory获取 objectFactory
            // 并通过泛型参数，指定ObjectFactory为User类的对象工厂
            ObjectFactory<User> objectFactory = (ObjectFactory<User>)beanFactory.getBean("objectFactory");
            // 通过对象工厂，延时查找user对象
            User user = objectFactory.getObject();
            // 打印user对象
            System.out.println("延时查找: "+ user);
        }
    
        /**
        * 实时查找
        */
        private static void lookupBeanInRealTime(BeanFactory beanFactory) {
        
            
            // 通过beanFactory直接查找名称为“user”的实例
            User user = (User)beanFactory.getBean("user");
            System.out.println("实时查找："+user);
        }

运行结果。两种方式都能正常查找出user

org.myspring.ioc.dependency.lookup.DependencyLookupDemo
    实时查找：User{
        userId=1231, name='jeff_rao'}
    延时查找: User{
        userId=1231, name='jeff_rao'}
    
    Process finished with exit code 0

### 按类型查找 ###

按类型查找分为了查找单一bean和查找多个符合条件的bean集合。为了实现可以查出多个bean集合，我们再新增一个对象，命名为SuperUser。作为User类的超类。该类扩展类User类，并新增了一个地址属性。

public class SuperUser extends User {
        
    
        private String address;
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    
        // 打印super类和user类的相关信息
        @Override
        public String toString() {
        
            return "SuperUser{" +
                    "address='" + address + '\'' +
                    "} " + super.toString();
        }
    }

同样，在xml文件中新增创建SuperUser的实例。

然后按类型查找实例

public static void main(String[] args){
        
    
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("/META-INFO/dependency-lookup-context.xml");
    
            // 按类型查找
            // 按类型查找单一bean
            lookupBeanByType(beanFactory);
            // 按类型查找多个符合条件的bean集合
            lookupBeansByType(beanFactory);
    
        }
    
        /**
        * 按类型查找Bean集合
        */
        private static void lookupBeansByType(BeanFactory beanFactory) {
        
    
            // 先判断是否是一个ListableBeanFactory
            if(beanFactory instanceof ListableBeanFactory){
        
                
                // 转化为一个listableBeanFactory
                ListableBeanFactory listableBeanFactory = (ListableBeanFactory)beanFactory;
                // 按类型查找实例
                // 返回参数是一个集合，key是实例名称，value是实例
                Map<String, User> retMap = listableBeanFactory.getBeansOfType(User.class);
                // 打印查找结果
                System.out.println("按类型查找bean集合："+ retMap);
            }
        }
    
    	/**
    	* 按类型查找单一bean实例
    	*/
        private static void lookupBeanByType(BeanFactory beanFactory) {
        
            // 依然是通过beanFactory的getBean方法查找实例
            User user = beanFactory.getBean(User.class);
            System.out.println("按类型查找单一bean: "+ user);
        }

运行结果

org.myspring.ioc.dependency.lookup.DependencyLookupDemo
    按类型查找单一bean: SuperUser{
        address='杭州'} User{
        userId=1231, name='jeff_rao'}
    按类型查找bean集合：{
        user=User{
        userId=1231, name='jeff_rao'}, superUser=SuperUser{
        address='杭州'} User{
        userId=1231, name='jeff_rao'}}
    
    Process finished with exit code 0

### 按注解查找 ###

依然还是使用BeanFactory的按注解查找方法。为了能按注解查找实例，我们定义一个Super注解。

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

其中，顺带一提这里的两个注解，@Target是用来标记作用目标

> @Target(ElementType.TYPE)——接口、类、枚举、注解  
> @Target(ElementType.FIELD)——字段、枚举的常量  
> @Target(ElementType.METHOD)——方法  
> @Target(ElementType.PARAMETER)——方法参数  
> @Target(ElementType.CONSTRUCTOR) ——构造函数  
> @Target(ElementType.LOCAL\_VARIABLE)——局部变量  
> @Target(ElementType.ANNOTATION\_TYPE)——注解  
> @Target(ElementType.PACKAGE)——包

@Retention表示注解的保留位置

> RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。  
> RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。  
> RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。

此处常用的注解还有  
@Document：说明该注解将被包含在javadoc中  
@Inherited：说明子类可以继承父类中的该注解

此处我们只使用了上面两个。

注解定义好后，把注解标记在SuperUser上。  
![在这里插入图片描述][20200722192259274.png]

然后通过注解的方式来获得带有Super标签的实例

public class DependencyLookupDemo {
        
    
        public static void main(String[] args){
        
    
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("/META-INFO/dependency-lookup-context.xml");
            // 按注解查找
            lookupBeansWithAnnotation(beanFactory);
        }
    
        // 按注解查找实例
        private static void lookupBeansWithAnnotation(BeanFactory beanFactory) {
        
            
            // 如果是ListableBeanFactory
            if(beanFactory instanceof ListableBeanFactory){
        
                
                // 将beanFactory转化为ListableBeanFactory
                ListableBeanFactory listableBeanFactory = (ListableBeanFactory)beanFactory;
                // 通过ListableBeanFactory，按注解获取指定实例
                Map<String, User> retMap = (Map)listableBeanFactory.getBeansWithAnnotation(Super.class);
                // 输出结果
                System.out.println("按类型查找bean集合："+ retMap);
            }
    
        }
    }

结果为

org.myspring.ioc.dependency.lookup.DependencyLookupDemo
    按类型查找bean集合：{
        superUser=SuperUser{
        address='杭州'} User{
        userId=1231, name='jeff_rao'}}
    
    Process finished with exit code 0

以上就是依赖查找的三种方式的示例。下面说明依赖注入是如何实现的。

## 依赖注入 ##

依赖注入样也分为几类

*  按名称注入
 *  按类型注入

依赖注入用到了Repository信息仓库。我们先建一个User的信息仓库

public class UserRepository {
        
    
        private Collection<User> users;
    
        public Collection<User> getUsers() {
        
            return users;
        }
    
        public void setUsers(Collection<User> users) {
        
            this.users = users;
        }
    
        @Override
        public String toString() {
        
            return "UserRepository{" +
                    "users=" + users +
                    '}';
        }
    }

信息仓库中有一个变量users。那么怎么在实例话这个bean的时候，把users里面的对象也一起注入进去呢？  
这里有好几种方式。

### 按名称注入 ###

同样的，我们在xml文件里去创建这个信息仓库的实例。

这里用到了一个util：list标签，需要在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”  
> 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"  
>

来支持这个标签。  
通过这个标签，我们可以按照名称，把user和superUser实例注入到user信息仓库的users变量中去。  
这就是按照名称来注入。  
下面打印user信息仓库，看users是否被正确注入了。

public class DependencyInjectDemo {
        
    
        public static void main(String[] args){
        
    
            BeanFactory beanFactory = new ClassPathXmlApplicationContext("/META-INFO/dependency-inject-context.xml");
    
            UserRepository userRepository = (UserRepository)beanFactory.getBean("userRepository");
    
            System.out.println(userRepository);
        }
    }

运行结果：

org.myspring.ioc.dependency.inject.DependencyInjectDemo
    UserRepository{
        users=[User{
        userId=1231, name='jeff_rao'}, SuperUser{
        address='杭州'} User{
        userId=1231, name='jeff_rao'}]}
    
    Process finished with exit code 0

### 按类型注入 ###

虽然上面按名称注入可以满足条件，但是对代码侵入性较强。如果后面再新增其他的user实例，那么需要在这边手动去注入到users中去。当然，这个要看实际场景，如果场景需要手动去加入，那么采用名称注入。如果场景不想要手动加入，想要新增的user实例都可以自动的注入到users中，那么可以考虑按类型来注入。

同样，我们还是在xml文件中来实现。  
其实很简单，只要通过autowire属性就可以实现了。

autowire，就是自动绑定，值选择byType按类型自动绑定。执行结果如下。

另外，采用按类型自动绑定的形式的话，就无法指定属性中的顺序了。

除了这两种注入外，Spring容器中还提供了两种自动注入的方式。就是我们熟知的，@Autowired和@Resource。这两个注解的使用方法和区别，在csdn中已经有很多人做了说明，可以参考借鉴。

另外，根据注入的方式，还可以把注入分为

*  构造方法注入
 *  setter方法注入
 *  接口注入

其中接口注入，需要实例去实现特定的接口，对代码侵入性较大，目前也处于退役状态，基本不用。而构造器注入则是通过构造方法注入。缺点在于需要注入的实例很多时，构造方法入参将会难以维护。setter方法注入相对来说比较灵活。

根据注入的时效性来分，又分为实时注入和延时注入。  
实时注入即在bean创建的时候就把需要注入的实例都注入进去。  
延时注入则是在需要的时候去注入。

## 比较 ##

依赖查找和依赖注入相比，依赖注入用的更多，且对代码的侵入性较小。另外，Spring也提供了很多注解来支持依赖注入，使得依赖注入的使用更加便利。依赖查找则需要开发者在代码中手动去查找，对代码侵入性较强。然而没有绝对的好坏，只能说现在的大多web应用中，依赖注入更加适用一些。

以上就是笔者最近学习的一些总结，如果不正指出，还望指正。

[20200722192259274.png]: https://img-blog.csdnimg.cn/20200722192259274.png