Question

我最近学习了Joshua Bloch's builder pattern来创建具有许多可选字段的对象。我多年来一直在使用类似的东西，但是直到布洛赫的书向我提出它之前，我从未使用过内部阶级。我喜欢它。

我知道另一个线程可能会在实际构建之前改变Bulider的配置（使用build()），这样可能需要重新验证封闭类的构造函数中的所有值。下面是一个构建器类的示例，它可以选择性地重新验证其数据。

所以我的问题是这样的：假设这是一个足够强大的设计，当所有值都有默认值时 - 知道这个类是使用默认值的不好选择 - 并且当每次设置尝试都被验证时，是这样的 - 检查有必要吗？虽然它可能不同，但它永远不会无效。这是对的吗？

（虽然这种设计是可管理的，但是由于重新验证的潜在需要，它当然很复杂。而且，老实说，我从来没有多线程，但我不想让我的库无法使用。）

感谢您的任何建议。

/**
   <P><CODE>java ReverifyBuilderInEnclosingCnstrXmpl</CODE></P>
 **/
public class ReverifyBuilderInEnclosingCnstrXmpl  {
   public static final void main(String[] igno_red)  {

      //Don't reverify
      ReverifyBuilderInEnclosingCnstrXmpl rvbdx = new ReverifyBuilderInEnclosingCnstrXmpl.Cfg().
         name("Big Bird").age(6).build();

      System.out.println(rvbdx.sName);
      System.out.println(rvbdx.iAge);

      //Do reverify
      rvbdx = new ReverifyBuilderInEnclosingCnstrXmpl.Cfg().
         reverifyInEnclosing().
         name("Big Bird").age(6).build();
   }

   public final String sName;
   public final int    iAge;
   /**
      <P>Create a new <CODE>ReverifyBuilderInEnclosingCnstrXmpl</CODE> with defaults.</P>
   **/
   public ReverifyBuilderInEnclosingCnstrXmpl()  {
      //Does not reverify. No need.
      this(new ReverifyBuilderInEnclosingCnstrXmpl.Cfg());
   }
   private ReverifyBuilderInEnclosingCnstrXmpl(ReverifyBuilderInEnclosingCnstrXmpl.Cfg rbdx_c)  {
      sName = rbdx_c.sName;
      iAge = rbdx_c.iAge;
      ReverifyBuilderInEnclosingCnstrXmpl.Cfg.zcibValues(rbdx_c, sName, iAge, "constructor");
   }
   public static class Cfg  {
      private String  sName   = null;
      private int     iAge    = -1;
      private boolean bReVrfy = false;
      public Cfg()  {
         //Defaults
         bReVrfy = false;
         name("Broom Hilda");
         age(127);
      }
      //Self-returning configuration...START
         //No way to unset.
         public Cfg reverifyInEnclosing()  {
            bReVrfy = true;
            return  this;
         }
         public Cfg name(String s_name)  {
            zcib_name(s_name, "name");
            sName = s_name;
            return  this;
         }
         public Cfg age(int i_age)  {
            zcib_age(i_age, "age");
            iAge = i_age;
            return  this;
         }
      //Self-returning configuration...END
      //Validate config...START
         public static final void zcibValues(ReverifyBuilderInEnclosingCnstrXmpl.Cfg rbdx_c, String s_name, int i_age, String s_clgFunc)  {
            try  {
               if(!rbdx_c.bReVrfy)  {
                  return;
               }
            }  catch(NullPointerException npx)  {
               throw  new NullPointerException("zcibValues: rbdx_c");
            }
            zcib_name(s_name, s_clgFunc);
            zcib_age(i_age, s_clgFunc);
         }
         public static final void zcib_name(String s_name, String s_clgFunc)  {
            if(s_name == null  ||  s_name.length() == 0)  {
               throw  new IllegalArgumentException(s_clgFunc + ": s_name (" + s_name + ") is null or empty.");
            }
         }
         public static final void zcib_age(int i_age, String s_clgFunc)  {
            if(i_age < 0)  {
               throw  new IllegalArgumentException(s_clgFunc + ": i_age (" + i_age + ") is negative.");
            }
         }
      //Validate config...END
      public ReverifyBuilderInEnclosingCnstrXmpl build()  {
         return  (new ReverifyBuilderInEnclosingCnstrXmpl(this));
      }
   }
}

Answer 1

首先 - 构建器模式不固有线程不安全。我不确定你是如何得出结论的。打算使用构建器的每个线程都将创建自己的Builder对象，以Joshua Bloch实用且美观的方式填充它并使用它来构造对象。在该机制中的任何地方都没有static个变量受到影响，除非您自己介绍，否则没有线程不安全。

您对验证的担忧 - 在我的拙见中 - 一个粗略的预优化，产生了可怕的，可怕的臃肿代码。 没有理由因为您知道数据有效而试图避免验证。验证几乎总是微不足道的，通常只需要一些指令。通过使用这些可怕的静态验证方法膨胀这个类，你可能会增加数千倍的cpu周期来加载这个膨胀的代码而不是通过避免验证来保存。

将您的设计和臃肿的代码与这个清晰，简洁，明确正确的和线程安全代码进行比较，看看我的意思：

public class Thing {

    public final String name;
    public final int age;

    public Thing() {
        this(new Thing.Builder());
    }

    private Thing(Thing.Builder builder) {
        name = builder.name;
        age = builder.age;
    }

    public static class Builder {

        private String name = null;
        private int age = -1;

        public Builder() {
            name("Broom Hilda");
            age(127);
        }

        public Builder name(String name) {
            if (name == null || name.length() == 0) {
                throw new IllegalArgumentException("Thing.Builder.name (" + name + ") is null or empty.");
            }
            this.name = name;
            return this;
        }

        public Builder age(int age) {
            if (age < 0) {
                throw new IllegalArgumentException("Thing.Builder.age (" + age + ") is negative.");
            }
            this.age = age;
            return this;
        }

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

Answer 2

您在架构级别上误解了模式：构造期间的所有数据都绑定到本地线程，而不是暴露给任何外部处理程序。调用当前构建时，现在最终参数集将传递给不可变对象，然后首先应验证这些对象的有效性构造函数中的参数，然后返回最终对象或抛出异常。

只要将构建器参数保持在线程本地，就不会导致任何线程问题。如果您违反此规则，您应该问问自己，您所做的事情是否正确和/或您如何以更细粒度的方式解决它。

因此，如果您的示例中需要使用来自不同线程的构建器，那么最简单和最安全的方法是创建一个新的构建器实例，而不是静态地执行它。如果您担心表现，ThreadLocal是您的朋友。

使Bloch的构建器模式成为线程安全的：如果NEVER无效，那么在封闭构造函数中需要重新检查吗？

2 个答案: