设计模式:建造者模式

目录

建造者模式(Builder Pattern)是一种创建型设计模式,它通过将复杂对象的构建过程与其表示分离,使得同样的构建过程可以创建不同的表示。该模式将对象的构建过程封装在一个独立的建造者类中,客户端通过指定不同的建造者来构建不同的对象。
在建造者模式中,有以下几个主要角色:

  1. 产品(Product):表示被构建的复杂对象。
  2. 建造者(Builder):定义了构建产品的抽象方法,可以有多个具体的建造者实现类。
  3. 指挥者(Director):负责使用建造者对象构建复杂对象,它并不知道具体的构建过程。
  4. 具体建造者(Concrete Builder):实现了建造者接口,负责具体产品的构建过程和组装。

代码

简单实现

java 复制代码
// Product class
class Product {
    private String partA;
    private String partB;
    private String partC;
    
     public void setPartA(String partA) {
        this.partA = partA;
    }
     public void setPartB(String partB) {
        this.partB = partB;
    }
     public void setPartC(String partC) {
        this.partC = partC;
    }
    
     public void show() {
        System.out.println("Product Parts:");
        System.out.println("Part A: " + partA);
        System.out.println("Part B: " + partB);
        System.out.println("Part C: " + partC);
    }
}
 // Builder interface
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}
 // Concrete Builder
class ConcreteBuilder implements Builder {
    private Product product;
     public ConcreteBuilder() {
        this.product = new Product();
    }
     @Override
    public void buildPartA() {
        product.setPartA("Part A");
    }
     @Override
    public void buildPartB() {
        product.setPartB("Part B");
    }
     @Override
    public void buildPartC() {
        product.setPartC("Part C");
    }
     @Override
    public Product getResult() {
        return product;
    }
}
 // Director
class Director {
    public Product construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}
 // Example usage
public class Main {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director();
        Product product = director.construct(builder);
        product.show();
    }
}

以上是建造者模式在Java中的实现示例。通过使用建造者接口和具体建造者类,将复杂对象的构建过程与其表示分离。指挥者类负责使用建造者对象构建产品对象。最终通过调用建造者的getResult()方法获取构建好的产品对象,并进行展示。

常用使用方法

当对象中参数过多时,频繁的get和set很麻烦,我们可以用建造者模式改造

java 复制代码
public class Test {

    private String partA;
    private String partB;
    private String partC;
    private String partD;

    private Test(Builder builder) {
        partA = builder.partA;
        partB = builder.partB;
        partC = builder.partC;
        partD = builder.partD;
    }

    public static final class Builder {
        private String partA;
        private String partB;
        private String partC;
        private String partD;

        public Builder() {}

        public Builder partA(String val) {
            partA = val;
            return this;
        }
        public Builder partB (String val) {
            partB = val;
            return this;
        }
        public Builder partC (String val) {
            partC = val;
            return this;
        }
        public Builder partD (String val) {
            partD = val;
            return this;
        }
        public Test build() {
            return new Test(this);}
    }
    @Override
    public String toString() {
        return "Test{" +
                "partA ='" + partA + '\'' +
                ", partB ='" + partB + '\'' +
                ", partC ='" + partC + '\'' +
                ", partD ='" + partD + '\'' +
                '}';
    }
}

public class Client {
    public static void main(String[] args) {
        Test test = new Test.Builder()
                .partA ("partA")
                .partB ("partB ")
                .partC ("partC")
                .partD ("partD ")
                .build();
        System.out.println(test);
    }
}

注解方法使用建造者模式

我们可以使用lombok.Builder注解使用构造者模式

java 复制代码
@Data
@Builder
public class Test {
    private String partA;
    private String partB;
    private String partC;
    private String partD;
}

public class Client {
    public static void main(String[] args) {
        Test test = new Test.Builder()
                .partA ("partA")
                .partB ("partB ")
                .partC ("partC")
                .partD ("partD ")
                .build();
        System.out.println(test);
    }
}

总结

建造者模式的优点:

  1. 将复杂对象的构建过程与表示分离,使得同样的构建过程可以创建不同的表示。
  2. 隐藏了产品的内部结构,使得客户端只需要关注产品的高层接口。
  3. 可以更加精细地控制产品的构建过程,灵活性高。

建造者模式的缺点:

  1. 是增加了代码的复杂度,需要创建多个类来实现建造者、产品和指挥者角色,增加了系统的抽象性和理解难度。

总结来说,建造者模式适用于需要创建复杂对象,且创建过程中涉及多个步骤和部件的场景。它提供了一种灵活、可扩展的对象构建方式,并且可以隐藏产品的内部细节。

相关推荐
SimonKing2 分钟前
WorkBuddy又推出新的限免模型(Hy4 flash)了,羊毛可以薅起来了
java·后端·程序员
Rain的Java大神之路15 分钟前
别再死背"三级缓存"了!拿 Spring 7.0.8 源码,把 IoC、AOP、事务、循环依赖四大深水区一次蹚平
java·后端·面试
H H.25 分钟前
Java企业级开发:从框架到工程化实战
java·开发语言·经验分享·其他·课程设计
wno70425 分钟前
springboot整合FastDFS
java·spring boot·后端
顧棟1 小时前
组件生命周期设计:从硬编码初始化到状态机
java·ide
特立独行的猫A9 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
一起_java9 小时前
技术文章-基于Dify-Agent的智能问答系统设计与实现
java·spring boot·后端·agent·dify
是2的10次方啊10 小时前
设计模式与生活·总论:AI 能替你砌墙,替不了你打地基
设计模式
Flynn Liang11 小时前
I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS
java·spring boot·性能优化·高并发·系统设计·虚拟线程·io密集型
吃我一窝jio12 小时前
Python与Go线程模型深度对比
java·开发语言·python