Spring之IoC

        Spring概括的说下，就是一个控制反转（IoC）和面向切面的框架。

        概括性的概念，足以说明IoC（Inversion of Control）理念在Spring的整个框架中举足轻重的位置。这篇文章，表述了本人对IoC的理解。

一、IoC出生之前

        IoC是一种设计思想，是相对于对象创建的控制权在程序控制而提出的设计方法，将对象的创建权利交给调用者。

        可以看下面的对比例子，可以更好的理解这一概念。

        1、先写个UserDao接口

public interface UserDao {
   public void getUser();
}

        2、UserDao的第一个实现类，获取用户数据

public class UserDaoImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("获取用户数据");
  }
}

        3、UserService接口

public interface UserService {
   public void getUser();
}

        4、UserService接口实现类

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoImpl();

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

        5、调用者调用

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

        这时需求有改动，需要从MySql数据库中获取用户信息，所以实现UserDao接口，实现类实现从MySql数据库总获取数据

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

        接着就是Service实现类，需要修改成MySql获取数据的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();

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

        再假设，需求又变更，需要从oracle数据库中获取用户信息，这是又得修改一遍UserDao的实现，修改Service的实现。

        到这里，可以看到，用户调用程序基本修改，需要修改的都是后台代码的实现，后台代码控制需要新建什么对象。这就是以前的实现方式：所有东西由程序控制创建。

二、IoC 

        将上面的例子，换一种实现，重写下Service实现类

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用set实现
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

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

        调用者调用代码修改如下：

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

        以上的实现，由用户控制选择创建什么对象，决定权由程序转向用户，这种思想，就是控制反转，即IoC。

四、IoC本质

        控制反转IoC是一种设计思想，依赖注入DI（Dependency Injection）是实现IoC的一种方法。没有使用IoC时，使用面向对象编程，对象的创建，由程序自己控制，对象的创建和对象间的依赖关系，完全由硬编码实现，耦合程度很高。IoC将对象的创建，交给第三方，即调用者。

五、Spring之IoC

        首先，可以先看一个Spring的简单例子，通过文件的方式，配置创建对象。

        1、准备一个maven工程，引入Spring依赖的包

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

        2、实现一个hello实体类

public class Hello {
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

        3、编写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">

   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>

</beans>

        4、测试下

@Test
public void test(){
   //解析beans.xml文件 , 生成管理相应的Bean对象
   ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
   //getBean : 参数即为spring配置文件中bean的id .
   Hello hello = (Hello) context.getBean("hello");
   hello.show();
}

        写到这里，我们可以对Spring的IoC做一下几点思考：

• 上面的例子，hello对象由Spring来创建
• 程序使用Spring后，对象的创建由Spring来控制，这就是Spring的IoC，不会由Service来创建对象。
• 控制：创建的对象的控制权，
• 反转：对象的创建由程序本身转移到Spring，程序本身编程接收对象。