模式结合设计方案
这个设计充分利用了两种模式的优势：工厂方法负责创建不同类型产品的建造者，而建造者模式负责分步骤构造复杂产品
。
类结构设计
md
- Computer (产品)
- ComputerBuilder (抽象建造者)
- GamingComputerBuilder, OfficeComputerBuilder (具体建造者)
- ComputerBuilderFactory (建造者工厂)
- ComputerDirector (指挥者)💻 完整代码实现
- 产品类 - Computer
java
public class Computer {
private String cpu;
private String memory;
private String storage;
private String graphicsCard;
private String powerSupply;
// 私有构造函数，只能通过建造者构建
private Computer() {}
// Setter方法
public void setCpu(String cpu) { this.cpu = cpu; }
public void setMemory(String memory) { this.memory = memory; }
public void setStorage(String storage) { this.storage = storage; }
public void setGraphicsCard(String graphicsCard) { this.graphicsCard = graphicsCard; }
public void setPowerSupply(String powerSupply) { this.powerSupply = powerSupply; }
@Override
public String toString() {
return String.format("Computer[CPU=%s, Memory=%s, Storage=%s, Graphics=%s, Power=%s]",
cpu, memory, storage, graphicsCard, powerSupply);
}
}- 抽象建造者 - ComputerBuilder
java
public interface ComputerBuilder {
void buildCpu();
void buildMemory();
void buildStorage();
void buildGraphicsCard();
void buildPowerSupply();
Computer getResult();
}- 具体建造者 - 游戏电脑和办公电脑
java
// 游戏电脑建造者
public class GamingComputerBuilder implements ComputerBuilder {
private Computer computer;
public GamingComputerBuilder() {
this.computer = new Computer();
}
@Override
public void buildCpu() {
computer.setCpu("Intel Core i9-13900K");
}
@Override
public void buildMemory() {
computer.setMemory("32GB DDR5 RGB");
}
@Override
public void buildStorage() {
computer.setStorage("2TB NVMe SSD + 4TB HDD");
}
@Override
public void buildGraphicsCard() {
computer.setGraphicsCard("NVIDIA GeForce RTX 4090");
}
@Override
public void buildPowerSupply() {
computer.setPowerSupply("1200W 80+ Platinum");
}
@Override
public Computer getResult() {
return computer;
}
}
// 办公电脑建造者
public class OfficeComputerBuilder implements ComputerBuilder {
private Computer computer;
public OfficeComputerBuilder() {
this.computer = new Computer();
}
@Override
public void buildCpu() {
computer.setCpu("Intel Core i5-12400");
}
@Override
public void buildMemory() {
computer.setMemory("16GB DDR4");
}
@Override
public void buildStorage() {
computer.setStorage("512GB NVMe SSD");
}
@Override
public void buildGraphicsCard() {
computer.setGraphicsCard("Integrated Intel UHD Graphics");
}
@Override
public void buildPowerSupply() {
computer.setPowerSupply("550W 80+ Bronze");
}
@Override
public Computer getResult() {
return computer;
}
}- 工厂方法 - 建造者工厂
java
public class ComputerBuilderFactory {
public enum ComputerType {
GAMING, OFFICE
}
public static ComputerBuilder createBuilder(ComputerType type) {
switch (type) {
case GAMING:
return new GamingComputerBuilder();
case OFFICE:
return new OfficeComputerBuilder();
default:
throw new IllegalArgumentException("不支持的电脑类型: " + type);
}
}
}- 指挥者 - ComputerDirector
java
public class ComputerDirector {
public Computer construct(ComputerBuilder builder) {
// 统一的构建流程，确保所有电脑都按正确顺序组装
builder.buildCpu();
builder.buildMemory();
builder.buildStorage();
builder.buildGraphicsCard();
builder.buildPowerSupply();
return builder.getResult();
}
// 可选的快速构建方法
public Computer constructGamingComputer() {
ComputerBuilder builder = ComputerBuilderFactory.createBuilder(
ComputerBuilderFactory.ComputerType.GAMING);
return construct(builder);
}
public Computer constructOfficeComputer() {
ComputerBuilder builder = ComputerBuilderFactory.createBuilder(
ComputerBuilderFactory.ComputerType.OFFICE);
return construct(builder);
}
}- 客户端使用
java
public class Client {
public static void main(String[] args) {
ComputerDirector director = new ComputerDirector();
// 方式1：通过工厂方法创建具体建造者，然后指挥者构建
System.out.println("=== 方式1：分步构建 ===");
ComputerBuilder gamingBuilder = ComputerBuilderFactory.createBuilder(
ComputerBuilderFactory.ComputerType.GAMING);
Computer gamingComputer = director.construct(gamingBuilder);
System.out.println("游戏电脑: " + gamingComputer);
// 方式2：直接使用指挥者的快捷方法
System.out.println("\n=== 方式2：快捷构建 ===");
Computer officeComputer = director.constructOfficeComputer();
System.out.println("办公电脑: " + officeComputer);
// 方式3：动态根据配置构建
System.out.println("\n=== 方式3：动态构建 ===");
String userPreference = "performance"; // 可以从配置文件中读取
Computer dynamicComputer;
if ("performance".equals(userPreference)) {
dynamicComputer = director.constructGamingComputer();
} else {
dynamicComputer = director.constructOfficeComputer();
}
System.out.println("动态配置电脑: " + dynamicComputer);
}
}✨ 设计模式的优越性体现
🎯 关注点分离与职责清晰
工厂方法专注于创建适当类型的建造者对象
建造者模式专注于分步骤构造复杂产品
指挥者控制构建过程，确保一致性
🔄 极高的灵活性和可扩展性
新增电脑类型时，只需要增加新的具体建造者，无需修改现有代码：
java
// 新增轻薄本建造者
public class UltrabookComputerBuilder implements ComputerBuilder {
// 实现所有构建方法...
}
// 在工厂中注册新类型
public static ComputerBuilder createBuilder(ComputerType type) {
switch (type) {
case GAMING: return new GamingComputerBuilder();
case OFFICE: return new OfficeComputerBuilder();
case ULTRABOOK: return new UltrabookComputerBuilder(); // 新增
default: throw new IllegalArgumentException("不支持的电脑类型: " + type);
}
}🛡️ 构建过程的质量保证
指挥者确保了所有电脑都按照正确的顺序和标准构建：
java
public Computer construct(ComputerBuilder builder) {
// 必须的顺序：先装基础部件，再装扩展部件
builder.buildCpu(); // 第一步：安装CPU
builder.buildMemory(); // 第二步：安装内存
builder.buildStorage(); // 第三步：安装存储
builder.buildGraphicsCard(); // 第四步：安装显卡
builder.buildPowerSupply(); // 第五步：安装电源
return builder.getResult();
}💎 总结
这种结合模式充分发挥了各自的优势：工厂方法提供了创建对象的灵活性，而建造者模式提供了构建复杂对象的精细控制。
这种设计使得系统在面对变化时更加健壮，特别是在需要创建具有复杂内部结构的对象时，优势更加明显。
当你的系统需要创建多种类型的复杂对象，且每种对象都有自己特定的构建过程时，考虑使用这种工厂方法与建造者模式的组合，它能为你带来更好的代码结构性和可维护性。