IoC——Inversion of Control 控制反转
DI——Dependency Injection 依赖注入
大家都知道，依赖注入是Spring中非常重要的一种设计模式。可能很多初学者对这种看起来高深的东西有一种抗拒，这里就
简单介绍一下到底什么是依赖注入，Spring到底又到底是如何运用依赖注入的。
依赖关系:在A组件中要引用B组件的对象，则称A依赖于B
依赖关系会造成各组件之间的硬编码，为解决依赖关系，一般的解决方法如下：
1、A组件先创建B组件，在调用B组件方法
2、A组件先通过B组建的工厂获取B组件，再调用B组件方法
3、A、B两个组件都由容器管理，容器先将B组件传给A组件，A组件直接调用B的方法
第一个是传统的方法，并没有解决依赖关系
第二个则造成了A与工厂类的耦合
Spring就是通过第三种方法解决的，被称为依赖注入。
依赖注入和控制反转其实就是将的同一个设计模式，只是从不同的角度进行描述的。
依赖注入是从组件之依赖关系讲的，指A不再主动的去创建B组件，而变为被动的接受容器的注入的B对象；
而控制反转是从对对象的控制方面讲的，是指程序代码直接操控的对象的调用权交给容器。
依赖注入包括两种方式，一是设值注入，一是构造注入。下面就以Spring中具体代码实现例子来解释两种依赖注入方式：
1、数据库操作的接口：
1 public interface UserDao { 2 3 void save(String name,String pass); 4 }
2、接口两种实现方式：
程序只是简单模拟连接数据库，并没有真正进行连接：
（1）
1 import com.csu.test.dao.UserDao;
2
3 public class UserDaoJdbc implements UserDao{
4
5 @Override
6 public void save(String name, String pass) {
7
8 System.out.println("模拟通过JDBC存储用户："+name );
9 }
10
11 }
（2）
1 import com.csu.test.dao.UserDao;
2
3 public class UserDaoHibernate implements UserDao{
4
5 @Override
6 public void save(String name, String pass) {
7
8 System.out.println("模拟通过Hibernate存储用户："+name );
9 }
10
11 }
3、Service 层：
1 import org.springframework.context.ApplicationContext;
2 import org.springframework.context.support.ClassPathXmlApplicationContext;
3
4 import com.csu.test.dao.UserDao;
5
6 public class UserService {
7
8 private UserDao userDao;
9
10
11
12 //1、通过为userDao提供sett方法，在配置文件中的property属性进行配置，即可解决A依赖B的问题
13 public void setUserDao(UserDao userDao) {
14 this.userDao = userDao;
15 }
16
17 //2、通过构造方法进行配置
18 public UserService(UserDao userDao){
19 this.userDao = userDao;
20 }
21
22
23
24 public void addUser(String name,String pass){
25 //UserDao userDao = new UserDao();
26 //UserDao userDao = new UserDaoJdbc();
27 //UserDao userDao = UserDaoFactory.getUserDao();
28
29 /**
30 //spring中可以向创建Spring容器
31 ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
32 UserDao userDao = ctx.getBean("userdao",UserDao.class);
33 userDao.save(name, pass);
34 **/
35
36 userDao.save(name, pass);
37 }
38 }
4、配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- 整个Spring 文件的根元素就是beans -->
<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 id="userdaoJdbc" class="com.csu.test.dao.impl.UserDaoJdbc"/>
<bean id="userdaoHibernate" class="com.csu.test.dao.impl.UserHibernate"/>
<bean id = "userService" class="com.csu.test.service.UserService">
<!-- property就是控制调用setter方法 -->
<!-- <property name = "userDao" ref = "userdaoJdbc"/> -->
<!-- 调用有参构造器 -->
<constructor-arg ref = "userdaoJdbc"/>
<!--更换实现方式-->
<!--
<property name = "userDao" ref = "userdaoHibernate"/>
<constructor-arg ref = "userdaoHibernate"/>
-->
</bean>
</beans>
这里重点解释一下吧：
在service层中的UserService类中，是依赖于数据库操作对象UserDao的，如大家所见，UserService类中我们并没有直接new出UserDao对象的，
怎么做到的呢：两种方式
（1）、设值注入：
对应函数为：public void setUserDao(UserDao userDao)
在配置文件中，对应id为userService的Bean设置，有一个property的属性，这意味着，当我们在得到userService的Bean对象时，根据property的属性，容器会自动调用
与name相应的set函数，即上面的函数，传入的参数依旧为Bean对象，所以用ref
（2）、构造注入
对应函数为：public UserService(UserDao userDao)
与设值注入类似，<constructor-arg>标签的含义就是调用构造函数，传递参数，自动实例化UserDao。
当然两种方式不要重复设置，上面已经注释掉一种，可以自己再测试一下。
5、测试主类：
1 import org.junit.Before;
2 import org.junit.Test;
3 import org.springframework.context.ApplicationContext;
4 import org.springframework.context.support.ClassPathXmlApplicationContext;
5
6 import com.csu.test.dao.UserDao;
7 import com.csu.test.service.UserService;
8
9 public class TestService {
10
11 UserService u;
12
13 @Test
14 public void testAddUser(){
15 ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
16 u = ctx.getBean("userService",UserService.class);
17
18 u.addUser("admin", "123");
19 }
20 }
这样，我们就实现了面向接口编程，具体的实现类配置在配置文件即可，像上面的代码，我们只需要更改配置文件，
就可以改变数据库的操作对象。
