spring是一个轻量级的容器框架，主要是为了使企业的开发变得简单、高效。无论是从大小还是开销来讲，他都可以算是轻量级的，也是非侵入性的。
下图是spring的框架示意图，说到spring，就不得不提他的控制反转（IOC，Inversion of Control）。
那么他的控制反转是如何实现的呢？
**控制反转一般有两种类型，依赖注入（DI）和依赖查找。依赖注入应用比较广泛。**
首先来看，如果没有使用spring，我们的一般操作是怎样的。
client，dao和manager三个包，其中client为客户端调用，UserDao和UserManager为接口。
~~~
/*
* mysql的实现类
*/
public class UserDao4MySqlImpl implements UserDao {
//添加用户
public void addUser(String username, String password) {
System.out.println("UserDao4MySqlImpl.addUser()");
}
}
/*
* oracle的实现类
*/
public class UserDao4OracleImpl implements UserDao {
//添加用户
public void addUser(String username, String password) {
System.out.println("UserDao4OracleImpl.addUser()");
}
}
~~~
业务层的实现类
~~~
public class UserManagerImpl implements UserManager {
@Override
public void addUser(String username, String password) {
// 由我们的应用程序负责服务（对象）定位
//如果不使用mysql数据库，就需要修改该类的方法实现
// UserDao userDao = new UserDao4MySqlImpl();
UserDao userDao = new UserDao4OracleImpl();
userDao.addUser(username, password);
}
}
~~~
客户端调用方法：
~~~
public class Client {
public static void main(String[] args) {
// 由我们的应用程序负责服务（对象）定位
UserManager userManager = new UserManagerImpl();
userManager.addUser("张三", "123");
}
}
~~~
我们知道对象的创建过程，如果需求有变，可以进行更换。尽管可以进行修改，但始终是应用程序来管理对象之间的依赖关系，而spring的控制反转，将这个操作交给容器管理。
DI（Dependency Injection）
这里说两种DI注入的方式：setter注入和构造方法注入。
1）setter注入
我们还是举上面的例子，dao包中的内容都不需要改变，我们只需要将manager包中进行调整即可。如在UserManagerImpl类中，注入UserDao。
~~~
public class UserManagerImpl implements UserManager {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
....
<span style="font-size:18px;">}</span>
~~~
配置文件
~~~
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="userDao4Mysql" class="com.spring.dao.UserDao4MySqlImpl"/>
<bean id="usrDao4Oracle" class="com.spring.dao.UserDao4OracleImpl"/>
<bean id="userManager" class="com.spring.manager.UserManagerImpl">
<!--使用setter方法注入-->
<property name="userDao" ref="usrDao4Oracle"/>
</bean>
</beans>
~~~
2）构造方法注入
~~~
public class UserManagerImpl implements UserManager {
private UserDao userDao;
//构造方法
public UserManagerImpl(UserDao userDao) {
this.userDao = userDao;
}
...
}
~~~
将配置文件中的userManager的bean进行修改
~~~
<bean id="userManager" class="com.spring.manager.UserManagerImpl">
<!--
<constructor-arg ref="userDao4Mysql"/>
-->
<!-- 使用构造函数 -->
<constructor-arg ref="usrDao4Oracle"/>
</bean>
~~~
当然，DI还有其他的实现方式，在这里就不介绍了，跟这两种都很类似。
小结：
通过控制反转，我们将类与类之间的关系，对象的生成放到了配置文件中，这样既在一定程度上实现了解耦，也使得改变更加容易。
