spring的ioc原理（java反射机制）

为什么要有ioc这个概念，其实自己以前一直不是很理解，后来随着自己经验稍微多了一些，认识到，在一些系统中，通过这种依赖注入的方式确实可以让代码之间的耦合更弱一些，可以更好管理对象之间的关系。。。

其实本来是想直接分析spring的源代码的，但是将ioc部分的代码，也就是beanfactory部分的代码大致的看了一次以后觉得spring的代码可能有点太多了，而且封装的太复杂，因此就直接打消了这中想法，就直接来看实现的原理好了，其实只是将原理抽出来的话还是非常的简单的，直接来看代码吧：

package test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Bean {
private String name;
private int age;
private double high;

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

public double getHigh() {
return high;
}
public void setHigh(double high) {
this.high = high;
}
//根据类型，将数据转化为相应的类型
public static Object castTo(String value, Class<?> type) {
if (type == String.class) {
return value;
} else if (type == int.class) {
return Integer.parseInt(value);
} else if (type == double.class){
return Double.parseDouble(value);
} else {
return null;
}
}

public static void setValue(Object object, String value, String paraName) {
try {
Class<?> type = object.getClass().getDeclaredField(paraName).getType();  //获取当前参数的类型class
Object tValue = Bean.castTo(value, type);   //将参数的值转换为相应的类型
String methodName = "set" + paraName.substring(0, 1).toUpperCase() + paraName.substring(1);  //根据标准，获取相应的方法名字
Method method = object.getClass().getMethod(methodName , new Class[]{type});  //获取要调用的方法
method.invoke(object, new Object[]{tValue});  //调用方法
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void main(String args[]) throws NoSuchFieldException, SecurityException {
Object a = new Object();
//Proxy.newProxyInstance(loader, interfaces, h)
Bean bean = new Bean();
Bean.setValue(bean, "fjs", "name");
Bean.setValue(bean, "123", "age");
Bean.setValue(bean, "176.5", "high");
System.out.println(bean.getName() + "   " + bean.getAge() + "   " + bean.getHigh());
}
}

上面就是实现依赖注入的最浅显的原理，通过java的反射机制，将属性的配置参数转化为相应的类型，然后在调用规定的set方法将参数设置就好了。。。