内容类型'application / json; charset = UTF-8'不支持Spring Boot REST API

时间：2019-08-08 20:41:37

标签： rest spring-boot postman

在Spring Boot Rest API中，我可以从数据库（GET）获取“ Utilisateurs”类实例，但是当我尝试使用POST方法添加新实例时，出现以下错误：


{
    "timestamp": "2019-08-08T20:17:41.292+0000",
    "status": 415,
    "error": "Unsupported Media Type",
    "message": "Content type 'application/json;charset=UTF-8' not supported",
    "path": "/utilisateurs/signup"
}

要避免这种不受支持的媒体类型错误，我应该怎么做？

我尝试发送带有和不带有“ Content-Type：application / json”标头的post方法

这是“ Utilisateurs”类：

package ma.netrent.entities;

import java.io.Serializable;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import com.fasterxml.jackson.annotation.JsonIgnore;

@Entity
public class Utilisateur implements Serializable {


    @Id
    @GeneratedValue
    private long id;

    private String image;

    private String prenom;

    private String nom;

    private String email;


    private String password;

    private String quartier;

    private String ville;

    private String pays;

    @Column(columnDefinition = "float default -1")
    private float note;

    private boolean accountExpired;

    private boolean accountLocked;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(ArrayList<Role> roles) {
        this.roles = roles;
    }

    @OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(name = "user_role", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "role_id"))
    private List<Role> roles;

    @OneToMany(fetch = FetchType.LAZY)
    private List<Commentaire> commentaires;


    @OneToMany(fetch = FetchType.LAZY, mappedBy = "proprietaire", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Immobilier> immobiliers;

    public Utilisateur() {

    }

    public Utilisateur(long id) {
        setId(id);
    }

    public Utilisateur(Utilisateur u) {
        this.id = u.id;
        this.image = u.image;
        this.accountExpired = u.accountExpired;
        this.password = u.password;
        this.accountLocked = u.accountLocked;
        this.commentaires = u.commentaires;
        this.regisrationDate = u.regisrationDate;
        this.immobiliers = u.immobiliers;
        this.note = u.note;
        this.prenom = u.prenom;
        this.nom = u.nom;
        this.email = u.email;
    }

    public Utilisateur(String email, String password, ArrayList<Role> roles) {
        this.roles = roles;
        this.password = password;
        this.email = email;
    }

    public List<Commentaire> getCommentaires() {
        return commentaires;
    }

    public void setCommentaires(List<Commentaire> commentaires) {
        this.commentaires = commentaires;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public boolean isAccountExpired() {
        return accountExpired;
    }

    public void setAccountExpired(boolean accountExpired) {
        this.accountExpired = accountExpired;
    }

    public boolean isAccountLocked() {
        return accountLocked;
    }

    public void setAccountLocked(boolean accountLocked) {
        this.accountLocked = accountLocked;
    }

    @SuppressWarnings("deprecation")
    @PrePersist
    void onCreate() {
        this.setRegisrationDate(new Timestamp((new Date()).getDate()));
    }

    @SuppressWarnings("deprecation")
    @PreUpdate
    void onPersist() {
        System.out.println("yoyo");
        this.setRegisrationDate(new Timestamp((new Date()).getDate()));
    }

    @Temporal(TemporalType.DATE)
    private Date regisrationDate;

    public float getNote() {
        return note;
    }

    public void setNote(float note) {
        this.note = note;
    }

    public String getImage() {
        return image;
    }

    public void setImage(String image) {
        this.image = image;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @JsonIgnore
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @JsonIgnore
    public List<Immobilier> getImmobiliers() {
        return immobiliers;
    }

    public void setImmobiliers(List<Immobilier> immobiliers) {
        this.immobiliers = immobiliers;
    }

    public String getQuartier() {
        return quartier;
    }

    public void setQuartier(String quartier) {
        this.quartier = quartier;
    }

    public String getVille() {
        return ville;
    }

    public void setVille(String ville) {
        this.ville = ville;
    }

    public String getPays() {
        return pays;
    }

    public void setPays(String pays) {
        this.pays = pays;
    }

    public Date getRegisrationDate() {
        return regisrationDate;
    }

    public void setRegisrationDate(Date regisrationDate) {
        this.regisrationDate = regisrationDate;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

}

控制器我将发布请求发送到：（公用事业/注册）


package ma.netrent.controllers;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import ma.netrent.entities.Utilisateur;
import ma.netrent.responseEntities.UtilisateurResponse;
import ma.netrent.services.UtilisateurService;

@RestController
@RequestMapping(value = "/utilisateurs")
public class UtilisateursController {
    @Autowired
    private UtilisateurService utilisateurService;

    @Autowired
    private PasswordEncoder bcryptEncoder;

    @RequestMapping(method = RequestMethod.GET, value = "/all")
    public ResponseEntity<UtilisateurResponse> tousLesUtilisateurs() {
        List<Utilisateur> allUtilisateurs = utilisateurService.getAllUtilisateurs();
        return (!allUtilisateurs.isEmpty()) ?
                utilisateursResponse(allUtilisateurs, null, HttpStatus.OK):
                utilisateursResponse(null, "Aucun Utilisateur dans la base de données", HttpStatus.OK);
    }

    @RequestMapping(value="/signup", method = RequestMethod.POST)
    public ResponseEntity<UtilisateurResponse> ajouterClient(@RequestBody Utilisateur u) {
        System.out.println(u.getEmail());
        String msg;
        HttpStatus httpStatus;
        if(utilisateurService.existByEmail(u.getEmail())) {
            msg="Email déjà utilisé !";
            httpStatus = HttpStatus.CONFLICT;
        }else {
            msg="Compte Crée avec succé";
            u.setPassword(bcryptEncoder.encode(u.getPassword()));
            utilisateurService.addUtilisateur(u);
            httpStatus = HttpStatus.CREATED;
        } 
        return utilisateursResponse(null, msg, httpStatus);
    }

    @RequestMapping(value="/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<UtilisateurResponse> supprimerUtilisateur(@PathVariable long id) {
        String msg;
        HttpStatus httpStatus;
        if( utilisateurService.existById(id) ) {
            utilisateurService.deleteUtilisateur(id);
            msg="compte Supprimé !";
            httpStatus = HttpStatus.OK;
        }else {
            msg="Cet utilisateur n'existe pas dans la base de données.";
            httpStatus = HttpStatus.NOT_FOUND;
        }

        return utilisateursResponse(null, msg, httpStatus);
    }

    @RequestMapping(value="/{id}", method = RequestMethod.PUT)
    public ResponseEntity<UtilisateurResponse> modifierUtilisateur(@PathVariable long id, @RequestBody Utilisateur u) {

        String msg;
        HttpStatus httpStatus;
        if( utilisateurService.existById(id) ) {
            utilisateurService.updateUtilisateur(id, u);
            msg="utilisateur modifié !";
            httpStatus = HttpStatus.OK;
        }else {
            msg="cet utilisateur n'existe pas dans la base de données.";
            httpStatus = HttpStatus.NOT_FOUND;
        }

        return utilisateursResponse(null, msg, httpStatus);
    }

    @RequestMapping(value="/{id}", method = RequestMethod.GET)
    public ResponseEntity<UtilisateurResponse> majUtilisateur(@PathVariable long id) {
        String msg=null;
        HttpStatus httpStatus;
        List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
        if( utilisateurService.existById(id) ) {
            httpStatus = HttpStatus.OK;
            utilisateurs.add(utilisateurService.getUtilisateur(id));
        }else {
            msg="cet utilisateur n'existe pas dans la base de données.";
            httpStatus = HttpStatus.NOT_FOUND;
        }

        return utilisateursResponse(utilisateurs, msg, httpStatus);
    }


    public static ResponseEntity<UtilisateurResponse> utilisateursResponse( List<Utilisateur> utilisateurs,
            String message, HttpStatus statusCode) {
            HttpHeaders headers = new HttpHeaders();
            int status = statusCode.value();
            headers.add("status", String.valueOf(statusCode));
            headers.add("message", message);
            return ResponseEntity.status(status).headers(headers)
                    .body(new UtilisateurResponse( message,  statusCode, utilisateurs));
        }

}

安全配置

package ma.netrent.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCrypt;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import ma.netrent.repository.UtilisateurRepository;

@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
@EnableJpaRepositories(basePackageClasses = UtilisateurRepository.class)
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;

    @Autowired
    private UserDetailsService jwtUserDetailsService;

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        // configure AuthenticationManager so that it knows from where to load
        // user for matching credentials
        // Use BCryptPasswordEncoder
        auth.userDetailsService(jwtUserDetailsService).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new PasswordEncoder() {

            @Override
            public String encode(CharSequence rawPassword) {
                return  BCrypt.hashpw(rawPassword.toString(), BCrypt.gensalt(4));
            }

            @Override
            public boolean matches(CharSequence rawPassword, String encodedPassword) {
                return BCrypt.checkpw(rawPassword.toString(), encodedPassword);
            }

        };
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        // We don't need CSRF for this example
        httpSecurity.csrf().disable()
                // dont authenticate this particular request
                .authorizeRequests()
                .antMatchers("/utilisateurs/signup","/login").permitAll()
                .antMatchers(HttpMethod.OPTIONS, "/**").permitAll()
                // all other requests need to be authenticated
                .anyRequest().authenticated()
                .and().
                // make sure we use stateless session; session won't be used to
                // store user's state.
                exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and().sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        // Add a filter to validate the tokens with every request
        httpSecurity.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

CORS过滤器：

package ma.netrent.config;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class MyCORSFilter implements Filter {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyCORSFilter.class);


@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;
    HttpServletResponse response = (HttpServletResponse) res;

    response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
   response.setHeader("Access-Control-Allow-Credentials", "true");
    response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
    //response.setHeader("Access-Control-Max-Age", "3600");
    //response.setHeader("Access-Control-Allow-Headers", " Content-Type, Accept, X-Requested-With, remember-me");
    response.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, Accept, X-Requested-With, remember-me");
     chain.doFilter(req, res);
}

@Override
public void init(FilterConfig filterConfig) {
    LOGGER.info("Filter initialized");
}

@Override
public void destroy() {
}

}

和我的pom.xml：


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.netrent</groupId>
    <artifactId>netRent415</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>netRent415</name>
    <description>plateforme communautaire gratuite de location de logements entre particuliers.</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>



        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.0.pr1</version>
        </dependency>

        <!-- 
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
         -->
         <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            </dependency>
         <!-- compiles the jsp pages -->
         <!--        
         <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>

         <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
         </dependency>
        --> 
            <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
            </dependency>

            <dependency>
                <groupId>org.junit</groupId>
                <artifactId>junit5-engine</artifactId>
                <version>5.0.0-ALPHA</version>
            </dependency>

            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.9.1</version>
            </dependency>

            <dependency>
                <groupId>com.paypal.sdk</groupId>
                <artifactId>rest-api-sdk</artifactId>
                <version>1.13.1</version>
            </dependency>
    </dependencies>



    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>5.2.4.Final</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

1 个答案:

答案 0 :(得分：0)

愚蠢的原因：我有2个setter的roles属性。超级哑巴，但可能会帮助某人。

相关问题
最新问题