设计模式（4）：建造者模式及其在Java中的应用实例

最新推荐文章于 2024-01-29 10:23:50 发布

行百里者半九九

最新推荐文章于 2024-01-29 10:23:50 发布

阅读量492

点赞数 1

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_41969790/article/details/107735921

版权

设计模式专栏收录该内容

14 篇文章 2 订阅

订阅专栏

建造者模式

4.1 建造者模式的实现不可变对象的创建示例

5 应用示例

1、什么是建造者模式？

（1）模式定义：

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

或者说：建造者模式将一个复杂对象的创建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2、建造者模式特性

（1）意图：

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

（2）主要解决：

主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

（3）何时使用：

一些基本部件不会变，而其组合经常变化的时候。

（4）如何解决：

将变与不变分离开。

（5）关键代码：

建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

3、建造者模式优缺点及应用场景

（1）优点：

1、建造者独立，易扩展。

2、便于控制细节风险。

（2）缺点：

1、产品必须有共同点，范围有限制。

2、如内部变化复杂，会有很多的建造类。

（3）使用场景：

1、需要生成的对象具有复杂的内部结构。

2、需要生成的对象内部属性本身相互依赖。

3、与不可变对象配合使用。

（4）注意事项：

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

4、建造者模式实现示例

4.1 建造者模式的一种标准实现示例

(1)假设场景：

假设一个产品有非常多的属性，如一个Product有productName,companyName,part1,part2.....在创建该对象时和它各部分的创建顺序有关。我们可以将该产品的创建抽象为一个ProductBuilder产品创建接口类，它的子类作为具体的创建者创建。我们建立一个指导Director类，用于知道产品船创建者创建产品。

(2)代码示例：

该产品Product类：

 public Product(String productName, String commpanyName, String part1, String part2, String part3, String part4) {
        this.productName = productName;
        this.commpanyName = commpanyName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public String getCommpanyName() {
        return commpanyName;
    }

    public void setCommpanyName(String commpanyName) {
        this.commpanyName = commpanyName;
    }

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public String getPart3() {
        return part3;
    }

    public void setPart3(String part3) {
        this.part3 = part3;
    }

    public String getPart4() {
        return part4;
    }

    public void setPart4(String part4) {
        this.part4 = part4;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", commpanyName='" + commpanyName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
}

创建者接口类ProductBuilder类：

//构建者抽象接口
interface ProductBuilder{
    void buildProductName(String productName);
    void buildcommpanyName(String commpanyName);
    void buildpart1(String part1);
    void buildpart2(String part2);
    void buildpart3(String part3);
    void buildpart4(String part4);
    //.....
    //定义一个创建最终对象的方法
    Product build();
}

一个自定义的默认具体创建者，可以根据需要创建不同的建造者，用于创建具体的产品：

//默认的创建创建者，可以有其他创建者
class DefaultConcreteProductBuilder implements ProductBuilder{

    private String productName;
    private String commpanyName;
    private String part1;
    private String part2;
    private String part3;
    private String part4;

    @Override
    public void buildProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public void buildcommpanyName(String commpanyName) {
        this.commpanyName = commpanyName;
    }

    @Override
    public void buildpart1(String part1) {
        this.part1 = part1;
    }

    @Override
    public void buildpart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public void buildpart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public void buildpart4(String part4) {
        this.part4 = part4;
    }

    @Override
    public Product build() {
        return new Product(this.productName,this.commpanyName,this.part1,this.part2,this.part3,this.part4);
    }
}

指导者Director类，用于指导创建者创建不同的产品：这里传入具体的建造者，makeProduct方法指导创建者完成产品的创建。

//指导者
class Director{
    private ProductBuilder builder;

    public Director(ProductBuilder builder) {
        this.builder = builder;
    }


    public Product makeProduct(String productName, String commpanyName, String part1, String part2, String part3, String part4){
        builder.buildProductName(productName);
        builder.buildcommpanyName(commpanyName);
        builder.buildpart1(part1);
        builder.buildpart2(part2);
        builder.buildpart3(part3);
        builder.buildpart4(part4);

        Product product = builder.build();
        return product;
    }
}

测试示例：

public class BuilderTest {
    public static void main(String[] args) {

        //建造者模式创建对象；后续需要创建其他的产品时，只需要创建其他的建造者并作为参数传入指导者就行
        ProductBuilder productBuilder = new DefaultConcreteProductBuilder();
        //创建指导者来指导创建
        Director director = new Director(productBuilder);
        Product product = director.makeProduct("productName", "companyName", "part1", "part2", "part3", "part4");
        System.out.println(product);
        
    }
}

示例输出：

Product{productName='productName', commpanyName='companyName', part1='part1', part2='part2', part3='part3', part4='part4'}

后续我们可以具体添加其他的建造者，用于完成产品的具体创建，但是这个创建使用的整体流程是不变的。指导者指导具体创建者创建产品。与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

4.1 建造者模式的实现不可变对象的创建示例

（1）场景描述：

和上述类似，不过该Product类的属性都是final的，也就是构建之后不可变。我们通过在该产品类内部定义一个静态建造者类来完成产品的构建。

（2）示例代码：

Product类及其内部静态建造者类如下：

class Product{

    private final String productName;
    private final String commpanyName;
    private final String part1;
    private final String part2;
    private final String part3;
    private final String part4;
    //....


    public Product(String productName, String commpanyName, String part1, String part2, String part3, String part4) {
        this.productName = productName;
        this.commpanyName = commpanyName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    //通过静态内部类
    static class Builder{
        private  String productName;
        private  String commpanyName;
        private  String part1;
        private  String part2;
        private  String part3;
        private  String part4;

        //让对象每次都返回自己，以实现链式调用
        public Builder productName(String productName){
            this.productName = productName;
            return this;
        }
        public Builder commpanyName(String commpanyName){
            this.commpanyName = commpanyName;
            return this;
        }
        public Builder part1(String part1){
            this.part1 = part1;
            return this;
        }
        public Builder part2(String part2){
            this.part2 = part2;
            return this;
        }
        public Builder part3(String part3){
            this.part3 = part3;
            return this;
        }
        public Builder part4(String part4){
            this.part4 = part4;
            return this;
        }

        //对象构建
        Product build(){
            Product product = new Product(this.productName,this.commpanyName,this.part1,this.part2,this.part3,this.part4);
            return product;
        }
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", commpanyName='" + commpanyName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", part4='" + part4 + '\'' +
                '}';
    }
}

使用时，我们通过new Product对象的内部Builder建造者完成产品的创建。演示示例：

public class BuilderTest2 {
    public static void main(String[] args) {

        Product product= new Product.Builder().productName("xxxname").commpanyName("xxxcommpany").part1("xxx1").part2("xxx2").part3("xxx3").part4("xxx4").build();
        System.out.println(product);

    }
}

这里可以使用链式创建产品，或初始化某个属性之后创建，非常灵活。

5 应用示例

（1）SpringMVC中的RequestMappingInfo类。（org.springframework.web.servlet.mvc.method.RequestMappingInfo）

（2）BeanDefinitionBuilder类。（org.springframework.web.servlet.mvc.method.BeanDefinitionBuilder）

本文源代码：https://github.com/JianfuYang/2020-yjf-review/tree/master/src/designpatterns/builder

声明：本文部分内容整理来源于网络，仅做个人学习使用！侵删~

行百里者半九九

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
设计模式（4）：建造者模式及其在Java中的应用实例

1、什么是建造者模式？（1）模式定义：建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。或者说：建造者模式将一个复杂对象的创建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式示例类图2、建造者模式特性（1）意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以
复制链接

扫一扫