eliminar la duplicación

Question

Tengo una clase que contiene 10 métodos que realizan casi las mismas cosas aparte de un evento clave. Dos ejemplos son los siguientes:

Public String ATypeOperation(String pin, String amount){ 
    doSomething(); 
    doMoreStuff(); 
    requestBuilder.buildATypeRequest(pin, amount); 
    doAfterStuff(); 
} 
 


Public String BTypeOperation(String name, String sex, String age){ 
    doSomething(); 
    doMoreStuff(); 
    requestBuilder.buildBTypeRequest(name, sex, age); 
    doAfterStuff(); 
} 
 

Como se puede ver a partir de los métodos anteriores, son similares, aparte de llamar a diferentes métodos proporcionados por RequestBuilder. El resto 8 son similares también. Aquí hay muchos códigos duplicados. Siento que hay una mejor manera de implementar esto, pero no sé cómo. Cualquier idea y sugerencia es apreciada.

Gracias, Sarah

Answer 1

usar algo como RequestBuilder, que acepta todos estos tipos de parámetros:

public RequestBuilder { 
    // setters and getters for all properties 

    public Request build() { 
     doStuff(); 
     Request request = new Request(this); 
     doAfterStuff(); 
     return request; 
    } 
} 

y luego

new RequestBuilder().setAge(age).setName(name).build(); 

Answer 2

What’s the nearest substitute for a function pointer in Java?

Function Pointers in Java

Answer 3

interface RequestBuilder { 
    void doStuff(params); 
} 

public RequestBuilder getARequestBuilder() { 
    return new RequestBuilder() { 
    void doStuff(params) { 
     // impl.details 
    } 
    } 
}  

public RequestBuilder getBRequestBuilder() { 
    return new RequestBuilder() { 
    void doStuff(params) { 
     // impl.details 
    } 
    } 
}  

public String buildRequest(yourParams, RequestBuilder builder){ 
    doBefore(); 
    builder.doStuff(yourParams); 
    doAfter(); 
} 

creo que esto se llama el patrón Strategy. Se parece mucho al patrón Command, pero debido a que encapsula un algoritmo, parece ser Estrategia :)

Lo que Bozho sugiere es el patrón Builder.

Le recomiendo que navegue por a list of patterns alguna vez, o compre Head First Patterns. Lectura realmente divertida

Answer 4

Usted podría pasar el objeto a un método constructor buildRequest genérico. Dado que no solo el algoritmo sino también los argumentos varían, los puse en el constructor. No creo que esa es una buena solución, pero yo quería mostrar un patrón de comandos aquí: D (Extraneon mostró cómo desacoplar params y comandos)

// call somewhere in the code: 
    Builder b = new BTypeBuilder(); 
    b.age = "20"; b.sex = "female"; b.name = "eve"; 
    String res = buildRequest(b); 

    Public String buildRequest(Builder builder) 
    { 
     doSomething(); 
     doMoreStuff(); 
     builder.build(); 
     doAfterStuff(); 
    } 

    // Command pattern 
    class BTypeBuilder implements Builder 
    { 
     String name, age, sex; 

     // Constructor here 

     void build() 
     { 
      // Do your stuff here 
     } 
    } 

    class ATypeBuilder implements Builder 
    { 
     String pin, amount; 

     // Constructor here 

     void build() 
     { 
      // Do your stuff here 
     } 
    } 

    public interface Builder 
    { 
     void build(); 
    } 

Answer 5

Además de otras respuestas, esto también podría ser útil para usted (si sólo quiere plugin de su método, no usar sus parámetros de 'antes' y 'después' de métodos)

interface Function0<R> { 
    R apply(); 
} 

public void performOperation(Function0<Void> operation) { 
    doSomething(); 
    doBeforeStuff(); 
    operation.apply(); 
    doAfterStuff(); 

} 

entonces se podría utilizar de esta manera,

final RequestBuilder builder = new RequestBuilder(); 
    performOperation(new Function0<Void>() { 
     public Void apply() { 
      builder.buildATypeRequest("1234", "2445"); 
      return null; 
     } 
    }); 

    performOperation(new Function0<Void>() { 
     public Void apply() { 
      builder.buildBTypeRequest("1234", "2445", "1234"); 
      return null; 
     } 
    }); 

Answer 6

en lugar de enviar una larga parámetro La lista eter simplemente inserta todos los parámetros en un mapa y envía ese mapa como argumento.