Spring--对于IoC的简单理解

1. IoC的定义

1. IOC(Inversion of Control) ,即控制反转，不是具体的技术，而是一种思想；
2. IOC意味着将你设计好的对象交给Spring容器来管理，而不是传统的在你的对象内部直接控制；
3. 对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。

2. 传统方式带来的问题

假设现在我们需要查询一个用户的数据，有3种方式可以查询，一种是默认查询，一种是去MySQL数据库中查询，还有一种是去Oracle数据库中查询，现在我们需要实现方法去使用不同方式进行查询

1. 首先创建一个查询接口（Dao层）,里面是我们需要的查询方法

public interface UserDao {
    void getUser();
}

2. 然后分别实现这个类，重写其中的方法

//默认读取的方法实现类
public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("默认数据读取");
    }
}

//MySQL数据库读取的方法实现类
public class UserDaoMySQLImpl implements UserDao{
    public void getUser() {
        System.out.println("MySQL读取用户数据");
    }
}

//Oracle数据库读取的方法实现类
public class UserDaoOracleImpl implements UserDao {
    public void getUser() {
        System.out.println("Oracle读取用户数据");
    }
}

3. 接下来就是编写服务层的接口（Service层）

public interface UserService {
    void getUser();
}

4. 由于有3种方式，所以我们需要写3个实现类，下面以实现默认查询方法为例

public class UserServiceImpl implements UserService {
    UserDao userDao = new UserDaoImpl();
    //UserDao userDao = new UserDaoMySQLImpl();
    //UserDao userDao = new UserDaoOracleImpl();

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

5. 测试方法

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

6. 出现的问题
   由于上面实现的是默认查询方法的实现，所以得到的结果是“默认数据读取”，如果我们需要去MySQL中读取，则需要去Service的实现类中去修改Dao的实现方式或者另外再写一个Service的实现；如果再用Oracle实现，就要重复上述工作，这样会带来大量的重复代码，并且使得代码的功能单一，即耦合性高

3. 解决耦合性高的办法

1. 由于问题主要出现在Service层的实现方面，有几个Dao就需要实现机场Service方法，而实现这些方法，唯一的区别就是Dao的实现不同，所以考虑采用Setter方法，在实现Service时动态注入Dao的值，注入我们所需要的Dao，这样便大大缓解了程序的耦合性

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

2. 这样，当我们需要不同方式去查找时，就传入相应的Dao参数即可，如此便实现了动态查询的方法

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

4. Spring的IoC实现

1. Spring可以通过读取XML配置文件的方式去读取参数，根据参数去创建所需要的对象(SpringBean)，文件名一般为applicationContext.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">

	<!--通过id去得到创建的对象，即所创建的对象的名字
	class为所需要创建对象的路径
	property为创建的类中属性名
	value为属性值对应的值
	ref为引用Spring中已经创建好的对象
	-->
    <bean id="userDaoImpl" class="com.hust.dao.UserDaoImpl"/>
    <bean id="mySQLImpl" class="com.hust.dao.UserDaoMySQLImpl"/>
    <bean id="oracleImpl" class="com.hust.dao.UserDaoOracleImpl"/>

    <bean id="UserServiceImpl" class="com.hust.service.UserServiceImpl">
        <property name="userDao" ref="userDaoImpl"/>
    </bean>

    <bean id="UserServiceImpl1" class="com.hust.service.UserServiceImpl">
        <property name="userDao" ref="mySQLImpl"/>
    </bean>

    <bean id="UserServiceImpl2" class="com.hust.service.UserServiceImpl">
        <property name="userDao" ref="oracleImpl"/>
    </bean>
</beans>

2. 通过读取XML文件来获取对象

public class MyTest {
    public static void main(String[] args) {
    	//参数为配置文件的名称	
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userServiceImpl = (UserService)context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
        UserService userServiceImpl1 = (UserService)context.getBean("UserServiceImpl1");
        userServiceImpl1.getUser();
        UserService userServiceImpl2 = (UserService)context.getBean("UserServiceImpl2");
        userServiceImpl2.getUser();
    }
}

5. 控制反转的核心

1. 控制：谁来控制对象的创建–由Spring来创建对象
2. 反转：程序本身不再创建对象，而变成被动地接收对象
3. 依赖注入：使用setter方法来对参数进行注入
4. 只需要在XML文件在去进行修改即可实现不同的方法
5. 总结：对象由Spring来创建，管理，装配