IoC容器中装配Bean

Bean的基本配置
        spring IoC容器根据XML配置文件中定义的Bean创建Bean的实例。
        Bean的命名：
                配置一个Bean时，需要为其指定一个id属性作为Bean的名称，id在IoC容器中必须是唯一的，此外id的命名要符合命名规范，例如：

                <bean id="#car1" class="com.baobaotao.simple.Car"/>

                用户可以用getBean()来获取IoC容器中的Car Bean。
                如过未指定id 或者name则将会默认使用class的名称代替。
        依赖注入：
                Spring支持两种注入方式，分别是属性注入和构造函数注入。属性注入就是使用setXXX()方法注入Bean的属性值或以来对象。下面是在Spring配置>文件中对Car进行属性注入的配置片段：

                <bean id="car" class="com.baobaotao.ditype.Car">
                        <property name="maxSpeed"><value>200</value></property>
                        <property name="brand"><value>红旗CA72</value></property>
                        <property name="price"><value>20000.00</value></property>
                </bean>

                配置的这个bean，并为其三个属性提供了属性值。具体来说，Bean的每一个属性对应一个<property>标签。name为属性的名称，在Bean实现类中有>其对应的setter方法。
        构造函数注入：
                构造函数注入保证一些必要的属性在Bean实例化时就得到设置。他保证Bean实例在实例化后就可以使用。
                按匹配类型入参：

                        package com.baobaotao.ditype;
                        public class Car{
                                ...
                                public Car(String brand,double price){
                                        this.brand=brand;
                                        this.price=price;
                                }
                        }

                Spring配置文件中使用构造函数注入装配这个Car Bean：
 

                       <bean id="car1" class="com.baobaotao.ditype.Car">
                                <construct-arg type="java.lang.String">
                                        <value>红旗CA72</value>
                                </construct-arg>
                                <construct-arg type="double">
                                        <value>20000</value>
                                </construct-arg>
                        </bean>

                在<construct-arg>中有一个type属性。
                按索引匹配入参：

                        构造函数
 

                      public Car(String brand,String corp,double price){
                                this.brand=brand;
                                this.corp=corp;
                                this.price=price;
                        }

                        Spring 配置文件中构造函数注入：

                       <bean id="car2" class="com.baobaotao.ditype.Car">
                                <construct-arg index="0" value="红旗CA72"/>
                                <construct-arg index="1" value="中国一汽"/>
                                <construct-arg index="2" value="20000"/>
                        </bean>

                联合使用类型和索引匹配入参：
                        构造函数：

                      public Car(String brand,String corp,double price){
                                this.brand=brand;
                                this.corp=corp;
                                this.price=price;
                        }
                        public Car(String brand,String corp,int maxSpeed){
                                this.brand=brand;
                                this.corp=corp;
                                this.maxSpeed=maxSpeed;
                        }

                        Spring 配置文件中构造函数注入：

                       <bean id="car3" class="com.baobaotao.ditype.Car">
                                <construct-arg index="0" type="java.lang.String">
                                        <value>红旗CA72</value>
                                </construct-arg>
                                <construct-arg index="1" type="java.lang.String">
                                        <value>中国一汽</value>
                                </construct-arg>
                                <construct-arg index="2" type="int">
                                        <value>200</value>
                                </construct-arg>
                        </bean>

                通过自身类型反射匹配入参：
                        由于java反射机制可以获取构造函数入参的类型，即使构造函数注入的配置不提供类型和索引信息，Spring依旧可以正确的完成构造函数>的注入工作。
                        构造函数：

                  public Boss(String name,Car car,Office office){
                                this.name=name;
                                this.car=car;
                                this.office=office;
                        }

                        由于car,office和name入参的类型都是可辨别的，所以无需在构造函数注入的配置时指定<construct-arg>的类型和索引：
          

                     <bean id="boss" class="com.baobaotao.ditype.Boss">
                                <construct-arg>
                                        <value>John</value>
                                </contruct-arg>
                                <construct-arg>
                                        <ref bean="car"/>
                                </construct-arg>
                                <construct-arg>
                                        <ref bean="office"/>
                                </contruct-arg>
                        </bean>
                        <bean id="car" class="com.baobaotao.ditype.Car"/>
                        <bean id="office" class="com.baobaotao.ditype.Office"/>

                循环依赖问题：
                        你中有我，我中有你问题。

                工厂方法注入：
                        很少需要手工编写基于工厂方法的类。因为工厂方法已经成为底层设施的一部分，因此工厂方法对于实际编码的重要性就大大降低。
                        非静态工厂方法：
  

                             package com.baobaotao.ditype;
                                public class CarFactory{
                                        public Car createHongQiCar(){
                                                Car car=new Car();
                                                car.setBrand("红旗CA72");
                                                return car;
                                        }

                               }
                        Spring 配置：
                                <bean id="carFactory" class="com.baobaotao.ditype.CarFactory"/>
                                <bean id="car5" factory-bean="carFactory" factory-method="createHongQiCar"/>

                        静态工厂方法：
                                package com.baobaotao.ditype;
                                public class CarFactory{
                                        public static Car createHongQiCar(){
                                                .....
                                        }
                                }
                        Spring 配置：
                                当使用静态工厂类型的方法后，用户无需在配置文件中定义工厂类的bean了：
                                <bean id="car6" class="com.baobaotao.ditype.CarFactory" factory-method="createHongQiCar"/>