多種工廠模式的運用
2023-06-05 18:00:28
目錄
在java中，萬物皆物件，這些物件都需要建立，如果建立的時候直接new該物件，就會對該物件耦合嚴重，假如我們要更換物件，所有new物件的地方都需要修改一遍，這顯然違背了軟體設計的開閉原則。如果我們使用工廠來生產物件，我們就只和工廠打交道就可以了，徹底和物件解耦，如果要更換物件，直接在工廠裡更換該物件即可，達到了與物件解耦的目的；所以說，工廠模式最大的優點就是：解耦。
一、簡單工廠模式（非23種設計模式）
簡單工廠不是一種設計模式，反而比較像是一種程式設計習慣。
1.1 結構
- 抽象產品 ：定義了產品的規範，描述了產品的主要特性和功能。
- 具體產品 ：實現或者繼承抽象產品的子類
- 具體工廠 ：提供了建立產品的方法，呼叫者通過該方法來獲取產品。
2.2 實現
2.2.1 簡單工廠類圖
簡單工廠方法處理建立物件的細節，一旦有了SimpleCoffeeFactory，CoffeeStore類中的orderCoffee()就變成此物件的客戶，後期如果需要Coffee物件直接從工廠中獲取即可。這樣也就解除了和Coffee實現類的耦合，同時又產生了新的耦合CoffeeStore物件和SimpleCoffeeFactory工廠物件的耦合，工廠物件和商品物件的耦合。再加新品種的咖啡，勢必要需求修改SimpleCoffeeFactory的程式碼，違反了開閉原則。工廠類的使用者端可能有很多，這時只需要修改工廠類的程式碼，省去其他的修改操作。
2.2.2 程式碼
/**
* 抽象產品：咖啡
*/
public abstract class Coffee {
// 抽象方法獲取子類的咖啡的名稱
public abstract String getName();
// 加糖
public void addSugar() {
System.out.println("加糖");
}
// 加奶
public void addMilk() {
System.out.println("加奶");
}
}
/**
* 具體產品：美式咖啡
*/
public class AmericanCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "美式咖啡";
}
}
/**
* 具體產品：拿鐵咖啡
*/
public class LatteCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "拿鐵咖啡";
}
}
/**
* 具體工廠：簡單咖啡工廠類，用來生產咖啡
*/
public class SimpleCoffeeFactory {
public Coffee createCoffee(String coffeeType){
// 宣告Coffee型別的變數，根據不同型別建立不同的coffee子類物件
Coffee coffee;
if("american".equals(coffeeType)){
coffee = new AmericanCoffee();
}else if ("latte".equals(coffeeType)){
coffee = new LatteCoffee();
}else {
throw new RuntimeException("sorry，本店沒有出售此類咖啡");
}
return coffee;
}
}
/**
* Coffee店
*/
public class CoffeeStore {
public Coffee orderCoffee(String coffeeType){
// 建立簡單工廠來提供生產咖啡的方法
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
// 呼叫生產咖啡的方法
Coffee coffee = factory.createCoffee(coffeeType);
// 加配料
coffee.addSugar();
coffee.addMilk();
return coffee;
}
}
/**
* 客戶點咖啡
*/
public class Client {
public static void main(String[] args) {
//建立咖啡店類物件
CoffeeStore store = new CoffeeStore();
Coffee coffee = store.orderCoffee("latte");
System.out.println(coffee.getName());
}
}
2.2.3 優缺點
優點：
封裝了建立物件的過程，可以通過引數直接獲取物件。把物件的建立和業務邏輯層分開，這樣以後就避免了修改客戶程式碼，如果要實現新產品直接修改工廠類，而不需要在原始碼中修改，這樣就降低了客戶程式碼修改的可能性，更加容易擴充套件。
缺點：
增加新產品時還是需要修改工廠類的程式碼，違背了「開閉原則」。
二、靜態工廠模式（非23種設計模式）
將工廠類中的建立物件的功能定義為靜態的，這個就是靜態工廠模式，它也不是23種設計模式中的。
3.1 程式碼
/**
* 抽象產品：咖啡
*/
public abstract class Coffee {
// 抽象方法獲取子類的咖啡的名稱
public abstract String getName();
// 加糖
public void addSugar() {
System.out.println("加糖");
}
// 加奶
public void addMilk() {
System.out.println("加奶");
}
}
/**
* 具體產品：美式咖啡
*/
public class AmericanCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "美式咖啡";
}
}
/**
* 具體產品：拿鐵咖啡
*/
public class LatteCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "拿鐵咖啡";
}
}
/**
* 具體工廠：簡單咖啡工廠類，用來生產咖啡
*/
public class SimpleCoffeeFactory {
// 靜態方法
public static Coffee createCoffee(String coffeeType){
// 宣告Coffee型別的變數，根據不同型別建立不同的coffee子類物件
Coffee coffee;
if("american".equals(coffeeType)){
coffee = new AmericanCoffee();
}else if ("latte".equals(coffeeType)){
coffee = new LatteCoffee();
}else {
throw new RuntimeException("sorry，本店沒有出售此類咖啡");
}
return coffee;
}
}
/**
* Coffee店
*/
public class CoffeeStore {
public Coffee orderCoffee(String coffeeType){
// 不需要建立簡單工廠來提供生產咖啡的方法
// 直接類呼叫靜態方法呼叫生產咖啡的方法
Coffee coffee = SimpleCoffeeFactory.createCoffee(coffeeType);
// 加配料
coffee.addSugar();
coffee.addMilk();
return coffee;
}
}
/**
* 客戶點咖啡
*/
public class Client {
public static void main(String[] args) {
//建立咖啡店類物件
CoffeeStore store = new CoffeeStore();
Coffee coffee = store.orderCoffee("latte");
System.out.println(coffee.getName());
}
}
三、工廠模式
定義一個用於建立物件的介面，讓子類決定範例化哪個產品類物件。工廠方法使一個產品類的範例化延遲到其工廠的子類。
3.1 結構
- 抽象工廠（Abstract Factory）：提供了建立產品的介面，呼叫者通過它存取具體工廠的工廠方法來建立產品。
- 具體工廠（ConcreteFactory）：主要是實現抽象工廠中的抽象方法，完成具體產品的建立。
- 抽象產品（Product）：定義了產品的規範，描述了產品的主要特性和功能。
- 具體產品（ConcreteProduct）：實現了抽象產品角色所定義的介面，由具體工廠來建立，它同具體工廠之間一一對應。
3.2 實現
3.2.1 工廠模式類圖
要增加產品類時也要相應地增加工廠類，不需要修改工廠類的程式碼了，這樣就解決了簡單工廠模式的缺點。
工廠方法模式是簡單工廠模式的進一步抽象。由於使用了多型性，工廠方法模式保持了簡單工廠模式的優點，而且克服了它的缺點。
3.2.2 程式碼
/**
* 抽象產品：咖啡
*/
public abstract class Coffee {
// 抽象方法獲取子類的咖啡的名稱
public abstract String getName();
// 加糖
public void addSugar() {
System.out.println("加糖");
}
// 加奶
public void addMilk() {
System.out.println("加奶");
}
}
/**
* 具體產品：美式咖啡
*/
public class AmericanCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "美式咖啡";
}
}
/**
* 具體產品：拿鐵咖啡
*/
public class LatteCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "拿鐵咖啡";
}
}
/**
* 抽象工廠
*/
public interface CoffeeFactory {
//建立咖啡物件的方法
Coffee createCoffee();
}
/**
* 美式咖啡工廠物件，專門用來生產美式咖啡
*/
public class AmericanCoffeeFactory implements CoffeeFactory {
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
/**
* 拿鐵咖啡工廠，專門用來生產拿鐵咖啡
*/
public class LatteCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
}
/**
* Coffee店
*/
public class CoffeeStore {
private CoffeeFactory factory;
public void setFactory(CoffeeFactory factory) {
this.factory = factory;
}
//點咖啡功能
public Coffee orderCoffee() {
Coffee coffee = factory.createCoffee();
//加配料
coffee.addMilk();
coffee.addsugar();
return coffee;
}
}
/**
* 客戶點咖啡
*/
public class Client {
public static void main(String[] args) {
//建立咖啡店物件
CoffeeStore store = new CoffeeStore();
//建立物件
//CoffeeFactory factory = new AmericanCoffeeFactory();
CoffeeFactory factory = new LatteCoffeeFactory();
store.setFactory(factory);
//點咖啡
Coffee coffee = store.orderCoffee();
System.out.println(coffee.getName());
}
}
3.2.3 優缺點
優點：
- 使用者只需要知道具體工廠的名稱就可得到所要的產品，無須知道產品的具體建立過程；
- 在系統增加新的產品時只需要新增具體產品類和對應的具體工廠類，無須對原工廠進行任何修改，滿足開閉原則；
缺點：
- 每增加一個產品就要增加一個具體產品類和一個對應的具體工廠類，這增加了系統的複雜度。
四、抽象工廠模式
抽象工廠模式是工廠方法模式的升級版本，工廠方法模式只生產一個等級的產品，而抽象工廠模式可生產多個等級的產品。是一種為存取類提供一個建立一組相關或相互依賴物件的介面，且存取類無須指定所要產品的具體類就能得到同族的不同等級的產品的模式結構。
4.1結構
- 抽象工廠（Abstract Factory）：提供了建立產品的介面，它包含多個建立產品的方法，可以建立多個不同等級的產品。
- 具體工廠（Concrete Factory）：主要是實現抽象工廠中的多個抽象方法，完成具體產品的建立。
- 抽象產品（Product）：定義了產品的規範，描述了產品的主要特性和功能，抽象工廠模式有多個抽象產品。
- 具體產品（ConcreteProduct）：實現了抽象產品角色所定義的介面，由具體工廠來建立，它 同具體工廠之間是多對一的關係。
4.2 實現
4.2.1 抽象工廠模式類圖
現咖啡店業務發生改變，不僅要生產咖啡還要生產甜點，如提拉米蘇、抹茶慕斯等，要是按照工廠方法模式，需要定義提拉米蘇類、抹茶慕斯類、提拉米蘇工廠、抹茶慕斯工廠、甜點工廠類，很容易發生類爆炸情況。其中拿鐵咖啡、美式咖啡是一個產品等級，都是咖啡；提拉米蘇、抹茶慕斯也是一個產品等級；拿鐵咖啡和提拉米蘇是同一產品族（也就是都屬於義大利風味），美式咖啡和抹茶慕斯是同一產品族（也就是都屬於美式風味）。所以這個案例可以使用抽象工廠模式實現。
4.2.2 程式碼
如果要加同一個產品族的話，只需要再加一個對應的工廠類即可，不需要修改其他的類。
/**
* 抽象產品：咖啡
*/
public abstract class Coffee {
// 抽象方法獲取子類的咖啡的名稱
public abstract String getName();
// 加糖
public void addSugar() {
System.out.println("加糖");
}
// 加奶
public void addMilk() {
System.out.println("加奶");
}
}
/**
* 具體產品：美式咖啡
*/
public class AmericanCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "美式咖啡";
}
}
/**
* 具體產品：拿鐵咖啡
*/
public class LatteCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "拿鐵咖啡";
}
}
/**
* 抽象產品：甜品
*/
public abstract class Dessert {
public abstract void show();
}
/**
* 具體產品：提拉米蘇類
*/
public class Trimisu extends Dessert {
public void show() {
System.out.println("提拉米蘇");
}
}
/**
* 具體產品：抹茶慕斯類
*/
public class MatchaMousse extends Dessert {
public void show() {
System.out.println("抹茶慕斯");
}
}
/**
* 抽象工廠： DessertFactory
*/
public interface DessertFactory {
//生產咖啡的功能
Coffee createCoffee();
//生產甜品的功能
Dessert createDessert();
}
/**
* 美式風味的甜品工廠
* 生產美式咖啡和抹茶慕斯
*/
public class AmericanDessertFactory implements DessertFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
public Dessert createDessert() {
return new MatchaMousse();
}
}
/**
* 義大利風味甜品工廠
* 生產拿鐵咖啡和提拉米蘇甜品
*/
public class ItalyDessertFactory implements DessertFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
public Dessert createDessert() {
return new Trimisu();
}
}
/**
* 客戶類
*/
public class Client {
public static void main(String[] args) {
//建立的是義大利風味甜品工廠物件
//ItalyDessertFactory factory = new ItalyDessertFactory();
//建立的是美式風味甜品工廠物件
AmericanDessertFactory factory = new AmericanDessertFactory();
//獲取拿鐵咖啡和提拉米蘇甜品
Coffee coffee = factory.createCoffee();
Dessert dessert = factory.createDessert();
System.out.println(coffee.getName());
dessert.show();
}
}
4.2.3 優缺點
優點：
當一個產品族中的多個物件被設計成一起工作時，它能保證使用者端始終只使用同一個產品族中的物件。
缺點：
當產品族中需要增加一個新的產品時，所有的工廠類都需要進行修改。
4.2.4 使用場景
-
當需要建立的物件是一系列相互關聯或相互依賴的產品族時，如電器工廠中的電視機、洗衣機、空調等。
-
系統中有多個產品族，但每次只使用其中的某一族產品。如有人只喜歡穿某一個品牌的衣服和鞋。
-
系統中提供了產品的類庫，且所有產品的介面相同，使用者端不依賴產品範例的建立細節和內部結構。
五、模式擴充套件
通過工廠模式+組態檔的方式解除工廠物件和產品物件的耦合。在工廠類中載入組態檔中的全類名，並建立物件進行儲存，使用者端如果需要物件，直接進行獲取即可。
5.1 定義組態檔
定義一個組態檔名稱為bean.properties。
american=config_factory.AmericanCoffee
latte=config_factory.LatteCoffee
5.2 程式碼
靜態成員變數用來儲存建立的物件（鍵儲存的是名稱，值儲存的是對應的物件），而讀取組態檔以及建立物件寫在靜態程式碼塊中，目的就是隻需要執行一次。
/**
* 抽象產品：咖啡
*/
public abstract class Coffee {
// 抽象方法獲取子類的咖啡的名稱
public abstract String getName();
// 加糖
public void addSugar() {
System.out.println("加糖");
}
// 加奶
public void addMilk() {
System.out.println("加奶");
}
}
/**
* 具體產品：美式咖啡
*/
public class AmericanCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "美式咖啡";
}
}
/**
* 具體產品：拿鐵咖啡
*/
public class LatteCoffee extends Coffee {
// 繼承父類別的方法，重寫直接返回名稱
public String getName() {
return "拿鐵咖啡";
}
}
/**
* 工廠類： CoffeeFactory
* 載入組態檔，獲取組態檔中設定的全類名，並建立該類的物件進行儲存
*/
public class CoffeeFactory {
// 定義容器物件儲存咖啡物件
private static HashMap<String,Coffee> map = new HashMap<String, Coffee>();
// 載入組態檔， 只需要載入一次
static {
// 建立Properties物件
Properties p = new Properties();
// 呼叫p物件中的load方法進行組態檔的載入
InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
p.load(is);
// 從p集合中獲取全類名並建立物件
Set<Object> keys = p.keySet();
for (Object key : keys) {
String className = p.getProperty((String) key);
// 通過反射技術建立物件
Class clazz = Class.forName(className);
Coffee coffee = (Coffee) clazz.newInstance();
// 將名稱和物件儲存到容器中
map.put((String)key,coffee);
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 根據名稱獲取物件
public static Coffee createCoffee(String name) {
return map.get(name);
}
}
/**
* 客戶類
*/
public class Client {
public static void main(String[] args) {
Coffee coffee = CoffeeFactory.createCoffee("american");
System.out.println(coffee.getName());
}
}
記錄每一個學習瞬間