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

将抽象工厂模式与建造者模式结合,可以优雅地处理需要创建​​多个产品族​​,且每个产品族内部对象​​构建过程复杂​​的场景。这种结合充分发挥了抽象工厂管理产品族的优势,以及建造者模式精细控制复杂对象构建过程的优势

下面我们通过一个构建不同风格(现代、古典)房屋的例子来具体说明。

🧱 核心组件定义

首先,我们定义房屋的组成部分和不同风格的具体实现。

​​1. 产品部件接口​​

定义门、窗、屋顶等部件的通用接口。

java 复制代码
// 门接口
public interface Door {
    void install();
    String getStyle();
}

// 窗接口
public interface Window {
    void install();
    String getStyle();
}

// 屋顶接口
public interface Roof {
    void build();
    String getStyle();
}

​​2. 具体产品部件​​

实现现代风格和古典风格的具体部件。

java 复制代码
// 现代风格门
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. 抽象工厂接口​​

java 复制代码
public interface HouseComponentFactory {
    Door createDoor();
    Window createWindow();
    Roof createRoof();
}

​​2. 具体工厂​​

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

java 复制代码
// 现代风格工厂
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. 产品:房屋​​

java 复制代码
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. 抽象建造者​​

java 复制代码
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. 具体建造者​​

java 复制代码
// 现代房屋建造者
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. 指挥者​​

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

👨‍💻 客户端使用

java 复制代码
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

​​扩展代码示例​​:

java 复制代码
// 田园风格门
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("田园");
    }
    // ... 实现构建方法
}
相关推荐
代码不停8 小时前
Java前缀和算法题目练习
java·开发语言·算法
豆沙沙包?8 小时前
2025年--Lc200- 414. 第三大的数(大根堆)--Java版
java·开发语言
在下木子生8 小时前
SpringBoot基于工厂模式的多类型缓存设计
java·spring boot·缓存
xxxxxxllllllshi8 小时前
Java中Elasticsearch完全指南:从零基础到实战应用
java·开发语言·elasticsearch·面试·职场和发展·jenkins
无毁的湖光Al8 小时前
日常问题排查-Younggc突然变长
java·jvm·后端
_星辰大海乀8 小时前
网络原理 -- HTTP
java·服务器·http·get方法·post方法
bkspiderx8 小时前
C++设计模式之行为型模式:访问者模式(Visitor)
c++·设计模式·访问者模式
没有bug.的程序员8 小时前
电商系统分布式架构实战:从单体到微服务的演进之路
java·分布式·微服务·云原生·架构·监控体系·指标采集
Lei活在当下8 小时前
【业务场景架构实战】8. 订单状态流转在 UI 端的呈现设计
android·设计模式·架构
Query*8 小时前
Java 设计模式——代理模式:从静态代理到 Spring AOP 最优实现
java·设计模式·代理模式