解决JPA @OneToMany 关系中ID冲突的策略与实践

// Movie.java
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Movie {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name="movie_id") // Movie实体的主键列
    private Integer id;
    // ... 其他属性
}

// wUser.java
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class wUser {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;

    @OneToMany(cascade =CascadeType.ALL)
    @JoinColumn(name = "movie_id") // 尝试将movie_id作为外键列
    private List<Movie> favouriteMovies;
    // ... 其他属性
}

// UserController.java
package com.example.omdbapirest.user;

import com.example.omdbapirest.movie.Movie;
import com.example.omdbapirest.movie.MovieService;
import lombok.RequiredArgsConstructor;
import org.json.simple.parser.ParseException;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {
    private final MovieService movieService;
    private final UserRepository repository; // 对应wUser的Repository
    // private final UserService service; // 如果UserService有其他业务逻辑，可以保留

    @GetMapping
    public List<wUser> getUsers(){
        return repository.findAll();
    }

    @PostMapping("/{id}/{moviename}")
    public wUser addMovieAsFavorite (@PathVariable (name= "id") int id,
                                     @PathVariable (name="moviename") String moviename)
            throws ParseException {
        // 使用Optional查找用户，避免getById在找不到时抛出异常
        Optional<wUser> userOptional = repository.findById(id);
        if (userOptional.isEmpty()) {
            // 可以抛出自定义异常或返回错误响应
            throw new RuntimeException("User not found with id: " + id);
        }
        wUser user = userOptional.get();

        // 检查电影是否已存在于用户的收藏中，避免重复添加
        // 更进一步，可以先查询MovieRepository看电影是否已存在于数据库，避免重复的电影记录
        // 假设MovieService.getDataFromOMDBAsMovie每次都返回一个新Movie对象
        Movie movieFromOmdb = movieService.getDataFromOMDBAsMovie(moviename); // 假设此方法已修改，不再内部保存Movie

        // 检查电影是否已存在于用户的收藏中
        boolean movieAlreadyInFavorites = user.getFavouriteMovies().stream()
                .anyMatch(m -> m.getTitle().equalsIgnoreCase(movieFromOmdb.getTitle()));

        if (!movieAlreadyInFavorites) {
            // 关键步骤：设置Movie与User的双向关联
            user.addFavoriteMovie(movieFromOmdb); // 使用辅助方法
        } else {
            // 电影已在收藏中，可以记录日志或返回特定信息
            System.out.println("Movie '" + movieFromOmdb.getTitle() + "' is already in user's favorites.");
        }

        // 保存用户，级联操作会处理Movie的持久化
        return repository.save(user);
    }
}

// MovieService.java
package com.example.omdbapirest.movie;

import lombok.RequiredArgsConstructor;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.springframework.stereotype.Service;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Optional; // 导入Optional

@Service
@RequiredArgsConstructor
public class MovieService {
    private final MovieRepository repository; // 保持对MovieRepository的引用，用于可能的查询

    public String getJSONFromURL(String strUrl) {
        // ... (保持不变)
        String jsonText = "";
        try {
            URL url = new URL(strUrl);
            InputStream is = url.openStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                jsonText += line + "\n";
            }
            is.close();
            bufferedReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jsonText;
    }

    public Movie getDataFromOMDBAsMovie(String moviename) throws ParseException {
        // 改进：首先尝试从数据库中查找电影，避免重复创建
        Optional<Movie> existingMovie = repository.findByTitle(moviename); // 假设MovieRepository有findByTitle方法
        if (existingMovie.isPresent()) {
            return existingMovie.get();
        }

        // 如果数据库中不存在，则从OMDB API获取并构建新Movie对象
        String strURL = "https://www.omdbapi.com/?t="+moviename+"&apikey=30ccf40c"; // 确保apikey是有效的
        String json = getJSONFromURL(strURL);

        JSONParser parser = new JSONParser();
        Object object = parser.parse(json);
        JSONObject mainJsonObject = (JSONObject) object;

        // 检查API响应是否成功，例如通过"Response"字段
        String responseStatus = (String) mainJsonObject.get("Response");
        if ("False".equalsIgnoreCase(responseStatus)) {
            String error = (String) mainJsonObject.get("Error");
            throw new RuntimeException("OMDB API Error: " + error);
        }

        Movie movie = new Movie();
        movie.setTitle((String)mainJsonObject.get("Title"));
        movie.setPlot((String)mainJsonObject.get("Plot"));
        movie.setGenre((String)mainJsonObject.get("Genre"));
        movie.setDirector((String)mainJsonObject.get("Director"));
        movie.setPosterURL((String)mainJsonObject.get("Poster"));

        // 在这里不再直接保存电影，而是返回Movie对象
        // 保存操作由UserController在管理User-Movie关系时进行
        return movie;
    }

    // 可以移除 addMovie 方法，因为保存操作现在通过User的级联进行
    // public Movie addMovie(Movie movie){
    //    return repository.save(movie);
    // }
}

// MovieRepository.java
package com.example.omdbapirest.movie;

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface MovieRepository extends JpaRepository<Movie, Integer> {
    Optional<Movie> findByTitle(String title);
}