上篇博客【SSH进阶之路】Spring简介，搭建Spring环境――轻量级容器框架（1），我们简单的介绍了Spring的基本概念，并且搭建了两个版本的Spring开发环境，但是我们剩下了Spring最核心的两大技术：IoC和AOP，没有深入介绍。从这篇博文开始，我们开始逐一的深入学习Spring的两个核心。Spring目前最引人注视的地方，就是IOC=Inversion Of Control（控制反转）或DI=Dependence
Injection(依赖注入)的设计思想。
这篇博客我们使用传统方式（即不使用Spring）来实现1个添加用户的实例，再同理使用Spring实现添加用户的实例，对照学习IoC的概念，和为何使用IoC等等，最后，简单总结。下面我们开始：
传统方式：
客户端：
public class Client {
public static void main(String[] args){
//由我们的利用程序负责服务（对象）定位，主动发起查找
UserManager userManager = new UserManagerImpl();
userManager.addUser("jiuqiyuliang", "123456");
}
}
业务逻辑层：
UserManager接口：添加用户的方法
public interface UserManager {
public void addUser(String userName,String password);
}
UserManager实现
public class UserManagerImpl implements UserManager{
@Override
public void addUser(String userName, String password) {
//由我们的利用程序负责服务（对象）定位，主动发起查找
//UserDao userDao = new UserDao4MysqlImpl();
UserDao userDao = new UserDao4
OracleImpl();
userDao.addUser(userName, password);
}
}
数据访问层：
UserDao接口：添加用户的方式
public interface UserDao {
public void addUser(String userName,String password);
}
UserDao两种实现（Mysql和Oracle）：传统方式使用配置文件，然后使用工厂来创建相应的对象（即我们常常说的配置文件+抽象工厂+反射，1会儿我们再看看Spring创建对象的方式）
public class UserDao4MysqlImpl implements UserDao{
@Override
public void addUser(String userName, String password) {
//打印访问Mysql的相干信息
System.out.println("UserDao4MysqlImpl.addUser");
}
}
public class UserDao4
OracleImpl implements UserDao{
@Override
public void addUser(String userName, String password) {
//打印访问
Oracle的相干信息
System.out.println("UserDao4
OracleImpl.addUser");
}
}
运行效果图：
看到上面的代码，非常的熟习，由于我们平时常常使用。但是问题来了，在业务逻辑层的实现中，UserDao有多种不同的实现方式，例如Mysql和Oracle，UserManager要依赖于UserDao的具体实现。并且对象是由我们自己负责创建的，我们主动的发起了1个查找，要依赖于1种数据库的实现。此时我们的UserManager就和UserDao的具体实现牢牢的耦合在1起了。我们再看客户端，我们要使用UserManager，同业务逻辑层1样，还得需要我们自己负责主动查找UserManager的具体实现。
我们可以发现：传统方式，对象和对象之间产生严重的依赖关系，耦合度非常高而且依赖关系都写死在了代码里，项目不容易修改和保护，必须要改代码。
下面我们使用Spring方式改造实例，实现一样的功能，让Spring管理我们的对象，看看Spring是怎样创建对象和描写对象之间依赖关系的。
Spring方式：
项目的包图：
客户端：
public class Client {
public static void main(String[] args){
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
//到IOC容器中获得UserManager
UserManager userManager = (UserManager) factory.getBean("userManager");
//UserManager使用UserDao，在配置文件已有依赖关系
userManager.addUser("jiuqiyuliang", "123456");
}
}
业务逻辑层：
UserManager实现：
public class UserManagerImpl implements UserManager{
private UserDao userDao;
//使用构造方式赋值
public UserManagerImpl(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void addUser(String userName, String password) {
userDao.addUser(userName, password);
}
}
Spring的配置文件：
<?xml version="1.0" encoding="UTF⑻"?>
<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⑷.1.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop⑷.1.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx⑷.1.xsd">
<!-- 使用spring管理对象的创建，还有对象的依赖关系 -->
<bean id="userDao4Mysql" class="com.tgb.spring.dao.UserDao4MysqlImpl"/>
<bean id="userDao4
Oracle" class="com.tgb.spring.dao.UserDao4
OracleImpl"/>
<bean id="userManager" class="com.tgb.spring.manager.UserManagerImpl">
<!-- (1)userManager使用了userDao，Ioc是自动创建相应的UserDao实现，都是由容器管理-->
<!-- (2)在UserManager中提供构造函数，让spring将UserDao实现注入（DI）过来 -->
<!-- (3)让spring管理我们对象的创建和依赖关系，必须将依赖关系配置到spring的核心配置文件中 -->
<constructor-arg ref="userDao4
Oracle"/>
</bean>
</beans>
由于其他地方的代码和效果图，同上，不再浪费大家的带宽。
对照传统的实现方式，再看客户端和UserManager，我们可以发现：通过IoC或DI，我们只需要通过简单的配置，而无需任何代码就能够指定UserManager中所需的UserDao的具体实现。UserManager只需利用容器注入的UserDao实例，完成本身的业务逻辑，而不用关心具体实现来自哪、由谁实现。换句话说：我们不再需要自己负责创建对象，保护对象的依赖关系，这些都有Spring替我们完成了。
传统方式和Spring方式对照：
传统方式：决定使用哪个具体实现是由利用程序负责的，在编译阶段就肯定了。
Spring方式：调用类只依赖接口，而不依赖具体的实现类，减少了耦合。控制权交给了容器，在运行期才由容器决定将具体的实现动态的“注入”到调用类的对象中。这也是使用IoC的根本缘由。
现在我们对IoC有了基本认识，我们再理解1下IoC的概念。
IoC
IoC（Inversion of Control），控制反转，用白话来说，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接控制。这也就是所谓“控制反转”的概念所在：控制权由利用代码中转到了外部容器，控制权的转移，就是所谓反转。
IoC的优缺点
优点：
1、把对象的创建和依赖关系定义在了XML文件中，我们改变子类的实现变得异常简单。
2、控制反转减轻了对象之间的耦合度，减轻了对象之间的依赖关系，增加了系统的灵活性，可保护性，和可移植性等等。
缺点：
1、生成对象的方式变复杂了（事实上操作还是挺简单的），对不习惯这类方式的人，会觉得有些别扭和不直观。
2、创建对象由于使用了反射技术，在效力上有些消耗。但相对IoC提高的保护性和灵活性来讲，这点消耗是微不足道的，除非某对象的生成对效力要求特别高。
总结
IoC使得面向对象的世界更加简单，面向接口编程成了可能。
引言：下篇博文，我为大家转载了1篇深入理解IoC原理的博文，相当简单，通俗易通。以后，我为大家准备了1篇依赖注入几种类型对照的博文，快马加鞭ing，敬请期待。