간단한 Spring Boot Restful API Sample Project 만들어보기 #1. Spring Security 설정 + CustomFilter 만들기

 

 

✔ 샘플 프로젝트를 만들기로 결정한 이유 

-> 시간이 조금 여유로운 요즘, 곧 개발 들어가기 전에 간단하게 샘플 프로젝트 만들면서 감 잡고? 있고 싶어서! 

그리고 만든 김에 오랜만에 티스토리에 글도 많이 올리면서 진행할 예정이다. 

 

 

✔ 개발 환경 

- Jdk 17 

- SpringBoot 3.2.3 

- Spring Security

- JPA + H2 (샘플 프로젝트라 그냥 간단히 구현할 수 있는 h2 사용할 예정이다.) 

- Spring REST Docs + mockMvc  (REST Docs 를 이용해서 api 문서 자동화할 예정이다.) 

 

 

✔ 지금 생각하는 기능 

- 로그인 및 회원가입 

- 게시글 작성, 조회, 수정, 삭제 

- 댓글 작성, 조회, 수정, 삭제 

( + 사용자 관리? )

이렇게 생각하고 있다. 우선 기초적인 것들 먼저 구현하고, 하면서 계속 추가 추가 하는게 내 바람?이다 ㅎㅎ 

 

✔  시큐리티 동작 방식 

1. 사용자가 로그인 페이지에 접근:
   • 사용자가 애플리케이션의 로그인 페이지로 이동하거나, 보호된 리소스에 접근하여 로그인이 필요한 경우 로그인 페이지로 이동된다.
2. 사용자가 자격 증명 제공:
   • 사용자는 아이디와 비밀번호 등의 자격 증명을 로그인 폼을 통해 제공한다.
3. AuthenticationFilter 실행:
   • 스프링 시큐리티의 AuthenticationFilter가 동작하면서 사용자가 제공한 자격 증명을 수집한다.
4. AuthenticationManager 검증:
   • AuthenticationFilter는 수집한 자격 증명을 AuthenticationManager에 전달한다.
   • AuthenticationManager는 등록된 AuthenticationProvider들을 순회하며 실제 인증 작업을 수행한다.
5. AuthenticationProvider 동작:
   • 각 AuthenticationProvider는 특정 인증 유형(예: 사용자 이름과 비밀번호)에 대한 처리를 담당한다.
   • 예를 들어, DaoAuthenticationProvider는 UserDetailsService를 통해 사용자 정보를 가져와 비밀번호를 확인하여 사용자를 인증한다.
6. 인증 성공 또는 실패:
   • 만약 인증이 성공하면, AuthenticationManager는 인증된 사용자를 나타내는 Authentication 객체를 생성한다.
   • 인증이 실패하면 예외가 발생하거나 null이 반환된다.
7. SecurityContextHolder에 Authentication 설정:
   • 성공적으로 인증된 경우, SecurityContextHolder에 현재 사용자의 Authentication 객체가 저장됩니다. 이 정보는 애플리케이션에서 언제든지 사용할 수 있다.
8. 인증 이벤트 발생:
   • 인증이 성공하면 AuthenticationSuccessEvent가 발생합니다. 이를 통해 커스텀 로그 및 이벤트 핸들링이 가능하다.
9. 인증된 사용자 리다이렉트 또는 이동:
   • 일반적으로 로그인이 성공하면 보호된 리소스로 리다이렉트하거나, 설정된 성공 URL로 이동한다.

 

 

0️⃣ build.gradle 

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.3'
    id 'io.spring.dependency-management' version '1.1.4'
    id 'org.asciidoctor.jvm.convert' version '3.3.2'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
    sourceCompatibility = '17'
}

configurations {
    compileOnly {
       extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

ext {
    set('snippetsDir', file("build/generated-snippets"))
}

dependencies {
    // web, lombok, devtools
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'

    // security
    implementation "org.springframework.boot:spring-boot-starter-security"
    testImplementation 'org.springframework.security:spring-security-test'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // jwt
    implementation 'io.jsonwebtoken:jjwt-api:0.12.5'
    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.5'
    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.5'

    // JDBC Session
    //implementation "org.springframework.session:spring-session-jdbc"

    // 비밀번호 암호화 라이브러리
    // https://mvnrepository.com/artifact/org.springframework.security/spring-security-crypto
    implementation 'org.springframework.security:spring-security-crypto'
    // https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on
    implementation 'org.bouncycastle:bcprov-jdk15on:1.70'

    // jpa, h2
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.h2database:h2'

    // test, restdocs
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'
}

tasks.named('test') {
    outputs.dir snippetsDir
    useJUnitPlatform()
}

tasks.named('asciidoctor') {
    inputs.dir snippetsDir
    dependsOn test
}

tasks.named('asciidoctor') 이런 모르는 설정들은 Spring REST Docs 관련 설정들이니 일단 그러려니 하고 넘어간다. 

 

 

1️⃣ Spring Security 설정 

스프링 시큐리티 의존성 추가해주고, 이제 제일 먼저 Spring Security 설정을 해줄 것이다. 

 

SecurityConfig 

package com.example.restful.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
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.WebSecurityCustomizer;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.crypto.scrypt.SCryptPasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import com.example.restful.api.repository.MemberRepository;
import com.example.restful.security.CustomUserDetailService;
import com.example.restful.security.filter.EmailPasswordAuthFiler;
import com.example.restful.security.handler.LoginFailHandler;
import com.example.restful.security.handler.LoginSuccessHandler;
import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;


@Slf4j
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig
{
    
    @Value("${custom.static.url}")
    private String[] staticUrlArray;
    
    @Value("${custom.permit.url}")
    private String[] permitUrlArray;
    
    private final ObjectMapper objectMapper;
    
    private final MemberRepository memberRepository;
    
    @Bean
    public WebSecurityCustomizer webSecurityCustomizer()
    {
       return web -> web.ignoring().requestMatchers(staticUrlArray)
             .requestMatchers(permitUrlArray)
             .requestMatchers(PathRequest.toH2Console());
    }
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception
    {
       return httpSecurity
             .csrf(AbstractHttpConfigurer::disable)
             .authorizeHttpRequests(
                   authorize ->
                         authorize.anyRequest().permitAll()
             )
             .addFilterBefore(emailPasswordAuthFiler(), UsernamePasswordAuthenticationFilter.class)
             .build();
    }
    
    @Bean
    public EmailPasswordAuthFiler emailPasswordAuthFiler()
    {
       EmailPasswordAuthFiler filter = new EmailPasswordAuthFiler("/auth/login", objectMapper);
       filter.setAuthenticationManager(authenticationManager());
       filter.setAuthenticationSuccessHandler(new LoginSuccessHandler(objectMapper));
       filter.setAuthenticationFailureHandler(new LoginFailHandler(objectMapper));
       
       
       return filter;
    }
    
    @Bean
    public AuthenticationManager authenticationManager()
    {
       DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
       provider.setUserDetailsService(new CustomUserDetailService(memberRepository));
       provider.setPasswordEncoder(passwordEncoder());
       
       return new ProviderManager(provider);
    }
    
    @Bean
    public PasswordEncoder passwordEncoder()
    {
       return new SCryptPasswordEncoder(16, 8, 1, 32, 64);
    }

}

-> 전체코드이고 밑에서 하나하나 뜯어볼 예정이다. 

 

우선 가장 기본적으로

@Slf4j
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig
{

-> @EnableWebSecurity @Configuration 어노테이션을 붙여야 한다. 그래야 시큐리티 설정 파일이란 걸 인식한다 ! 

 

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity httpSecurity) throws Exception
{
    return httpSecurity
          .csrf(AbstractHttpConfigurer::disable)
          .authorizeHttpRequests(
                authorize ->
                      authorize.anyRequest().permitAll()
          )
          .addFilterBefore(emailPasswordAuthFiler(), UsernamePasswordAuthenticationFilter.class)
          .build();
}

-> 스프링 시큐리티를 너~~~무 오랜만에 다시 해보는데 @Bean으로 등록해서 사용하며, 람다식으로 변경됐다. 

(이걸..이제서야 다시 해보다니....) 

 

SecurityFilterChain 은 Spring Security에서 사용되는 필터 체인을 정의하는 인터페이스이다. 
이 인터페이스는 여러 보안 필터를 조합해서 하나의 필터체인을 만들 수 있다. 
이 필터 체인을 활용해서 다양한 보안 기능을 적용하는데 사용할 수 있다. 
-> 인증, 권한 부여, 세션 관리, CSRF 방어 등이 있다. 

 

CRSF 는 RESTful api 에서는 disable 했다. 

🔽 이유에 대해서는 ChatGPT의 도움을 얻었다. 👍👍

Spring Security에서 RESTful API를 개발할 때 CSRF(Cross-Site Request Forgery) 보호를 해제(disable)하는 경우가 있습니다. RESTful API는 주로 stateless하며, CSRF는 주로 웹 애플리케이션에서 발생하는 공격을 방어하기 위한 것입니다. 그러므로 RESTful API에서 CSRF 보호를 해제하는 이유에 대해 살펴보겠습니다:

1. Stateless Nature of RESTful APIs:
RESTful API는 주로 stateless하게 설계되어 있습니다. 각 요청은 이전 요청과 독립적이며, 서버는 클라이언트의 상태를 기억하지 않습니다.
CSRF 공격은 특정 사용자의 인증 정보가 악의적인 공격자에 의해 이용되는 공격으로, 주로 웹 애플리케이션에서 세션을 이용한 공격으로 발생합니다. Stateless한 API에서는 이러한 세션 공격이 덜 적용되므로 CSRF를 사용할 필요가 줄어듭니다.

2. CSRF는 주로 웹 페이지에 적용됨:
CSRF는 주로 웹 페이지 간 요청을 통한 공격을 방어하기 위한 것입니다. RESTful API는 일반적으로 브라우저에서 직접 요청되는 것이 아니라, 프로그래밍 방식으로 호출되기 때문에 브라우저에서의 CSRF 공격 가능성이 적습니다.

3. 인증 방법의 차이:
RESTful API는 주로 토큰 기반의 인증 방식을 사용합니다. 토큰 기반의 인증은 요청마다 토큰을 포함하여 전달되어야 하며, 이는 일반적으로 브라우저의 쿠키와는 다릅니다. CSRF는 쿠키를 통한 세션 공격을 방어하기 위한 것이므로, 토큰 기반의 인증에서는 이에 민감하지 않을 수 있습니다.

* 그러나 CSRF를 비활성화하는 것은 보안 측면에서 주의해야 할 사항입니다. 만약에 브라우저를 통해 API에 접근하는 경우나, 보안 상 중요한 작업을 수행하는 API가 있다면, CSRF 보호를 고려해야 합니다. CSRF 공격에 취약하지 않은 상황이더라도, API의 특성과 보안 요구사항을 고려하여 결정하는 것이 중요합니다.

 

우선 시큐리티 설정을 통해 모든 요청을 permit 했고, 기본으로 적용되는 UsernamePassworddAuthenticationFilter 를 확장해 내가 만들 CustomFilter -> emailPasswordAuthFilter를 사용해 AuthenticationManager에게 전달할 것이다. 

그리고 build ! 

 

UsernamePassworddAuthenticationFilter 은 Spring security에서 사용자 이름과 비밀번호를 사용하여 인증을 수행하는 데 사용되는 필터 중 하나이다. 이 필터를 통해 주로 HTTP POST 요청에서 사용자 로그인 정보를 받아와서 실제 인증을 처리한다.

기본적으로 /login 에서 동작하며 요청에서 사용자 아이디와 비밀번호를 추출하고, UsernamePasswordAuthenticationToken 객체를 생성해AuthenticationManager에게 전달한다. 

 

@Bean
public WebSecurityCustomizer webSecurityCustomizer()
{
    return web -> web.ignoring().requestMatchers(staticUrlArray)
          .requestMatchers(permitUrlArray)
          .requestMatchers(PathRequest.toH2Console());
}

 

 

WebSecurityCustomizer는 Spring Security 에서 제공하는 함수형 인터페이스로, 웹 보안 구성을 커스텀할 수 있다. 
시큐리티를 거치지 않을 url 들을 따로 설정해서 빈으로 등록했다. 

 

->

staticUrlArray : /favicon.ico, /index.html
permitUrlArray : /login/**, /error/**, /test/**
/h2-console 도 시큐리티 거치면 확인하기 어렵기 때문에 제외해준다. 

(이건 appliation.yml에 저장해두고, 가져와서 사용한다.)

 

	@Bean
	public EmailPasswordAuthFiler emailPasswordAuthFiler()
	{
		EmailPasswordAuthFiler filter = new EmailPasswordAuthFiler("/auth/login", objectMapper);
		filter.setAuthenticationManager(authenticationManager());
		filter.setAuthenticationSuccessHandler(new LoginSuccessHandler(objectMapper));
		filter.setAuthenticationFailureHandler(new LoginFailHandler(objectMapper));
		
		
		return filter;
	}
	
	@Bean
	public AuthenticationManager authenticationManager()
	{
		DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
		provider.setUserDetailsService(new CustomUserDetailService(memberRepository));
		provider.setPasswordEncoder(passwordEncoder());
		
		return new ProviderManager(provider);
	}
	
	@Bean
	public PasswordEncoder passwordEncoder()
	{
		return new SCryptPasswordEncoder(16, 8, 1, 32, 64);
	}

-> 다음 EmailPasswordAuthFilter는 이제 UsernamePasswordAuthenticationFilter를 확장해 내가 커스텀한 filter 이다. 

나는 email을 id로 사용할 것이기 때문에 EmailPasswordAuthFilter라고 정했다. 

그리고 formLogin을 사용하지 않고 restful api이니까 json으로 email (id)와 password를 받을 것이기 때문에 커스텀했다. 

 

filter를 만들고, filter로 UsernamePasswordAuthenticationToken 생성한 다음, AuthenticationManager에 전달해야 하므로AuthenticationManager 도 빈으로 등록해서 설정해주고, 인증 후 SuccessHandler와 FailHandler를 각각 만들어서 설정해준다.

 

AuthenticationManager에는 실제 인증을 처리할 AuthenticationProvider를 지정해준다. 

그리고 UserDetailService를 내가 만든 CustomUserDetailService를 넘겨준다. 

그리고 어떤 PasswordEncoder를 사용할지 설정해주면 된다. 
(나는 ScryptPasswordEncoder라는 걸 의존성 추가해서 사용한다.) 

https://mvnrepository.com/artifact/org.springframework.security/spring-security-crypto 

AuthenticationManager 는 Spring Security에서 인증을 처리하는 핵심 인터페이스이다. 
이 인터페이스는 Authentication 객체를 입력받아 실제로 사용자를 인증하는 역할을 담당한다. 
Spring Security는 AuthenticationManager를 통해 사용자가 제공한 인증 정보를 검사하고, 인증이 성공하면
Authentication 객체를 반환한다. 그리고  이 객체에는 사용자의 인증된 정보 및 권한 정보가 포함되어 있다. 
Spring Security에서는 AuthenticationManager를 사용하여 로그인 처리 및 보안 관련 작업을 수행한다. 

AuthenticationProvider는 Spring Security에서 인증을 담당하는 인터페이스로, 이 인터페이스는 실제로 사용자를 인증하는 역할을 수행하며, 다양한 인증 메커니즘을 지원한다. 
DaoAuthenticationProvider, JwtAuthenticationProvider, LdapAuthenticationProvider 등이 AuthenticationProvider
를 구현하고 있다.
AuthenticationProvider 의 주요 메서드는 authenticate 이다. 이 메서드는 Authentication 객체를 인자로 받아 실제 인증을 수행하고, 성공할 경우 Authentication 객체를 반환하고 실패할 경우 AuthenticationException 을 던진다.

 

 

EmailPAsswordAuthFilter 

public class EmailPasswordAuthFiler extends AbstractAuthenticationProcessingFilter
{
    private final ObjectMapper objectMapper;
    
    public EmailPasswordAuthFiler(String defaultFilterProcessUrl, ObjectMapper objectMapper)
    {
       super(defaultFilterProcessUrl);
       this.objectMapper = objectMapper;
    }
    
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException
    {
       EmailPassword emailPassword = objectMapper.readValue(request.getInputStream(), EmailPassword.class);
       
       UsernamePasswordAuthenticationToken authRequest =
             UsernamePasswordAuthenticationToken.unauthenticated(emailPassword.getEmail(), emailPassword.getPassword());
       
       authRequest.setDetails(this.authenticationDetailsSource.buildDetails(request));
       
       return this.getAuthenticationManager().authenticate(authRequest);
    }
    
}

EmailPasswordAuthFilter에서 request를 EmailPassword로 값을 받아오고, 

이 값을 통해 UsernamePasswordAuthenticationToken 생성한다. 

그리고 AutheticationManager에 이 토큰 값을 넘겨주면 된다. 

 

AbstractAuthenticationProcessingFilter는 스프링 시큐리티에서 제공하는 필터 중 하나로, 사용자의 인증(authentication)을 처리하는 역할을 하는 추상 클래스입니다. 이 클래스는 실제로 사용자의 인증을 처리하는 구현을 하기 위해 상속받아야 하는데, 주로 로그인(form login)에 사용된다. 

attemptAuthentication
-> 이 메서드는 실제로 사용자의 인증을 시도하는 메서드이다. 이 메서드를 구현해서 사용자가 제공한 자격 증명을 확인하고 AuthenticationManager를 통해 실제 인증을 수행하면 된다. 
-> Provider를 통해 실제 인증을 처리하고, 이때 인증 성공시 Authtication 객체 반환하고 실패시 null 반환한다. 

UsernamePasswordAuthenticationToken은스프링 시큐리티에서 사용자의 아이디와 비밀번호를 기반으로 하는 인증을 수행하는 데 사용되는 구체적인 Authentication 객체다. 이 토큰은 주로 폼 로그인(form login)에서 사용자의 인증을 처리할 때 생성되고 활용된다.
UsernamePasswordAuthenticationToken은 Authentication인터페이스를 구현해서 사용자의 인증 정보를 담는 객체로서 역할을 한다. 

 

 

EmailPassword

@Getter
@Setter
public class EmailPassword
{
    private String email;
    private String password;
}

 

 

CustomUserDetailService 

@Service
@RequiredArgsConstructor
public class CustomUserDetailService implements UserDetailsService
{
    private final MemberRepository memberRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
    {
       Member member = memberRepository.findByEmail(username).orElseThrow(() -> new UsernameNotFoundException("[" + username + "] 사용자를 찾을 수 없습니다."));
       
       return new UserPrincipal(member);
    }
}

 

-> AuthenticationManager에서 인증을 처리하기 위해 사용자 정보를 로드해야 한다. 

받은 email 정보를 가지고 (여기서는 username이 id 즉, email이다.) memberRepository에서 조회해 해당 사용자가 존재하는지 확인한다. 

사용자의 정보를 반환한 다음 Custom한 UserPrincipal로 반환한다.

 

UserPrincipal 

@Getter
public class UserPrincipal extends User
{
    private final Long userId;
    public UserPrincipal(Member member)
    {
       super(member.getEmail(), member.getPassword(), List.of(new SimpleGrantedAuthority("ROLE_USER")));
       this.userId = member.getId();
    }
}

User는 UserDetails를 구현한 클래스이고, 이를 상속받아 UserPrincipal 을 만들었다. 

그리고 우선 권한은 USER 권한을 부여한다. 

 

 

UserDetailsService 스프링 시큐리티에서 사용자 정보를 로드하는 인터페이스다. 주로 사용자 인증(authentication) 과정에서 사용되며, 스프링 시큐리티가 사용자의 아이디(username)를 기반으로 해당 사용자의 정보를 가져오는 역할을 수행한다.

UserDetailsService 를 구현하려면, loadUserByUsername 메서드를 구현해야 한다. 이 메서드는 사용자의 아이디를 받아 해당 사용자의 정보를 반환하는 역할을 한다. 

UserDetails 는 스프링 시큐리티에서 사용자 정보를 나타내는 인터페이스이다. 이 인터페이스를 구현한 객체는 스프링 시큐리티에서 사용자 인증, 권한 부여, 계정 잠금 등과 관련된 작업을 수행하는 데 사용된다.

 

 

LoginSucessHandler 

@Slf4j
@RequiredArgsConstructor
public class LoginSuccessHandler implements AuthenticationSuccessHandler
{
    private final ObjectMapper objectMapper;
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException
    {
       UserPrincipal principal = (UserPrincipal) authentication.getPrincipal();
       log.info("****** LoginSuccessHandler.onAuthenticationSuccess  user={} ******", principal.getUsername());
       
       response.setContentType(MediaType.APPLICATION_JSON_VALUE);
       response.setCharacterEncoding(StandardCharsets.UTF_8.displayName());
       response.setStatus(HttpStatus.OK.value());
       
       objectMapper.writeValue(response.getWriter(), ApiResponse.ok(principal));
    
    }
}

-> 로그인 성공했을 때 수행하는 핸들러이다. 지금은 로그인 성공하면 json으로 principal 값을 내려주고 있다. (샘플이니까 ㅎ) 

 

 

LoginFailHandler 

@Slf4j
@RequiredArgsConstructor
public class LoginFailHandler implements AuthenticationFailureHandler
{
    private final ObjectMapper objectMapper;
    
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException
    {
       log.info("****** LoginSuccessHandler.onAuthenticationFailure ******");
       ApiResponse<Object> apiResponse = ApiResponse.of(HttpStatus.BAD_REQUEST, "아이디 또는 비밀번호가 올바르지 않습니다.", null);
       
       response.setContentType(MediaType.APPLICATION_JSON_VALUE);
       response.setCharacterEncoding(StandardCharsets.UTF_8.displayName());
       response.setStatus(HttpStatus.BAD_REQUEST.value());
       
       objectMapper.writeValue(response.getWriter(), apiResponse);
    }
}

-> 로그인 실패했을 때 핸들러이다. 

 

AuthenticationSuccessHandler는 스프링 시큐리티에서 로그인 인증에 성공했을 때의 처리를 담당하는 인터페이스이다. 로그인이 성공하면 해당 핸들러를 통해 추가적인 동작이나 리다이렉션을 수행할 수 있다. 

onAuthenticationSuccess는 로그인 인증에 성공했을 때 실행되는 메서드이다.여기에서 원하는 로직을 추가하거나 리다이렉션을 설정할 수 있다.일반적으로 HttpServletRequest, HttpServletResponse, Authentication 객체 등을 파라미터로 받는다. 

AuthenticationFailureHandler는 스프링 시큐리티에서 로그인 인증에 실패했을 때의 처리를 담당하는 인터페이스이다. 로그인이 실패하면 해당 핸들러를 통해 추가적인 동작이나 에러 메시지를 처리할 수 있다.

onAuthenticationFailure는 로그인 인증에 실패했을 때 실행되는 메서드이다.여기에서 원하는 로직을 추가하거나 실패 시의 에러 메시지를 설정할 수 있다.일반적으로 HttpServletRequest, HttpServletResponse, AuthenticationException 객체 등을 파라미터로 받는다.

 

 

 

👩‍💻 : 우선 오늘은 기본적인 Security 설정 + CustomAuthFilter를 만들어서 세팅해 로그인 구현을 완료했다. 

RESTful api 방식이니까 form login 이 아니라 json으로 email, pasword 를 받아서 처리하기 위해 filter를 커스텀해서 만들었다. 사실 처음에는 막 따라하면서 만든 거라 좀 정리가 안됐는데 글 작성하면서 더 정리가 되는 기분 ㅎㅎ 

근데 글을 쓰다보니 사실 회원 가입부터 먼저 했어야 했나 싶은데 이미 스프링 설정부터 글쓰기를 시작해버렸다 😀

그래서 아직 소개 안한 MemberRepository가 위에서 살짝 나왔는데, 이는 다음 글에서 확인할 수 있을 것이다 헷