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）对于一个全新的应用来说，不推荐使用工厂方法的注入方式。
