通俗讲java反射机制ioc_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方法将参数设置就好了。。。