開始學(xué)習(xí)設(shè)計模式，這是小卷學(xué)習(xí)設(shè)計模式的第1篇文章，今天了解下工廠模式，以及框架中用到工廠模式的案例

1.概覽

概覽.png

2.分類

設(shè)計模式分為三類：

• 創(chuàng)建型：在創(chuàng)建對象的同時隱藏創(chuàng)建邏輯，不使用new直接實例化對象，程序判斷創(chuàng)建哪些對象時更靈活
• 結(jié)構(gòu)型：通過類和接口間的繼承、引用實現(xiàn)創(chuàng)建復(fù)雜結(jié)構(gòu)的對象。
• 行為型：通過類之間不同通信方式實現(xiàn)不同行為。

工廠模式屬于創(chuàng)建型設(shè)計模式，具體可以分為三類：

• 簡單工廠模式，定義一個工廠類，根據(jù)傳入?yún)?shù)動態(tài)創(chuàng)建不同類型的對象，缺點是新增產(chǎn)品需要修改工廠類邏輯，違背開閉原則
• 工廠方法模式，將對象的創(chuàng)建延遲到子類，每個產(chǎn)品對應(yīng)一個工廠類，擴展更好
• 抽象工廠模式，用于創(chuàng)建產(chǎn)品族（多個相關(guān)聯(lián)的系列對象），比如汽車工廠同時生產(chǎn)輪胎和引擎

3.簡單工廠模式

簡單??模式指由?個??對象來創(chuàng)建實例，客戶端不需要關(guān)注創(chuàng)建邏
輯，只需提供傳???的參數(shù)。

如：Spring的BeanFactory使用了簡單工廠模式，根據(jù)傳入一個唯一標(biāo)識來獲取Bean對象

下面是簡單工廠模式的示例代碼：

interface Car {
    void drive();
}

class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Benz.......");
    }
}

class Bmw implements Car {
    @Override
    public void drive() {
        System.out.println("Bmw......");
    }
}

class CarFactory {
    public Car createCar(String type) {
        if ("Benz".equals(type)) {
            return new Benz();
        }
        if ("Bmw".equals(type)) {
            return new Bmw();
        }
        throw new IllegalArgumentException("unknown type");
    }
}

public class SimpleFactory {
    public static void main(String[] args) {
        Car car = CarFactory.createCar("Bmw");
        car.drive(); //輸出Bmw......
    }
}

4.工廠方法模式

定義一個抽象??，其定義了產(chǎn)品的?產(chǎn)接?，但不負責(zé)具體的產(chǎn)
品，將?產(chǎn)任務(wù)交給不同的派?類??

示例代碼：

//工廠接口
interface CarFactory {
    Car createCar();
}
//每個產(chǎn)品對應(yīng)一個工廠
class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

class BmwFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Bmw();
    }
}

public class MethondFactory {
    public static void main(String[] args) {
        CarFactory carFactory = new BenzFactory();
        Car car = carFactory.createCar();
        car.drive(); //輸出Benz.......
    }
}

5.抽象工廠模式

簡單??模式和???法模式不管??怎么拆分抽象，都只是針對?類產(chǎn)
品，如果要?成另?種產(chǎn)品，就?較難辦了！

抽象工廠模式通過在 AbstarctFactory中增加創(chuàng)建產(chǎn)品的接?，并在具體?
工廠中實現(xiàn)新加產(chǎn)品的創(chuàng)建

//產(chǎn)品族接口（汽車 + 輪胎）
interface Car {
    void drive();
}

interface Tire {
    void wear();
}

//具體產(chǎn)品族，Benz族系列
class BenzCar implements Car {
    @Override
    public void drive() {
        System.out.println("Benz Car.......");
    }
}

class BenzTire implements Tire {
    @Override
    public void wear() {
        System.out.println("Benz Tire......");
    }
}
//抽象工廠接口
interface CarAbstractFactory {
    Car createCar();
    Tire createTire();
}
//具體工廠實現(xiàn)
class BenzFactory implements CarAbstractFactory {
    @Override
    public Car createCar() {
        return new BenzCar();
    }
    @Override
    public Tire createTire() {
        return new BenzTire();
    }
}
//使用
public class AbstractFactory {
    public static void main(String[] args) {
        CarAbstractFactory carAbstractFactory = new BenzFactory();
        Car car = carAbstractFactory.createCar();
        Tire tire = carAbstractFactory.createTire();
        car.drive(); //輸出Benz Car.......
        tire.wear();
    }
}

6.具體框架案例

如SLF4J的LoggerFactory就使用了工廠模式，調(diào)用getLogger()方法來獲取Logger實例

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Demo {
    private static final Logger logger = LoggerFactory.getLogger(Demo.class);
    
    public static void main(String[] args) {
        logger.info("Hello SLF4J");
    }
}