Spring IoC — 基于XML的配置

1、属性注入

注意点：

1）如果类中显示定义了一个带参的构造函数，则一定还要显示提供一个无参构造函数，否则使用属性注入时将抛出异常。

2）JavaBean关于属性命名的特殊规范。Spring只会检查Bean中是否有对应的Setter方法，至于Bean中是否有对应的属性变量则不做要求。如maxSpeed对应setMaxSpeed()，brand对应setBrand()。

所以<property>元素的属性变量名应满足：xxx的属性对应setXxx(）方法。变量的前两个字母要么全部大写，要么全部小写。

Car类：

package com.ioc.ch4_3_1;

/**

 * Created by gao on 16-3-25.

 */

public class Car {

    private int maxSpeed;

    public String brand;

    private double price;

    public Car() {

    }

    public Car(int maxSpeed, String brand, double price) {

        this.maxSpeed = maxSpeed;

        this.brand = brand;

        this.price = price;

    }

    public void setMaxSpeed(int maxSpeed) {

        this.maxSpeed = maxSpeed;

    }

    public void setBrand(String brand) {

        this.brand = brand;

    }

    public void setPrice(double price) {

        this.price = price;

    }

    public int getMaxSpeed() {

        return maxSpeed;

    }

    public String getBrand() {

        return brand;

    }

    public double getPrice() {

        return price;

    }

    public String toString() {

        return "brand:" + brand + "/maxSpeed:" + maxSpeed + "/price:" + price;

    }

}

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-3.0.xsd">

    <bean id="car" class="com.ioc.ch4_3_1.Car">

        <property name="maxSpeed"><value>300</value></property>

        <property name="brand"><value>奥迪</value></property>

        <property name="price"><value>150000.00</value></property>

    </bean>

</beans>

测试类：

package com.ioc.ch4_3_1;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 * Created by gao on 16-3-25.

 */

public class Test {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_1\\beans.xml");

        Car car = (Car) ctx.getBean("car");

        System.out.println(car.toString());

    }

}

输出结果：

brand:奥迪/maxSpeed:300/price:150000.0

2、构造函数注入

注意点：循环依赖问题。Spring容器能顺利实例化以构造函数注入方式配置的Bean有一个前提是：Bean构造函数入参引用的对象必须已经准备就绪。如果两个Bean都采用构造函数注入，而且都通过构造函数入参引用对方，则会发生循环依赖问题。这时可以将构造函数注入方式调整为属性注入方式。

Car类：

package com.ioc.ch4_3_2;

/**

 * Created by gao on 16-3-25.

 */

public class Car {

    private int maxSpeed;

    public String brand;

    private double price;

    private String corp;

    public Car() {

    }

    public Car(String brand, double price) {

        this.brand = brand;

        this.price = price;

    }

    public Car(int maxSpeed, String brand, double price) {

        this.maxSpeed = maxSpeed;

        this.brand = brand;

        this.price = price;

    }

    public Car(String brand, String corp, int maxSpeed) {

        this.brand = brand;

        this.corp = corp;

        this.maxSpeed = maxSpeed;

    }

    public void setMaxSpeed(int maxSpeed) {

        this.maxSpeed = maxSpeed;

    }

    public void setBrand(String brand) {

        this.brand = brand;

    }

    public void setPrice(double price) {

        this.price = price;

    }

    public String getCorp() {

        return corp;

    }

    public void setCorp(String corp) {

        this.corp = corp;

    }

    public int getMaxSpeed() {

        return maxSpeed;

    }

    public String getBrand() {

        return brand;

    }

    public double getPrice() {

        return price;

    }

    public String toString() {

        return "brand:" + brand + "\tmaxSpeed:" + maxSpeed + "\tprice:" + price + "\tcorp:" + corp;

    }

}

Boss类：

package com.ioc.ch4_3_2;

public class Boss {

    private String name;

    private Car car;

    private Office office;

    public Boss(String name, Car car, Office office) {

        this.name = name;

        this.car = car;

        this.office = office;

    }

    public Boss(String name, Car car) {

        this.name = name;

        this.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 String toString(){

        return "name:"+name+"\tcar:"+car.getBrand()+"\toffice:"+office;

    }

}

Office类：

package com.ioc.ch4_3_2;

public class Office {

}

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-3.0.xsd">

    <!--构造函数注入：type -->

    <bean id="car1" class="com.ioc.ch4_3_2.Car">

        <constructor-arg type="java.lang.String">

            <value>car1_甲壳虫</value>

        </constructor-arg>

        <constructor-arg type="double">

            <value>300000.0</value>

        </constructor-arg>

    </bean>

    <!--构造函数注入：index-->

    <bean id="car2" class="com.ioc.ch4_3_2.Car">

        <constructor-arg index="0" value="300"/>

        <constructor-arg index="1" value="car2_宝马"/>

        <constructor-arg index="2" value="200000.0"/>

    </bean>

    <!--构造函数注入：type&index -->

    <bean id="car3" class="com.ioc.ch4_3_2.Car">

        <constructor-arg index="0" type="java.lang.String">

            <value>car3_红旗CA72</value>

        </constructor-arg>

        <constructor-arg index="1" type="java.lang.String">

            <value>中国一汽</value>

        </constructor-arg>

        <constructor-arg index="2" type="int">

            <value>200</value>

        </constructor-arg>

    </bean>

    <!--构造函数注入：自动识别入参类型 -->

    <bean id="boss1" class="com.ioc.ch4_3_2.Boss">

        <constructor-arg>

            <value>John</value>

        </constructor-arg>

        <constructor-arg>

            <ref bean="car1" />

        </constructor-arg>

        <constructor-arg>

            <ref bean="office" />

        </constructor-arg>

    </bean>

    <bean id="car" class="com.ioc.ch4_3_2.Car"/>

    <bean id="office" class="com.ioc.ch4_3_2.Office" />

 </beans>

测试类：

package com.ioc.ch4_3_2;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 * Created by gao on 16-3-25.

 */

public class Test {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_2\\beans.xml");

        Car car1 = (Car) ctx.getBean("car1");

        System.out.println(car1.toString());

        System.out.println("--------------------------------");

        Car car2 = (Car) ctx.getBean("car2");

        System.out.println(car2.toString());

        System.out.println("--------------------------------");

        Car car3 = (Car) ctx.getBean("car3");

        System.out.println(car3.toString());

        System.out.println("--------------------------------");

        Boss boss1 = (Boss) ctx.getBean("boss1");

        System.out.println(boss1.toString());

    }

}

输出结果：

brand:car1_甲壳虫 maxSpeed:0 price:300000.0 corp:null

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

brand:car2_宝马 maxSpeed:300 price:200000.0 corp:null

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

brand:car3_红旗CA72 maxSpeed:200 price:0.0 corp:中国一汽

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

name:John car:car1_甲壳虫 office:com.ioc.ch4_3_2.Office@9eed10a

3、工厂方法注入

有非静态工厂方法和静态工厂方法两种方式

Car类：

package com.ioc.ch4_3_3;

/**

 * Created by gao on 16-3-25.

 */

public class Car {

    private int maxSpeed;

    public String brand;

    private double price;

    public Car() {

    }

    public Car(int maxSpeed, String brand, double price) {

        this.maxSpeed = maxSpeed;

        this.brand = brand;

        this.price = price;

    }

    public void setMaxSpeed(int maxSpeed) {

        this.maxSpeed = maxSpeed;

    }

    public void setBrand(String brand) {

        this.brand = brand;

    }

    public void setPrice(double price) {

        this.price = price;

    }

    public int getMaxSpeed() {

        return maxSpeed;

    }

    public String getBrand() {

        return brand;

    }

    public double getPrice() {

        return price;

    }

    public String toString() {

        return "brand:" + brand + "\tmaxSpeed:" + maxSpeed + "\tprice:" + price;

    }

}

CarFactory类：

package com.ioc.ch4_3_3;

public class CarFactory {

    //创建Car的工厂方法

   public Car createHongQiCar(){

       Car car = new Car();

       car.setBrand("car5_奔驰");

       return car;

   }

   //工厂类方法是静态的

   public static Car createCar(){

       Car car = new Car();

       return car;

   }

}

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-3.0.xsd">

    <bean id="carFactory" class="com.ioc.ch4_3_3.CarFactory"/>

    <bean id="car5" factory-bean="carFactory" factory-method="createHongQiCar"/>

    <bean id="car6" class="com.ioc.ch4_3_3.CarFactory" factory-method="createCar"/>

 </beans>

测试类：

package com.ioc.ch4_3_3;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

 * Created by gao on 16-3-25.

 */

public class Test {

    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:com\\ioc\\ch4_3_3\\beans.xml");

        Car car5 = (Car) ctx.getBean("car5");

        System.out.println(car5.toString());

        System.out.println("-----------------------");

        Car car6 = (Car) ctx.getBean("car6");

        System.out.println(car6.toString());

    }

}

输出结果：

brand:car5_奔驰 maxSpeed:0 price:0.0

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

brand:null maxSpeed:0 price:0.0

注入方法的考量：

1）支持使用构造函数注入的理由：

· 构造函数可以保证一些重要的属性在Bean实例化时就设置好，避免了因为一些重要属性没有提供，导致一个无用Bean实例的情况；

· 不需要为每个属性提供Setter方法，减少了类的方法个数；

· 可以更好地封装类变量，不需要为每个属性指定setter方法，避免外部错误的调用。

2）更多的开发者更倾向于使用属性注入方式，反对构造函数注入的理由：

· 如果一个类的属性众多，构造函数的签名将变成一个庞然大物，可读性很差；

· 灵活性不强，在有些属性是可选的情况下，如果通过构造函数注入，也需要为可选的参数提供一个null值；

· 如果有多个构造函数，需要考虑配置文件和具体构造函数匹配歧义的问题，配置上相对复杂；

· 构造函数不利于类的继承和扩展，因为子类需要引用到父类复杂的构造函数；

· 构造函数注入有时会造成循环依赖的问题。

3）对于一个全新的应用来说，不推荐使用工厂方法的注入方式。

巴特西

Spring IoC — 基于XML的配置

最新文章

热门文章