在 Spring Boot 中使用 JPA 从具有 OneToMany 关系的实体中删除对象 [英] Delete object from an entity with a OneToMany relationship between both using JPA in Spring Boot
问题描述
下午好，我正在使用 REST API，在其中我有一个包含许多歌曲的播放列表，为此我使用了 JPA 以及使我能够在两者之间建立关系的好处.现在，如果我想删除已经添加到播放列表中的歌曲，我不能这样做，我在下面展示我的类
Good afternoon, I am working with a REST API in which I have a playlist that has many songs, for which I am using JPA and the benefits that allow me to make the relationships between the two. Now, if I want to delete a song already added to the PlayList, I can't do it, I show you my classes below
类播放列表
@Entity
@Table(name = "PLAY_LIST")
public class PlayList {
@JsonIgnore
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "ID")
private Long id;
//@JsonView(View.Get.class)
@Column(name="name")
private String name;
//@JsonView(View.Get.class)
@Column(name="description")
private String description;
//@JsonView(View.Get.class)
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true, mappedBy = "playList")
private List<Song> songs = new ArrayList<>();
@Transient
public void addSong(Song song) {
song.setPlayList(this);
songs.add(song);
}
@Transient
public void removeSong(Song song) {
songs.remove(song);
}
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return this.description;
}
public void setDescription(String description) {
this.description = description;
}
public List<Song> getSongs() {
return this.songs;
}
public void setSongs(List<Song> songs) {
this.songs = songs;
}
}
这里我有添加歌曲和删除的方法，但是删除对我不起作用.
Here I have the methods of adding songs and removing, however, removing is not working for me.
课堂歌曲
Entity
@Table(name = "SONG")
public class Song{
@JsonIgnore
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "ID")
private Long id;
//@JsonView(View.Create.class)
@Column(name = "title")
private String title;
//@JsonView(View.Create.class)
@Column(name = "artist")
private String artist;
//@JsonView(View.Create.class)
@Column(name = "album")
private String album;
//@JsonView(View.Create.class)
@Column(name = "year")
private int year;
/*
Fetch: Esta propiedad se utiliza para determinar cómo debe ser cargada la entidad.
LAZY (perezoso): Indica que la relación solo se cargará cuando la propiedad sea leída por primera vez */
//@JsonView(View.Get.class)
@JsonIgnore
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "PLAY_LIST_ID")
private PlayList playList;
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return this.title;
}
public void setTitle(String title) {
this.title = title;
}
public String getArtist() {
return this.artist;
}
public void setArtist(String artist) {
this.artist = artist;
}
public String getAlbum() {
return this.album;
}
public void setAlbum(String album) {
this.album = album;
}
public int getYear() {
return this.year;
}
public void setYear(int year) {
this.year = year;
}
public PlayList getPlayList() {
return this.playList;
}
public void setPlayList(PlayList playList) {
this.playList = playList;
}
}
我的类控制器
@RestController
@RequestMapping("playlist")
public class PlayListController {
@Autowired
private PlayListService playListService;
@Autowired
private SongRepository songRepository;
// Get playlist by id with songs belongs that playlist
@GetMapping("/get/{id}")
public Optional<PlayList> getPlayListByID(@PathVariable(value = "id") Long id) {
Optional<PlayList> playList = playListService.getById(id);
return playList;
}
@PostMapping("/create")
public PlayList createPlayList(@RequestBody PlayListDTO playListDTO) {
PlayList playList = new PlayList();
playList.setName(playListDTO.getName());
playList.setDescription(playListDTO.getDescription());
playList.setSongs(new ArrayList<>());
for (int x=0; x<playListDTO.getSongs().size(); x++) {
Song songs=new Song();
songs.setTitle(playListDTO.getSongs().get(x).getTitle());
songs.setArtist(playListDTO.getSongs().get(x).getArtist());
songs.setAlbum(playListDTO.getSongs().get(x).getAlbum());
songs.setYear(playListDTO.getSongs().get(x).getYear());
playList.addSong(songs);
}
return playListService.savePlayList(playList);
}
@PutMapping("/update/{id}")
public PlayList updatePlayList(@PathVariable(value = "id") Long id,@RequestBody Song song){
PlayList playList = playListService.getById(id).get();
song.setPlayList(playList);
playList.getSongs().add(song);
playListService.savePlayList(playList);
return playList;
}
@DeleteMapping("/delete/{id}")
public PlayList deletePlayList(@PathVariable(value = "id") Long id,@RequestBody Song song){
PlayList playList =playListService.getById(id).get();
System.out.println(playList.getSongs());
playList.removeSong(song);
System.out.println(playList.getSongs());
return playList;
}
}
所以我正在存储播放列表及其歌曲，方法 POST
So I am storing the Playlist with its songs, method POST
{
"name": "Lista 1",
"description": "Lista de reproduccion 2020 spotify",
"songs": [
{
"title": "Tan Enamorados",
"artist": "CNCO",
"album": "Tan Enamorados",
"year": 2020
},
{
"title": "Hawai",
"artist": "Maluma",
"album": "PAPI JUANCHO",
"year": 2020
}
]
}
现在，为了消除我正在传递播放列表的 id 和歌曲的请求(在 BD 中自动创建的没有歌曲 id 的对象)，但是，我无法从播放列表中消除歌曲，并且在它返回的日志级别在控制台中打印
Now, to eliminate I am passing the id of the PlayList and the Request of the song (object without the id of the song that is automatically created in BD), however, I cannot eliminate the song from the PlayList, and at the logs level it returns this doing a print in console
例如，我想删除以下歌曲:
Example, I want to delete the following song:
但是它没有被删除并且它返回相同的列表给我
however it is not removed and it returns the same list to me
我是否遗漏了什么可以删除歌曲而不必删除播放列表?
Am I missing something to be able to delete a song without having to delete the playlist?
推荐答案
使用 PlayList 中的所有歌曲列表删除歌曲并不是一个好主意.@OneToMany 关联没有连接表.所以我们可以更简单地删除一首歌曲，使用SONG表(这是@OneToMany的连接表不方便的主要原因).
It is not a very good idea to remove a song using all the songs list in the PlayList.
There is not a join table for @OneToMany association. So we can delete a song much simpler, using SONG table (this is the main reason why a join table for @OneToMany is not convienent).
为此您需要一个歌曲 ID，并且您需要使用 CrudRepository.deleteById() 方法.为此，您可以使用完整的组合(标题、艺术家、专辑、年份)，但将歌曲 ID 添加到 JSON 会更简单.
You need a song id for that and you need to use CrudRepository.deleteById() method.
You can use the full combination (title, artist, album, year) for that, but much simpler to add a song id to JSON.
最好使用此端点 URL 删除歌曲
Better to use this endpoint URL to delete a song
/{playListId}/songs/{songId}
您不需要 URL 中的 delete 部分，您已经使用了 DELETE HTTP 方法.
You don't need delete part in the URL, you already use DELETE HTTP method.
为什么您的代码不起作用
- 使用列表中的删除方法不正确
@Transient
public void removeSong(Song song) {
songs.remove(song);
}
songs.remove() 在列表中找不到song，List.remove() 通过引用找到歌曲.它需要有一个开放的持久上下文并从中获取一首歌曲才能在列表中找到它.
songs.remove() can't find song in the list, List.remove() finds a song by a reference. It needs to have an open persistent context and get a song from it to have an ability to find it in the list.
- 不使用事务(打开的持久上下文)让 Hibernate 知道歌曲已被删除并且 Hibernate 必须更新数据库.
所以一个有效的场景
start @Transactional
Spring starts a database transaction
Spring opens a persistent context
load PlayList
load a song from the database (using id or other song attributes)
delete a song from PlayList songs (or delete a song from PlayList songs using id)
end @Transactional
Hibernate flushes changes and delete a song in the database
persistent context is closed
database transaction is committed
这篇关于在 Spring Boot 中使用 JPA 从具有 OneToMany 关系的实体中删除对象的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
