<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>用户页面</title>
    <link href="./css/user.css" rel="stylesheet" type="text/css">
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(to right, #e2e3e5, #ffffff);
            margin: 0;
            color: #333;
        }

        .topbar {
            background-color: #343a40;
            color: white;
            padding: 15px 20px;
            display: flex;
            justify-content: space-between;
            align-items: center;
            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
        }

        .topbar button {
            background-color: #dc3545;
            border: none;
            color: white;
            padding: 10px 15px;
            border-radius: 20px;
            cursor: pointer;
            transition: background-color 0.3s, transform 0.3s;
            font-weight: bold;
        }

        .topbar button:hover {
            background-color: #c82333;
            transform: scale(1.05);
        }

        .sidebar {
            width: 240px;
            background-color: #343a40;
            color: white;
            padding: 20px;
            position: fixed;
            top: 75px;
            height: calc(100% - 75px);
            overflow-y: auto;
            box-shadow: 2px 0 10px rgba(0, 0, 0, 0.2);
        }

        .sidebar h1 {
            text-align: center;
            font-size: 24px;
            margin-bottom: 20px;
            font-weight: bold;
        }

        .sidebar button {
            font-size: 16px;
            width: 100%;
            padding: 12px;
            margin: 8px 0;
            border: none;
            border-radius: 8px;
            background-color: #495057;
            color: white;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .sidebar button:hover {
            background-color: #5a6268;
        }

        .main-content {
            margin-left: 240px;
            padding: 25px;
            flex-grow: 1;
            background-color: #f8f9fa;
            margin-top: 75px;
            flex-direction: column;
            align-items: center;
        }

        .section {
            width: 100%;
            max-width: 800px;
            margin-bottom: 30px;
            text-align: center;
            /* background-color: white;  */
            border-radius: 10px;
            /* 圆角 */
            /* box-shadow: 0 2px 15px rgba(0, 0, 0, 0.1);  */
            padding: 20px;
        }

        .form-container {
            padding: 20px;
            margin: 0 auto;
        }

        .form-container input {
            width: calc(100% - 30px);
            padding: 15px;
            border: 1px solid #ccc;
            border-radius: 5px;
            margin: 10px 0;
            transition: border-color 0.3s;
        }

        .form-container input:focus {
            border-color: #007bff;
            outline: none;
        }

        .query-button {
            padding: 12px 20px;
            font-size: 16px;
            border: none;
            border-radius: 5px;
            background-color: #007bff;
            color: white;
            cursor: pointer;
            transition: background-color 0.3s, transform 0.3s;
        }

        .query-button:hover {
            background-color: #0056b3;
            transform: scale(1.05);
        }

        .search-results-container {
            padding: 20px;
            border-radius: 10px;
            width: 100%;
            margin-top: 20px;
        }

        .search-result-item {
            background-color: white;
            padding: 15px;
            margin: 10px 0;
            border-radius: 10px;
            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        .search-result-item div {
            flex: 1;
            margin-right: 20px;
        }

        .book-actions button {
            background-color: #007bff;
            color: white;
            border: none;
            padding: 10px 15px;
            border-radius: 5px;
            cursor: pointer;
            transition: background-color 0.3s;
        }

        .book-actions button:hover {
            background-color: #0056b3;
        }

        .book-list {
            list-style-type: none;
            padding: 0;
            width: 100%;
        }

        .book-list li {
            background-color: white;
            padding: 15px;
            margin: 10px 0;
            border-radius: 10px;
            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
            display: flex;
            justify-content: space-between;
            align-items: center;
        }

        .book-list button {
            background-color: #007bff;
            padding: 8px 12px;
            border: none;
            border-radius: 4px;
            color: white;
            cursor: pointer;
            transition: background-color 0.3s, transform 0.3s;
        }

        .book-list button:hover {
            background-color: #0056b3;
            transform: scale(1.05);
        }
    </style>
</head>

<body>
    <div class="topbar">
        <div>用户：<span id="username-display">未登录</span></div>
        <button onclick="logout()">退出</button>
    </div>
    <div class="sidebar">
        <h1>用户菜单</h1>
        <button onclick="showSection('search')">搜索书籍</button>
        <button onclick="showSection('history')">借阅历史</button>
        <button onclick="showSection('favorites')">我的收藏</button>
    </div>
    <div class="main-content">
        <div class="section" id="searchSection">
            <div class="form-container">
                <h1>搜索书籍</h1>
                <input type="text" id="searchInput" placeholder="搜索书名或作者">
                <button class="query-button" onclick="searchBooks()">查询</button>
            </div>
            <div id="searchResults" class="search-results-container"></div>
        </div>
        <div class="section" id="historySection" style="display:none;">
            <h1>借阅历史</h1>
            <ul class="book-list" id="borrowHistory"></ul>
        </div>
        <div class="section" id="favoritesSection" style="display:none;">
            <h1>我的收藏</h1>
            <ul class="book-list" id="favoritesList"></ul>
        </div>
    </div>

    <script>
        document.addEventListener("DOMContentLoaded", function () {
            updateUsernameDisplay();
        });

        function logout() {
            alert('已退出登录');
            localStorage.removeItem('userInfo');
            localStorage.removeItem('username');
            updateUsernameDisplay();
            window.location.href = 'login.html';
        }

        function updateUsernameDisplay() {
            const username = localStorage.getItem('username');
            const usernameDisplay = document.getElementById('username-display');
            if (username) {
                usernameDisplay.textContent = username;
            } else {
                usernameDisplay.textContent = '未登录';
                console.log('在 localStorage 中未找到用户名');
            }
        }

        function showSection(section) {
            const sections = document.querySelectorAll('.section');
            sections.forEach(s => s.style.display = 'none');
            document.getElementById(section + 'Section').style.display = 'block';

            if (section === 'favorites') {
                loadFavorites();
            } else if (section === 'history') {
                loadBorrowHistory();
            }
        }

        function searchBooks() {
            const keyword = document.getElementById('searchInput').value;
            if (keyword.trim() === '') {
                alert('请输入搜索关键词');
                return;
            }

            fetch('http://localhost:8080/api/books/search', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ keyword: keyword })
            })
                .then(response => response.json())
                .then(data => {
                    console.log(data);
                    displaySearchResults(data);
                })
                .catch(error => console.error('Error:', error));
        }

        function displaySearchResults(books) {
            const searchResults = document.getElementById('searchResults');
            searchResults.innerHTML = '';

            if (books.length === 0) {
                searchResults.innerHTML = '<p>没有找到相关书籍</p>';
            } else {
                books.forEach(book => {
                    const listItem = document.createElement('div');
                    listItem.className = 'search-result-item';
                    listItem.innerHTML = `
                        <div>
                            <strong>书名:</strong> ${book.title}<br>
                            <strong>作者:</strong> ${book.author}<br>
                            <strong>出版年份:</strong> ${book.year_published}
                        </div>
                        <div class="book-actions">
                            <button onclick="borrowBook(${book.id})">借阅</button>
                            <button onclick="addToFavorites(${book.id})">添加到收藏</button>
                        </div>
                    `;
                    searchResults.appendChild(listItem);
                });
            }
        }

        function getUserId() {
            const userInfo = JSON.parse(localStorage.getItem('userInfo'));
            return userInfo ? userInfo.id : null;
        }

        // 借阅书籍
        function borrowBook(bookId) {
    const userId = getUserId();
    if (!userId) {
        alert('用户信息已失效，请重新登录');
        window.location.href = 'login.html';
        return;
    }

    // 检查书籍是否在收藏中
    fetch(`http://localhost:8080/api/borrow-records/borrow${userId}`)
        .then(response => response.json())
        .then(favorites => {
            const isFavorited = favorites.some(fav => fav.book_id === bookId);
            if (isFavorited) {
                alert('您已经将此书收藏，不能重复借阅！');
                return; // 不允许再次借阅
            }

            // 检查书籍是否已经被借出
            return fetch(`http://localhost:8080/user/borrow-history/${userId}`);
        })
        .then(response => response.json())
        .then(borrowedRecords => {
            const isAlreadyBorrowed = borrowedRecords.some(record => record.book_id === bookId && !record.is_returned);
            if (isAlreadyBorrowed) {
                alert('您已借阅此书，必须先还书才能借阅！');
                return; // 不允许借阅
            }

            // 如果没有借过，允许借阅
            return fetch('http://localhost:8080/user/borrow-book', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ userId: userId, bookId: bookId })
            });
        })
        .then(response => {
            if (response && response.ok) {
                return response.text();
            } else {
                throw new Error('网络响应不正常');
            }
        })
        .then(data => {
            alert('您已成功借阅');
            loadBorrowHistory();
        })
        .catch(error => console.error('Error:', error));
}

        // 加载借阅历史
        function loadBorrowHistory() {
            const userId = getUserId();
            if (!userId) {
                alert('用户信息已失效，请重新登录');
                window.location.href = 'login.html';
                return;
            }

            fetch(`http://localhost:8080/user/borrow-history/${userId}`)
                .then(response => response.json())
                .then(data => {
                    displayBorrowHistory(data);
                })
                .catch(error => console.error('Error:', error));
        }

        function displayBorrowHistory(borrowRecords) {
            const borrowHistory = document.getElementById('borrowHistory');
            borrowHistory.innerHTML = '';

            if (borrowRecords.length === 0) {
                borrowHistory.innerHTML = '<p>没有借阅记录</p>';
            } else {
                borrowRecords.forEach(record => {
                    const listItem = document.createElement('li');
                    const borrowDate = new Date(record.borrow_date);
                    const formattedDate = borrowDate.toLocaleDateString('zh-CN', {
                        year: 'numeric',
                        month: '2-digit',
                        day: '2-digit'
                    });

                    listItem.textContent = `书名: ${record.title} - 作者: ${record.author} - 借阅日期: ${formattedDate} - 状态: ${record.status}`;

                    const returnButton = document.createElement('button');
                    returnButton.textContent = '还书';
                    returnButton.onclick = function () {
                        console.log('Attempting to return book with Record ID:', record.id);
                        returnBook(record.id, returnButton);
                    };

                    if (record.status === '已还书') {
                        returnButton.disabled = true;
                        returnButton.textContent = '已还书';
                    }

                    listItem.appendChild(returnButton);
                    borrowHistory.appendChild(listItem);
                });
            }
        }

        function returnBook(borrowRecordId, returnButton) {
            const userId = getUserId();
            console.log('User ID:', userId);
            console.log('Record ID:', borrowRecordId);
            if (!userId || !borrowRecordId) {
                alert('无效的用户 ID 或借阅记录 ID');
                return;
            }

            console.log("Returning book with Record ID:", borrowRecordId, "for User ID:", userId);

            returnButton.disabled = true;
            returnButton.textContent = '处理中...';

            fetch('http://localhost:8080/user/return-book', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ userId: userId, recordId: borrowRecordId })
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('网络响应不正常');
                    }
                    return response.json();
                })
                .then(data => {
                    alert(data.message);
                    loadBorrowHistory();
                })
                .catch(error => {
                    console.error('Error:', error);
                    alert('还书时发生错误，请稍后再试');
                    returnButton.disabled = false;
                    returnButton.textContent = '还书';
                });
        }

        // 添加到收藏
        function addToFavorites(bookId) {
            const userId = getUserId();
            if (!userId) {
                alert('用户信息已失效，请重新登录');
                window.location.href = 'login.html';
                return;
            }
            fetch('http://localhost:8080/api/favorites/add', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ userId: userId, bookId: bookId })
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('网络响应不正常');
                    }
                    return response.json();
                })
                .then(data => {
                    if (data.error) {
                        alert(data.error);
                    } else {
                        alert(data.message);
                        loadFavorites();
                    }
                })
                .catch(error => {
                    console.error('Error:', error);
                    alert('添加收藏时发生错误，请稍后再试');
                });
        }

        // 加载收藏书籍
        function loadFavorites() {
            const userId = getUserId();
            if (!userId) {
                alert('用户信息已失效，请重新登录');
                window.location.href = 'login.html';
                return;
            }

            fetch(`http://localhost:8080/api/favorites/${userId}`)
                .then(response => response.json())
                .then(data => {
                    displayFavorites(data);
                })
                .catch(error => console.error('Error:', error));
        }

        // 显示收藏书籍
        function displayFavorites(favoriteBooks) {
            const favoritesList = document.getElementById('favoritesList');
            favoritesList.innerHTML = '';
            if (favoriteBooks.length === 0) {
                favoritesList.innerHTML = '<p>没有收藏的书籍</p>';
            } else {
                favoriteBooks.forEach(book => {
                    const listItem = document.createElement('li');
                    listItem.textContent = `书名: ${book.title} - 作者: ${book.author}`;

                    const borrowButton = document.createElement('button');
                    borrowButton.textContent = '借阅';
                    borrowButton.onclick = function () {
                        borrowFromFavorites(book.id);
                    };

                    const deleteButton = document.createElement('button');
                    deleteButton.textContent = '删除收藏';
                    deleteButton.onclick = function () {
                        removeFromFavorites(book.id);
                    };

                    listItem.appendChild(borrowButton);
                    listItem.appendChild(deleteButton);
                    favoritesList.appendChild(listItem);
                });
            }
        }

        // 从收藏中借阅书籍
function borrowFromFavorites(bookId) {
    const userId = getUserId();
    if (!userId) {
        alert('用户信息已失效，请重新登录');
        window.location.href = 'login.html';
        return;
    }

    // 检查用户的借阅历史
    fetch(`http://localhost:8080/user/borrow-history/${userId}`)
        .then(response => response.json())
        .then(borrowedRecords => {
            // 检查该书籍是否已经被借阅
            const isAlreadyBorrowed = borrowedRecords.some(record => record.book_id === bookId && !record.is_returned);
            if (isAlreadyBorrowed) {
                alert('您已借阅此书，必须先还书才能借阅！');
                return; // 不允许借阅
            }

            // 在借阅前检查用户的收藏
            fetch(`http://localhost:8080/user/favorites/${userId}`)
                .then(response => response.json())
                .then(favorites => {
                    const isFavorited = favorites.some(fav => fav.book_id === bookId);
                    if (!isFavorited) {
                        alert('这本书再您的收藏里了');
                        return; // 不允许借阅
                    }

                    // 如果没有借过，允许借阅
                    fetch('http://localhost:8080/user/borrow-from-favorite', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json'
                        },
                        body: JSON.stringify({ userId: userId, bookId: bookId })
                    })
                    .then(response => {
                        if (!response.ok) {
                            throw new Error('网络响应不正常');
                        }
                        return response.json();
                    })
                    .then(data => {
                        if (data.error) {
                            alert(data.error);
                        } else {
                            alert(data.message);
                            loadFavorites();
                            loadBorrowHistory();
                        }
                    })
                    .catch(error => {
                        console.error('Error:', error);
                        alert('借阅书籍时发生错误，请稍后再试');
                    });
                })
                .catch(error => {
                    console.error('Error:', error);
                    alert('获取收藏记录时发生错误，请稍后再试');
                });
        })
        .catch(error => {
            console.error('Error:', error);
            alert('获取借阅记录时发生错误，请稍后再试');
        });
}
        // 从收藏中删除书籍
        function removeFromFavorites(bookId) {
            const userId = getUserId();
            if (!userId) {
                alert('用户信息已失效，请重新登录');
                window.location.href = 'login.html';
                return;
            }

            fetch('http://localhost:8080/api/favorites/remove', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ userId: userId, bookId: bookId })
            })
                .then(response => response.json())
                .then(data => {
                    if (data.error) {
                        alert(data.error);
                    } else {
                        alert('您已成功从收藏中删除这本书');
                        loadFavorites();
                    }
                })
                .catch(error => console.error('Error:', error));
        }
    </script>
</body>

</html>package com.example.librarysystem.controller;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.example.librarysystem.entity.Books;
import com.example.librarysystem.mapper.BooksMapper;
import com.example.librarysystem.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;


import java.util.Collections;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @Autowired
    private BooksMapper booksMapper;

    // 添加图书的接口
    @PostMapping("/add")
    public ResponseEntity<?> addBook(@RequestBody Books book) {


        try {
            Books savedBook = bookService.addBook(book);
            return new ResponseEntity<>(savedBook, HttpStatus.OK);
        } catch (Exception e) {
            throw new RuntimeException("添加图书失败：" + e.getMessage());
        }
    }
    // 根据书名删除图书的新接口
    @PostMapping("/deleteByTitle")
    public ResponseEntity<?> deleteBookByTitle(@RequestBody Map<String, String> map, @RequestHeader(value = "user-type", required = false) String userType) {
        if (!"admin".equals(userType)) {


            return new ResponseEntity<>("权限不足，只有管理员可以删除图书", HttpStatus.FORBIDDEN);
        }
        String title = map.get("title");
        try {
            bookService.deleteBookByTitle(title);
            return new ResponseEntity<>("Book deleted successfully", HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>("删除图书失败：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteBook(@PathVariable Long id, @RequestHeader(value = "user-type", required = false) String userType) {
        if (!"admin".equals(userType)) {
            return new ResponseEntity<>("权限不足，只有管理员可以删除图书", HttpStatus.FORBIDDEN);
        }
        try {
            bookService.deleteBook(id);
            return new ResponseEntity<>("Book deleted successfully", HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>("删除图书失败：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    @GetMapping("/{id}")
    public ResponseEntity<Books> getBookById(@PathVariable Long id) {
        Books book = bookService.getBookById(id);

        if (book == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }

        return new ResponseEntity<>(book, HttpStatus.OK);
    }
    // 新增根据书名修改图书的接口
    @PostMapping("/editByTitle")
    public ResponseEntity<?> editBookByTitle(@RequestBody Map<String, String> map) {
        String oldTitle = map.get("oldTitle");
        String newTitle = map.get("newTitle");
        String newAuthor = map.get("newAuthor");
        String newYearPublishedStr = map.get("newYearPublished");
        int newYearPublished = 0;
        try {
            if (newYearPublishedStr!= null &&!newYearPublishedStr.isEmpty()) {
                newYearPublished = Integer.parseInt(newYearPublishedStr);
            }
        } catch (NumberFormatException e) {
            return new ResponseEntity<>("出版年份格式错误", HttpStatus.BAD_REQUEST);
        }
        Books newBookInfo = new Books();
        newBookInfo.setTitle(newTitle);
        newBookInfo.setAuthor(newAuthor);
        newBookInfo.setYearPublished(newYearPublished);
        try {
            bookService.editBookByTitle(oldTitle, newBookInfo);
            return new ResponseEntity<>("Book edited successfully", HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>("修改图书失败：" + e.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    @GetMapping("/all")
    public ResponseEntity<List<Books>> getBooks() {
        List<Books> books = bookService.getBooks();
        return new ResponseEntity<>(books, HttpStatus.OK);
    }

    @PostMapping("/edit")
    public ResponseEntity<?> editBook(@RequestBody Books book) {
        Books editedBook = bookService.editBook(book);
        return new ResponseEntity<>(editedBook, HttpStatus.OK);
    }

    @PostMapping("/search")
    public ResponseEntity<List<Books>> getBook(@RequestBody Map<String, String> map) {
        String value = map.get("keyword");

        List<Books> booksList = null;
        try {
            booksList = booksMapper.selectList(Wrappers.<Books>lambdaQuery().eq(Books::getTitle, value));
        } catch (Exception e) {
            booksList = Collections.emptyList();
        }

        return new ResponseEntity<>(booksList, HttpStatus.OK);

    }
}package com.example.librarysystem.controller;
//
import com.example.librarysystem.entity.BorrowRecord;
import com.example.librarysystem.service.BorrowRecordService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/borrow-records")
public class BorrowRecordController {
    @Autowired
    private BorrowRecordService borrowRecordService;

    @PostMapping("/borrow")
    public ResponseEntity<?> borrowBook(@RequestBody BorrowRecord borrowRecord) {
        BorrowRecord savedRecord = borrowRecordService.borrowBook(borrowRecord);
        return new ResponseEntity<>(savedRecord, HttpStatus.OK);
    }

    @GetMapping()
    public ResponseEntity<List<BorrowRecord>> getBorrowRecords() {
        List<BorrowRecord> records = borrowRecordService.getBorrowRecords();
        return new ResponseEntity<>(records, HttpStatus.OK);
    }

    @GetMapping("/{id}")
    public ResponseEntity<BorrowRecord> getBorrowRecordById(@PathVariable Long id) {
        BorrowRecord record = borrowRecordService.getBorrowRecordById(id);
        if (record!= null) {
            return new ResponseEntity<>(record, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteBorrowRecord(@PathVariable Long id) {
        borrowRecordService.deleteBorrowRecord(id);
        return new ResponseEntity<>("Borrow record deleted successfully", HttpStatus.OK);
    }

    @PostMapping("/edit")
    public ResponseEntity<?> editBorrowRecord(@RequestBody BorrowRecord borrowRecord) {
        BorrowRecord editedRecord = borrowRecordService.editBorrowRecord(borrowRecord);
        return new ResponseEntity<>(editedRecord, HttpStatus.OK);
    }
}package com.example.librarysystem.controller;

import com.example.librarysystem.entity.Favorite;
import com.example.librarysystem.service.FavoriteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/favorites")
public class FavoriteController {
    @Autowired
    private FavoriteService favoriteService;

    @PostMapping("/add")
    public ResponseEntity<?> addFavorite(@RequestBody Favorite favorite) {
        Favorite savedFavorite = favoriteService.addFavorite(favorite);
        return new ResponseEntity<>(savedFavorite, HttpStatus.OK);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteFavorite(@PathVariable Long id) {
        favoriteService.deleteFavorite(id);
        return new ResponseEntity<>("Favorite deleted successfully", HttpStatus.OK);
    }

    @GetMapping("/{userId}")
    public ResponseEntity<List<Favorite>> getFavoritesByUserId(@PathVariable Long userId) {
        List<Favorite> favorites = favoriteService.getFavoritesByUserId(userId);
        return new ResponseEntity<>(favorites, HttpStatus.OK);
    }
}当我点击搜索书籍时，没有给我返回书籍，修改代码，让他能够正确返回书籍