El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Entendiendo la Estructura del Proyecto Spring Boot

Siguiente ►
►

En esta sección, aprenderemos sobre la estructura típica de un proyecto Spring Boot. Comprender cómo se organiza un proyecto Spring Boot es crucial para desarrollar aplicaciones de manera eficiente y mantener el código limpio y manejable.

Estructura Básica del Proyecto

Cuando creas un nuevo proyecto Spring Boot, generalmente verás una estructura de directorios similar a la siguiente:

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myapp/
│   │   │               ├── MySpringBootApplication.java
│   │   │               ├── controller/
│   │   │               ├── service/
│   │   │               └── repository/
│   │   ├── resources/
│   │       ├── application.properties
│   │       └── static/
│   │       └── templates/
│   └── test/
│       ├── java/
│       │   └── com/
│       │       └── example/
│       │           └── myapp/
│       │               └── MySpringBootApplicationTests.java
├── .gitignore
├── mvnw
├── mvnw.cmd
├── pom.xml
└── README.md

Desglose de la Estructura

  1. src/main/java: Contiene el código fuente de la aplicación.

    • com/example/myapp: Paquete base de la aplicación.
      • MySpringBootApplication.java: Clase principal que arranca la aplicación Spring Boot.
      • controller: Contiene las clases de controladores que manejan las solicitudes HTTP.
      • service: Contiene las clases de servicio que implementan la lógica de negocio.
      • repository: Contiene las interfaces de repositorio que interactúan con la base de datos.

  2. src/main/resources: Contiene los recursos de la aplicación.

    • application.properties: Archivo de configuración principal de Spring Boot.
    • static: Contiene recursos estáticos como HTML, CSS, JavaScript, imágenes, etc.
    • templates: Contiene plantillas Thymeleaf u otros motores de plantillas.

  3. src/test/java: Contiene las pruebas unitarias e integradas.

    • MySpringBootApplicationTests.java: Clase de prueba principal.

  4. .gitignore: Archivo que especifica qué archivos y directorios deben ser ignorados por Git.

  5. mvnw y mvnw.cmd: Scripts para ejecutar Maven Wrapper, que permite construir el proyecto sin necesidad de tener Maven instalado globalmente.

  6. pom.xml: Archivo de configuración de Maven que define las dependencias y configuraciones del proyecto.

  7. README.md: Archivo de documentación del proyecto.

Explicación Detallada

Clase Principal

package com.example.myapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}
  • @SpringBootApplication: Esta anotación combina tres anotaciones importantes: @Configuration, @EnableAutoConfiguration, y @ComponentScan. Marca esta clase como la clase principal de configuración y arranque de la aplicación.
  • main: El método principal que utiliza SpringApplication.run para iniciar la aplicación.

Controladores

package com.example.myapp.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}
  • @RestController: Marca la clase como un controlador donde cada método devuelve un objeto de dominio en lugar de una vista.
  • @GetMapping: Mapea las solicitudes HTTP GET a métodos específicos.

Servicios

package com.example.myapp.service;

import org.springframework.stereotype.Service;

@Service
public class HelloService {
    public String getGreeting() {
        return "Hello, World!";
    }
}
  • @Service: Marca la clase como un servicio, que contiene la lógica de negocio.

Repositorios

package com.example.myapp.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.myapp.model.User;

public interface UserRepository extends JpaRepository<User, Long> {
}
  • JpaRepository: Proporciona métodos CRUD y más para la entidad User.

application.properties

server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
  • server.port: Configura el puerto del servidor.
  • spring.datasource.url: Configura la URL de la base de datos.
  • spring.datasource.username: Configura el nombre de usuario de la base de datos.
  • spring.datasource.password: Configura la contraseña de la base de datos.

Ejercicio Práctico

Ejercicio 1: Crear un Proyecto Spring Boot

  1. Crear un Proyecto: Usa Spring Initializr (https://start.spring.io/) para crear un nuevo proyecto Spring Boot con las siguientes dependencias:

    • Spring Web
    • Spring Data JPA
    • H2 Database

  2. Estructura del Proyecto: Asegúrate de que la estructura del proyecto se vea como la descrita anteriormente.

  3. Clase Principal: Crea la clase principal MySpringBootApplication en el paquete com.example.myapp.

  4. Controlador: Crea un controlador HelloController en el paquete com.example.myapp.controller que maneje una solicitud GET en la ruta /hello.

  5. Servicio: Crea un servicio HelloService en el paquete com.example.myapp.service que devuelva un saludo.

  6. Repositorio: Crea una interfaz UserRepository en el paquete com.example.myapp.repository que extienda JpaRepository.

Solución

// MySpringBootApplication.java
package com.example.myapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}
// HelloController.java
package com.example.myapp.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}
// HelloService.java
package com.example.myapp.service;

import org.springframework.stereotype.Service;

@Service
public class HelloService {
    public String getGreeting() {
        return "Hello, World!";
    }
}
// UserRepository.java
package com.example.myapp.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.myapp.model.User;

public interface UserRepository extends JpaRepository<User, Long> {
}

Conclusión

En esta sección, hemos explorado la estructura básica de un proyecto Spring Boot y hemos creado un proyecto simple con controladores, servicios y repositorios. Comprender esta estructura te ayudará a organizar tu código de manera eficiente y a seguir las mejores prácticas en el desarrollo de aplicaciones Spring Boot. En el próximo módulo, profundizaremos en las anotaciones de Spring Boot y cómo se utilizan para simplificar el desarrollo de aplicaciones.

◄ Anterior
◄
Siguiente ►
►

Curso de Spring Boot

Módulo 1: Introducción a Spring Boot

Módulo 2: Conceptos Básicos de Spring Boot

Módulo 3: Construyendo Servicios Web RESTful

Módulo 4: Acceso a Datos con Spring Boot

Módulo 5: Seguridad en Spring Boot

Módulo 6: Pruebas en Spring Boot

Módulo 7: Funciones Avanzadas de Spring Boot

Módulo 8: Despliegue de Aplicaciones Spring Boot

Módulo 9: Rendimiento y Monitoreo

Módulo 10: Mejores Prácticas y Consejos

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados