java设计模式：抽象工厂模式 + 建造者模式

将抽象工厂模式与建造者模式结合，可以优雅地处理需要创建​​多个产品族​​，且每个产品族内部对象​​构建过程复杂​​的场景。这种结合充分发挥了抽象工厂管理产品族的优势，以及建造者模式精细控制复杂对象构建过程的优势
。
下面我们通过一个构建不同风格（现代、古典）房屋的例子来具体说明。

🧱 核心组件定义
首先，我们定义房屋的组成部分和不同风格的具体实现。

​​1. 产品部件接口​​
定义门、窗、屋顶等部件的通用接口。

// 门接口
public interface Door {void install();String getStyle();
}// 窗接口
public interface Window {void install();String getStyle();
}// 屋顶接口
public interface Roof {void build();String getStyle();
}

​​2. 具体产品部件​​
实现现代风格和古典风格的具体部件。

// 现代风格门
public class ModernDoor implements Door {@Override public void install() { System.out.println("安装现代风格门：简洁线条，玻璃元素"); }@Override public String getStyle() { return "现代"; }
}// 古典风格门
public class ClassicalDoor implements Door {@Override public void install() { System.out.println("安装古典风格门：雕花装饰，实木材质"); }@Override public String getStyle() { return "古典"; }
}// 现代风格窗
public class ModernWindow implements Window {@Override public void install() { System.out.println("安装现代风格窗：大面积玻璃，极简窗框"); }@Override public String getStyle() { return "现代"; }
}// 古典风格窗
public class ClassicalWindow implements Window {@Override public void install() { System.out.println("安装古典风格窗：繁复窗格，装饰性窗棂"); }@Override public String getStyle() { return "古典"; }
}// 现代风格屋顶
public class ModernRoof implements Roof {@Override public void build() { System.out.println("建造现代风格屋顶：平顶设计，可作露台"); }@Override public String getStyle() { return "现代"; }
}// 古典风格屋顶
public class ClassicalRoof implements Roof {@Override public void build() { System.out.println("建造古典风格屋顶：坡面设计，琉璃瓦"); }@Override public String getStyle() { return "古典"; }
}

🏭 抽象工厂模式应用：创建产品族
抽象工厂负责创建一整套风格一致的产品部件。
​​1. 抽象工厂接口​​

public interface HouseComponentFactory {Door createDoor();Window createWindow();Roof createRoof();
}

​​2. 具体工厂​​
实现现代风格和古典风格的具体工厂。

// 现代风格工厂
public class ModernComponentFactory implements HouseComponentFactory {@Override public Door createDoor() { return new ModernDoor(); }@Override public Window createWindow() { return new ModernWindow(); }@Override public Roof createRoof() { return new ModernRoof(); }
}// 古典风格工厂
public class ClassicalComponentFactory implements HouseComponentFactory {@Override public Door createDoor() { return new ClassicalDoor(); }@Override public Window createWindow() { return new ClassicalWindow(); }@Override public Roof createRoof() { return new ClassicalRoof(); }
}

🏗️ 建造者模式应用：组装复杂房屋
建造者模式负责将部件一步步组装成完整的房屋对象
。
​​1. 产品：房屋​​

public class House {private Door door;private Window window;private Roof roof;private String style;public void setDoor(Door door) { this.door = door; }public void setWindow(Window window) { this.window = window; }public void setRoof(Roof roof) { this.roof = roof; }public void setStyle(String style) { this.style = style; }public void display() {System.out.println("\n=== " + style + "风格房屋建造完成 ===");door.install();window.install();roof.build();System.out.println("房屋整体风格协调性检查通过！");}
}

​​2. 抽象建造者​​

public abstract class HouseBuilder {protected House house = new House();public abstract void buildDoor();public abstract void buildWindow();public abstract void buildRoof();public House getHouse() { return house; }
}

​​3. 具体建造者​​

// 现代房屋建造者
public class ModernHouseBuilder extends HouseBuilder {private HouseComponentFactory factory;public ModernHouseBuilder() {this.factory = new ModernComponentFactory(); // 使用现代风格工厂house.setStyle("现代");}@Override public void buildDoor() { house.setDoor(factory.createDoor()); }@Override public void buildWindow() { house.setWindow(factory.createWindow()); }@Override public void buildRoof() { house.setRoof(factory.createRoof()); }
}// 古典房屋建造者
public class ClassicalHouseBuilder extends HouseBuilder {private HouseComponentFactory factory;public ClassicalHouseBuilder() {this.factory = new ClassicalComponentFactory(); // 使用古典风格工厂house.setStyle("古典");}@Override public void buildDoor() { house.setDoor(factory.createDoor()); }@Override public void buildWindow() { house.setWindow(factory.createWindow()); }@Override public void buildRoof() { house.setRoof(factory.createRoof()); }
}

​​4. 指挥者​​

public class HouseDirector {public House constructHouse(HouseBuilder builder) {builder.buildDoor();   // 第一步：安装门builder.buildWindow(); // 第二步：安装窗builder.buildRoof();   // 第三步：建造屋顶return builder.getHouse();}
}

👨‍💻 客户端使用

public class Client {public static void main(String[] args) {HouseDirector director = new HouseDirector();// 建造现代风格房屋HouseBuilder modernBuilder = new ModernHouseBuilder();House modernHouse = director.constructHouse(modernBuilder);modernHouse.display();// 建造古典风格房屋HouseBuilder classicalBuilder = new ClassicalHouseBuilder();House classicalHouse = director.constructHouse(classicalBuilder);classicalHouse.display();// 动态选择风格String preference = "modern"; // 可从配置读取HouseBuilder builder = preference.equals("modern") ? new ModernHouseBuilder() : new ClassicalHouseBuilder();House dynamicHouse = director.constructHouse(builder);dynamicHouse.display();}
}

✨ 模式结合的优势
这种结合使用的方式带来了显著的好处：
优势
说明
​​双重解耦​​
客户端与具体产品创建、组装过程均解耦，只需关心最终产品。

​​强一致性保证​​
抽象工厂确保部件风格一致，建造者确保组装顺序正确。

​​极高的扩展性​​
新增产品族（如田园风格）只需增加新工厂和建造者，符合开闭原则。

​​构建流程复用​​
HouseDirector中的构建算法可复用于任何风格的房屋建造。

​​精细控制​​
建造者模式允许对构建步骤进行精细控制，抽象工厂确保部件质量。

🔄 扩展新的产品族
增加一个“田园风格”产品族非常容易：
​​新增产品部件​​：创建 RusticDoor, RusticWindow, RusticRoof
​​新增抽象工厂实现​​：创建 RusticComponentFactory
​​新增具体建造者​​：创建 RusticHouseBuilder
​​扩展代码示例​​：

// 田园风格门
public class RusticDoor implements Door {@Override public void install() { System.out.println("安装田园风格门：原木材质，自然纹理"); }@Override public String getStyle() { return "田园"; }
}// 田园风格工厂
public class RusticComponentFactory implements HouseComponentFactory {@Override public Door createDoor() { return new RusticDoor(); }@Override public Window createWindow() { return new RusticWindow(); } // 需实现RusticWindow@Override public Roof createRoof() { return new RusticRoof(); } // 需实现RusticRoof
}// 田园房屋建造者
public class RusticHouseBuilder extends HouseBuilder {public RusticHouseBuilder() {this.factory = new RusticComponentFactory();house.setStyle("田园");}// ... 实现构建方法
}