详解SpringIOC容器相关知识

详解SpringIOC容器相关知识

一、前言

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

区别：

没有IOC的思路：若要使用某个对象，就必须自己负责去写对象的创建

IOC的思路：若要使用某个对象，只需要从Spring容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权交给了Spring框架。

好莱坞法则：Don't call me, I 'll call you

举例说明：

做菜，做蒜薹炒猪肉

你有两种做法：

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

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

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

再举一个例子

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

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

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

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

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

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

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

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

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

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

二、IOC原理实战

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

org.springframework

spring-webmvc

5.2.0.RELEASE

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

// 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本质

像http://上图所示，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.pohttp://jo;

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内容如下：

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans.xsd">

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans.xsd">

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

可以看到需要借助一个工厂来读取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来创建，管理和装配。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。