众所周知，Spring向来以IOC和AOP独创江湖，这是Spring的招牌和成名作。一直以来只是学着用Spring去快速开发一些项目，只知道如何配置实用，却没有去仔细看一下Spring的IOC是个什么东东。于是在网上找到几个介绍Spring IOC的文章，看过之后发现IOC的概念也没有什么难理解的，不过，Spring将其发光发热了，将IOC用的炉火纯青，淋漓尽致。好了，我就把一些介绍IOC的文章粗略记录一下吧，以备复习之用，参考了很多别人的文章，在此一并谢过！
IOC（有人也叫DI），就是控制反转，也叫依赖注入。大体的意思就是：不再靠程序员去手动创建类，由Spring替你创建和管理，降低业务逻辑之间的耦合程度。那么简答一句话：控制反转，到底控制什么反转了？答案就是获取对象的方式。我们可以简单地把IOC理解为一个管家，作为主人的你，你需要告诉你需要什么样的东西，管家就会帮你找出来，前提当然是这个东西是你的并且管家也知道有这么个东西。哈哈哈，有管家真好。。。
那么，Spring是如何实现IOC的呢？最好的方式是去看源代码，不过如果你只是想了解IOC，那么下面的例子可能会对你有帮助。
如何实现IOC，大体思路如下：
1.实现接口或者继承超类
2.使用setter方式或者构造函数的方式定义注入类
3.调用IOC获得注入类并调用其实现方法
假设场景：项目经理要你开发一个获取数据库时间的通用模块，要你兼容Mysql，Oracle，SQLServer，客户端调用者只需要传入要调用哪种数据库，你就返回对应的数据库时间。你会怎么做？
1.声明一个获取数据库时间的接口，提供一个获取数据库时间的接口方法
package com.robin;
public interface IDataBase {
public String getDate();
}
2.声明三个实现接口的类
package com.robin;
public class MySqlImpl implements IDataBase {
@Override
public String getDate() {
return "MYSQL的时间是2010-mysql";
}
}
package com.robin;
public class OracleImpl implements IDataBase {
@Override
public String getDate() {
return "Oracle的时间是2010-oracle";
}
}
package com.robin;
public class SqlServerImpl implements IDataBase {
@Override
public String getDate() {
return "SqlServer的时间是2010-SqlServer";
}
}
3.使用setter方式或者构造函数的方式定义注入类package com.robin;
public class BaseDataImpl {
private IDataBase database;
public void setDatebase(IDataBase database){
this.database = database;
}
public BaseDataImpl(IDataBase database){
this.database = database;
}
public String getDate(){
return database.getDate();
}
}
4.测试一下
package com.robin;
public class TestGetDate {
public static void main(String[] args) {
BaseDataImpl base = new BaseDataImpl(new MySqlImpl());
BaseDataImpl base1 = new BaseDataImpl(new OracleImpl());
BaseDataImpl base2 = new BaseDataImpl(new SqlServerImpl());
System.out.println(base.getDate());
System.out.println(base1.getDate());
System.out.println(base2.getDate());
}
}
在测试类中调用不懂得实现类，就会输入不同的时间，我们就实现了不再采用new的方式去获取对象，只需要传入一个标示数据库类型的名字就可以了，这就是IOC的简单实现，Spring的IOC原理大体也是这样的。
下面让我们一起来了解一下Spring是如何运行的
public static void main(String[] args) {
ApplicationContext context = new FileSystemXmlApplicationContext("applicationContext.xml");
Animal animal = (Animal) context.getBean("animal");
animal.say();
}
那么我们先看一下applicationContext.xml中是怎么配置的
<bean id="animal" class="phz.springframework.test.Cat"> <property name="name" value="kitty" /> </bean>
这个配置文件声明了一个Cat类，并且该类有一个成员属性：name
public class Cat implements Animal {
private String name;
public void say() {
System.out.println("I am " + name + "!");
}
public void setName(String name) {
this.name = name;
}
}
该类还实现了一个Animal的接口
public interface Animal {
public void say();
}
很明显该测试的输出结果是：I am kitty
那么Spring是如何进行查找和执行的呢？
首先，我们先创建一个Bean，用来存放一个Bean拥有的属性
/* Bean Id */ private String id; /* Bean Class */ private String type; /* Bean Property */ private Map<String, Object> properties = new HashMap<String, Object>();
一个Bean包括id，type和properties。接下来Spring就开始加载我们的配置文件了，将我们配置的信息保存在一个HashMap中，这个HashMap中的key就是bean的Id，HashMap的value就是这个bean。这样我们就能通过context.getBean("animal");来获取Animal这个类。Spring不但可以注入基本类型，还可以注入像List，Map这样的类型。
<bean id="test" class="Test"> <property name="testMap"> <map> <entry key="a"> <value>1</value> </entry> <entry key="b"> <value>2</value> </entry> </map> </property> </bean>
Spring是如何保存的呢？
if (beanProperty.element("map") != null) {
Map<String, Object> propertiesMap = new HashMap<String, Object>();
Element propertiesListMap = (Element) beanProperty
.elements().get(0);
Iterator<?> propertiesIterator = propertiesListMap
.elements().iterator();
while (propertiesIterator.hasNext()) {
Element vet = (Element) propertiesIterator.next();
if (vet.getName().equals("entry")) {
String key = vet.attributeValue("key");
Iterator<?> valuesIterator = vet.elements()
.iterator();
while (valuesIterator.hasNext()) {
Element value = (Element) valuesIterator.next();
if (value.getName().equals("value")) {
propertiesMap.put(key, value.getText());
}
if (value.getName().equals("ref")) {
propertiesMap.put(key, new String[] { value
.attributeValue("bean") });
}
}
}
}
bean.getProperties().put(name, propertiesMap);
}
然后就是最核心的部分了，让我们看一下Spring是如何实现依赖注入的吧，其实也非常简单，就是通过反射机制。在实例化一个类时，先通过反射调用类中的set方法将保存在HashMap中的类属性注入到类中。
首先是先实例化一个类：使用的反射
public static Object newInstance(String className) {
Class<?> cls = null;
Object obj = null;
try {
cls = Class.forName(className);
obj = cls.newInstance();
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
return obj;
}
然后将这个类的属性及方法注入进去public static void setProperty(Object obj, String name, String value) {
Class<? extends Object> clazz = obj.getClass();
try {
String methodName = returnSetMthodName(name);
Method[] ms = clazz.getMethods();
for (Method m : ms) {
if (m.getName().equals(methodName)) {
if (m.getParameterTypes().length == 1) {
Class<?> clazzParameterType = m.getParameterTypes()[0];
setFieldValue(clazzParameterType.getName(), value, m,
obj);
break;
}
}
}
} catch (SecurityException e) {
throw new RuntimeException(e);
} catch (IllegalArgumentException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
最后Spring将实例返回给我们
if (value instanceof Map) {
Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
.iterator();
Map<String, Object> map = new HashMap<String, Object>();
while (entryIterator.hasNext()) {
Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
if (entryMap.getValue() instanceof String[]) {
map.put((String) entryMap.getKey(),
getBean(((String[]) entryMap.getValue())[0]));
}
}
BeanProcesser.setProperty(obj, property, map);
}
这里只是举个例子，实际Spring做的工作远不止这些，我们理解Spring的工作原理就好了。