Quindi abbiamo implementato il modello di builder per la maggior parte del nostro dominio per aiutare a comprendere cosa effettivamente viene passato a un costruttore e per i normali vantaggi offerti da un builder. L'unica differenza era che abbiamo esposto il builder attraverso le interfacce in modo da poter concatenare le funzioni richieste e le funzioni non richieste per garantire che i parametri corretti fossero passati. Ero curioso di sapere se esistesse uno schema come questo.
Esempio di seguito:
public class Foo
{
private int someThing;
private int someThing2;
private DateTime someThing3;
private Foo(Builder builder)
{
this.someThing = builder.someThing;
this.someThing2 = builder.someThing2;
this.someThing3 = builder.someThing3;
}
public static RequiredSomething getBuilder()
{
return new Builder();
}
public interface RequiredSomething { public RequiredDateTime withSomething (int value); }
public interface RequiredDateTime { public OptionalParamters withDateTime (DateTime value); }
public interface OptionalParamters {
public OptionalParamters withSeomthing2 (int value);
public Foo Build ();}
public static class Builder implements RequiredSomething, RequiredDateTime, OptionalParamters
{
private int someThing;
private int someThing2;
private DateTime someThing3;
public RequiredDateTime withSomething (int value) {someThing = value; return this;}
public OptionalParamters withDateTime (int value) {someThing = value; return this;}
public OptionalParamters withSeomthing2 (int value) {someThing = value; return this;}
public Foo build(){return new Foo(this);}
}
}
Esempio di come viene chiamato:
Foo foo = Foo.getBuilder().withSomething(1).withDateTime(DateTime.now()).build();
Foo foo2 = Foo.getBuilder().withSomething(1).withDateTime(DateTime.now()).withSomething2(3).build();