TP6.3 - Ejercicio Airport-Flight-Passenger

Objetivos

Este trabajo práctico de evaluación le permitirá:

• Modelar relaciones complejas entre entidades JPA
• Crear consultas con las convenciones de nomenclatura de Spring Data JPA
• Utilizar @Query con JPQL para consultas avanzadas
• Probar sus competencias en Spring Data JPA

Duración estimada: 2h30 - 3h

Nivel: Intermedio a Avanzado

---

Contexto

Debe crear una aplicación de gestión de aeropuerto con:

• Airports (Aeropuertos)
• Flights (Vuelos)
• Passengers (Pasajeros)

---

Parte 1: Modelado de Entidades

1.1 Diagrama de Relaciones

1.2 Entidad Airport

Cree src/main/java/com/example/airport/model/Airport.java:

package com.example.airport.model;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.util.List;

@Entity
@Table(name = "airports")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Airport {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false, length = 3)
    private String code;  // Ej: "YUL", "JFK", "CDG"

    @Column(nullable = false)
    private String name;  // Ej: "Montréal-Trudeau"

    @Column(nullable = false)
    private String city;  // Ej: "Montréal"

    @Column(nullable = false)
    private String country;  // Ej: "Canada"

    @OneToMany(mappedBy = "departureAirport")
    private List<Flight> departingFlights;

    @OneToMany(mappedBy = "arrivalAirport")
    private List<Flight> arrivingFlights;
}

1.3 Entidad Flight

Cree src/main/java/com/example/airport/model/Flight.java:

package com.example.airport.model;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.time.LocalDateTime;
import java.util.List;

@Entity
@Table(name = "flights")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Flight {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String flightNumber;  // Ej: "AC301"

    @ManyToOne
    @JoinColumn(name = "departure_airport_id", nullable = false)
    private Airport departureAirport;

    @ManyToOne
    @JoinColumn(name = "arrival_airport_id", nullable = false)
    private Airport arrivalAirport;

    @Column(nullable = false)
    private LocalDateTime departureTime;

    @Column(nullable = false)
    private LocalDateTime arrivalTime;

    @Column(nullable = false)
    private Double price;

    @Column(nullable = false)
    private Integer capacity;

    @ManyToMany
    @JoinTable(
        name = "flight_passengers",
        joinColumns = @JoinColumn(name = "flight_id"),
        inverseJoinColumns = @JoinColumn(name = "passenger_id")
    )
    private List<Passenger> passengers;
}

1.4 Entidad Passenger

Cree src/main/java/com/example/airport/model/Passenger.java:

package com.example.airport.model;

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;

import java.time.LocalDate;
import java.util.List;

@Entity
@Table(name = "passengers")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Passenger {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String firstName;

    @Column(nullable = false)
    private String lastName;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(unique = true, nullable = false)
    private String passportNumber;

    @Column(nullable = false)
    private LocalDate birthDate;

    @ManyToMany(mappedBy = "passengers")
    private List<Flight> flights;
}

---

Parte 2: Datos de Prueba

2.1 Archivo data.sql

Cree src/main/resources/data.sql:

-- Airports
INSERT INTO airports (code, name, city, country) VALUES ('YUL', 'Montréal-Trudeau International', 'Montréal', 'Canada');
INSERT INTO airports (code, name, city, country) VALUES ('YYZ', 'Toronto Pearson International', 'Toronto', 'Canada');
INSERT INTO airports (code, name, city, country) VALUES ('JFK', 'John F. Kennedy International', 'New York', 'USA');
INSERT INTO airports (code, name, city, country) VALUES ('LAX', 'Los Angeles International', 'Los Angeles', 'USA');
INSERT INTO airports (code, name, city, country) VALUES ('CDG', 'Charles de Gaulle', 'Paris', 'France');
INSERT INTO airports (code, name, city, country) VALUES ('LHR', 'Heathrow', 'Londres', 'UK');
INSERT INTO airports (code, name, city, country) VALUES ('FRA', 'Frankfurt', 'Francfort', 'Germany');

-- Flights
INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AC301', 1, 2, '2025-06-15 08:00:00', '2025-06-15 09:30:00', 250.00, 180);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AC401', 1, 3, '2025-06-15 10:00:00', '2025-06-15 11:45:00', 450.00, 200);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AF001', 1, 5, '2025-06-15 18:00:00', '2025-06-16 06:30:00', 850.00, 300);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('BA123', 6, 3, '2025-06-16 09:00:00', '2025-06-16 12:00:00', 550.00, 250);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('LH456', 7, 5, '2025-06-16 14:00:00', '2025-06-16 15:30:00', 200.00, 150);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AA789', 3, 4, '2025-06-17 07:00:00', '2025-06-17 10:30:00', 350.00, 180);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AC501', 2, 1, '2025-06-17 16:00:00', '2025-06-17 17:30:00', 250.00, 180);

INSERT INTO flights (flight_number, departure_airport_id, arrival_airport_id, departure_time, arrival_time, price, capacity) 
VALUES ('AF002', 5, 1, '2025-06-18 22:00:00', '2025-06-19 06:00:00', 900.00, 300);

-- Passengers
INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Jean', 'Dupont', 'jean.dupont@email.com', 'FR123456', '1985-03-15');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Marie', 'Martin', 'marie.martin@email.com', 'FR789012', '1990-07-22');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('John', 'Smith', 'john.smith@email.com', 'US345678', '1978-11-08');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Emma', 'Wilson', 'emma.wilson@email.com', 'UK901234', '1995-01-30');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Pierre', 'Bernard', 'pierre.bernard@email.com', 'CA567890', '1982-09-12');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Sophie', 'Tremblay', 'sophie.tremblay@email.com', 'CA123789', '2000-05-25');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Michael', 'Brown', 'michael.brown@email.com', 'US456123', '1970-12-03');

INSERT INTO passengers (first_name, last_name, email, passport_number, birth_date) 
VALUES ('Anna', 'Schmidt', 'anna.schmidt@email.com', 'DE789456', '1988-04-18');

-- Flight-Passenger associations
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (1, 1);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (1, 2);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (1, 5);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (2, 1);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (2, 3);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (3, 1);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (3, 2);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (3, 4);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (3, 8);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (4, 3);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (4, 4);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (5, 8);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (6, 3);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (6, 7);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (7, 5);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (7, 6);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (8, 1);
INSERT INTO flight_passengers (flight_id, passenger_id) VALUES (8, 2);

---

Parte 3: Las 20 Consultas a Implementar

Nivel FÁCIL (Preguntas 1-7)

Cree los métodos en los repositories apropiados.

---

Pregunta 1: Encontrar un aeropuerto por su código

Repository: AirportRepository

Firma:

Optional<Airport> findByCode(String code);

Prueba: Encontrar el aeropuerto "YUL"

---

Pregunta 2: Listar todos los aeropuertos de un país

Repository: AirportRepository

Firma:

List<Airport> findByCountry(String country);

Prueba: Encontrar todos los aeropuertos de Canadá

---

Pregunta 3: Encontrar un pasajero por email

Repository: PassengerRepository

Firma:

Optional<Passenger> findByEmail(String email);

Prueba: Encontrar el pasajero con el email "jean.dupont@email.com"

---

Pregunta 4: Listar los pasajeros por apellido

Repository: PassengerRepository

Firma:

List<Passenger> findByLastName(String lastName);

Prueba: Encontrar todos los pasajeros apellidados "Smith"

---

Pregunta 5: Encontrar un vuelo por su número

Repository: FlightRepository

Firma:

Optional<Flight> findByFlightNumber(String flightNumber);

Prueba: Encontrar el vuelo "AC301"

---

Pregunta 6: Listar los vuelos cuyo precio es inferior a un valor

Repository: FlightRepository

Firma:

List<Flight> findByPriceLessThan(Double maxPrice);

Prueba: Encontrar los vuelos de menos de 300$

---

Pregunta 7: Listar los pasajeros nacidos antes de una fecha

Repository: PassengerRepository

Firma:

List<Passenger> findByBirthDateBefore(LocalDate date);

Prueba: Encontrar los pasajeros nacidos antes de 1990

---

Nivel MEDIO (Preguntas 8-14)

---

Pregunta 8: Listar los vuelos entre dos precios

Repository: FlightRepository

Firma:

List<Flight> findByPriceBetween(Double minPrice, Double maxPrice);

Prueba: Vuelos entre 200$ y 500$

---

Pregunta 9: Listar los vuelos que salen de un aeropuerto específico

Repository: FlightRepository

Firma:

List<Flight> findByDepartureAirport_Code(String airportCode);

Prueba: Vuelos que salen de "YUL"

---

Pregunta 10: Listar los vuelos que llegan a un país

Repository: FlightRepository

Firma:

List<Flight> findByArrivalAirport_Country(String country);

Prueba: Vuelos que llegan a Francia

---

Pregunta 11: Buscar pasajeros por apellido (contiene)

Repository: PassengerRepository

Firma:

List<Passenger> findByLastNameContainingIgnoreCase(String keyword);

Prueba: Pasajeros cuyo apellido contiene "art"

---

Pregunta 12: Listar los vuelos después de una fecha/hora

Repository: FlightRepository

Firma:

List<Flight> findByDepartureTimeAfter(LocalDateTime dateTime);

Prueba: Vuelos que salen después del 16 de junio de 2025

---

Pregunta 13: Aeropuertos de una ciudad específica con orden por nombre

Repository: AirportRepository

Firma:

List<Airport> findByCityOrderByNameAsc(String city);

Prueba: Aeropuertos de Nueva York ordenados por nombre

---

Pregunta 14: Vuelos con capacidad superior a un valor

Repository: FlightRepository

Firma:

List<Flight> findByCapacityGreaterThanEqual(Integer minCapacity);

Prueba: Vuelos con al menos 250 plazas

---

Nivel DIFÍCIL (Preguntas 15-20)

Estas consultas requieren @Query con JPQL.

---

Pregunta 15: Encontrar los vuelos de un pasajero por su email

Repository: FlightRepository

Firma:

@Query("SELECT f FROM Flight f JOIN f.passengers p WHERE p.email = :email")
List<Flight> findFlightsByPassengerEmail(@Param("email") String email);

Prueba: Vuelos del pasajero "jean.dupont@email.com"

---

Pregunta 16: Contar el número de pasajeros en un vuelo

Repository: FlightRepository

Firma:

@Query("SELECT COUNT(p) FROM Flight f JOIN f.passengers p WHERE f.flightNumber = :flightNumber")
Long countPassengersByFlightNumber(@Param("flightNumber") String flightNumber);

Prueba: Número de pasajeros en el vuelo "AC301"

---

Pregunta 17: Encontrar los pasajeros de un vuelo específico

Repository: PassengerRepository

Firma:

@Query("SELECT p FROM Passenger p JOIN p.flights f WHERE f.flightNumber = :flightNumber")
List<Passenger> findPassengersByFlightNumber(@Param("flightNumber") String flightNumber);

Prueba: Pasajeros del vuelo "AF001"

---

Pregunta 18: Vuelos entre dos aeropuertos (por código)

Repository: FlightRepository

Firma:

@Query("SELECT f FROM Flight f WHERE f.departureAirport.code = :departureCode AND f.arrivalAirport.code = :arrivalCode")
List<Flight> findFlightsBetweenAirports(@Param("departureCode") String departureCode, 
                                        @Param("arrivalCode") String arrivalCode);

Prueba: Vuelos de "YUL" a "CDG"

---

Pregunta 19: Precio medio de los vuelos que salen de un país

Repository: FlightRepository

Firma:

@Query("SELECT AVG(f.price) FROM Flight f WHERE f.departureAirport.country = :country")
Double findAveragePriceByDepartureCountry(@Param("country") String country);

Prueba: Precio medio de los vuelos que salen de Canadá

---

Pregunta 20: Pasajeros que han tomado más de N vuelos

Repository: PassengerRepository

Firma:

@Query("SELECT p FROM Passenger p WHERE SIZE(p.flights) >= :minFlights")
List<Passenger> findFrequentTravelers(@Param("minFlights") int minFlights);

Prueba: Pasajeros que han tomado al menos 2 vuelos

---

Parte 4: Solucionario Completo

AirportRepository.java

package com.example.airport.repository;

import com.example.airport.model.Airport;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface AirportRepository extends JpaRepository<Airport, Long> {

    // Q1: Encontrar un aeropuerto por su código
    Optional<Airport> findByCode(String code);

    // Q2: Listar todos los aeropuertos de un país
    List<Airport> findByCountry(String country);

    // Q13: Aeropuertos de una ciudad con orden
    List<Airport> findByCityOrderByNameAsc(String city);
}

---

PassengerRepository.java

package com.example.airport.repository;

import com.example.airport.model.Passenger;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDate;
import java.util.List;
import java.util.Optional;

@Repository
public interface PassengerRepository extends JpaRepository<Passenger, Long> {

    // Q3: Encontrar un pasajero por email
    Optional<Passenger> findByEmail(String email);

    // Q4: Listar los pasajeros por apellido
    List<Passenger> findByLastName(String lastName);

    // Q7: Pasajeros nacidos antes de una fecha
    List<Passenger> findByBirthDateBefore(LocalDate date);

    // Q11: Búsqueda por apellido (contiene)
    List<Passenger> findByLastNameContainingIgnoreCase(String keyword);

    // Q17: Pasajeros de un vuelo específico
    @Query("SELECT p FROM Passenger p JOIN p.flights f WHERE f.flightNumber = :flightNumber")
    List<Passenger> findPassengersByFlightNumber(@Param("flightNumber") String flightNumber);

    // Q20: Pasajeros frecuentes (que han tomado N+ vuelos)
    @Query("SELECT p FROM Passenger p WHERE SIZE(p.flights) >= :minFlights")
    List<Passenger> findFrequentTravelers(@Param("minFlights") int minFlights);
}

---

FlightRepository.java

package com.example.airport.repository;

import com.example.airport.model.Flight;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Repository
public interface FlightRepository extends JpaRepository<Flight, Long> {

    // Q5: Encontrar un vuelo por su número
    Optional<Flight> findByFlightNumber(String flightNumber);

    // Q6: Vuelos cuyo precio es inferior a un valor
    List<Flight> findByPriceLessThan(Double maxPrice);

    // Q8: Vuelos entre dos precios
    List<Flight> findByPriceBetween(Double minPrice, Double maxPrice);

    // Q9: Vuelos que salen de un aeropuerto (por código)
    List<Flight> findByDepartureAirport_Code(String airportCode);

    // Q10: Vuelos que llegan a un país
    List<Flight> findByArrivalAirport_Country(String country);

    // Q12: Vuelos después de una fecha/hora
    List<Flight> findByDepartureTimeAfter(LocalDateTime dateTime);

    // Q14: Vuelos con capacidad mínima
    List<Flight> findByCapacityGreaterThanEqual(Integer minCapacity);

    // Q15: Vuelos de un pasajero por email
    @Query("SELECT f FROM Flight f JOIN f.passengers p WHERE p.email = :email")
    List<Flight> findFlightsByPassengerEmail(@Param("email") String email);

    // Q16: Contar los pasajeros de un vuelo
    @Query("SELECT COUNT(p) FROM Flight f JOIN f.passengers p WHERE f.flightNumber = :flightNumber")
    Long countPassengersByFlightNumber(@Param("flightNumber") String flightNumber);

    // Q18: Vuelos entre dos aeropuertos
    @Query("SELECT f FROM Flight f WHERE f.departureAirport.code = :departureCode AND f.arrivalAirport.code = :arrivalCode")
    List<Flight> findFlightsBetweenAirports(@Param("departureCode") String departureCode, 
                                            @Param("arrivalCode") String arrivalCode);

    // Q19: Precio medio de los vuelos por país de salida
    @Query("SELECT AVG(f.price) FROM Flight f WHERE f.departureAirport.country = :country")
    Double findAveragePriceByDepartureCountry(@Param("country") String country);
}

---

Parte 5: Pruebas y Validación

application.properties

spring.datasource.url=jdbc:h2:mem:airportdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

spring.jpa.hibernate.ddl-auto=create
spring.jpa.show-sql=true
spring.jpa.defer-datasource-initialization=true

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

spring.sql.init.mode=always

Clase de Prueba

Cree una clase de prueba para validar sus consultas:

package com.example.airport;

import com.example.airport.model.*;
import com.example.airport.repository.*;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class AirportApplicationTests {

    @Autowired
    private AirportRepository airportRepository;

    @Autowired
    private FlightRepository flightRepository;

    @Autowired
    private PassengerRepository passengerRepository;

    @Test
    void q1_findAirportByCode() {
        var airport = airportRepository.findByCode("YUL");
        assertTrue(airport.isPresent());
        assertEquals("Montréal", airport.get().getCity());
    }

    @Test
    void q2_findAirportsByCountry() {
        var airports = airportRepository.findByCountry("Canada");
        assertEquals(2, airports.size());
    }

    @Test
    void q6_findFlightsByPriceLessThan() {
        var flights = flightRepository.findByPriceLessThan(300.0);
        assertFalse(flights.isEmpty());
        flights.forEach(f -> assertTrue(f.getPrice() < 300));
    }

    @Test
    void q15_findFlightsByPassengerEmail() {
        var flights = flightRepository.findFlightsByPassengerEmail("jean.dupont@email.com");
        assertFalse(flights.isEmpty());
        System.out.println("Vuelos de Jean Dupont: " + flights.size());
    }

    @Test
    void q16_countPassengersByFlight() {
        Long count = flightRepository.countPassengersByFlightNumber("AC301");
        assertEquals(3, count);
    }

    @Test
    void q20_findFrequentTravelers() {
        var travelers = passengerRepository.findFrequentTravelers(2);
        assertFalse(travelers.isEmpty());
        System.out.println("Viajeros frecuentes: " + travelers.size());
    }
}

---

Criterios de Evaluación

Criterio	Puntos
Entidades correctamente modeladas	15%
Relaciones JPA correctas (@ManyToOne, @ManyToMany)	15%
Preguntas 1-7 (Fácil)	21% (3% cada una)
Preguntas 8-14 (Medio)	28% (4% cada una)
Preguntas 15-20 (Difícil)	18% (3% cada una)
Pruebas pasan	3%
Total	100%

---

Consejos

Para las convenciones de nomenclatura:

• findBy + PropertyName = búsqueda simple
• _ permite navegar en las relaciones (ej: findByDepartureAirport_Code)
• Containing = LIKE %keyword%
• IgnoreCase = búsqueda insensible a mayúsculas/minúsculas

Para @Query:

• JPQL utiliza los nombres de las clases Java, no los nombres de las tablas SQL
• JOIN para navegar en las relaciones
• SIZE() para contar los elementos de una colección
• AVG(), COUNT(), SUM() para agregaciones

---

Recursos

• Spring Data JPA Reference
• JPQL Reference

---

Volver al Módulo 6