Java 빌더 패턴에 해당하는 Scala는 무엇입니까?

Java 빌더 패턴에 해당하는 Scala는 무엇입니까?

---

Java에서 매일하는 작업에서, 유창한 인터페이스를 위해 빌더를 많이 사용합니다. 예 : new PizzaBuilder(Size.Large).onTopOf(Base.Cheesy).with(Ingredient.Ham).build();

빠르고 더러운 Java 접근 방식을 사용하면 각 메소드 호출이 빌더 인스턴스를 변경하고 this. 변경되지는 않지만 더 많은 입력이 필요하며 수정하기 전에 빌더를 먼저 복제합니다. 빌드 메소드는 결국 빌더 상태에 대한 무거운 작업을 수행합니다.

Scala에서 동일한 것을 달성하는 좋은 방법은 무엇입니까?

나는 그 보장하기 위해 원하는 경우 onTopOf(base:Base)한 번만 호출 한 다음 이후에만 한 with(ingredient:Ingredient)하고 build():Pizza, 호출 할 수있는 라 감독이 빌더를 어떻게이 접근 가겠어요?

---

Scala 2.8의 Builder 패턴에 대한 또 다른 대안은 기본 인수 및 명명 된 매개 변수와 함께 변경 불가능한 케이스 클래스를 사용하는 것입니다. 약간 다르지만 효과는 스마트 기본값, 모든 값이 지정되고 구문 검사로 한 번만 지정됩니다.

다음은 간결함 / 속도 값으로 문자열을 사용합니다.

scala> case class Pizza(ingredients: Traversable[String], base: String = "Normal", topping: String = "Mozzarella")
defined class Pizza

scala> val p1 = Pizza(Seq("Ham", "Mushroom"))                                                                     
p1: Pizza = Pizza(List(Ham, Mushroom),Normal,Mozzarella)

scala> val p2 = Pizza(Seq("Mushroom"), topping = "Edam")                               
p2: Pizza = Pizza(List(Mushroom),Normal,Edam)

scala> val p3 = Pizza(Seq("Ham", "Pineapple"), topping = "Edam", base = "Small")       
p3: Pizza = Pizza(List(Ham, Pineapple),Small,Edam)

그런 다음 기존의 불변 인스턴스를 일종의 빌더로 사용할 수도 있습니다.

scala> val lp2 = p3.copy(base = "Large")
lp2: Pizza = Pizza(List(Ham, Pineapple),Large,Edam)

---

여기에는 세 가지 주요 대안이 있습니다.

1. Java, 클래스 및 모두에서와 동일한 패턴을 사용하십시오.

2. 명명 된 기본 인수와 복사 방법을 사용합니다. 케이스 클래스는 이미 이것을 제공하지만 여기에 케이스 클래스가 아닌 예제가 있으므로 더 잘 이해할 수 있습니다.

   object Size {
       sealed abstract class Type
       object Large extends Type
   }
   
   object Base {
       sealed abstract class Type
       object Cheesy extends Type
   }
   
   object Ingredient {
       sealed abstract class Type
       object Ham extends Type
   }
   
   class Pizza(size: Size.Type, 
               base: Base.Type, 
               ingredients: List[Ingredient.Type])
   
   class PizzaBuilder(size: Size.Type, 
                      base: Base.Type = null, 
                      ingredients: List[Ingredient.Type] = Nil) {
   
       // A generic copy method
       def copy(size: Size.Type = this.size,
                base: Base.Type = this.base,
                ingredients: List[Ingredient.Type] = this.ingredients) = 
           new PizzaBuilder(size, base, ingredients)
   
   
       // An onTopOf method based on copy
       def onTopOf(base: Base.Type) = copy(base = base)
   
   
       // A with method based on copy, with `` because with is a keyword in Scala
       def `with`(ingredient: Ingredient.Type) = copy(ingredients = ingredient :: ingredients)
   
   
       // A build method to create the Pizza
       def build() = {
           if (size == null || base == null || ingredients == Nil) error("Missing stuff")
           else new Pizza(size, base, ingredients)
       }
   }
   
   // Possible ways of using it:
   new PizzaBuilder(Size.Large).onTopOf(Base.Cheesy).`with`(Ingredient.Ham).build();
   // or
   new PizzaBuilder(Size.Large).copy(base = Base.Cheesy).copy(ingredients = List(Ingredient.Ham)).build()
   // or
   new PizzaBuilder(size = Size.Large, 
                    base = Base.Cheesy, 
                    ingredients = Ingredient.Ham :: Nil).build()
   // or even forgo the Builder altogether and just 
   // use named and default parameters on Pizza itself
   

3. Use a type safe builder pattern. The best introduction I know of is this blog, which also contains references to many other articles on the subject.

   Basically, a type safe builder pattern guarantees at compile time that all required components are provided. One can even guarantee mutual exclusion of options or arity. The cost is the complexity of the builder code, but...

---

It's the same exact pattern. Scala allows for mutation and side effects. That said, if you'd like to be more of a purest, have each method return a new instance of the object that you're constructing with the element(s) changed. You could even put the functions within the Object of a class so that there's a higher level of separation within your code.

class Pizza(size:SizeType, layers:List[Layers], toppings:List[Toppings]){
    def Pizza(size:SizeType) = this(size, List[Layers](), List[Toppings]())

object Pizza{
    def onTopOf( layer:Layer ) = new Pizza(size, layers :+ layer, toppings)
    def withTopping( topping:Topping ) = new Pizza(size, layers, toppings :+ topping)
}

so that your code might look like

val myPizza = new Pizza(Large) onTopOf(MarinaraSauce) onTopOf(Cheese) withTopping(Ham) withTopping(Pineapple)

(Note: I've probably screwed up some syntax here.)

---

Case classes solve the problem as shown in previous answers, but the resulting api is difficult to use from java when You have scala collections in your objects. To provide a fluent api to java users try this:

case class SEEConfiguration(parameters : Set[Parameter],
                               plugins : Set[PlugIn])

case class Parameter(name: String, value:String)
case class PlugIn(id: String)

trait SEEConfigurationGrammar {

  def withParameter(name: String, value:String) : SEEConfigurationGrammar

  def withParameter(toAdd : Parameter) : SEEConfigurationGrammar

  def withPlugin(toAdd : PlugIn) : SEEConfigurationGrammar

  def build : SEEConfiguration

}

object SEEConfigurationBuilder {
  def empty : SEEConfigurationGrammar = SEEConfigurationBuilder(Set.empty,Set.empty)
}


case class SEEConfigurationBuilder(
                               parameters : Set[Parameter],
                               plugins : Set[PlugIn]
                               ) extends SEEConfigurationGrammar {
  val config : SEEConfiguration = SEEConfiguration(parameters,plugins)

  def withParameter(name: String, value:String) = withParameter(Parameter(name,value))

  def withParameter(toAdd : Parameter) = new SEEConfigurationBuilder(parameters + toAdd, plugins)

  def withPlugin(toAdd : PlugIn) = new SEEConfigurationBuilder(parameters , plugins + toAdd)

  def build = config

}

Then in java code the api is really easy to use

SEEConfigurationGrammar builder = SEEConfigurationBuilder.empty();
SEEConfiguration configuration = builder
    .withParameter(new Parameter("name","value"))
    .withParameter("directGivenName","Value")
    .withPlugin(new PlugIn("pluginid"))
    .build();

---

using Scala partial applies are feasible if you are building a smallish object that you don't need to pass over method signatures. If any of those assumptions don't apply, I recommend using a mutable builder to build an immutable object. With this being scala you could implement the builder pattern with a case class for the object to build with a companion as the builder.

Given that the end result is a constructed immutable object I don't see that it defeats any of the Scala principles.

ReferenceURL : https://stackoverflow.com/questions/4625580/what-is-the-scala-equivalent-to-a-java-builder-pattern