單例、多例模式

假設，老張開車去東北

public class Car {
    public void run(){      
      System.out.println("冒著煙奔跑中car.........");
    }
}

public class Test {
    public static void main(String[] args) {    
        //如果把new交給司機，那麼司機想new多少car就能有多少。
        Car c=new Car();
        c.run();        
    }
}

想要控制只給老張一輛車，不讓他隨便new出來，可以把Car的建構函式設為private，Car自主生產一個例項，不再依賴於new，封裝一個方法，讓Car定義一個方法返回唯一例項。

單例模式

public class Car {  
    private static Car car=new Car();   //例項
    private Car(){  }   //建構函式私有

    //單例模式的getInstance方法==靜態工廠方法
    public static Car getInstance(){
       return car;  
    }   
    public void run(){
        System.out.println("冒著煙奔跑中car.........");
    }
}

測試：
因為Car的getInstance（）方法返回static變數，是同一個例項，所以c1和c2是同一個物件。

public class Test { 
    public static void main(String[] args) {        
        Car c1=Car.getInstance();
        Car c2=Car.getInstance();
        if(c1==c2){
            System.out.print("same car");
        }       
    }
}

如果需要在Car中產生多個例項，不只是一個例項，可以用多例模式。
比如JDBC的連線池，從池中選擇一條連線使用，使用後回收到池中，Connection就是多例

多例模式
在Car中定義List<Car>成員變數

private static List<Car> cars=new ArrayList<Car>();

再把cars初始化，當需要使用的時候，就從cars中選擇一個使用。

工廠模式

new產生例項，如果想對物件的生產過程也能夠進行定製，有好多可擴充套件性，且能封裝生產過程，使用工廠模式

1、簡單工廠模式

//Moveable介面用於實現run
public class Car implements Moveable{
    @Override
    public void run() {
        System.out.print("開汽車\n");
    }
} 

//Moveable介面用於實現run
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.print("開飛機\n");      
    }
}

工廠

public class CarFactory {
    public Car createCar(){
        return new Car();
    }
}

public class PlaneFactory {
    public Plane createPlane(){
        return new Plane();
    }
}

public class Test { 
    public static void main(String[] args) {
        PlaneFactory planeFactory=new PlaneFactory();
        Plane p=planeFactory.createPlane();//從工廠獲取
        p.run();        
    }
}

簡單工廠模式的工廠可擴充套件性不好，如果想要替換工廠，則換掉的工廠方法也得改，可擴充套件性不好

2、抽象工廠模式

產生交通工具的抽象工廠

public abstract class VehicleFactory {
    abstract Moveable create();
}

繼承自抽象工廠類的具體工廠（子工廠）

public class CarFactory extends VehicleFactory{
    @Override
    Moveable create() {
        return new Car();
    }
}

public class PlaneFactory extends VehicleFactory{
    @Override
    Moveable create() {
        return new Plane();
    }
}

public class Test { 
    public static void main(String[] args) {
        VehicleFactory factory=new PlaneFactory();
        Plane p=(Plane) factory.create();//多型，會隱藏具體實現方法
        p.run();

        factory=new CarFactory();
        Car c=(Car) factory.create();//多型，會隱藏具體實現方法
        c.run();
    }
}

不僅可以控制物件，還可以控制物件的生產過程。
需要修改的只有VehicleFactory factory=new PlaneFactory();，需要生產什麼物件，就new出相應的工廠，如果有配置檔案，連這個都不用修改

體會：產生物件的方法，就是工廠方法，不一定侷限於是在哪個位置，是哪個範疇，學習到最後要靈活運用，手中無劍心中有劍

getInstance和Factory在jdk中常用，還有abstractFactory也非常常用

3、配置檔案

對於普通工廠來說，產生產品系列時，會產生工廠氾濫的問題，對於抽象工廠來說，也有一個問題：比如抽象工廠類，當它需要在抽象類中新增或者刪去一個方法（即改變產品時），就需要改動所有繼承自該廠的所有子類的方法，改動的地方太多
spring提供了一種方案：
1、spring提供的是bean工廠（BeanFactory)
2、原先通過new方式得到的例項Bean物件，現在通過配置檔案的配置來配置例項

模擬spring
1、配置檔案spring.properties

VehicleType=com.HL.spring.Train  //  鍵值對

2、通過java的Properties、反射來獲取例項物件

package com.HL.spring;
import java.io.IOException;
import java.util.Properties;
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {

        //用來讀配置檔案的
        Properties pros=new Properties();
        //Test.class.getClassLoader():拿到裝載類物件的class裝載器,getResourceAsStream：把檔案當成流
        pros.load(Test.class.getClassLoader().getResourceAsStream("com/HL/spring/spring.properties"));

        //獲取key為VehicleType的值
        String vehicleTypeName=pros.getProperty("VehicleType");
        System.out.println(vehicleTypeName);

        //運用java的反射機制，通過字串得到例項
        Object o=Class.forName(vehicleTypeName).newInstance();
        Moveable m=(Moveable)o;
        m.run();    
    }
}

4、Spring

Spring中的運用：使用application.xml作為全域性配置檔案
application.xml中的配置資訊

<Bean id="v" class="com.HL.spring.Car" />

載入配置檔案，用ClassPathXmlApplication

BeanFactory f=new ClassPathXmlApplicationContext("application.xml");//載入配置檔案中配置的Bean類

java解析XML檔案，有多種方法，比如JDOM、SAX等，可以搜尋一下JDOM/XPATH程式設計指南.
spring中載入完xml配置檔案之後，會把配置檔案中宣告的Bean放在List中，然後放進Map中，即Bean容器（IOC），提供給應用程式（程式通過getBean根據id得到Bean），即AOP

Object o=f.getBean("v");//根據id獲取相應ID的Bean例項
Moveable m=(Moveable)o;
m.run();

這就是Bean容器，即IOC。