Spring Boot – Estructura del código

No hay un diseño específico o una estructura de código para Spring Boot Projects. Sin embargo, existen algunas mejores prácticas seguidas por los desarrolladores que también nos ayudarán. Puede dividir su proyecto en capas como capa de servicio, capa de entidad, capa de repositorio , etc. También puede dividir el proyecto en módulos. Por ejemplo, el proyecto principal tiene dos módulos secundarios. El primer módulo es para la capa de datos y el segundo módulo es para la capa web. También puede dividir el proyecto en funciones.

Nota: Evite el paquete predeterminado

Está. porque se dice que una clase está en un paquete predeterminado cuando no incluye una declaración de paquete . No es una buena práctica incluir una clase en el paquete predeterminado. Es porque Spring escanea las clases en paquetes y subpaquetes mencionados en las anotaciones como @ComponentScan , @EntityScan , @SpringBootApplication , etc. 

Nota: Se recomienda utilizar las convenciones de nomenclatura de paquetes de Java con un nombre de dominio inverso. Por ejemplo, com.gfg.demo .

• Clase de aplicación principal

Se recomienda colocar la clase de aplicación principal en el paquete raíz con anotaciones como @SpringBootApplication o @ComponentScan o @EnableAutoConfiguration . Permite que Spring escanee todas las clases en el paquete raíz y los subpaquetes. Por ejemplo, MainApplicaiton.java se coloca en el paquete raíz y todas las clases relacionadas con Customer en el subpaquete com.gfg.demo.customer y las clases relacionadas con Order en com.gfg.demo.order . 

La estructura de diseño es la siguiente:

Analicemos dos enfoques que la mayoría de los desarrolladores suelen utilizar para estructurar sus proyectos Spring Boot.

1. Estructura por función
2. Estructura por capa

Estructura 1: Por característica

En este enfoque, todas las clases pertenecientes a una característica determinada se colocan en el mismo paquete. La estructura por características se muestra en el siguiente ejemplo.

Ejemplo

com
 +- gfg
     +- demo
         +- MyApplication.java
         |
         +- customer
         |   +- Customer.java
         |   +- CustomerController.java
         |   +- CustomerService.java
         |   +- CustomerRepository.java
         |
         +- order
             +- Order.java
             +- OrderController.java
             +- OrderService.java
             +- OrderRepository.java

Las ventajas de esta estructura son las siguientes: 

• Encontrar una clase para modificar es fácil.
• Al eliminar un subpaquete en particular, se pueden eliminar todas las clases relacionadas con una característica determinada.
• Probar y refactorizar es fácil.
• Las características se pueden enviar por separado.

Estructura 2: por capa

Otra forma de colocar las clases es por capa, es decir; todos los controladores se pueden colocar en el paquete de controladores y los servicios en el paquete de servicios y todas las entidades en el dominio o modelo, etc.

Ejemplo

com
 +- gfg
     +- demo
         +- MyApplication.java
         |
         +- domain
         |   +- Customer.java
         |   +- Order.java
         |
         +- controllers
         |     +- OrderController.java
         |   +- CustomerController.java
         |
         +- services
         |    +- CustomerService.java
         |    +- OrderService.java
         |
         +- repositories
              +- CustomerRepository.java
              +- OrderRepository.java    

Aunque la estructura anterior parece factible y fácil de ubicar clases por capa. Tiene pocas desventajas en comparación con la estructura por características. 

• Las características o los módulos no se pueden enviar por separado.
• Difícil de localizar una clase perteneciente a una característica determinada.
• La refactorización de código en una característica determinada es difícil ya que las clases de características se encuentran en cada capa.
• Provoca conflictos de fusión entre los desarrolladores que utilizan GitHub, BitBucket , etc. para la colaboración.

Ahora terminemos adquiriendo la ubicación de MainApplication.java . como en las dos estructuras propuestas anteriormente, hemos visto que MainApplication.java se coloca en el paquete raíz con la anotación @SpringBootApplication . Es como se muestra a continuación en un ejemplo de muestra que es el siguiente:

Ejemplo

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

}