Java 内容类型'；应用程序/json；字符集=UTF-8'；

嗨，当我使用邮递员发送post请求时，有人能帮我解决这个错误吗？这是我的控制器

package com.example.rba.controller;

import java.util.Date;
import java.util.List;
import java.util.Objects;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;

import org.apache.commons.lang.RandomStringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.rba.model.Booking;
import com.example.rba.model.LoginResponse;
import com.example.rba.model.Room;
import com.example.rba.model.User;
import com.example.rba.repository.BookingRepository;
import com.example.rba.repository.RoomRepository;
import com.example.rba.repository.UserRepository;

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

@RestController
@RequestMapping("/api")
public class Controller {

    @Autowired
    BookingRepository bookingRepository;
    @Autowired
    RoomRepository roomRepository;
    @Autowired
    private JavaMailSender sender;
    @Autowired
    UserRepository userRepository;

    public String generatedString = RandomStringUtils.randomAlphabetic(10);

    @GetMapping("/read")
    public List<Booking> read() {
        return bookingRepository.findAll();
    }

    @GetMapping("/rooms")
    public List<Room> room(){
        return roomRepository.findAll();
    }

    @PostMapping(path = "/createBooking/{location}", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, 
            consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
    public ResponseEntity<String> create(@PathVariable(value = "location") String location,
            @Validated @RequestBody Booking book) {
        book.setStatus("reserved");
        book.setBookingCode(generatedString);

        bookingRepository.save(book);

        MimeMessage message = sender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message);
        StringBuilder sb = new StringBuilder();

        try {
            String[] array = new String[book.getAtt().size()];
            int index = array.length;
            for (Object value : book.getAtt()) {
                array[index] = (String) value;
            }
            helper.setTo(array[index]);
            sb.append("Agenda:" + " " + book.getBookingDesc()).append(System.lineSeparator());
            sb.append("When:" +  " " + book.getDateBooked() + " " + book.getStartTime() + " " + "To" + " " + book.getEndTime())
                    .append(System.lineSeparator());
            sb.append("Where:" + " " + location).append(System.lineSeparator());
            sb.append("By:" + " " + book.getBookedUser()).append(System.lineSeparator());
            sb.append("Booking code:" + " " + generatedString);
            helper.setText(sb.toString());
            helper.setSubject("Meeting");
        } catch (MessagingException e) {
            e.printStackTrace();
            return new ResponseEntity<>("Error while sending mail ..", HttpStatus.BAD_REQUEST);
        }
        sender.send(message);

        return new ResponseEntity<>("Inputs have been saved", HttpStatus.OK);
    }

    @PutMapping("/editEquip/{id}")
    public ResponseEntity<Room> edit(@PathVariable(value = "id") Long id, @Validated @RequestBody Room room) {
        Room editRoom = roomRepository.getOne(id);

        if (Objects.isNull(editRoom)) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }

        editRoom.setEquip(room.getEquip());

        Room newEquip = roomRepository.save(editRoom);
        return new ResponseEntity<>(newEquip, HttpStatus.OK);
    }

    @GetMapping("/getEquip")
    public List<Room> readEquip() {
        return roomRepository.findAll();
    }

    @PostMapping("/login")
    public ResponseEntity<LoginResponse> login(@Validated @RequestBody User user){
        String jwtToken = "";
        String username = user.getName();
        String password = user.getPassword();

        LoginResponse response = new LoginResponse();
        if(user.getName() == null && user.getPassword() == null || user.getName() != username && user.getPassword() != password) {
            return new ResponseEntity<>(response, HttpStatus.UNAUTHORIZED);
        }

        List<User> reg = 
                userRepository.findByNameAndPassword(username, password);

        jwtToken = Jwts.builder().setSubject(username).claim("info", user)
                .setIssuedAt(new Date()).signWith(SignatureAlgorithm.HS256, "secretKey")
                .compact();

        if(Objects.isNull(reg) || reg.isEmpty()) {
            response.setStatus(false);
            response.setMessage(username + " " + "doesn't exist");
            return new ResponseEntity<>(response, HttpStatus.UNAUTHORIZED);
        }
        else {
            response.setStatus(true);
            response.setMessage("Welcome");
            response.setToken(jwtToken);
        }

        return new ResponseEntity<>(response, HttpStatus.ACCEPTED);
    }

    @PostMapping("/register")
    private ResponseEntity<String> register(@Validated @RequestBody User user) {

        user.setPassword(generatedString);

        MimeMessage message = sender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message);
        StringBuilder sb = new StringBuilder();

        try {
            helper.setTo(user.getName());
            sb.append("Password:" + " " + user.getPassword());
            helper.setText(sb.toString());
            helper.setSubject("Registeration");
        } catch (MessagingException e) {
            e.printStackTrace();
            return new ResponseEntity<>("Error while sending mail ..", HttpStatus.BAD_REQUEST);
        }
        sender.send(message);

        userRepository.save(user);
        return new ResponseEntity<>("Registered Successfully, Please check your email for your password", HttpStatus.CREATED);
    }

}

package com.example.rba.controller；
导入java.util.Date；
导入java.util.List；
导入java.util.Objects；
导入javax.mail.MessaginException；
导入javax.mail.internet.mimessage；
导入org.apache.commons.lang.RandomStringUtils；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.http.HttpStatus；
导入org.springframework.http.MediaType；
导入org.springframework.http.ResponseEntity；
导入org.springframework.mail.javamail.JavaMailSender；
导入org.springframework.mail.javamail.mimessagehelper；
导入org.springframework.validation.annotation.Validated；
导入org.springframework.web.bind.annotation.GetMapping；
导入org.springframework.web.bind.annotation.PathVariable；
导入org.springframework.web.bind.annotation.PostMapping；
导入org.springframework.web.bind.annotation.PutMapping；
导入org.springframework.web.bind.annotation.RequestBody；
导入org.springframework.web.bind.annotation.RequestMapping；
导入org.springframework.web.bind.annotation.RestController；
导入com.example.rba.model.Booking；
导入com.example.rba.model.LoginResponse；
导入com.example.rba.model.Room；
导入com.example.rba.model.User；
导入com.example.rba.repository.BookingRepository；
导入com.example.rba.repository.RoomRepository；
导入com.example.rba.repository.UserRepository；
导入io.jsonwebtoken.Jwts；
导入io.jsonwebtoken.SignatureAlgorithm；
@RestController
@请求映射（“/api”）
公共类控制器{
@自动连线
预订存储库预订存储库；
@自动连线
RoomRepository RoomRepository；
@自动连线
私有JavaMailSender；
@自动连线
用户存储库用户存储库；
publicstringgeneratedstring=RandomStringUtils.randomAlphabic（10）；
@GetMapping（“/read”）
公共列表读取（）{
return bookingRepository.findAll（）；
}
@GetMapping（“/rooms”）
公众名单室（）{
return roomRepository.findAll（）；
}
@PostMapping（path=“/createBooking/{location}”，产生=MediaType.APPLICATION\u JSON\u UTF8\u值，
consumes=MediaType.APPLICATION\u JSON\u UTF8\u值）
公共响应属性创建（@PathVariable（value=“location”）字符串位置，
@已验证@RequestBody预订簿）{
账面价值（保留）；
book.setBookingCode（generatedString）；
bookingRepository.save（book）；
MimeMessage message=sender.createMimeMessage（）；
MimeMessageHelper=新的MimeMessageHelper（消息）；
StringBuilder sb=新的StringBuilder（）；
试一试{
String[]数组=新字符串[book.getAtt（）.size（）]；
int index=array.length；
for（对象值：book.getAtt（））{
数组[索引]=（字符串）值；
}
setTo（数组[索引]）；
sb.append（“议程：”+“+book.getBookingDesc（））.append（System.lineSeparator（））；
sb.追加（“当：“+”+book.getDateBooked（）+”+book.getStartTime（）+“+”到“+”+book.getEndTime（））
.append（System.lineSeparator（））；
sb.append（“其中：“+”+位置）.append（System.lineSeparator（））；
sb.append（“By:”+“+book.getBookedUser（））.append（System.lineSeparator（））；
sb.追加（“预订代码：“+”+生成字符串）；
helper.setText（sb.toString（））；
helper.setSubject（“会议”）；
}捕获（消息异常e）{
e、 printStackTrace（）；
返回新的响应属性（“发送邮件时出错…”，HttpStatus.BAD_请求）；
}
发送者。发送（消息）；
返回新的响应状态（“输入已保存”，HttpStatus.OK）；
}
@PutMapping（“/editEquip/{id}”）
公共响应属性编辑（@PathVariable（value=“id”）长id，@Validated@RequestBody Room）{
Room editRoom=roomRepository.getOne（id）；
if（Objects.isNull（编辑室））{
返回新的ResponseEntity（未找到HttpStatus.NOT_）；
}
editRoom.setequipm（room.getequipm（））；
Room newequipm=roomRepository.save（编辑室）；
返回新的响应状态（newEquipment，HttpStatus.OK）；
}
@GetMapping（“/GetEquipment”）
公开名单{
return roomRepository.findAll（）；
}
@后映射（“/login”）
公共响应身份登录（@Validated@RequestBody用户）{
字符串jwtToken=“”；
字符串username=user.getName（）；
字符串password=user.getPassword（）；
LoginResponse响应=新的LoginResponse（）；
if（user.getName（）==null和user.getPassword（）==null | | user.getName（）！=username和user.getPassword（）！=password）{
返回新的ResponseEntity（响应，HttpStatus.UNAUTHORIZED）；
}
列表注册表=
userRepository.findByNameAndPassword（用户名、密码）；
jwtToken=Jwts.builder（）.setSubject（用户名）。声明（“信息”，用户）
.setIssuedAt（新日期（））.signWith（SignatureAlgorithm.HS256，“secretKey”）
.compact（）；
if（Objects.isNull（reg）| | reg.isEmpty（））{
回答：setStatus（假）；
response.setMessage（用户名+++”不存在）；
返回新的ResponseEntity（响应，HttpStatus.UNAUTHORIZED）；
}
否则{
回答：setStatus（正确）；
回复：setMessage（“欢迎”）；
setToken（jwtToken）；
}
返回新的ResponseEntity（response，HttpStatus.ACCEPTED）；
}
@后映射（“/寄存器”）
私有响应性寄存器（@Validated@RequestBody用户）{
user.setPassword（generatedString）；
MimeMessage message=sender.createMimeMessage（）；
MimeMessageHelper=新的MimeMessageHelper（消息）；
StringBuilder sb=新的StringBuilder（）；