Spring . IOC

1.1 IOC理论推导

1.UserDao接口

public interface UserDao {
 ? ?void getUser();
}

2.UserDaoImpl接口实现类

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

3.UserServices业务接口

public interface UserServices {
 ? ?void getUser();
}

4.UserServicesImpl业务接口实现类

程序猿掌握主动权，程序主动创建对象（需要根据用户的需求修改底层代码，十分麻烦！！）

public class UserServicesImpl implements UserServices{
 ? ?//根据需要使用的业务创建对象
 ? ?private UserDao userDao = new UserDaoImpl();
?
 ? ?public void getUser() {
 ? ? ? ?userDao.getUser();
 ?  }
}

将控制权交给用户，根据用户需求，程序被动的创建对象（使用set结构实现）

public class UserServicesImpl implements UserServices{
?
 ? ?private UserDao userDao;
 ? ?
 ? ?//使用set方法动态的实现值的注入
 ? ?public void setUserDao(UserDao userDao) {
 ? ? ? ?this.userDao = userDao;
 ?  }
?
 ? ?public void getUser() {
 ? ? ? ?userDao.getUser();
 ?  }
}

使用set方法的好处就是程序猿不再需要去管理对象的创建，全部交给用户端的需求，被动创建。
系统的耦合性大大的降低，程序猿可以更加卖力与业务动能的开发（真是头秃呀~）。
这种思想是IOC的原型。

1.2 IOC的本质

用结构图理解下：

控制反转(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬解码在程序中，对象的创建由程序控制，控制反转后对象的创建移交于第三方，即获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式把二者合二为一。Bean的定义信息直接以注解的形式定义在实现类中，实现零配置的目的。

控制反转是一种通过描述(xml或者注解)并通过第三方去生产或者获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Denpendency injection，DI）。

1.3 HelloSpring

1.pojo的Hello类

package pojo;
?
public class Hello {
 ? ?private String name;
?
 ? ?public String getName() {
 ? ? ? ?return name;
 ?  }
 ? //依赖注入使用set的实现方式
 ? ?public void setName(String name) {
 ? ? ? ?this.name = name;
 ?  }
?
 ? ?@Override
 ? ?public String toString() {
 ? ? ? ?return "Hello{" +
 ? ? ? ? ? ? ? ?"name='" + name + '\'' +
 ? ? ? ? ? ? ? ?'}';
 ?  }
}

2.配置文件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"
 ? ? ? xmlns:context="http://www.springframework.org/schema/context"
 ? ? ? xsi:schemaLocation="http://www.springframework.org/schema/beans
 ? ? ? http://www.springframework.org/schema/beans/spring-beans.xsd">
?
 ? ?<!--使用Spring来创建对象，在Spring中对象称为bean
 ? ?类型 对象名 = new 类型()；
 ? ?id = 对象名；
 ? ?class = new的类型
 ? ?property：给对象中的属性赋值
 ? ?-->
 ? ? ? ?
 ? ? ? ?<bean id="hello" class="pojo.Hello">
 ? ? ? ? ? ?<property name="name" value="spring"/>
 ? ? ? ?</bean>
</beans>

3.测试文件TestMain

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Hello;
?
public class TestMain {
 ? ?public static void main(String[] args) {
 ? ? ? ?//获取ApplicationContext，获取Spring容器
 ? ? ? ?ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
 ? ? ? ?//从Spring容器获取对象(容器在手，天下我有！！)
 ? ? ? ?Hello hello = context.getBean("hello", Hello.class);
 ? ? ? ?System.out.println(hello.getName());
 ?  }
}

上面这整个过程就叫做控制反转(还有点蒙圈中o(╥﹏╥)o......)