通過呼叫靜態工廠方法建立Bean

• 呼叫靜態工廠方法建立Bean是將物件建立的過程封裝到靜態方法中.當客戶端需要物件時，只需要簡單地呼叫靜態方法，而不必關心建立物件的細節
• 要宣告通過靜態方法建立的Bean,需要在Bean的class屬性裡指定擁有該工廠的方法的類，同時在factory-method屬性裡指定工廠方法的名稱。最後，使用元素為該方法傳遞方法引數。

通過呼叫例項工廠方法建立Bean

• 例項工廠方法:將物件的建立過程封裝到另外一個物件例項的方法裡。當客戶端需要請求物件時，只需要簡單的呼叫該例項方法而不需要關心物件的建立細節。
• 要宣告通過例項工廠方法創健的Bean
  1. 在bean的factory-bean屬性裡指定擁有該工廠方法的Bean
  2. 在factory-method屬性裡指定該工廠方法的名稱
  3. 使用constructor-arg元素為工廠方法傳遞方法引數

例子程式

基本結構

Car.java

package com.spring.beans.factory;

public class Car {

    private String brand;
    private double price;

    public String getBrand() {
        return brand;
    }

    public void setBrand
 
(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Car(){
        System.out.println("Car's Constructor...");
    }

    @Override
    public String toString
 
() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
    public Car(String brand,double price){
        super();
        this.brand = brand;
        this.price = price;
    }
}

StaticCarFactory.java(靜態工廠方法建立bean)

package com.spring.beans.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 靜態工廠方法:直接呼叫某一個類的靜態方法就可以返回 Bean 的例項
 */
public class StaticCarFactory {

    private static Map<String, Car> cars = new HashMap<String,Car>();

    static{
        cars.put("audi",new Car("audi",300000));
        cars.put("ford",new Car("ford",400000));
    }

    //靜態工廠方法
    public static Car getCar(String name){
        return cars.get(name);
    }

}

InstanceCarFactory.java(例項工廠方法建立bean)

package com.spring.beans.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 例項工廠方法:例項工廠的方法，即現需要建立工廠本身，再呼叫工廠的例項方法來返回bean的例項
 */
public class InstanceCarFactory {

    private Map<String,Car> cars = null;

    public InstanceCarFactory(){
        cars = new HashMap<String,Car>();
        cars.put("audi",new Car("audi",300000));
        cars.put("ford",new Car("ford",400000));
    }
    public Car getCar(String brand){
        return cars.get(brand);
    }
}

beans-factory.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.xsd">

    <!--通過靜態工廠方法來配置bean,注意不是配置靜態工廠方法例項-->
    <!--
        class 屬性：      指向靜態工廠方法的全類名
        factory-method:   指向靜態工廠方法的名字
        constructor-arg： 如果工廠方法需要傳入引數，則使用constructor-arg 來配置引數
    -->
    <bean id="car1"
          class="com.spring.beans.factory.StaticCarFactory"
          factory-method="getCar">
        <constructor-arg value="audi"></constructor-arg>
    </bean>

    <!--配置工廠的例項-->
    <bean id="carFactory" class="com.spring.beans.factory.InstanceCarFactory"></bean>

    <!--通過例項工廠方法來配置bean-->
    <!--
        factory-bean 屬性：指向例項工廠方法的bean
        factory-method:    指向工廠方法的名字
        constructor-arg：  如果工廠方法需要傳入引數，則使用constructor-arg 來配置引數
    -->
    <bean id = "car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="ford"></constructor-arg>
    </bean>

</beans>

Main.java

package com.spring.beans.factory;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args){

        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
        Car car1 = (Car) ctx.getBean("car1");
        System.out.println(car1);

        Car car2 = (Car) ctx.getBean("car2");
        System.out.println(car2);
    }
}

執行結果