Sørg for sikkerheten til Spring-applikasjonen din ved å utnytte de robuste funksjonene som tilbys av Spring Security-rammeverket.

Spring Security-rammeverket sikrer applikasjonen din gjennom autentisering og autorisasjon. I standardtilstanden sikrer Spring Security at hver HTTP-forespørselsbane (eller side) i applikasjonen din krever autentisering av en enkelt global bruker.

Dette rammeverket er også ekstremt fleksibelt. Den lar deg lage tilpassede sikkerhetsregler for hver HTTP-forespørselsbane i applikasjonen din, så vel som de forskjellige brukerne. Så du kan fjerne sikkerhetsbegrensningen på sider som ikke krever brukerautorisasjon (for eksempel en hjemmeside). Og angi rollene og autoritetene til spesifikke brukertyper.

Legger til Spring Security til applikasjonen din

Det er to måter å legge til Spring Security i applikasjonen din. Du kan enten velge det som en avhengighet når du genererer en ny Spring Boot-applikasjon bruker Spring initializr, eller legg den til i byggespesifikasjonsfilen i avhengighetsdelen etter generering av prosjektet.

instagram viewer

Hvis du valgte ett av Gradle-prosjektalternativene, er avhengighetsfilen bygge.gradle. Men hvis du valgte Maven, er den filen det pom.xml.

Din bygge.gradle filen skal inneholde følgende avhengighet:

dependencies {
 implementation 'org.springframework.boot: spring-boot-starter-security'
}

Mens din pom.xml filen skal inneholde følgende avhengighet:


org.springframework.boot
spring-boot-starter-security

Eksempelapplikasjonen som brukes i artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Bruker Spring Security

Når du legger til Spring Security-avhengigheten til applikasjonen din, kan du begynne å bruke rammeverket umiddelbart. Bare utfør applikasjonen din og naviger deretter til Spring Boots hjemmeside (eller hvilken som helst side i applikasjonen din). Eksempelapplikasjonen bruker følgende innledende kontroller for å kontrollere Spring Boots standard lokal vert: 8080 be om:

package com.springSecurityDemo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
publicclassWebController{

@GetMapping("/")
public String home(){
return"Welcome!";
 }
}

Når du kjører applikasjonen din etter å ha lagt til enkeltkontrollerklassen ovenfor, genereres følgende innledende visning:

Du vil legge merke til at den automatisk leder deg til localhost: 8080/logg inn side, og den gjør dette før den lar deg få tilgang til andre sider i applikasjonen. På dette stadiet må du oppgi standard brukernavn (som er brukeren) og det automatisk genererte passordet (som du finner i konsollen). Konsollen vil generere en linje som følgende:

Using generated security password: c4070465-4c65-4e72-8c3f-3800e631ba81

Hver gang du starter programmet på nytt vil det automatisk genererte passordet endres, men brukernavnet forblir det samme. Hvis du skriver inn standard brukernavn og passord, vil du lede deg til riktig visning i applikasjonen.

Tilpassing av vårsikkerhet

For å tilpasse applikasjonssikkerheten din, må du overstyre Spring Securitys standardkonfigurasjon. Men før det (forutsatt at du allerede har Spring Web) trenger du flere andre avhengigheter for denne eksempelapplikasjonen:

  • Spring Data JPA
  • MySQL JDBC-driver
  • Timianblad
  • Lombok

Thymeleaf-rammeverket vil generere forskjellige visninger. Lombok vil bidra til å redusere koden i objektklassene dine. JPA-biblioteket og MySQL-driveren lar deg bruke en MySQL-database med applikasjonen, men du har muligheten til å bruke hvilken som helst database du er komfortabel med. Å bruke en database betyr å konfigurere applikasjoner.egenskaper fil under ressursfilen.

spring.datasource.url=jdbc: mysql://${MYSQL_HOST: localhost}:3306/spring_security
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update

Konfigurasjonskoden ovenfor lar deg koble til en lokal MySQL-database kalt vår_sikkerhet, med brukernavn på rot, og passord (1234). Du må oppdatere disse dataene for å matche databasenavnet og påloggingsinformasjonen din.

Etter å ha lagt til dine ekstra avhengigheter og opprettet databasen din, kan du begynne å bestemme hvor mange visninger applikasjonen din skal ha. Du må også vite hvordan sikkerheten for hver side ser ut. Vår eksempelapplikasjon har 6 visninger:

  • Hjemmeside
  • Registreringsside
  • Påloggingsside
  • Logg ut side
  • Brukerside
  • Feilside

Den eneste visningen som vil kreve brukerautorisasjon er brukersiden. Denne siden er kun tilgjengelig for brukere som først registrerer seg og deretter logger på applikasjonen. I tillegg til Spring Boots standardpakke, må du opprette fire andre pakker i applikasjonen din.

Registreringskontrollørklassen

Kontrollerpakken vil inneholde klassene som håndterer HTTP-forespørsler. Avhengig av funksjonen til en side kan du vanligvis gruppere hver HTTP-forespørsel i én kontrollerklasse, slik tilfellet er med WebController klasse. Imidlertid har registreringsvisningen flere unike funksjoner, og kan derfor ha en privat kontrollerklasse:

@Controller
@RequestMapping("/register")
publicclassRegistrationController{
private UserRepository userRepo;
private PasswordEncoder passwordEncoder;

publicRegistrationController( UserRepository userRepo, PasswordEncoder passwordEncoder){
this.userRepo = userRepo;
this.passwordEncoder = passwordEncoder;
 }
@GetMapping
public String registerForm(){
return"registration";
 }
@PostMapping
public String processRegistration(RegistrationForm form){
 userRepo.save(form.toUser(passwordEncoder));
return"redirect:/login";
 }
}

De Registreringskontroller klasse er en inngangsport til sikkerhetsaspektet av applikasjonen din. De @RequestMapping merknad spesifiserer typen forespørsel denne kontrolleren vil håndtere (forespørsler om localhost: 8080/register).

De @GetMapping merknad indikerer ganske enkelt at hvis søknaden mottar en forespørsel om /register, den registreringsskjema() metoden skal håndtere den forespørselen ved å returnere registreringsvisningen.

Etter at en besøkende har klikket på registrer-knappen, deretter @PostMapping annotering kommer inn. De prosessregistrering() metoden lar deg legge inn brukerdataene den får fra Registreringsskjema klasse til databasen ved å bruke UserRepository klasse. Men før den lagrer disse dataene, prosessregistrering() metoden krypterer brukerens passord ved hjelp av VårensPasswordEncoder grensesnitt.

Opprette nye sikkerhetskonfigurasjoner

Siden Spring 3.1 kan utviklere nå lage konfigurasjoner for Spring Security ved å bruke Java, som betyr klasser i stedet for XML. Det viktigste som disse konfigurasjonsklassene krever er @Konfigurasjon merknad.

@Configuration
publicclassSecurityConfiguration{
}

De @Konfigurasjon merknad indikerer at klassen ovenfor er en konfigurasjonsklasse. Disse klassene gir bønner til Vårsøknadskontekst, som er en beholder som Spring bruker til å lage og administrere de forskjellige komponentene (eller bønnene) i en applikasjon. Den første bønnen i Sikkerhetskonfigurasjon klasse er passordEncoder bønne.

@Bean
public PasswordEncoder passwordEncoder(){
 returnnew BCryptPasswordEncoder();
}

De Registreringskontroller klasse bruker passordEncoder bean for å kode nye passord før du lagrer dem i databasen. En annen viktig bønne du må legge til Sikkerhetskonfigurasjon klasse er userDetailsService bønne.

@Bean
public UserDetailsService userDetailsService(UserRepository userRepo){
 return username -> {
 Customer customer = userRepo.findByUsername(username);
if (customer != null)
return customer;
thrownew UsernameNotFoundException("Customer '" + username + "' not found");
 };
}

De userDetailsService bean ansetter VårsikkerhetUserDetailsService grensesnitt for å hente en brukers brukernavn og passord for autentisering, under en kundes påloggingsøkt. Så snart en kunde klikker på påloggingsknappen i påloggingsvisningen, vil userDetailsService bønne springer i bevegelse.

Gjennom UserRepository, den userDetailsService bean får tilgang til alle eksisterende kunder i databasen. Dette grensesnittet bruker deretter UserRepository for å finne en bruker med et matchende brukernavn og passord, returnerer deretter alle denne kundens attributter som et objekt.

Hvis det returnerte objektet er en kunde, får denne kunden tilgang til applikasjonen. Ellers vil siden automatisk oppdateres slik at brukeren kan skrive inn gyldig legitimasjon.

Filterkjeden

Vårens sikkerhetSecurityFilterChain grensesnittet er nyttig applikasjonsprogrammeringsgrensesnitt (API) som spiller en viktig rolle i Spring Security-konfigurasjonen. Dette grensesnittet fungerer med VårsikkerhetHttpSikkerhet klasse for å lage en filterkjede for spesifikke HTTP-forespørsler.

@Bean
public SecurityFilterChain filterChain(HttpSecurity http)throws Exception {
 http
 .authorizeHttpRequests((authorize) -> authorize
 .requestMatchers("/user").hasAuthority("USER").anyRequest().permitAll())
 .formLogin(formLogin -> formLogin
 .loginPage("/login").defaultSuccessUrl("/user", true))
 .logout(logout -> logout.logoutSuccessUrl("/logout")); 
 return http.build();
}

De filterkjede bønne ovenfor bruker SecurityFilterChain API for å utføre flere oppgaver. For det første bruker den HttpSikkerhet klasse for å diktere at bare brukere som har rollen som BRUKER kan få tilgang lokal vert: 8080/bruker. Og en bruker får denne rollen etter registrering, takket være getAuthorities() metode som hvert nytt kundeobjekt implementerer.

@Override
public Collection extends="extends" grantedauthority="grantedauthority"?> getAuthorities() {
 return Arrays.asList(new SimpleGrantedAuthority("USER"));
}

Filterkjeden tillater uautentisert tilgang til alle andre URL-er i applikasjonen. De filterkjede bean bruker også formLogin() og Logg ut() metoder for HttpSikkerhet klasseobjekt.

Disse metodene lar deg automatisk lede en bruker til bestemte sider etter at de har utført en oppgave. Så en bruker som skriver inn riktig legitimasjon og klikker på påloggingsknappen på /login siden blir automatisk sendt til /user side.

Til slutt, den filterkjede bean bygger og returnerer filterkjeden, som lar autoriserte brukere få tilgang til applikasjonen. Alle tre bønner i Sikkerhetskonfigurasjon klasse arbeide sammen for å sikre søknaden din.

Imidlertid filterkjede bean spiller den viktigste rollen som å diktere autorisasjonsnivået for hver HTTP-forespørsel. Når du begynner å legge til flere sider i applikasjonen din, kan du bruke filterkjede bean for å angi sikkerhetsnivået.

Den største fordelen med Spring Security

Spring Security gir deg full kontroll over ikke bare hvem som har tilgang til applikasjonen din, men også hvilken type tilgang en bruker kan ha (gjennom funksjonen for brukerroller). Tilgangskontroll er en av de viktigste aspektene ved enhver applikasjon. Å gi generelle brukere ufiltrert tilgang til applikasjonen din på grunn av begrensede adgangskontrollbarrierer kan vise seg å være en kostbar feil.