Spring MVC, Hibernate, MySQL (database relationships) - mysql

Question

As part of the training project, I create a database of passenger rail traffic. A user registers, buys a train ticket. The train goes on a route with several stations.
Help, please, deal with relationships.
There are several entities: user, ticket, train, station, route.
I create each entity as a:
#Entity
#Table(name = "...")
public class ... implements Serializable { ... }
User:
id (primary key),
email,
password,
firstName,
lastName,
birthDate,
role (user/admin for example).
With this, I understand everything. Further questions arise. Ticket:
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column("TICKET_ID")
private int id;
// One user can have multiple tickets?
#ManyToOne
#JoinColumn(name = "USER_ID")
private User user;
#Column(name = "SALE_TIME")
private Date saleTime;
// One train can have multiple tickets?
#ManyToOne
#JoinColumn(name = "TRAIN_ID")
private Train train;
#Column(name = "CARRIAGE")
private int carriage;
#Column(name = "PLACE")
private int place;
Is everything right here? Next...
#Entity
#Table(name = "TRAINS")
public class Train implements Serializable {
#Id
#GeneratedValue(strategy = GenerationType.AUTO)
#Column(name = "TRAIN_ID")
private int id;
#Column(name = "TRAIN_NUMBER")
private int number;
#Column(name = "SEATS")
private int seats;
// on the way for example
#Column(name = "STATUS")
private String status;
How to set a train a fixed number of seats and how to reduce them when buying a ticket?
With the Station is not difficult: id, name, status.
And finally, Route:
#Entity
#Table(name = "ROUTE_POINT")
public class RoutePoint implements Serializable {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "ROUTE_ID")
private int id;
// ?????????
#ManyToOne
#JoinColumn(name = "TRAIN_NUMBER")
private Train train;
// ?????????
#ManyToOne
#JoinColumn(name = "STATION_NAME")
private Station station;
#Column(name = "DATE_ARRIVAL")
private Date dateArrival;
#Column(name = "DATE_DEPARTURE")
private Date dateDeparture;
Please help me deal with annotations and relationships, and most importantly, understand this. Google is already purple, the best understanding comes through practice. Thank.

Answer 1

First of all - don't use primitive types for iDs. Use Integer or better Long.
According to the Hibernate documentation:
We recommend that you declare consistently-named identifier properties
on persistent classes and that you use a nullable (i.e.,
non-primitive) type.
About seats. There is two ways. First way:
- You don't need to reduce seats in trains. It can be fixed. Just when your customer trying to buy tickets, your application doing query to database for all tickets on that train. And if number of existing tickets are more or equals than train capacity customer just can't buy ticket. But that way is good, when all your seats are equals (don't have numbers, like in bus, for example). But if your seats are not equal (train with different type of seats) you go with second way:
- You must have another entity SEATS, which has id, number, price etc., etc. and has ManyToOne relationship with TRAIN. In that time TRAIN must have next field
#OneToMany(mappedBy = "train", cascade = CascadeType.ALL)
private Set<Seat> seats;
pros:
- If you properly set getters and setters (and it's not just
public setSeats (Set<Seat> seats) {
this.seats = seats
}
, you must google for right setters, cuz if you setters works only by eager fetch - it's not right setters), you'll have advantage of cascading (for example - when you delete train from DB, all seats will be deleted automatically)
cons:
- bidirectional relationship can be the pain in the performance when you use JPQL (N+1 and so on, and you feel it when your table will be more than 1000 rows). So there is third way:
You still have SEAT entity. Train can know about seats anything, but in Seat you have field Train like this
#OneToOne
public Train getTrain() {
return train;
}
public void setTrain(Train train) {
this.train = train;
}
cons:
- When you want to delete train, you should at first delete all seats from that train
pros:
- It's much faster than bidirectional relation for JPQL