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還有其他的實現方式，在這里就不介紹了，跟這兩種都很類似。
小結：
通過控制反轉，我們將類與類之間的關系，對象的生成放到了配置文件中，這樣既在一定程度上實現了解耦，也使得改變更加容易。
