Validering i Spring Boot
1. Oversigt
Når det kommer til validering af brugerinput, giver Spring Boot stærk støtte til denne almindelige, men alligevel kritiske opgave lige ud af kassen.
Selvom Spring Boot understøtter problemfri integration med brugerdefinerede validatorer, de facto-standarden til udførelse af validering er Hibernate Validator, Bean Validation framework's reference implementering.
I denne vejledning vi ser på, hvordan vi validerer domæneobjekter i Spring Boot.
2. Maven-afhængighederne
I dette tilfælde lærer vi, hvordan vi validerer domæneobjekter i Spring Boot ved at opbygge en grundlæggende REST-controller.
Controlleren vil først tage et domæneobjekt, derefter validere det med Hibernate Validator, og til sidst vil det fortsætte det til en H2-database i hukommelsen.
Projektets afhængighed er ret standard:
org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-data-jpa com.h2database h2 1.4.197 runtime Som vist ovenfor inkluderede vi spring-boot-starter-web i vores pom.xml fil, fordi vi har brug for den til oprettelse af REST-controlleren. Lad os desuden sørge for at kontrollere de nyeste versioner af spring-boot-starter-jpa og H2-databasen på Maven Central.
Fra og med Boot 2.3 skal vi også eksplicit tilføje spring-boot-starter-validering afhængighed:
org.springframework.boot spring-boot-starter-validering 3. En simpel domæneklasse
Da vores projekts afhængigheder allerede er på plads, skal vi derefter definere et eksempel på en JPA-enhedsklasse, hvis rolle udelukkende er modellering af brugere.
Lad os se på denne klasse:
@Entity offentlig klasse bruger {@Id @GeneratedValue (strategi = GenerationType.AUTO) privat lang id; @NotBlank (message = "Navn er obligatorisk") privat strengnavn; @NotBlank (message = "E-mail er obligatorisk") privat E-mail med streng; // standardkonstruktører / settere / getters / toString}Implementeringen af vores Bruger enhedsklasse er ret anæmisk, men det viser i en nøddeskal, hvordan man bruger Bean Validation's begrænsninger til at begrænse navn og e-mail felter.
For enkelheds skyld begrænsede vi målfelterne ved kun at bruge @NotBlank begrænsning. Vi specificerede også fejlmeddelelserne med besked attribut.
Derfor, når Spring Boot validerer klasseinstansen, de begrænsede felter må ikke være nul, og deres trimmede længde skal være større end nul.
Derudover giver Bean Validation mange andre praktiske begrænsninger udover @NotBlank. Dette giver os mulighed for at anvende og kombinere forskellige valideringsregler til de begrænsede klasser. For yderligere information, se venligst de officielle dokumentation for validering af bønner.
Da vi bruger Spring Data JPA til at gemme brugere i H2-databasen i hukommelsen, er vi også nødt til at definere en simpel lagergrænseflade for at have grundlæggende CRUD-funktionalitet på Bruger genstande:
@Repository offentlig grænseflade UserRepository udvider CrudRepository {}4. Implementering af en REST-controller
Selvfølgelig skal vi implementere et lag, der giver os mulighed for at få de værdier, der er tildelt vores Bruger objektets begrænsede felter.
Derfor kan vi validere dem og udføre et par yderligere opgaver afhængigt af valideringsresultaterne.
Spring Boot gør denne tilsyneladende komplekse proces virkelig enkel gennem implementeringen af en REST-controller.
Lad os se på implementeringen af REST-controller:
@RestController offentlig klasse UserController {@PostMapping ("/ brugere") ResponseEntity addUser (@Valid @RequestBody brugerbruger) {// vedvarende bruger returnerer ResponseEntity.ok ("Brugeren er gyldig"); } // standardkonstruktører / andre metoder} I en Spring REST - sammenhæng implementeringen af tilføj bruger () metoden er ret standard.
Selvfølgelig er den mest relevante del brugen af @Gyldig kommentar.
Når Spring Boot finder et argument kommenteret med @Gyldig, den bootstrapper automatisk standard-implementeringen af JSR 380 - Hibernate Validator - og validerer argumentet.
Når målargumentet ikke godkender valideringen, kaster Spring Boot a MethodArgumentNotValidException undtagelse.
5. Den @ExceptionHandler Kommentar
Selvom det er virkelig praktisk at have Spring Boot til at validere Bruger genstand videregivet til tilføj bruger () metode automatisk, er den manglende facet i denne proces, hvordan vi behandler valideringsresultaterne.
Det @ExceptionHandler kommentar giver os mulighed for at håndtere bestemte typer undtagelser via en enkelt metode.
Derfor kan vi bruge det til behandling af valideringsfejl:
@ResponseStatus (HttpStatus.BAD_REQUEST) @ExceptionHandler (MethodArgumentNotValidException.class) public Map handleValidationExceptions (MethodArgumentNotValidException ex) {Kortfejl = nyt HashMap (); ex.getBindingResult (). getAllErrors (). forEach ((error) -> {String fieldName = ((FieldError) error) .getField (); String errorMessage = error.getDefaultMessage (); errors.put (fieldName, errorMessage); }); returneringsfejl }Vi specificerede MethodArgumentNotValidException undtagelse som den undtagelse, der skal håndteres. Derfor kalder Spring Boot denne metode når det specificerede Bruger objektet er ugyldigt.
Metoden gemmer navnet og postvalideringsfejlmeddelelsen for hvert ugyldigt felt i en Kort. Derefter sender den Kort tilbage til klienten som en JSON-repræsentation til videre behandling.
Kort sagt giver REST-controlleren os mulighed for nemt at behandle anmodninger til forskellige slutpunkter, validere Bruger objekter, og send svarene i JSON-format.
Designet er fleksibelt nok til at håndtere controllersvar gennem flere webniveauer, lige fra skabelonmotorer som Thymeleaf, til en fuldt udstyret JavaScript-ramme som Angular.
6. Test af REST-controlleren
Vi kan nemt teste funktionaliteten af vores REST-controller med en integrationstest.
Lad os starte med at spotte / autoledning af UserRepository interface implementering sammen med UserController eksempel, og en MockMvc objekt:
@RunWith (SpringRunner.class) @WebMvcTest @ AutoConfigureMockMvc public class UserControllerIntegrationTest {@MockBean private UserRepository userRepository; @Autowired UserController userController; @Autowired privat MockMvc mockMvc; // ...} Da vi kun tester weblaget, bruger vi @WebMvcTest kommentar. Det giver os mulighed for let at teste anmodninger og svar ved hjælp af det sæt statiske metoder, der er implementeret af MockMvcRequestBuilders og MockMvcResultMatchers klasser.
Lad os nu teste tilføj bruger () metode med en gyldig og en ugyldig Bruger genstand sendt i anmodningsorganet:
@Test offentlig ugyldigt nårPostRequestToUsersAndValidUser_thenCorrectResponse () kaster undtagelse {MediaType textPlainUtf8 = ny MediaType (MediaType.TEXT_PLAIN, Charset.forName ("UTF-8")); String user = "{\" name \ ": \" bob \ ", \" email \ ": \" [email protected] \ "}"; mockMvc.perform (MockMvcRequestBuilders.post ("/ brugere") .content (bruger) .contentType (MediaType.APPLICATION_JSON_UTF8)). og Expect (MockMvcResultMatchers.status (). isOk ()). og Expect (MockMvcResultat) textPlainUtf8)); } @Test offentlig ugyldigt nårPostRequestToUsersAndInValidUser_thenCorrectResponse () kaster undtagelse {String user = "{\" name \ ": \" \ ", \" email \ ": \" [email protected] \ "}"; mockMvc.perform (MockMvcRequestBuilders.post ("/ brugere") .content (bruger) .contentType (MediaType.APPLICATION_JSON_UTF8)) .ogExpect (MockMvcResultMatchers.status (). isBadRequest ()) .andExpect (MockMat. ", Is.is (" Navn er obligatorisk "))). Og Expect (MockMvcResultMatchers.content () .contentType (MediaType.APPLICATION_JSON_UTF8)); }} Derudover kan vi teste REST controller API ved hjælp af en gratis API-applikation til test af livscyklus, såsom postbud.
7. Kørsel af prøveapplikationen
Endelig kan vi køre vores eksempelprojekt med en standard hoved () metode:
@SpringBootApplication public class Application {public static void main (String [] args) {SpringApplication.run (Application.class, args); } @Bean offentlig CommandLineRunner-kørsel (UserRepository userRepository) kaster Undtagelse {return (String [] args) -> {User user1 = new User ("Bob", "[email protected]"); Bruger bruger2 = ny bruger ("Jenny", "[email protected]"); userRepository.save (user1); userRepository.save (user2); userRepository.findAll (). forEach (System.out :: println); }; }} Som forventet skulle vi se et par Bruger genstande udskrevet i konsollen.
En POST-anmodning til // localhost: 8080 / brugere slutpunkt med et gyldigt Bruger objektet returnerer Snor “Brugeren er gyldig”.
Ligeledes en POST-anmodning med en Bruger objekt uden navn og e-mail værdier returnerer følgende svar:
{"name": "Navn er obligatorisk", "email": "E-mail er obligatorisk"}8. Konklusion
I denne artikel vi lærte det grundlæggende ved at udføre validering i Spring Boot.
Som sædvanligt er alle eksemplerne vist i denne artikel tilgængelige på GitHub.
