# Guía de Mejores Prácticas para Spring Boot

## Requisitos de Proceso Importantes
- SIEMPRE presenta un plan detallado y espera aprobación explícita antes de implementar cualquier cambio de código
- No proceder con la implementación hasta recibir confirmación del usuario
- Al presentar el plan, proporciona un desglose paso a paso de todos los archivos a crear o modificar
- Pregunta directamente: "¿Apruebas este plan antes de proceder con la implementación?"

## Convenciones de Nomenclatura Spring Boot

### Patrones Generales de Nomenclatura

| Tipo de Elemento | Patrón/Estilo | Ejemplo(s) |
|------------------|---------------|------------|
| **Controllers** | `PascalCase + Controller` | `UserController`, `ProductController` |
| **Services** | `PascalCase + Service` | `UserService`, `PaymentService` |
| **Repositories** | `PascalCase + Repository` | `UserRepository`, `OrderRepository` |
| **Entities** | `PascalCase` | `User`, `Product`, `Order` |
| **DTOs** | `PascalCase + Dto/Request/Response` | `UserDto`, `CreateUserRequest` |
| **Configuration Classes** | `PascalCase + Config` | `DatabaseConfig`, `SecurityConfig` |

## Estructura de Proyecto Spring Boot

```
src/
├── main/
│   ├── java/
│   │   └── com/company/myapp/
│   │       ├── MyAppApplication.java
│   │       ├── config/
│   │       │   ├── SecurityConfig.java
│   │       │   └── DatabaseConfig.java
│   │       ├── controller/
│   │       │   └── UserController.java
│   │       ├── service/
│   │       │   ├── UserService.java
│   │       │   └── impl/
│   │       │       └── UserServiceImpl.java
│   │       ├── repository/
│   │       │   └── UserRepository.java
│   │       ├── entity/
│   │       │   └── User.java
│   │       ├── dto/
│   │       │   ├── UserDto.java
│   │       │   └── CreateUserRequest.java
│   │       ├── exception/
│   │       │   ├── GlobalExceptionHandler.java
│   │       │   └── UserNotFoundException.java
│   │       └── util/
│   │           └── DateUtils.java
│   └── resources/
│       ├── application.yml
│       ├── application-dev.yml
│       ├── application-prod.yml
│       └── db/migration/
└── test/
    └── java/
        └── com/company/myapp/
```

## Mejores Prácticas de Desarrollo

### Arquitectura por Capas
- **Controller Layer**: Solo manejo de HTTP requests/responses
- **Service Layer**: Lógica de negocio
- **Repository Layer**: Acceso a datos
- **Entity Layer**: Modelos de dominio

### Configuración
```yaml
# application.yml
spring:
  profiles:
    active: dev
  datasource:
    url: jdbc:postgresql://localhost:5432/myapp
    username: ${DB_USERNAME:admin}
    password: ${DB_PASSWORD:password}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
    properties:
      hibernate:
        format_sql: true
```

### Dependency Injection
- Usar **constructor injection** (recomendado)
- Evitar **field injection** (@Autowired en campos)
- Usar **@RequiredArgsConstructor** de Lombok cuando sea apropiado

```java
@Service
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    // Métodos del servicio...
}
```

### Exception Handling
```java
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleUserNotFound(UserNotFoundException ex) {
        ErrorResponse error = new ErrorResponse("USER_NOT_FOUND", ex.getMessage());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
    }
}
```

### Testing
- Usar **@SpringBootTest** para pruebas de integración
- **@WebMvcTest** para pruebas de controladores
- **@DataJpaTest** for pruebas de repositorio
- **@TestContainers** para pruebas con base de datos real

### Security
- Implementar **Spring Security** para autenticación/autorización
- Usar **JWT** para APIs stateless
- Configurar **CORS** apropiadamente
- Validar todas las entradas con **@Valid** y **Bean Validation**

### Performance
- Usar **@Cacheable** para cache de métodos
- Implementar **lazy loading** en JPA cuando sea necesario
- Configurar **connection pooling** apropiadamente
- Usar **@Async** para operaciones no bloqueantes