缺少必需的请求正文：public org.springframework.http.responseEntity

Question

基于Web中的示例创建了两个应用程序：Angular中的Frontend和customer）Angular URL：http://localhost:4200/Spring Boot URL：http://localhost:9020/（REST：http://localhost:9020/API/）

根据这里的专家对我前面问题的说明(https://stackoverflow.com/posts/58685251)，我面临着新的问题，因为我无法在自己的内部解决它。

export class Customer {
    id: number;
    firstname: string;
    lastname: string;
    age: number;
    active: boolean;}

import { Component, OnInit } from '@angular/core';

import { Customer } from '../customer';
import { CustomerService } from '../customer.service';

@Component({
  selector: 'create-customer',
  templateUrl: './create-customer.component.html',
  styleUrls: ['./create-customer.component.css']
})
export class CreateCustomerComponent implements OnInit {

  customer: Customer = new Customer();
  submitted = false;

  constructor(private customerService: CustomerService) { }

  ngOnInit() {
  }

  newCustomer(): void {
    this.submitted = false;
    this.customer = new Customer();
  }

  save() {

    this.customerService.createCustomer(this.customer)
      .subscribe(data => {console.log(data);
        console.log(this.customer);
        this.submitted = true;},error => console.log(error));
    this.customer = new Customer();
    this.customer.firstname="HHH";

}

  onSubmit() {

    this.save();
  }
}

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Customer } from './customer';

@Injectable({
  providedIn: 'root'
})
export class CustomerService {

  private baseUrl = 'http://localhost:9020/api/';

  constructor(private http: HttpClient) { }

  getCustomer(id: number): Observable<Object> {
    return this.http.get(`${this.baseUrl}` + `customers/${id}`);
  }

  createCustomer(customer: Customer): Observable<Object> {
    console.log(customer);
   return this.http.post(`${this.baseUrl}` + `create`, customer);
  }

  updateCustomer(id: number, value: any): Observable<Object> {
    return this.http.put(`${this.baseUrl}/${id}`, value);
  }

  deleteCustomer(id: number): Observable<any> {
    return this.http.delete(`${this.baseUrl}` + `customers/${id}`, { responseType: 'text' });
  }

  getCustomersList(): Observable<any> {
    return this.http.get(`${this.baseUrl}` + `customers`);
  }

  getCustomersByAge(age: number): Observable<any> {
    return this.http.get(`${this.baseUrl}` + `customers/age/${age}`);
  }

  deleteAll(): Observable<any> {
    return this.http.delete(`${this.baseUrl}` + `customers/delete`, { responseType: 'text' });
  }
}

CREATE TABLE customer(
   id INT NOT NULL AUTO_INCREMENT,
   firstname VARCHAR(20) NOT NULL,
   lastname VARCHAR(20) NOT NULL,
   age INT,
   active boolean,
   PRIMARY KEY (id)
);

- server.port=9020 
 - spring.datasource.url=jdbc:h2:file:./testdb
 - spring.datasource.username=H2 spring.datasource.password=password
 - spring.jpa.hibernate.ddl-auto = update 
 - spring.jpa.show-sql=true

@CrossOrigin(origins = "http://localhost:4200")
@RestController
@RequestMapping("/api")
public class CustomerController {

  @Autowired
  CustomerRepository repository;

  @RequestMapping(value = "/create")
  public ResponseEntity<Customer> postCustomer(@RequestBody Customer customer) {
    try {
    LOG.setLevel(Level.ALL);
    LOG.info("public ResponseEntity<Customer> postCustomer(@RequestBody Customer customer");
    LOG.info("customer.getFirstName(): "+customer.getFirstName());
    //new Customer(customer.getId(),customer.getFirstName(),customer.getLastName(),customer.getAge(),customer.isActive())
      Customer _customer = repository.save(customer);
      return new ResponseEntity<>(_customer, HttpStatus.CREATED);
    } catch (Exception e) {
      return new ResponseEntity<>(null, HttpStatus.EXPECTATION_FAILED);
    }
  }

.

@ResponseBody
@Entity
@Table(name = "Customer")
public class Customer implements Serializable {

    private static final long serialVersionUID = -3009157732242241606L;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(name = "lastname")
    private String lastname;

    @Column(name = "firstname")
    private String firstname;

    @Column(name = "age")
    private int age;

    @Column(name = "active")
    private boolean active = true;

    public Customer() {
    }


    public Customer(String firstName, String lastName, int age, boolean active) {
        this.firstname = firstName;
        this.lastname = lastName;
        this.age = age;
        this.active=active;
    }

    public long getId() {
        return id;
    }

    public String getFirstName() {
        return firstname;
    }

    public void setFirstName(String firstName) {
        this.firstname = firstName;
    }

    public void setLastName(String lastName) {
        this.lastname = lastName;
    }

    public String getLastName() {
        return this.lastname;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return this.age;
    }

    public boolean isActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
    }

    @Override
    public String toString() {
        String info = String.format("Customer info: id = %d, firstname = %s, lastname = %s, age = %d", firstname,
                lastname, age, id);
        return info;
    }
}

预期结果是坚持使用正确的Firstname和Lastname的customer，但我得到了异常：

This application has no explicit mapping for /error, so you are seeing this as a fallback.

Thu Nov 07 17:53:03 CET 2019
There was an unexpected error (type=Bad Request, status=400).
Required request body is missing: public org.springframework.http.ResponseEntity<.model.Customer> .controller.CustomerController.postCustomer(model.Customer)
org.springframework.http.converter.HttpMessageNotReadableException: Required request body is missing: public org.springframework.http.ResponseEntity<model.Customer> .controller.CustomerController.postCustomer(com.javasampleapproach.mysql.model.Customer)
    at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.readWithMessageConverters(RequestResponseBodyMethodProcessor.java:160)
    at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.resolveArgument(RequestResponseBodyMethodProcessor.java:130)
    at org.springframework.web.method.support.HandlerMethodArgumentResolverComposite.resolveArgument(HandlerMethodArgumentResolverComposite.java:127)
    at org.springframework.web.method.support.InvocableHandlerMethod.getMethodArgumentValues(InvocableHandlerMethod.java:167)
    at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:134)
    at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104)
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:892)
    at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:797)
    at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87)
    at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1039)
    at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:942)

Answer 1

只有在返回ResponseEntity<>时才会这样做：

   @RequestMapping(value = "${jwt.route.registration.path}", method = RequestMethod.POST)
   public ResponseEntity<User> registration(@RequestBody ExternalUser externalUser){
       System.out.println(externalUser.getUsername());
   User userInstance=((JwtUserDetailsService)userDetailsService).saveUser(externalUser);
   return new ResponseEntity<User>(userInstance,HttpStatus.OK);
    }