spring--设置注入VS构造注入

1、在传统的程序设计中，调用亲自创建被调用者的实例，即由程序控制“对象之间的依赖关系”，这种方式的耦合度比较高；控制反转就是将由程序控制的“对象间的依赖关系”转交给Ioc容器来进行控制，被调用者的实例创建工作不再是调用者完成， 大大降低了调用者和被调用者之间的关系。Ioc(inversion of control：控制反转)和Di(dependency Injection:依赖注入) 是相同的概念。

　　

2、实现依赖注入的方式：
2.1、属性注入：
 //bean类  被关联
    package com.liu.spring;
    public class RefBean {
        private String meg;
        public String getMeg() {
            return meg;
        }
        public void setMeg(String meg) {
            this.meg = meg;
        }
    }
    //bean 将关联RefBean类
    package com.liu.spring;
    public class MessageBean {
        private String message;
        private RefBean refBean;//关联的RefBean类
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
        public RefBean getRefBean() {
            return refBean;
        }
        public void setRefBean(RefBean refBean) {
            this.refBean = refBean;
        }
    }
  //配置文件
    <beans>
        <!-- 配置文件 1.先配置类为RefBean -->
        <bean id="refBean" class="com.liu.spring.RefBean">
            <property name="meg">
                <value>我是属性注入方式实现的(我在RefBean类中)</value>
            </property>
        </bean>
        <!-- 2、再来配置类 MessageBean  -->
        <bean id="messageBean" class="com.liu.spring.MessageBean">
            <property name="message">
                <value>Spring框架(我是在MessageBean类中)</value>
            </property>
            <!-- 加入另一个bean  -->
            <property name="refBean">
                <ref local="refBean"/>
            </property>
        </bean>
    </beans>
  //测试类
    package com.liu.action;
    public class Action_01 {    
        public static void main(String[] args) {
            //加载配置文件
            ClassPathResource resource=new ClassPathResource("applicationContext.xml");
            //创建bean工厂
            BeanFactory factory=new XmlBeanFactory(resource);
            //获取对用的实例(就避免的new对象)
            MessageBean message=(MessageBean) factory.getBean("messageBean");
            //打印结果
            System.out.println(message.getMessage()+","+message.getRefBean().getMeg());
        }
    }
    //最终的结果是
    Spring框架(我是在MessageBean类中),我是属性注入方式实现的(我在RefBean类中)

　　

2.2、构造方法注入：
注：只需在被关联的类中写好构造函数，在配置文件之中写好配置文件就行
    //配置文件写法
     <bean id="messageBean" class="com.liu.spring.MessageBean">
         <!--- 构造函数注入的关键标签 --->
         <constructor-arg index="0">
             <value>Spring框架(我是在MessageBean类中)</value>
         </constructor-arg>
         <constructor-arg index="1">
             <!-- 引用之外的bean  -->
             <ref local="refBean"/>
         </constructor-arg>
     </bean>
     <!-- 被关联的bean类--->
     <bean id="refBean" class="com.liu.spring.RefBean">
        <property name="meg">
            <value>我是属性注入方式实现的(我在RefBean类中)</value>
        </property>
    </bean>    
2.3、构造注入须知：
    为了避免现在的配置文件的歧义而引起的张冠李戴，在bean中存在多个构造函数时，使用显示指定index和type属性
    比较直观。
2.4、属性注入和构造注入的比较：
    2.4.1、属性注入的特点是不需要知道属性的类型，但是必须知道属性的名称；使用set()方法实现依赖注入
    2.4.2、构造函数注入的特点是不需要知道参数的名称，不需要知道set()，但是必须知道参数的序号和类型，必须定义包含不同参数
                的构造函数。
    2.4.3、构造函数注入和属性注入方式各有优缺点。
3、循环依赖问题：
    3.1、什么是循环依赖：
                    spring容器能够顺利实例化以构造函数注入的方式配置的Bean有一个前提：Bean引用的构造函数入参引用的对象必须已近准备就绪。由于这种机制，如果两个bean都采用构造函数注入，而且都是通过构造函数入参引用对方，就会发生死锁，就是依赖循环。

          实体类如下：
//Boss类
        package com.liu.spring;
        public class Boss {    
            private String name;
            private Car car;
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public Car getCar() {
                return car;
            }
            public void setCar(Car car) {
                this.car = car;
            }
            //构造函数
            public Boss(String name, Car car) {
                super();
                this.name = name;
                this.car = car;
            }
        }
        //car类
        package com.liu.spring;
        public class Car {
            private String brand;
            private Boss boss;
            public String getBrand() {
                return brand;
            }
            public void setBrand(String brand) {
                this.brand = brand;
            }
            public Boss getBoss() {
                return boss;
            }
            public void setBoss(Boss boss) {
                this.boss = boss;
            }
            //构造函数
            public Car(String brand, Boss boss) {
                super();
                this.brand = brand;
                this.boss = boss;
            }
        }
   //配置文件
        <!-- 循环依赖问题的配置文件如下 (错) -->
        <bean id="car" class="com.liu.spring.Car"><!-- car类 -->
            <constructor-arg>
                <value>我是劳斯莱斯(来之car类)</value>
            </constructor-arg>
            <constructor-arg>
                <ref local="boss"/><!-- 引用boss -->
            </constructor-arg>
        </bean>
        <bean id="boss" class="com.liu.spring.Boss">
            <constructor-arg>
                <value>我是刘明(来之boss类)</value>
            </constructor-arg>
            <constructor-arg>
                <ref local="car"/><!-- 引用car -->
            </constructor-arg>
        </bean>
        异常为：Exception in thread "main" org.springframework.beans.factory.BeanCreationException:
    3.2、循环依赖解决方法(配置文件使用属性注入)
 <!-- 循环依赖问题的配置文件如下 (正确) -->
        <bean id="car" class="com.liu.spring.Car">
            <property name="brand">
                <value>我是劳斯拉斯(来之car类)</value>
            </property>
            <property name="boss">
                <ref local="boss"/>
            </property>
        </bean>
        <bean id="boss" class="com.liu.spring.Boss">
            <property name="name">
                <value>我是不知道(来之boss类)</value>
            </property>
            <property name="car">
                <ref local="car"/>
            </property>
        </bean>
        ------测试类------------------
        //加载配置文件
        ClassPathResource resource=new ClassPathResource("applicationContext.xml");
        //创建bean工厂
        BeanFactory factory=new XmlBeanFactory(resource);
        //获得对应的实体类
        Car car=(Car) factory.getBean("car");
        Boss boss=(Boss) factory.getBean("boss");
        System.out.println(car.getBrand()+"========"+car.getBoss().getName());
        System.out.println(boss.getName()+"======="+boss.getCar().getBrand());
        最后的结果是：
        我是劳斯拉斯(来之car类)========我是不知道(来之boss类)
        我是不知道(来之boss类)=======我是劳斯拉斯(来之car类)