¿Cómo marcar un método obligatorio?

Question

supongamos que crea una Persona nombres de clase utilizando el Builder, y supongamos que la clase contiene métodos constructor body(), head(), arms() y por supuesto build() y considere métodos head() y build() obligatorio para el usuario de esta clase.

Nos gustaría de alguna manera marcar estos métodos como obligatorios, de ser posible usando anotaciones. Si un usuario de esta clase intenta crear una instancia de Persona pero olvidó llamar a cualquiera de estos métodos, nos gustaría obtener algún tipo de advertencia, ya sea del compilador de Java, o tal vez de Eclipse o Maven, que usamos para construir nuestro proyectos - cualquiera de ellos lo haría.

¿Es posible hacer? ¿De qué manera sugerirías?

Answer 1

Aquí se muestra un ejemplo con el uso de diferentes tipos para hacer algunas partes obligatoria (que también hace que la orden se llama a los métodos obligatorios):

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; 
    } 
} 

---

Editar

El PO fue tan impresionado con esta respuesta que lo escribió por completo en un blog. Es una versión tan inteligente del patrón de construcción que un tratamiento completo merece ser referenciado aquí.

Answer 2

De ninguna manera con el compilador.

que puede hacer es lanzar una excepción de ejecución del método build() que el constructor no se ha inicializado correctamente (y tener una prueba de que se invoca en la fase de prueba experta)

Pero también puede tener build(..) aceptar una HeadDetails objeto. De esa forma tou no puede invocar build sin especificar los parámetros obligatorios.

Answer 3

Tal vez dentro de build() se puede verificar si se han llamado a todos los métodos requeridos. Tal vez la instancia Person tiene algún control de cordura interno que se desencadena por build().

Por supuesto, esto comprueba el comportamiento del tiempo de ejecución y no es un análisis estático como usted lo describe.

Answer 4

no es posible llamar a estos métodos en el constructor de persona?

Answer 5

¿Por qué no llamar a body(), head(), arms() en la construcción() - Método si es realmente obligatorio y devolver Person en el método build()?

[editar]

ejemplo corto:

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

Creo que el uso correcto del Builder resolvería el problema que está teniendo.

Crearía la clase PersonBuilder que contendría los métodos setBody() y setArms() y cualquier otro método de configuración de parámetros opcional. El constructor del constructor tomaría los parámetros requeridos. Entonces el método build() devolvería la nueva instancia de 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); 
    } 
} 

alternativa usted puede pasar el parámetro Head al método build() pero prefiero pasar en el constructor en su lugar.