Builder模式与配置对象 [英] Builder pattern vs. config object

问题描述

构建器模式在创建不可变对象时很流行，但是创建构建器会产生一些编程开销。所以我想知道为什么不简单地使用配置对象。

The builder pattern is popular to create immutable objects, but there is some programming overhead to create a builder. So I wonder why not simply using a config object.

构建器的用法如下所示：

The usage of a builder would look like this:

Product p = Product.Builder.name("Vodka").alcohol(0.38).size(0.7).price(17.99).build();

很明显，这是非常易读和简洁的，但你必须实现构建器：

It is obvious that this is very readable and concise, but you have to implement the builder:

public class Product {

    public final String name;
    public final float alcohol;
    public final float size;
    public final float price;

    private Product(Builder builder) {
        this.name = builder.name;
        this.alcohol = builder.alcohol;
        this.size = builder.size;
        this.price = builder.price;
    }

    public static class Builder {

        private String name;
        private float alcohol;
        private float size;
        private float price;

        // mandatory
        public static Builder name(String name) {
            Builder b = new Builder();
            b.name = name;
            return b;
        }

        public Builder alcohol(float alcohol) {
            this.alcohol = alcohol;
            return.this;
        }

        public Builder size(float size) {
            this.size = size;
            return.this;
        }

        public Builder price(float price) {
            this.price = price;
            return.this;
        }

        public Product build() {
            return new Product(this);
        }

    }

}

<我的想法是，通过使用这样的简单配置对象来减少代码：

My idea is, to reduce the code by using a simple config object like this:

class ProductConfig {

        public String name;
        public float alcohol;
        public float size;
        public float price;

        // name is still mandatory
        public ProductConfig(String name) {
            this.name = name;
        }

}

public class Product {

    public final String name;
    public final float alcohol;
    public final float size;
    public final float price;

    public Product(ProductConfig config) {
        this.name = config.name;
        this.alcohol = config.alcohol;
        this.size = config.size;
        this.price = config.price;
    }

}

用法：

ProductConfig config = new ProductConfig("Vodka");
config.alcohol = 0.38;
config.size = 0.7;
config.price = 17.99;
Product p = new Product(config);

此用法需要更多行但是也非常易读，但实现起来要简单得多对于不熟悉构建器模式的人来说，它更容易理解。顺便说一下：这个模式有没有名称？

This usage needs a few more lines but is also very readable, but the implementation is much simpler and maybe it is easier to understand for someone who isn't familiar with the builder pattern. By the way: is there a name for this pattern?

我忽略了配置方法的缺点吗？

Is there a drawback in the config approach that I've overlooked?

推荐答案

构建器模式改进了解耦 - 您的Product可以是一个接口，唯一知道实现（或某些情况下的实现）的类是构建器。如果构建器还实现了一个接口，那么你可以将它注入代码中以进一步增加去耦。

The builder pattern improves decoupling - your Product can be an interface and the only class that knows about the implementation (or implementations, in some cases) is the builder. If the builder also implements an interface then you can inject this into your code to increase decoupling further.

这种去耦意味着你的代码更易于维护和更容易测试。

This decoupling means your code is more maintainable and easier to test.

这篇关于Builder模式与配置对象的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！