org.springframework.web.client.UnknownContentTypeException：无法提取响应：找不到适合responsetype的HttpMessageConverter

org.springframework.web.client.UnknownContentTypeException: Could not extract response: no suitable HttpMessageConverter found for response type [class java.lang.Integer] and content type [text/plain;charset=UTF-8]

Im getting above error for below method in QuestionController Service Class

QuizController.java

@RestController
@RequestMapping("quiz")
public class QuizController {
@Autowired
QuizService quizservice;

// Create quiz for admin
@PostMapping("createquiz")
public Object createQuiz(@RequestBody QuizDto quizDto)
{
    return quizservice.createQuiz(quizDto);
}

// Get questions from given quiz Id for users
@GetMapping("getquestions/{quizId}")
public Object getQuestionsFromQuizIds(@PathVariable Integer quizId)
{
    return quizservice.getQuestionsFromQuizId(quizId);
}

// Calculaet score of user as per user's response-
@PostMapping("claculateScore")
public Object claculateScore(@RequestBody List<Response> responses)
{
    return quizservice.claculateScore(responses);
}

@PostMapping("getScore")
public Object getScoreForUsers(@RequestBody List<Response> responses)
{
    return quizservice.getScoreForUsers(responses);
}

}

QuizService.java

@Service
public class QuizService {

    @Autowired
    QuizInterface quizInterface;

    @Autowired
    QuizRepo quizRepo;

    public Object createQuiz(QuizDto quizDto) {
        try {
            if (quizDto.getTitle() != null && quizDto.getCategory() != null && quizDto.getNumOfQues() != null) {
                Quiz quiz = new Quiz();
                quiz.setTitlel(quizDto.getTitle());
                List<Integer> questionIds = quizInterface.findQuestionIdsForUsers(quizDto.getCategory(),
                        quizDto.getNumOfQues());
                quiz.setQuestionIds(questionIds);
                quizRepo.save(quiz);
                return new ResponseEntity<>("Quiz Saved in DB successfully...", HttpStatus.OK);
            } else {
                return new ResponseEntity<>("title, category or numOfQuestions is never passed in request...",
                        HttpStatus.BAD_REQUEST);
            }

        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }

    }

    // This function is dependent on both quiz and question DB
    public Object getQuestionsFromQuizId(Integer quizId) {
        System.out.println("Reaching quiz service.....................................******************&&&&&&&&&&&&&&&&&&&&&&&");
        try {
            Optional<Quiz> quiz_optional = quizRepo.findById(quizId);
            if(!quiz_optional.isPresent())
                return new ResponseEntity<>("Requested quizId is not present in DB", HttpStatus.BAD_REQUEST);
            Quiz quiz = quiz_optional.get();
            System.out.println(quiz.toString());                                /////////////////////////////****************************************************** */
            List<Integer> questionIds = quiz.getQuestionIds();
            System.out.println("Before interface............................******************&&&&&&&&&&&&&&&&&&&&&&&");
            List<QuestionOnly> questionsFromQuestionIdsforUsers = quizInterface
                    .findQuestionsFromQuestionIds(questionIds);
            System.out.println(questionsFromQuestionIdsforUsers.toString());    /////////////////////////////****************************************************** */
            return new ResponseEntity<>(questionsFromQuestionIdsforUsers, HttpStatus.OK);
        } 
        catch (Exception e) {
            return new ResponseEntity<>("Couldn't create questions"+e.getMessage(),HttpStatus.BAD_REQUEST);
        }
    }

    public Object claculateScore(List<Response> responses) {
        System.out.println(
                "Reaching calculate score..................score.................score.score.................score.score.................score.score.................score");
        System.out.println("Here its in quiz service " + quizInterface.claculateScore(responses));
        return quizInterface.claculateScore(responses);
    }
    
    public Object getScoreForUsers(List<Response> responses) {
        Object score = quizInterface.getScoreForUsers(responses);
        return score;
    }

}

QuizInterface

@FeignClient("QUESTION-SERVICE")
public interface QuizInterface {
    @GetMapping("question/createQuestionsForUsers")
    public List<Integer> findQuestionIdsForUsers(@RequestParam String category, @RequestParam Integer numOfQues); // Here the function declaration should be like just how its present in QuestionService.

    @PostMapping("question/getQuestionsFromquestionIds")
    public List<QuestionOnly> findQuestionsFromQuestionIds(@RequestBody List<Integer> questionIds);

    @PostMapping("question/claculateScore")
    public Object claculateScore(@RequestBody List<Response> responses);

    @PostMapping("question/getScore")
    public Object getScoreForUsers(@RequestBody List<Response> responses);
    
}

QuestionController

@RestController
@RequestMapping("question")
public class QuestionController {
    @Autowired
    QuestionService questionService;

    // Create
    @PostMapping("addAllQuestions")
    public Object addAllQuestions(@RequestBody List<Question> questions)
    {
        return questionService.addAllQuestions(questions);
    }

    //Read
    @GetMapping("viewAllQuestions")
    public Object viewAllQuestions()
    {
        return questionService.viewAllQuestions();
    }

    // Update
    @PutMapping("updateQuestion")
    public Object updateQuestions(@RequestBody Question question)
    {
        return questionService.updateQuestions(question);
    }

    // Delete
    @DeleteMapping("deleteQuestion")
    public Object deleteQuestion(@RequestParam Integer id)
    {
        return questionService.deleteQuestion(id);
    }

    // Methods for quiz - 
    @GetMapping("createQuestionsForUsers")
    public List<Integer> findQuestionIdsForUsers(@RequestParam String category,@RequestParam Integer numOfQues)
    {
        return questionService.findQuestionIdsForUsers(category, numOfQues);
    }

    @PostMapping("getQuestionsFromquestionIds")
    public Object findQuestionsFromQuestionIds(@RequestBody List<Integer> questionIds) {
        System.out.println("Reaching question controller..........");
        return questionService.findQuestionsFromQuestionIds(questionIds);
    }
    
    @PostMapping("claculateScore")
    public Object claculateScore(@RequestBody List<Response> responses)
    {
        System.out.println(
                "reaching claculate score questionoo9oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo");////////////////////////////=====================================
        System.out.println("Hereit is - " + questionService.claculateScore(responses));
        return questionService.claculateScore(responses);
    }

    @PostMapping("getScore")
    public Object getScoreForUsers(@RequestBody List<Response> responses)
    {
        return questionService.getScoreForUsers(responses);
    }
}

QuestionService

@Service
public class QuestionService {

    @Autowired
    QuestionRepo questionRepo;
    public Object addAllQuestions(List<Question> questions) {
        if(!questions.isEmpty())
        {
            questionRepo.saveAll(questions);
            return new ResponseEntity<>(questions.size()+" questions added to DB", HttpStatus.OK);
        }
        else
        {
            return new ResponseEntity<>("No questions found for adding to DB....", HttpStatus.BAD_REQUEST);
        }
    }

    public Object viewAllQuestions() {
        try {
            List<Question> questions = questionRepo.findAll();
            if (questions.isEmpty()) {
                return new ResponseEntity<>("Cannot find any question to view inside DB...", HttpStatus.BAD_REQUEST);
            } 
            else
                return new ResponseEntity<>(questions, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(e.getMessage(),HttpStatus.BAD_REQUEST);
        }
    }

    public Object updateQuestions(Question question) {
        try {
            Optional<Question> questionToBeUpdated_optional = questionRepo.findById(question.getId());  // This statement will throw an exception here.
            if(questionToBeUpdated_optional.isPresent())
            {
                Question updatedQuestion = new Question(question.getId(), question.getQuestionTitle(),
                        question.getOption1(), question.getOption2(), question.getOption3(), question.getOption4(),
                        question.getRightAnswer(), question.getDifficultylevel(), question.getCategory());
                questionRepo.save(updatedQuestion);
                return new ResponseEntity<>("Updated question is - "+ questionRepo.findById(question.getId()).toString(), HttpStatus.OK);
            }
            else
            {
                return new ResponseEntity<>("Question to be updated is not present in DB", HttpStatus.BAD_REQUEST);
            }
            
        } catch (Exception e) {
            return new ResponseEntity<>("Please provide a question with ID.",HttpStatus.BAD_REQUEST);
        }
    }

    public Object deleteQuestion(Integer id) {
        try {
            Integer idToBeDeleted = id;
            if (questionRepo.existsById(id))
                questionRepo.deleteById(idToBeDeleted); // deleteById will not throw exception even if idToBeDeleted is null.
            else
                return new ResponseEntity<>("Question with provided id is not present in DB", HttpStatus.BAD_REQUEST);
            return new ResponseEntity<>("Question Deleted SuccessFully....", HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>("Please enter a question Id which need to be deleted...",
                    HttpStatus.BAD_REQUEST);
        }
    }

    // Methods used in Quiz interface - 
    
    public List<Integer> findQuestionIdsForUsers(String category, Integer numOfQues) {
        return questionRepo.findQuestionIdsForUsers(category, numOfQues);
    }

    // public List<QuestionOnly> findQuestionsFromQuestionIds(List<Integer> questionIds) {
    //     System.out.println("Reaching question service..........");
    //     List<QuestionOnly> questionsForUsers = new ArrayList<>();
    //     for(Integer questionId : questionIds)
    //     {
    //         Question questionForQuestionId = questionRepo.findById(questionId).get();
    //         questionsForUsers.add(new QuestionOnly(questionForQuestionId.getId(), questionForQuestionId.getQuestionTitle(),
    //                         questionForQuestionId.getOption1(), questionForQuestionId.getOption2(),
    //                         questionForQuestionId.getOption3(), questionForQuestionId.getOption4()));
    //     }
    //     return questionsForUsers;
    // }

    public Object findQuestionsFromQuestionIds(List<Integer> questionIds) {
        System.out.println("Reaching question service..........");
        List<QuestionOnly> questionsForUsers = new ArrayList<>();
        for(Integer questionId : questionIds)
        {
            Question questionForQuestionId = questionRepo.findById(questionId).get();
            questionsForUsers.add(new QuestionOnly(questionForQuestionId.getId(), questionForQuestionId.getQuestionTitle(),
                            questionForQuestionId.getOption1(), questionForQuestionId.getOption2(),
                            questionForQuestionId.getOption3(), questionForQuestionId.getOption4()));
        }
        return new ResponseEntity<>(questionsForUsers.toString(),HttpStatus.OK);
    }

    public Object claculateScore(List<Response> responses) {
        System.out.println("Reaching claculateScore questionService......................^^^^^^^^^^^^^^^^^^^^^^^^^^^^^&&&&&&&&&&&&&&&&&&********************************(((((((((((((((())))))))))))))))");
        try {
            if (responses.isEmpty())
            {
                System.out.println("Testing......................^^^^^^^^^^^^^^^^^^^^^^^^^^^^^&&&&&&&&&&&&&&&&&&********************************(((((((((((((((())))))))))))))))");
                return new ResponseEntity<>("please choose any answer and submit..", HttpStatus.BAD_REQUEST);
            }
            Integer score = 0;
            for (Response response : responses) {
                String rightAnswer = questionRepo.findById(response.getId()).get().getRightAnswer();

                if (response.getChosenAnswer().equals(rightAnswer))
                    score++;
            }
            String res = "Your score is - ";
            return new ResponseEntity<>(res, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }
    }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public Object getScoreForUsers(List<Response> responses)
    {
        try {
            if (!responses.isEmpty()) {
                Integer score = 0;
                for(Response r:responses)
                {
                    Optional<Question> questionOptional = questionRepo.findById(r.getId());
                    if (questionOptional.isPresent()) {
                        Question question = questionOptional.get();
                        if (question.getRightAnswer().equals(r.getChosenAnswer()))
                            score++;
                    } 
                    else {
                        throw new NullPointerException("Question with requested ID - " + r.getId() + " is not present in DB");
                    }
                }
                return new ResponseEntity<>(score, HttpStatus.OK);    // -This line is working
                // return new ResponseEntity<>("Your score is = "+score, HttpStatus.OK); // But this line is not working - here I am getting - " no suitable HttpMessageConverter found for response type" error why is that?
            } else {
                return new ResponseEntity<>("No options selected....",HttpStatus.BAD_REQUEST);
            }
        } 
        catch (Exception e) {
            return new ResponseEntity<>(e.getMessage(), HttpStatus.BAD_REQUEST);
        }
    }
    
}