Spring boot one to one with foreign key - spring-boot

Question

I am want to store room details and room types in my db. I have created an entity for Room as follows.
#Data
#Entity
public class Room {
#Id
private String room_id;
private Boolean status;
private Double price;
private Long type;
private Long occupancy;
#OneToOne(fetch = FetchType.LAZY, optional = true)
#JoinColumn(name = "type_id", nullable = false)
private RoomType roomType;
}
I have create a RoomType entity as follows:
#Data
#Entity
public class RoomType {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String type;
}
To save a Room Entity in my DB, the following is the request body format need to be given
{
"room_id": "string",
"status": true,
"price": 0,
"roomType": {
"id": 1,
"type": "string"
}
}
I want to have the request body as follows
{
"room_id": "string",
"status": true,
"price": 0,
"roomType": 1 # This the roomType foreign key
}
I want to have one to one relationship, so when retrieving the Room details, I will get the roomType values also in the following format.
{
"room_id": "string",
"status": true,
"price": 0,
"roomType": {
"id": 0,
"type": "string"
}
}
Or Is there any better way to handle this type of problem in spring boot??

Answer 1

I think there are two different concepts in here:
The inner representation of a Room in your service (The classes you use and their relations)
The outer representation (The one exposed by your API)
If you want those two representation to be the same, you could just serialize/deserialize data using the Room class directly (which I assume is what you are currently doing). For example:
#Controller
class MyController {
#PostMapping
#ResponseStatus(HttpStatus.CREATED)
#ResponseBody
public Room createRoom(#RequestBody Room room) {
// Here room will be automatically deserialized from the request body
// Do stuff with the received room in here
// ...
// Here the returned room will be automatically serialized to
// the response body
return createdRoom;
}
}
However, if you don't want the inner and outer representations to be the same, you can use the DTO pattern (Data Transfer Object). Example in Spring here.
Now, you would have three different classes, Room and it's DTOs:
public class RoomRequestDTO {
private String room_id;
private Boolean status;
private Double price;
private Long type;
private Long occupancy;
private Integer roomType; // This is now an Integer
// Setters and Getters ...
}
public class RoomResponseDTO {
private String room_id;
private Boolean status;
private Double price;
private Long type;
private Long occupancy;
private RoomType roomType; // This is a RoomType instance
// Setters and Getters ...
}
Now, your controller would receive RoomRequestDTOs and send RoomResponseDTOs:
#Controller
class MyController {
#PostMapping
#ResponseStatus(HttpStatus.CREATED)
#ResponseBody
public RoomResponseDTO createRoom(#RequestBody RoomRequestDTO roomReqDTO) {
Room room = ... // Convert from DTO to Room
// Do stuff with the received room in here
RoomResponseDTO roomRespDTO = ... // Convert to the DTO
return roomRespDTO;
}
}
This approach also has the advantage that you can now change the inner representaion of Room without afecting the API. This is, you could decide to merge the Room and RoomType classes in one, without affecting the outer representation.
Note: In the example I have linked, they use the ModelMapper library. If you do not desire to introduce that dependecy, you could simple add a contructor and a method to the DTOs as such
public RoomResponseDTO(Room room) {
// Manually asign the desired fields in here
this.id = room.getId();
// ...
}
public Room toRoom() {
Room room = new Room();
// Manually asing the desired field in here
room.setId(this.id);
// ...
return room;
}
However, this approach would make you have to change these methods whenever you want to change the representations of Room. The ModeMapper library does this for you.