Spring实例-通过Java的反射机制和spring IOC初始化JavaBean

通过反射的方法实例化对象

1 声明PO实体： 

public class Car 
{  
    //品牌
    private String brand; 
    //颜色
    private String color;  
    //最大速度
    private int maxSpeed;  

    //默认不带参数的构造方法 
    public Car(){}  

    //带参构造方法 
    public Car(String brand,String color,int maxSpeed)
    {   
        this.brand = brand;  
        this.color = color;  
        this.maxSpeed = maxSpeed;  
    }  

    //输出基本信息
    public void introduce() 
    {   
        System.out.println("brand:"+brand+";color:"+color+";maxSpeed:" +maxSpeed);  
    }  
    
    //省略参数的getter/Setter方法  

}

2 测试类：

public class TestReflect 
{
    public static Car  initByDefaultConst() throws Throwable
    {
        //1 通过类装载器获取Car类对象
        //1.1 声明classloader对象 也就是类装载器
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //1.2 声明类对象 并使用类装载器 把类装载给类对象 也就是说这个对象 实际表示了一个类
        Class classCar = loader.loadClass("com.test.ioc.po.Car"); 

        //2 获取类的默认不带参数的构造方法 并通过它实例化对象
        //2.1 声明构造方法对象 并实例化
        Constructor cons = classCar.getDeclaredConstructor((Class[])null); 
        //2.2 声明一个Car对象 并用类对象的构造方法对象 实例化
        Car car = (Car)cons.newInstance();


        //3 通过反射设置属性 
        //3.1 获取方法对象                参数说明：1 方法名  2 返回类型的class
        Method setBrand = classCar.getMethod("setBrand",String.class);	
        //3.2 使用方法对象注入属性 参数说明：1 对象 2属性值
        setBrand.invoke(car,"红旗CA72");
        
        Method setColor = classCar.getMethod("setColor",String.class);
        setColor.invoke(car,"黑色");	
        
        Method setMaxSpeed = classCar.getMethod("setMaxSpeed",int.class);
        setMaxSpeed.invoke(car,200);		
        return car;
    }

    public static void main(String[] args) throws Throwable 
    {
        //使用自定义的反射构造器注入新的对象
        Car car = initByDefaultConst();
        //输出对象的属性
        car.introduce();
    }
}

例子中通过反射实例化对象的通俗理解如下过程：

核心关键词是Class对象，ClassLoader，构造方法对象，方法对象。

反射的理解：

反射的意思其实就是把抽象的东西实体化，并让他做一些实际的事情，比如传统的一个类，就是在声明对象的时候使用的，做一些对象的抽象定义（描述对象有哪些属性和方法）。

当我们给对象一些实在的属性值，也就是实例化了，这个对象才真正有了意义。

反射的作用在于把一个类自己变成了一个实实在在的对象，我们可以直接调用这个对象里的各个方法来做一些实际的事情。比如调用类对象的方法对象，实例化对象的一些属性。

反射过程的理解：

首先要有个ClassLoader来Load Class，为什么要用ContextClassLoader？因为他能读取已经定义的Class。

然后定义一个Class对象，用ClassLoader载入也就是把抽象的类载入为一个实体的类对象。

然后就可以使用这个class的各个内部对象和方法来执行灵活的实例化过程了。

通过spring IOC实例化对象

1 声明PO类 

public class Person
{
    //Properties数据结构类似于一个map 而且可以实例化为property文件
    private Properties basicInfo;

    //基本信息
    public Properties getBasicInfo()
    {
        return basicInfo;
    }

    public void setBasicInfo(Properties basicInfo)
    {
        this.basicInfo = basicInfo;
    }  
}

2 定义配置文件和测试类 

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
    ">

	<bean id="John" class="com.test.ioc.po.Person">
		<property name="basicInfo">
			<props>
				<!-- 姓名 -->
				<prop key="name">John</prop>
				<!-- 身高 -->
				<prop key="stature">1.75</prop>
				<!-- 体重 -->
				<prop key="avoirdupois">120</prop>
			</props>
		</property>
	</bean>
</beans>

public class TestIoc
{

    /**
     * @param args
     */
    public static void main(String[] args)
    {

        //1 使用spring的容器 1.1 spring ioc配置文件 1.2解析并实例化容器
        //ApplicationContext context = new ClassPathXmlApplicationContext("/test_spring/src/spring_conf/applicationContext.xml");
        ApplicationContext context = new ClassPathXmlApplicationContext(" classpath:/spring_conf/applicationContext.xml");
       
        //2 从容器中获取Bean进行注入和初始化  参数1 Bean的id  参数2 Bean的class
        Person John = context.getBean("John", Person.class);
        //3 执行业务逻辑
        System.out.println("John's stature is " + John.getBasicInfo().getProperty("stature"));
    }

}

3 IOC过程的理解

首先是定义一个Context也就是上下文对象，对应于一个Context配置，Context通俗讲就是Bean的上下文，在例子中定义了Bean的属性初始值。

IOC的控制反转是在Context中控制的，也就是各种依赖关系在Context中定义。

IOC的理解有3个关键词：Bean、Context、Core。Context就是定义依赖关系的文件，Bean就是实例化的对象，而执行实例化的过程就是Core。Core也就是由spring的IOC机制完成了从定义到实例化的过程，反应在例子中就是Bean的实例化过程。

4 实际上spring的IOC注入方法还有如下几种：

1) 通过构造器注入

2) setter方法注入

3) 工厂方法注入

4) 常量值注入

5) 属性值设置为其他bean

各种注入方法参考如下：

http://sishuok.com/forum/blogPost/list/2447.html