Spring的DI(Ioc)

注入bean有两种方式：

注入其他bean：
方式一
<bean id="orderDao" class="cn.itcast.service.OrderDaoBean"/>
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
	<property name="orderDao" ref="orderDao"/>
</bean>
方式二(使用内部bean,但该bean不能被其他bean使用)
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
	<property name="orderDao">
		<bean class="cn.itcast.service.OrderDaoBean"/>
	</property>
</bean>

　　

一般我们的工程在service层依赖dao层的实现来实现业务逻辑。

service层：

public class PersonServiceImpl implements PersonService {
	
	private PersonDao personDao;
	
	@Override
	public void save() {
		personDao.save();
		System.out.println("service :  " + " save 方法");
	}
	public PersonDao getPersonDao() {
		return personDao;
	}
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}
}

　　

dao层：

public class PersonDaoImpl implements PersonDao {
	@Override
	public void save() {
		System.out.println("dao层的save方法");
	}
}

　　

beans.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
           
    <bean id="personDaoImpl" class="cn.gbx.dao.PersonDaoImpl"></bean>
 	<bean id="personServiceImpl" class="cn.gbx.serviceimpl.PersonServiceImpl" >
 		<property name="personDao" ref="personDaoImpl"></property>
 	</bean>
</beans>

　　

测试方法：

public class SpringTest {
	@Test
	public void spring1() {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		PersonService ps = (PersonService)ctx.getBean("personServiceImpl");
		ps.save();
	}
}

　　

然后我们就实现了Spring对bean对象的依赖注入。 service层所依赖的dao层的PersonDao对象不是由service本身去创建管理，而是交给了第三方容器Spring去管理。

那么Spring是如何管理的呢？

我们可想而知

1： 首先必须解析XML 将 <bean>标签和 <property>标签都解析出来

2： 利用反射实例话对象

3： 利用内省将实例化完成的对象注入到有依赖的对象里面

我们可以自己模拟实现：

package cn.gbx.myExample;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.beanutils.ConvertUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;

public class MyClassPathXmlApplicationContext {

	private List<DefBean> defBeans = new ArrayList<DefBean>();  //存储<bean>标签的信息
	private Map<String, Object> singltons = new HashMap<String, Object>(); //存储读出来的对象
	
	
	public MyClassPathXmlApplicationContext() {
		super();
	}

	public MyClassPathXmlApplicationContext(String filename) {
		this.readXML(filename);
		this.instanceBean();
		this.injectProperty();
	}
	//利用内省将属性注入
	private void injectProperty() {
		for (DefBean defBean : defBeans) {
			Object bean = singltons.get(defBean.getId());
			if (bean != null) {
				//要想将依赖的对象注入，我们就要通过内省来操作对象的属性
				try {
					BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
					PropertyDescriptor[] ps = beanInfo.getPropertyDescriptors();
				
					for (DefProperty p : defBean.getDefPropertys()) {
						for (PropertyDescriptor propertyDes : ps) {
							if (propertyDes.getName().equals(p.getName())) {
								Method setter = propertyDes.getWriteMethod();
								if (setter != null) {
									Object value = null;
									if (p.getRef() != null && !"".equals(p.getRef())) {
										value = singltons.get(p.getRef());
									} else { //基本数据类型利用beanUtils实现转化
										value = ConvertUtils.convert(p.getValue(),propertyDes.getPropertyType());
									}
									setter.setAccessible(true); //这样即使set方法是私有的都可以访问
									setter.invoke(bean, value); //把引用对象注入到bean属性里面
								}
								break;
							}
						}
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
    //利用反射实例化对象
	private void instanceBean() {
		for (DefBean bean : defBeans) {
			//输出测试读取的xml
			/*System.out.println(bean.getId() + "  : " + bean.getClassName());
			System.out.println("------------------------");
			for (DefProperty p : bean.getDefPropertys()) {
				System.out.println("Property : name = " + p.getName() + "  :  ref = " + p.getRef());
			}
			*/
			
			if (bean.getClassName() != null && !"".equals(bean.getClassName())) {
				try {
					singltons.put(bean.getId(), Class.forName(bean.getClassName()).newInstance());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	}

	private void readXML(String filename) {
		SAXReader reader = new SAXReader();
		Document document = null;
		URL xmlPath = this.getClass().getClassLoader().getResource(filename);
		try {
			document = reader.read(xmlPath);
			//创建命名空间
			Map<String, String> nsMap = new HashMap<String, String>();
			nsMap.put("ns", "http://www.springframework.org/schema/beans");
			
			//创建查询路径
			XPath xsub = document.createXPath("//ns:beans/ns:bean");
			xsub.setNamespaceURIs(nsMap); // 设置命名空间
			
			List<Element> elements = xsub.selectNodes(document);
			
			DefBean defBean = null;
			for (Element e : elements) {
				String id = e.attributeValue("id");
				String className = e.attributeValue("class");
				defBean = new DefBean(id, className);
				
				//为<bean>节点设置查询路径
				XPath xPropertySub = e.createXPath("ns:property");
				xPropertySub.setNamespaceURIs(nsMap);
				List<Element> propertys =  xPropertySub.selectNodes(e);
				
				DefProperty defProperty = null;
				for (Element e2 : propertys) {
					String name = e2.attributeValue("name");
					String ref = e2.attributeValue("ref");
					String value = e2.attributeValue("value");
					defProperty = new DefProperty(name, ref, value);
					defBean.getDefPropertys().add(defProperty);
				}
				
				defBeans.add(defBean);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	public Object getBean(String key) {
		return singltons.get(key);
	}
	
	
}

　　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
           
    <bean id="personDaoImpl" class="cn.gbx.dao.PersonDaoImpl"></bean>
 	<bean id="personServiceImpl" class="cn.gbx.serviceimpl.PersonServiceImpl" >
 		<property name="personDao" ref="personDaoImpl"></property>
 		<property name="name" value="ok-gbx"></property>
 		<property name="id" value="22"></property>
 	</bean>
</beans>