Spring——IOC(控制反转)

学习 SPringle 框架，IOC 是核心内容之一，今天来总结并谈谈对 Spring 中 IOC 的理解

1. IOC 是什么？

控制反转，不是什么技术，而是一种思想，思想的学习相对代码来说稍微难以理解一些。IOC是将你设计好的对象交给容器控制，而不是传统的在你的对象内部进行直接的控制。

• 谁控制了谁？控制的是什么？：传统的javase，我们是通过 new 一个对象的形式创建，是程序主动创建依赖对象，而 IOC 是有专门一个容器来创建这些对象，即右容器来对象的创建; 谁控制谁？是 IOC 容器控制了对象，主要控制外部资源获取
• 为何是反转，哪些方面反转： 传统应用程序，我们进行 new 对象主动控制直接获取依赖对象，这是正转；反转则是由容器来帮忙创建及注入依赖对象，对象被动接收依赖对象。

1.1 传统业务处理代码实现

Dao层

// 编写一个接口 UserDao
public interface UserDao {
  public void getUser();
}

====================================
/**
	实现上面的接口
*/
public class UserDaoImpl implements UserDao {
  public void getUser(){
    System.out.println("UserDao~~~~");
  }
}

Service 层

// 编写一个 Service 接口 UserService
public interface UserService {
  public void getUser();
}

===============================================

/**
	实现上面的接口
*/
public class UserServiceImpl implements UserService {
 	// 导入 dao 对象
  private UserDao userDao;
  public void getUser(){
    userDao.getUser();
  }
}

测试类

public class MyTest {
  public static void main(String[] args) {
    UserService userService = new UserServiceImpl();
    userService.getUser();
  }
}

通过这种测试的方法，可以通过测试。但是如果我们 dao 中再次增加一个类，需要是功能，那么我们需要做的是

1. 先建立一个类并实现接口，写出方法

public class UserMysqlDaoImpl implement UserDao{
	public void getMysql(){
		system.out.println("MySQL实现类执行了");
	}
}

2. 在业务层调用 dao 层

private UserDao = new UserMysqlDaoImpl();

/**
	这样的操作，每次有新的需求之后都需要在 new 之后做出改变，如果增加的量多，时十分不方便得
*/

1.2 利用 IOC 控制反转的 思想（XML）

针对上面传统的方式，我们利用 set 注入的方式

将 service 层中的代码进行修改

public class UserServiceImpl implements UserService {
  UserDao userDao;
	// 添加 set 方法注入
  public void setUserDao(UserDao userDao){
  	this.userDao = userDao;
  }

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

测试类

UserService userService = new UserServiceImpl();
((UserServiceImpl)userService).setUserDao(new UserDaoImpl());
userService.getUser();

2. 依赖注入

以最原始的 XML 方式进行展示

2.1 通过构造器方式注入

id: bean 的唯一标识符，也就是相当于我们学的对象名
class = new 的对象
name：属性名	value: 属性值
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="AD钙"></constructor-arg>
</bean>

2.2 Set 方式注入

依赖：bean 对象的创建依赖于容器

1. 复杂类型

public class Address{
	String address;
    public String getAddress(){
        return address;
    }
    public void setAddress(String address){
        this.address = address;
    }
}

2. 真实的测试对象

public class Student{
	private String name;
    private Address address;
    private String books;
    private List<String> hobby;
    private Map<String, String> card;
    private Set<String> games;
    private String wife;
    private Properties Info;
}

3. 完善注入信息

<bean id="address" class="com.kuang.pojo.Address">
    <property name="address" value="西安"></property>
</bean>
<bean id="student" class="com.kuang.pojo.Student">
    <!--第一种，普通值注入-->
    <property name="name" value="AD钙"></property>
    <!--第二种，bean注入，ref-->
    <property name="address" ref="address"></property>
    <!--数组注入，ref-->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>西游记</value>
            <value>水浒传</value>
            <value>三国演义</value>
        </array>
    </property>
    <!--List-->
    <property name="hobby">
        <list>
            <value>听歌</value>
            <value>吃饭</value>
            <value>看电影</value>
        </list>
    </property>
    <!--Map-->
    <property name="card">
        <map>
            <entry key="身份证" value="111111111111" />
            <entry key="学生卡" value="222222222222"></entry>
        </map>
    </property>
    <!--set-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>COC</value>
            <value>BOB</value>
        </set>
    </property>
    <!--null-->
    <property name="wife">
        <null></null>
    </property>
    <!--properties-->
    <property name="info">
        <props>
            <prop key="学号">202202313</prop>
            <prop key="性别">男</prop>
            <prop key="姓名">李四</prop>
        </props>
    </property>
</bean>

3. 使用注解实现自动装配

在 JDK1.5 之后支持注解，Spring 就支持注解了

使用注解须知：
导入约束。congtext 约束

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 开启自动装配 -->
    <context:annotation-config/>

</beans>

自动装配

@Autowired：自动装配通过类型。姓名

直接在属性上使用即可！也可以在 set 方法上使用

@Autowired 和 @Resource 区别
都是用来自动装配，都可以放在属性字段上
@Autowired 通过 byType 的方式实现
@Resource 默认通过 byname 的方式实现，如果找不到名字，则通过 byType 实现，都不行，就会报错

---

衍生的注解：
@Component 有几个衍生注解，在开发中，会按照三层架构分层 ！
dao层 —— @Repository
service层 —— @Service
controller层 —— @Controller

这四个注解功能都是一样的，都是代表将某个类注册到 Spring 中，装配Bean

---

小结：

我们在使用自动装配的时候就必须开启注解的支持

<context:annotation-config/>

IOC 思想的学习需要代码的实操，通过各种案例来满满培养控制反转这种思想，小编也是回顾学习 IOC 相信以后在项目中操作几次会对这种编程如鱼得水。