design patterns - Generación de código de patrón de generador en IntelliJ

design-patterns intellij-idea

Question

¿Hay alguna forma de automatizar la escritura de patrones de construcción en IntelliJ?

Por ejemplo, dada esta clase simple:

class Film {
   private String title;
   private int length;

   public void setTitle(String title) {
       this.title = title;
   }

   public String getTitle() {
       return this.title;
   }

   public void setLength(int length) {
       this.length = length;
   }

   public int getLength() {
       return this.length;
   }
}

¿Hay alguna manera de que pueda obtener el IDE para generar esto o algo similar?

public class FilmBuilder {

    Film film;

    public FilmBuilder() {
        film = new Film();
    }

    public FilmBuilder withTitle(String title) {
        film.setTitle(title);
        return this;
    }

    public FilmBuilder withLength(int length) {
        film.setLength(length);
        return this;
    }

    public Film build() {
        return film;
    }
}

Answer 1

A continuación se explica cómo superar las shortcomings mencionadas por Mansoor Siddiqui :

1) Necesita usar un constructor existente como referencia.

Lo cual es muy fácil de generar. Simplemente presione Alt + Ins en Windows para invocar el menú Generar y elija Constructor .

2) No se puede acceder rápidamente a través del menú "Generar" (comando + N en OS X)

Simplemente vaya a Settings -> Keymap , busque el Builder y asígnele un acceso directo de su elección (si usa esta funcionalidad muy a menudo, lo que raramente es el caso). Puede asignar Alt + B por ejemplo.

Otra alternativa es Ctrl + Shift + A (Find Action). Comience a escribir Builder e inmediatamente tendrá acceso al comando:

Puede usar este acceso directo para acceder rápidamente a cualquier función de IntelliJ IDEA (esto ayuda mucho cuando no recuerda exactamente cómo se llama el comando y dónde encontrarlo).

3) Solo genera clases externas de Constructor. Como otros han mencionado, es muy común usar clases internas estáticas cuando se implementa el patrón de generador.

También prefiero mis constructores como clases internas estáticas. Desafortunadamente, no hay una forma directa de hacerlo, pero aún es posible. Solo tiene que definir la clase interna anidada usted mismo (déjelo vacío), y cuando invoque el cuadro de diálogo Replace Constructor with Builder , elija Use existing opción Use existing y seleccione su clase interna. ¡Funciona de maravilla! Sin embargo, hubiera sido más fácil hacer esta opción configurable.

Answer 2

Como complemento a la respuesta de @CrazyCoder, creo que es muy útil saber que en el lado superior derecho del cuadro de diálogo Reemplazar Constructor con Generador hay un botón de configuración que puede usar para cambiar el nombre del prefijo de los instaladores.

Answer 3

En mi opinión, la forma más sencilla de obtener la clase estática interna en lugar de una separada es:

1. Si aún no tiene un constructor, genere uno usando Generar un diálogo de constructor
2. Luego, usa Reemplazar Constructor con Constructor
3. Mueva la clase recién creada de nuevo a la inicial usando Mover refactorización (tecla de acceso directo: F6)

Answer 4

Encontré la generación de patrones de generador incorporada en IntelliJ un poco torpe por algunas razones:

1. Necesita usar un constructor existente como referencia.
2. No se puede acceder rápidamente a través del menú "Generar" ( command+N en OS X).
3. Solo genera clases externas de Constructor. Como otros han mencionado, es muy común usar clases internas estáticas cuando se implementa el patrón de generador.

El complemento de InnerBuilder resuelve todas estas deficiencias y no requiere configuración o configuración. Aquí hay un generador de muestra generado por el complemento:

public class Person {
    private String firstName;
    private String lastName;
    private int age;

    private Person(Builder builder) {
        firstName = builder.firstName;
        lastName = builder.lastName;
        age = builder.age;
    }

    public static final class Builder {
        private String firstName;
        private String lastName;
        private int age;

        public Builder() {
        }

        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Person build() {
            return new Person(this);
        }
    }
}

Answer 5

Genere el constructor de la clase haciendo clic derecho en la clase Generate> Constructor. Luego, en Windows, presiona Ctrl + Shift + A para encontrar acción y escribe "constructor", selecciona "Reemplazar constructor con constructor ...".

Answer 6

La forma de IntelliJ de esto es, en mi humilde opinión, es complicada. Hay dos plugins (prefiero este: https://plugins.jetbrains.com/plugin/7354 ) que sirven para el propósito mucho mejor.

Por ejemplo, prefiero tener la clase Builder como una clase interna del PoJo. Para lograr eso con IntelliJ necesita pocos golpes extra.

Otra ventaja para el complemento es la ubicación de la funcionalidad (en el menú contextual Generate... ).

Answer 7

Para aquellos que quieran reemplazar "demasiados parámetros" con un patrón de generador, haga "extraer objeto de parámetro" y luego el constructor de conversión al constructor mencionado en otras respuestas aquí.

Answer 8

Si se está preguntando si esto se puede usar para crear una clase con una clase interna de construcción como lo describe Joshua Block , primero tiene que definir primero una clase interna vacía, luego marcar "Usar existente" y buscar su clase recién creada (clase interna) ) y presiona "Refactor".

¡PD! El cursor debe residir dentro del constructor (pre-escrito) para poder usar la función de refactorización "Reemplazar Constructor con Constructor".

Answer 9

Utilice el refactorizado Reemplazar constructor con generador.

Para usar esta función, haga clic en la firma del constructor en su código, luego haga clic con el botón derecho y seleccione el menú "Refactorizar", luego haga clic en "Reemplazar Constructor con Constructor ..." para abrir el cuadro de diálogo y generar el código.