Come contrassegnare un metodo obbligatorio?

Question

supponga di creare una persona nomi di classi utilizzando il builder, e supponiamo che la classe Builder contiene i metodi body(), head(), arms() e naturalmente build() e prendere in considerazione metodi head() e build() obbligatorio per l'utente di questa classe.

Vorremmo in qualche modo contrassegnare questi metodi obbligatori, se possibile usando annotazioni. Se un utente di questa classe prova a creare un'istanza Person ma ha dimenticato di chiamare uno di questi metodi, vorremmo ricevere qualche tipo di avviso - sia dal compilatore java, sia da Eclipse o Maven, che usiamo per costruire il nostro progetti - ognuno di loro farebbe.

È possibile fare? Quale strada suggeriresti?

Answer 1

Ecco un esempio con l'utilizzo di tipi diversi di fare alcune parti obbligatorie (ma rende anche l'ordine di chiamare i metodi obbligatori):

package test; 

import test.StepOne.StepThree; 
import test.StepOne.StepTwo; 
import test.StepOne.LastStep; 

public class TestBuilder { 

    public static void main(String[] args) { 

     String person1 = PersonBuilder.newInstance().head("head").body("body").arm("arm").leg("leg").build(); 

     String person2 = PersonBuilder.newInstance().head("head").body("body").arm("arm").build(); 

    } 

} 

interface StepOne { 

    // mandatory 
    StepTwo head(String head); 

    interface StepTwo { 
     // mandatory 
     StepThree body(String body); 
    } 

    interface StepThree { 
     // mandatory 
     LastStep arm(String arm); 
    } 

    // all methods in this interface are not mandatory 
    interface LastStep { 
     LastStep leg(String leg); 
     String build(); 
    } 

} 

class PersonBuilder implements StepOne, StepTwo, StepThree, LastStep { 

    String head; 
    String body; 
    String arm; 
    String leg; 

    static StepOne newInstance() { 
     return new PersonBuilder(); 
    } 

    private PersonBuilder() { 
    } 



    public StepTwo head(String head) { 
     this.head = head; 
     return this; 
    } 

    public LastStep arm(String arm) { 
     this.arm = arm; 
     return this; 
    } 

    public StepThree body(String body) { 
     this.body = body; 
     return this; 
    } 

    public LastStep leg(String leg) { 
     this.leg = leg; 
     return this; 
    } 

    public String build() { 
     return head + body + arm + leg; 
    } 
} 

---

Modifica

L'OP era così colpito da questa risposta che lo ha scritto completamente in un blog. È una visione così intelligente del modello di costruzione che merita di essere citato qui un trattamento completo.

Answer 2

Impossibile con il compilatore.

si può fare è lanciare un'eccezione di runtime dal metodo build() che il costruttore non è correttamente inizializzata (e avere un test che viene richiamata in fase di test Maven)

Ma si può anche avere build(..) accettare una HeadDetails oggetto. In questo modo tou non può invocare build senza specificare i parametri obbligatori.

Answer 3

Forse all'interno di build() è possibile verificare se sono stati chiamati tutti i metodi richiesti. In breve, l'istanza Person ha un controllo interno di integrità che viene attivato da build().

Ovviamente questo controlla il comportamento di runtime e non è un'analisi statica come la descrivi.

Answer 4

non è possibile chiamare questi metodi nel costruttore di Person?

Answer 5

Perché non chiamare body(), head(), arms() nel build() - Metodo se è davvero obbligatorio e restituisce Person nel metodo build()?

[modifica]

breve esempio:

public class Builder { 

private final String bodyProp; 

private final String headProp; 

private final String armsProp; 

private String hearProps; 

public Builder(String bodyProp, String headProp, String armsProp) { 
    super(); 
    this.bodyProp = bodyProp; // check preconditions here (eg not null) 
    this.headProp = headProp; 
    this.armsProp = armsProp; 
} 

public void addOptionalHair(String hearProps) { 
    this.hearProps = hearProps; 
} 

public Person build() { 
    Person person = new Person(); 

    person.setBody(buildBody()); 
    // ... 

    return person; 
} 



private Body buildBody() { 
    // do something with bodyProp 
    return new Body(); 
} 


public static class Person { 

    public void setBody(Body buildBody) { 
     // ... 
    } 
} 

public static class Body { 
} 
} 

Answer 6

Credo che il corretto utilizzo del builder avrebbe risolto il problema riscontrato.

Vorrei creare la classe PersonBuilder che conterrebbe i metodi setBody() e setArms() e ogni altro metodo di impostazione parametri opzionale. Il costruttore del costruttore avrebbe preso i parametri richiesti. Quindi il metodo build() restituirebbe la nuova istanza di Person.

public class PersonBuilder 
{ 
    private final Head head; 
    private Body body; 
    private Arms arms; 

    public PersonBuilder(Head head) 
    { 
     this.head = head; 
    } 

    public void setBody(Body body) 
    { 
     this.body = body; 
    } 

    public void setArms(Arms arms) 
    { 
     this.arms = arms; 
    } 

    public Person build() 
    { 
     return new Person(head, body, arms); 
    } 
} 

In alternativa si potrebbe passare il parametro al metodo Headbuild() ma preferisco passarlo nel costruttore, invece.