Säkerställ säkerheten för din Spring-applikation genom att utnyttja de robusta funktionerna som erbjuds av Spring Security-ramverket.

Spring Security-ramverket säkrar din applikation genom autentisering och auktorisering. I standardtillståndet säkerställer Spring Security att varje HTTP-begäransökväg (eller sida) i din applikation kräver autentisering av en enda global användare.

Detta ramverk är också extremt flexibelt. Det låter dig skapa anpassade säkerhetsregler för varje HTTP-förfrågningsväg i din applikation, såväl som för de olika användarna. Så du kan ta bort säkerhetsbegränsningen på sidor som inte kräver användarbehörighet (som en hemsida). Och ställ in roller och behörigheter för specifika användartyper.

Lägger till Spring Security till din applikation

Det finns två sätt att lägga till Spring Security i din applikation. Du kan antingen välja det som ett beroende när du genererar en ny Spring Boot-applikation med Spring initializr, eller lägg till den i din byggspecifikationsfil i beroendesektionen efter att du har skapat ditt projekt.

instagram viewer

Om du valde ett av Gradle-projektalternativen är beroendefilen det bygga.gradle. Men om du valde Maven, är den filen det pom.xml.

Din bygga.gradle filen bör innehålla följande beroende:

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

Medan ditt pom.xml filen bör innehålla följande beroende:


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

Exempelapplikationen som används i artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Använder Spring Security

När du har lagt till Spring Security-beroendet i din applikation kan du börja använda ramverket omedelbart. Kör helt enkelt din applikation och navigera sedan till Spring Boots hemsida (eller valfri sida i din applikation). Exempelapplikationen använder följande initiala kontroller för att styra Spring Boots standard lokal värd: 8080 begäran:

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!";
 }
}

Om du kör din applikation efter att ha lagt till den enskilda styrenheten ovan genereras följande initiala vy:

Du kommer att märka att den automatiskt leder dig till localhost: 8080/login sida, och den gör detta innan den ger dig tillgång till någon annan sida i programmet. I det här skedet måste du ange standardanvändarnamnet (som är användaren) och det automatiskt genererade lösenordet (som du hittar i konsolen). Konsolen kommer att generera en rad som följande:

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

Varje gång du startar om din applikation kommer det automatiskt genererade lösenordet att ändras, men användarnamnet förblir detsamma. Om du anger standardanvändarnamnet och lösenordet kommer du till lämplig vy i din applikation.

Anpassa vårsäkerhet

För att anpassa din applikationssäkerhet måste du åsidosätta Spring Securitys standardkonfiguration. Men innan det (förutsatt att du redan har Spring Web) behöver du flera andra beroenden för denna exempelapplikation:

  • Spring Data JPA
  • MySQL JDBC-drivrutin
  • Timjanblad
  • Lombok

Thymeleaf-ramverket kommer att generera olika vyer. Lombok hjälper till att minska koden i dina objektklasser. JPA-biblioteket och MySQL-drivrutinen gör att du kan använda en MySQL-databas med programmet, men du har möjlighet att använda vilken databas som helst som du är bekväm med. Att använda en databas innebär att konfigurera applikationer.egenskaper filen under resursfilen.

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

Konfigurationskoden ovan låter dig ansluta till en lokal MySQL-databas som heter vår_säkerhet, med ett användarnamn på rot, och lösenord (1234). Du måste uppdatera dessa data så att de matchar ditt databasnamn och dina uppgifter.

När du har lagt till dina ytterligare beroenden och skapat din databas kan du börja bestämma hur många visningar din applikation ska ha. Du måste också veta hur säkerheten för varje sida ser ut. Vår exempelapplikation har 6 vyer:

  • Hemsida
  • Registreringssida
  • Login sida
  • Logga ut sidan
  • Användarsida
  • Felsida

Den enda vy som kräver användarbehörighet är användarsidan. Den här sidan är endast tillgänglig för användare som först registrerar sig och sedan loggar in på applikationen. Utöver Spring Boots standardpaket måste du skapa fyra andra paket i din applikation.

Klassen Registration Controller

Kontrollpaketet kommer att innehålla klasserna som hanterar HTTP-förfrågningar. Beroende på funktionen hos en sida kan du vanligtvis gruppera varje HTTP-begäran i en kontrollklass, vilket är fallet med WebController klass. Registreringsvyn har dock mer unika funktioner, så den kan ha en privat kontrollklass:

@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 RegistrationController klass är en inkörsport till säkerhetsaspekten av din applikation. De @RequestMapping annotation anger vilken typ av begäran som denna styrenhet kommer att hantera (förfrågningar till localhost: 8080/register).

De @GetMapping anteckning anger helt enkelt att om ansökan får en begäran om /register, den anmälningsblankett() metod ska hantera den begäran genom att returnera registreringsvyn.

När en besökare klickar på registreringsknappen, sedan @PostMapping anteckning kommer in i bilden. De processRegistration() metoden låter dig lägga upp användardata som den får från Anmälningsblankett klass till databasen med hjälp av UserRepository klass. Men innan den lagrar denna data, processRegistration() metoden krypterar användarens lösenord med VårensPasswordEncoder gränssnitt.

Skapa nya säkerhetskonfigurationer

Sedan Spring 3.1 kan utvecklare nu skapa konfigurationer för Spring Security med Java, vilket innebär klasser istället för XML. Det viktigaste som dessa konfigurationsklasser kräver är @Konfiguration anteckning.

@Configuration
publicclassSecurityConfiguration{
}

De @Konfiguration anteckning indikerar att klassen ovan är en konfigurationsklass. Dessa klasser ger bönor till Våransökningssammanhang, som är en behållare som Spring använder för att skapa och hantera de olika komponenterna (eller bönorna) i en applikation. Den första bönan i Säkerhetskonfiguration klass är passwordEncoder böna.

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

De RegistrationController klass använder passwordEncoder bean för att koda nya lösenord innan du sparar dem i databasen. En annan viktig böna som du måste lägga till Säkerhetskonfiguration klass är userDetailsService böna.

@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 sysselsätter Vårens säkerhetUserDetailsService gränssnitt för att hämta en användares användarnamn och lösenord för autentisering, under en kunds inloggningssession. Så snart en kund klickar på inloggningsknappen i inloggningsvyn, visas userDetailsService bönor kommer i rörelse.

Genom UserRepository, den userDetailsService bean får tillgång till alla befintliga kunder i databasen. Detta gränssnitt använder sedan UserRepository för att hitta en användare med ett matchande användarnamn och lösenord, returnerar sedan alla denna kunds attribut som ett objekt.

Om det returnerade objektet är en kund får denna kund tillgång till applikationen. Annars kommer sidan automatiskt att uppdateras så att användaren kan ange giltiga referenser.

Filterkedjan

Vårens säkerhetSecurityFilterChain gränssnittet är användbart applikationsprogrammeringsgränssnitt (API) som spelar en viktig roll i Spring Security-konfigurationen. Detta gränssnitt fungerar med Vårens säkerhetHttpSäkerhet klass för att skapa en filterkedja för specifika HTTP-förfrågningar.

@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 filterkedja bean ovan använder SecurityFilterChain API för att utföra flera uppgifter. För det första använder den HttpSäkerhet klass för att diktera att endast användare som har rollen som ANVÄNDARE kan komma åt localhost: 8080/användare. Och en användare får denna roll efter registrering, tack vare getAuthorities() metod som varje nytt kundobjekt implementerar.

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

Filterkedjan tillåter oautentiserad åtkomst till alla andra webbadresser i applikationen. De filterkedja bean använder också formLogin() och logga ut() metoder för HttpSäkerhet klassobjekt.

Med dessa metoder kan du automatiskt dirigera en användare till specifika sidor efter att de har utfört en uppgift. Så, en användare som anger rätt referenser och klickar på inloggningsknappen på /login sidan kommer automatiskt att dirigeras till /user sida.

Slutligen, den filterkedja bean bygger och returnerar filterkedjan, vilket tillåter behöriga användare att komma åt programmet. Alla tre bönor i Säkerhetskonfiguration klass arbeta tillsammans för att säkra din ansökan.

Men den filterkedja bean spelar den mer betydande rollen att diktera behörighetsnivån för varje HTTP-begäran. När du börjar lägga till fler sidor i din applikation kan du använda filterkedja bean för att ställa in deras säkerhetsnivå.

Den stora fördelen med Spring Security

Spring Security ger dig fullständig kontroll över inte bara vem som har åtkomst till din applikation, utan också vilken typ av åtkomst en användare kan ha (genom funktionen för användarroller). Åtkomstkontroll är en av de enskilt viktigaste aspekterna av alla applikationer. Att ge allmänna användare ofiltrerad åtkomst till din applikation på grund av begränsade hinder för åtkomstkontroll kan visa sig vara ett kostsamt misstag.