spring ioc原理 反射_spring ioc原理 反射_spring ioc aop的原理

IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将推动类 、参数信息等配置在其对应的配置文件中 ，那么当必须修改实现类或参数信息时，只应该设置配置文件就能，这种方式在上例的基础上更进一步的减少了类与类之间的耦合。我们还可以对某对象所必须的其他对象进行注入 ，这种注入都是在配置文件中做的，Spring的IOC的推动原理运用的就是Java的反射模式，Spring还充当了工厂的角色spring ioc原理 反射，我们不需要自己构建工厂类 。Spring的工厂类会给我们完成配置文件的加载、利用反射模式注入对象等工作，我们可以借助bean的名称获得对应的对象。下面令我们说说如下的模拟Spring的bean工厂类：

1、BeanFactory.java

package com.yt.manager.spring;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.log4j.Logger;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
/**
 * @ClassName: BeanFactory
 * @Project: base-info
 * @Author: zxf
 * @Date: 2011-5-19
 */
public class BeanFactory {
	
	Logger log = Logger.getLogger(BeanFactory.class);
	private Map<String, Object> beanMap = new HashMap<String, Object>();
	/**
	 * bean工厂的初始化
	 * 
	 * @param xml
	 */
	public void init(String xml) {
		try {
			//读取指定的配置文件
			SAXReader reader = new SAXReader();
			//从class目录下获取指定的配置文件
			ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
			InputStream inputStream = classLoader.getResourceAsStream(xml);
			//读取xml文件
			Document document = reader.read(inputStream);
			//获取跟节点
			Element root = document.getRootElement();
			//遍历bean节点
			Element foo;
			for(Iterator iteBean = root.elementIterator("bean");iteBean.hasNext();){
				foo = (Element)iteBean.next();
				//获取bean的属性id和class
				Attribute id = foo.attribute("id");
				Attribute cls = foo.attribute("class");
				//利用java反射机制，通过class的名称获取Class对象
				Class bean = Class.forName(cls.getText());
				//获取对应class信息
				java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
				//获取其属性描述
				java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
				//设置值的方法
                Method mSet = null;
                //创建一个对象(创建此 Class 对象所表示的类的一个新实例。如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。)
                Object obj = bean.newInstance();
                
                //遍历该bean的property属性
                for(Iterator iteProperty = foo.elementIterator("property");iteProperty.hasNext();){
                	Element elementProperty = (Element)iteProperty.next();
                	//获取该property的name属性
                	Attribute name = elementProperty.attribute("name");
                	String value = null;
                	//获取该property的子元素value的值
                	for(Iterator iteValue = elementProperty.elementIterator("value");iteValue.hasNext();){
                		Element elementValue = (Element)iteValue.next();
                		value = elementValue.getText();
                		break;
                	}
                	
                	for (int k = 0; k < pd.length; k++) {
                		log.info(pd[k].getName());
                        if (pd[k].getName().equalsIgnoreCase(name.getText())) {
                               mSet = pd[k].getWriteMethod();
                               //利用Java的反射机制调用对象的某个set方法，并将值设置进去
                               mSet.invoke(obj, value);
                        }
                 }
                }
               //将对象放入beanMap中，其中key为id值，value为对象
                beanMap.put(id.getText(), obj);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
    /**
     * 通过bean的id获取bean的对象.
     * @param beanName bean的id
     * @return 返回对应对象
     */
     public Object getBean(String beanName) {
           Object obj = beanMap.get(beanName);
           return obj;
     }
     public static void main(String[] args) {
         BeanFactory factory = new BeanFactory();
         factory.init("config.xml");
         JavaBean javaBean = (JavaBean) factory.getBean("javaBean");
         System.out.println("userName=" + javaBean.getUserName());
         System.out.println("password=" + javaBean.getPassWord());
     }
}

2、JavaBean.java

package com.yt.manager.spring;
/**
 * @Description:
 * @ClassName: JavaBean
 * @Project: base-info
 * @Author: zxf
 * @Date: 2011-5-19
 */
public class JavaBean {
	private String userName;
	private String passWord;
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassWord() {
		return passWord;
	}
	public void setPassWord(String passWord) {
		this.passWord = passWord;
	}
}

3、config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id = "javaBean" class="com.yt.manager.spring.JavaBean">
		<property name="userName">
			<value>这是姓名</value>
		</property>
		<property name="passWord">
			<value>这是密码</value>
		</property>
	</bean>
</beans>

可以提到，虽然在main()方法中没有对属性赋值，但属性值已经被注入，在BeanFactory类中的Class bean = Class.forName(cls.getText()); 通过类名来获得对应的类，mSet.invoke(obj, value);通过invoke方法来读取特定对象的特定方式，实现的机理都是基于Java的反射模式，在此我们有一次见证了Java反射机制的超强。当然，这并非对IOC的一个简单演示，在Spring中，情况应复杂得多，例如，可以一个bean引用另一个beanspring ioc原理 反射，还可以有多个配置文件、通过多种方式载入配置文件之类。不过原理还是采取Java的反射模式来推动IOC的。

在本文中，笔者通过讲述Java反射机制概述与初探、IOC使用的背景、IOC粉墨登场等内容，演示了Java反射机制API的强大功能，并借助编写自己的简单的IOC框架，让观众更好的理解了IOC的推动原理。本文通过IOC的一个简要实现示例，模拟了Spring中IOC的实现，虽然并非完成了Spring中依赖注入的一小部分工作， 但是很好的凸显了Java反射机制在Spring中的应用，能使我们可更好的从原理上认识IOC的推动，也可为我们推动自己的准Spring框架提供方案，有兴趣的朋友可以借助Spring的源码进行IOC的进一步的学习。

附：通过java反射机制获取指定类的属性和方式

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/jisuanjixue/article-138289-1.html