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方法将参数设置就好了。。。