注入依赖对象

注入依赖对象
基本类型对象注入：
<bean id="orderService" class="cn.itcast.service.OrderserviceBean">
<constructor-arg index="0" type="java.lang.String" value="xxx"/>//构造器注入
<property name="name" value="zhao"/>//属性setter方法注入
</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>

<?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" default-lazy-init="false">
       
       
       
       
       
       <bean id="personService1" class="cn.itcast.service.impl.PersonServiceBean" init-method="init" destroy-method="destory"></bean>
       
       
       <bean id="personService2" class="cn.itcast.service.impl.PersonServiceBeanFactory" factory-method="createPersonServiceBean" lazy-init="true"/>
       
       <bean id="personServiceFactory" class="cn.itcast.service.impl.PersonServiceBeanFactory"/>
       <bean id="personService3" factory-bean="personServiceFactory" factory-method="createPersonServiceBean2" scope="prototype"/>
       
       
       <bean id="personDao" class="cn.itcast.dao.impl.PersonDaoBean"></bean>
       <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">
         <property name="personDao" ref="personDao"></property>
       </bean>
       
</beans>

IOC控制反转
public class PersonServiceBean{
private PersonDao personDao=new PersonDaoBean();
public void save(Person person){
personDao.save(person);
}
}

personDaoBean是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转。

依赖注入（Dependency Injection)
当我们把依赖对象交给容器负责创建，那么PersonServiceBean类可以改成如下：
public class PersonServiceBean{
private PerSonDao personDao;
//通过构造器把创建好的依赖对象注入进PersonServiceBean，当然也可以使用setter方法进行注入。
public PersonServiceBean(PersonDao personDao){
this.personDao=personDao;
}
public void save(Person person){
personDao.save(person);
}
}
所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

public class ItcastClassPathXMLApplicationContext {
private List<BeanDefinition> beanDefines = new ArrayList<BeanDefinition>();
private Map<String, Object> sigletons = new HashMap<String, Object>();

public ItcastClassPathXMLApplicationContext(String filename){
  this.readXML(filename);
  this.instanceBeans();
  this.injectObject();//注入对象
}
/**
* 为bean对象属性注入值
*/
private void injectObject() {
   for(BeanDefinition beanDefinition:beanDefines){//循环所有的bean
    Object bean=sigletons.get(beanDefinition.getId());//通过Id取得实例化后beanDefines中的Bean
    if(bean!=null){//判断bean是否获取到
     try {
     PropertyDescriptor[] ps=Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();// 取得bean的属性描述
     for(PropertyDefinition propertyDefinition:beanDefinition.getPropertys()){
       for(PropertyDescriptor properdesc:ps){
        if(propertyDefinition.getName().equals(properdesc.getName())){//判断循环的属性是否在bean中存在
         Method setter=properdesc.getWriteMethod();//获取属性的setter方法
         if(setter!=null){//判断属性是否有setter方法
          Object value=sigletons.get(propertyDefinition.getRef());//取得ref所引用的对象
          setter.setAccessible(true);//设置为允许访问，防止setter方法为私有时抛出异常
          setter.invoke(bean, value);//把引用对象注入到属性中
         }
         break;
        }
       }
      }
    } catch (Exception e) {
     e.printStackTrace();
    }
    }
   }
}
/**
* 完成bean的实例化
*/
private void instanceBeans() {
  for(BeanDefinition beanDefinition : beanDefines){
   try {
    if(beanDefinition.getClassName()!=null && !"".equals(beanDefinition.getClassName().trim()))
     sigletons.put(beanDefinition.getId(), Class.forName(beanDefinition.getClassName()).newInstance());
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}
/**
* 读取xml配置文件
* @param filename
*/
private void readXML(String filename) {
        SAXReader saxReader = new SAXReader();//创建一个读取器
         Document document=null;
         try{
          URL xmlpath = this.getClass().getClassLoader().getResource(filename);//取得类的类装载器
          document = saxReader.read(xmlpath);//读取文件的内容得到一个document
          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");//创建beans/bean查询路径
          xsub.setNamespaceURIs(nsMap);//设置命名空间
          List<Element> beans = xsub.selectNodes(document);//获取文档下所有bean节点
          for(Element element: beans){
             String id = element.attributeValue("id");//获取id属性值
             String clazz = element.attributeValue("class"); //获取class属性值
             BeanDefinition beanDefine = new BeanDefinition(id, clazz);
             XPath propertysub=element.createXPath("ns:property");//通过element创建查询路径，此时的路径为相对路径（即：//ns:beans/ns:bean下的ns:property）
             propertysub.setNamespaceURIs(nsMap);//设置命名空间
             List<Element> propertys=propertysub.selectNodes(element);//获取文档下所有bean节点
             for(Element property:propertys){
             String propertyName=property.attributeValue("name");//获取属性的name和ref
             String propertyref=property.attributeValue("ref");
//             System.out.println(propertyName+"="+propertyref);
             PropertyDefinition propertyDefinition=new PropertyDefinition(propertyName,propertyref);//将name和ref赋给propertyDefinition
             beanDefine.getPropertys().add(propertyDefinition);
             }
             beanDefines.add(beanDefine);
          }
         }catch(Exception e){
             e.printStackTrace();
         }
}
/**
* 获取bean实例
* @param beanName
* @return
*/
public Object getBean(String beanName){
  return this.sigletons.get(beanName);
}
}

--------------------------------------------------------------------------------------------------

public ItcastClassPathXMLApplicationContext(String filename) {
  this.readXML(filename);
  this.instanceBeans();
  this.injectObject();// 注入对象
}

/**
* 为bean对象属性注入值
*/
private void injectObject() {
  for (BeanDefinition beanDefinition : beanDefines) {// 循环所有的bean
   Object bean = sigletons.get(beanDefinition.getId());// 通过Id取得实例化后beanDefines中的Bean
   if (bean != null) {// 判断bean是否获取到
    try {
     PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();// 取得bean的属性描述
     for (PropertyDefinition propertyDefinition : beanDefinition.getPropertys()) {
      for (PropertyDescriptor properdesc : ps) {
       if (propertyDefinition.getName().equals(properdesc.getName())) {// 判断循环的属性是否在bean中存在
        Method setter = properdesc.getWriteMethod();// 获取属性的setter方法
        if (setter != null) {// 判断属性是否有setter方法
         Object value = null;
         if(propertyDefinition.getRef()!=null && !"".equals(propertyDefinition.getRef().trim())){// 如果引用存在
          value = sigletons.get(propertyDefinition.getRef());// 取得ref所引用的对象
         } else {
          // 通过ConvertUtils将propertyDefinition.getValue()转换成与properdesc.getPropertyType()对应的值
          value = ConvertUtils.convert(propertyDefinition.getValue(), properdesc.getPropertyType());
         }
         setter.setAccessible(true);// 设置为允许访问，防止setter方法为私有时抛出异常
         setter.invoke(bean, value);// 把引用对象注入到属性中
        }
        break;
       }
      }
     }
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  }
}

/**
* 完成bean的实例化
*/
private void instanceBeans() {
  for (BeanDefinition beanDefinition : beanDefines) {
   try {
    if (beanDefinition.getClassName() != null&& !"".equals(beanDefinition.getClassName().trim()))
     sigletons.put(beanDefinition.getId(),Class.forName(beanDefinition.getClassName()).newInstance());
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
}

/**
* 读取xml配置文件
*
* @param filename
*/
private void readXML(String filename) {
  SAXReader saxReader = new SAXReader();// 创建一个读取器
  Document document = null;
  try {
   URL xmlpath = this.getClass().getClassLoader().getResource(filename);// 取得类的类装载器
   document = saxReader.read(xmlpath);// 读取文件的内容得到一个document
   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");// 创建beans/bean查询路径
   xsub.setNamespaceURIs(nsMap);// 设置命名空间
   List<Element> beans = xsub.selectNodes(document);// 获取文档下所有bean节点
   for (Element element : beans) {
    String id = element.attributeValue("id");// 获取id属性值
    String clazz = element.attributeValue("class"); // 获取class属性值
    BeanDefinition beanDefine = new BeanDefinition(id, clazz);
    XPath propertysub = element.createXPath("ns:property");// 通过element创建查询路径，此时的路径为相对路径（即：//ns:beans/ns:bean下的ns:property）
    propertysub.setNamespaceURIs(nsMap);// 设置命名空间
    List<Element> propertys = propertysub.selectNodes(element);// 获取文档下所有bean节点
    for (Element property : propertys) {
     String propertyName = property.attributeValue("name");// 获取属性的name和ref
     String propertyref = property.attributeValue("ref");
     String propertyValue = property.attributeValue("value");
     // System.out.println(propertyName+"="+propertyref);
     PropertyDefinition propertyDefinition = new PropertyDefinition(propertyName, propertyref, propertyValue);// 将name和ref赋给propertyDefinition
     beanDefine.getPropertys().add(propertyDefinition);
    }
    beanDefines.add(beanDefine);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
}

/**
* 获取bean实例
*
* @param beanName
* @return
*/
public Object getBean(String beanName) {
return this.sigletons.get(beanName);
}
}