亲宝软件园·资讯

展开

SpringIOC容器 详解SpringIOC容器相关知识

IPostYellow 人气:0
想了解详解SpringIOC容器相关知识的相关内容吗,IPostYellow在本文为您仔细讲解SpringIOC容器的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Spring,IOC容器,Spring容器,下面大家一起来学习吧。

一、前言

IOC控制反转,不是一种技术,而是一种设计思想,就是将原本在程序中手动创建对象的控制权,交给Spring框架来管理。

区别:

举例说明:

做菜,做蒜薹炒猪肉

你有两种做法:

第一种,自己养猪,然后种蒜薹。等到猪长大了,你就可以杀猪,蒜薹成熟了,就收割。然后开始炒,做成了蒜薹炒猪肉。

第二种,从农贸市场获取猪和蒜薹,拿回来直接炒,做成了蒜薹炒猪肉。

此时的IOC就相当于这个农贸市场,我要做菜,我去农贸市场拿过来就可以了,而不需要自己去弄。为什么要Java对象放到容器里?因为我们要做到拿来即用,便于管理。那你能管理农贸市场吗?你不能,那谁来管农贸市场?Spring!这就是控制反转IOC,我们把控制权交给了Spring框架,他来帮我们管这个农贸市场,他来养猪,他来种菜。我们只需在要菜的时候,去市场买就好了。

再举一个例子

过年了,想要给家里打扫个卫生,你想请几个钟点工来打扫。也有两种做法。

第一种:自己主动找,找身边人看看谁认识钟点工,你自己打电话邀约,谈价格

第二种:直接找家政公司,直接提出需求即可。

第一种方式就是我们自己创建对象的方式,自己主动new几个钟点工。而第二种就是spring给我们提供的IOC方式,家政公司就是一个容器,能给我提供很多的服务,钟点工对象是spring帮我们创建的。

又过了几天,我又想给厨房的油烟机清理一下,也能直接打电话给家政公司,提出需求。

那上述例子中的农贸市场和家政公司哪里来啊?

我们可以自己构建,就像自己成立一个公司一样。具体在程序中表现为:

1.使用配置文件或者注解的方式定义一下我们自己容器里存放的东西。

或者去别人的公司里找。具体在程序中表现为:

2.一定有很多人创建了自己的公司,这些服务都可以集成在我们自己的容器里,为我们提供强大的功能,比如spring自带很多的template模板类。

二、IOC原理实战

首先在pom.xml文件中加入spring的相关jar包。

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
</dependencies>

我们定义我们的接口和实现类

// UserDao接口
public interface UserDao {
    void getUser();
}
// UserDao实现类1,mysql实现
public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("mysql实现");
    }
}
// UserDao实现类2,oracle实现
public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("oracle实现");
    }
}

然后我们的业务实现类,在不使用set注入的情况下,是这样的:

//业务接口
public interface UserService {
    void getUser();
}
//业务实现类
public class UserServiceImpl implements UserService {
    //传统的方法中,如果这边要改变,那就必须将这里的语句改变才可以
    private UserDao userDao = new UserDaoImpl();

    public void getUser() {
        userDao.getUser();
    }
}

对应的测试类:

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层,不需要接触dao层
        UserServiceImpl userService =new UserServiceImpl();
        userService.getUser();
    }
}

但是你会发现使用这种方法如果我在测试这里想用oracle实现,那就必须新增一个业务实现类或者修改我原本的业务实现类,违反了开闭原则。

所以我们的业务实现类要使用set方法动态注入我们的UserDao实现类。

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    // 利用set进行动态实现值的注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

如此一来只需要在测试类中通过set方法,传入对应的实现类对象,就可以实现调用不同的实现对象的getUser方法。

public class MyTest {
    public static void main(String[] args) {
        // 利用set注入的方法,我们可以不需要修改service中的代码,从而实现多个不同对象的getUser方法
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoImpl());
        userService.getUser();//mysql实现
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();//oracle实现
    }
}

这两种模式的区别可以发现。之前,控制UserDao实现类的控制权,在程序员手上,程序员写在UserServiceImpl里,写死了对应的是实现类,如果要修改的话,程序员就必须去修改对应的代码。而后面这种方法,控制UserDao实现类的控制权,就已经不在程序员手上了。现在程序是被动接收对象,然后动态set注入实现了可以随意使用不同的实现类的getUser方法。

这其实就是一种控制反转IOC的原型。这种思想从本质上解决了问题,程序员不用再去管理对象的创建了。系统的耦合性大大降低。可以更加专注的在业务的实现上。spring的底层全部都是基于这种思想去实现的。

三、IOC本质

在这里插入图片描述

像上图所示,IOC本质上就是把左边变成了右边。本来是业务层里程序员写来主动决定调用的下面的Mysql还是Oracle,但是现在通过IOC,可以把主动权交给用户,让用户想用Mysql用Mysql,想用Oracle就用Oracle。

DI(依赖注入)是实现IOC的一种方法,在没有IOC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码再程序中,对象的创建由程序自己控制(也就是程序员自己写),控制反转(IOC)后将对象的创建移交给第三方了,控制反转的这个反转说的就是获得依赖对象的方式反转了。

采用XML配置方式配置Bean的时候,Bean的定义信息和实现是分离的,而采用注解的方式的时候两者是合为一体的,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目睹。

控制反转是一种通过描述(XML或者注解)并通过第三方去生产或获得特定对象的方式。在Spring中实现控制反转的是IOC容器,其实现方式是依赖注入(Dependency Injection,DI)

四、spring helloworld

找到1.2.2实例化容器部分,发现了其配置文件格式:

在这里插入图片描述

首先创建我们的实体类Hello:

package com.hj.pojo;
public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

然后根据文档中所述,在resources文件下创建beans.xml文件来使用spring创建对象。beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用spring来创建对象,在spring中这些都称为bean
    bean = 对象 相当于 new Hello();
    正常是 类型 变量名 = new 类型();
          Hello hello = new Hello();
    利用bean来实现,id就是变量名,class就是我们对象的类型
    里面的property相当于给对象中的属性设置一个值。
    -->
    <bean id="hello" class="com.hj.pojo.Hello">
        <!--
        ref:引用spring容器中创建好的对象
        value:具体的值,基本数据类型
        -->
        <property name="str" value="Spring"/>
    </bean>

</beans>

再次查看官方文档,查询如何使用容器。

在这里插入图片描述

可以看到需要借助一个工厂来读取bean的定义并进行访问,然后创建对象。

import com.hj.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {    
	public static void main(String[] args) {        
		//获取spring的上下文对象        
		ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");        
		//我们的对象现在都在spring中管理了,我们要使用,直接去取出来就可以了        
		Hello hello = (Hello) context.getBean("hello");        
		System.out.println(hello.toString());//Hello{str='Spring'}        
		//思考?        
		//Hello对象是谁创建的?是由Spring创建的        
		//Hello对象的属性是怎么设置的?是由Spring容器设置的    
		}
	}

这个Hello对象由spring创建并且由spring容器设置属性的过程就是控制反转。

五、小结

控制:谁来控制对象的创建,传统的应用程序的对象是由程序本身控制创建的,使用spring后,对象是由spring来创建的。

反转:程序本身不创建对象,而变成被动的接收对象

依赖注入:就是利用set方法来进行注入

IOC是一种编程思想,由主动的编程去变成被动的接收。

我们回头看Hello类里左边有个豆子的标志了,这说明这个类已经被Spring托管了。

在这里插入图片描述

所谓的IoC,一句话来概括:对象由spring来创建,管理和装配。

加载全部内容

相关教程
猜你喜欢
用户评论