Spring Boot: What is the best way to map entities

I have two entities Flight and Booking. I will try to map this two entities. In a first case, I will map both entity with relational mapping annotations which will create a tight coupling with the database. In a second case, I will not map my both entity using relational mapping annotation. I think it will create a loose coupling with the database. I just wanted to know which is the efficient way to working with the mapping.

Here is my first case :

Entity

public class Flight
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long flightId;
	private Integer flightName;
	private Date departureTime;
	
	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
	private Set<Booking> bookings;

    // Getter, Setter, Constructors
}

public class Booking
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long bookingId;
	private Integer passangerName;
	private String passengerLocation;
	private Date bookingTime;
	
	@ManyToOne
	@JoinColumn(name = "flightId")
	private Flight flight;

    // Getter, Setter, Constructors
}

Here is my second case :

Entity

public class Flight
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long flightId;
	private Integer flightName;
	private Date departureTime;

    // Getter, Setter, Constructors
}

public class Booking
{
    @Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long bookingId;
	private Integer passangerName;
	private String passengerLocation;
	private Date bookingTime;
	
    // Here we will take a reference of Flight entity but it's not actully mapped
	private Long flightId;

    // Getter, Setter, Constructors
}

I am asking this question because, One of my senior told me to use relational mapping annotation will take much time to load your applicalication.

> In a first case, I will map both entity with relational mapping annotations which will create a tight coupling with the database. In a second case, I will not map my both entity using relational mapping annotation. I think it will create a loose coupling with the database. I just wanted to know which is the efficient way to working with the mapping.

In both cases your code is completely coupled to the schema of your database.

Using @OneToMany and @ManyToOne doesn't make your code more closely dependent on the database. Whichever way you go, you have:

• an @Entity class for each table, with
• an attribute for each column.

That is, it's a copy in Java of the relational schema.

And that's perfectly fine. Why should your Java entities be decoupled from the relational schema in the first place?

You have a data model. The relational schema is a representation of that model in SQL, and your @Entity classes are a representation of that model in Java. It's perfectly natural that they should be coupled. They represent the same thing.

Hell, the whole point of ORM is to make it easy to couple them!

Developers who just try to arbitrarily "decouple" things that don't need to be decoupled create bloat and complexity and unmaintainability further down the line.

> One of my senior told me to use relational mapping annotation will take much time to load your application.

I mean, no experienced developer should be making a silly blanket statement like that, not without a whole lot of conditions and caveats, so perhaps you misunderstood.

But, anyway, here's my conditional and caveated statement.

No, it's not in general the case that @OneToMany and @ManyToOne cause performance problems. JPA and Hibernate are used in millions of highly-performing systems all over the world, for the past two decades.

Of course, I can easily come up with (contrived or otherwise) situations where one might want to avoid using associations in favor of something else. And certainly association mapping in ORM comes with some quirks and gotchas for the inexperienced.

But association mapping is not a thing you should just avoid on principle. Rather: understand it, and learn to use it properly.