[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(Spring Security, 접근 불가 페이지 만들기)

Spring Security 프레임워크

Spring Security 프레임워크는 Spring 서버에서 필요한 인증 및 인가를 위해 많은 기능을 제공해줌으로써 개발의 수고를 덜어줌

사용하기 위해서 framework 추가해줘야함 → Security(build.gradle 내)

implementation 'org.springframework.boot:spring-boot-starter-security'

Spring Security는 Filter 기반으로 동작함
Spring Security 프레임워크 사용을 위해 기본적인 Security 설정해줘야함
Security는 기본적으로 Session 방식으로 동작함(+Default 로그인도 제공함)

Security 설정(config > WebSecurityConfig 클래스 파일 생성)

package com.sparta.springauth.config;

import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity // Spring Security 지원을 가능하게 함
public class WebSecurityConfig {

    // Security 사용할 때, 어떤 URL을 인가할지에 대한 설정과 어떤 기능을 사용하고 사용하지 않겠다는 옵션 설정
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // CSRF 설정
        http.csrf((csrf) -> csrf.disable()); // 'CSRF를 사용하지 않겠다'라고 설정

        http.authorizeHttpRequests((authorizeHttpRequests) ->
                authorizeHttpRequests
                        // 'resources 하위 파일(js, css)로 요청이 들어왔을 때 모든 접근 허용하겠다'라는 의미
                        .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() // resources 접근 허용 설정
                        // .requestMatchers("/api/user/**").permitAll() // /api/user/ 형태로 오는 URL은 모든 접근 허용
                        .anyRequest().authenticated() // 그 외 모든 요청 인증처리
                // 여러 옵션 존재함
        );

        // 로그인 사용 -> Spring Security에서 기본적으로 제공하는 로그인 페이지 존재함
        // 또한, 비밀번호를 제공해줌(username은 기본적으로 'user')
        http.formLogin(Customizer.withDefaults());

        return http.build();
    }
}

CSRF(Cross-Site Request Forgery, 사이트 간 요청 위조)
공격자가 인증된 브라우저에 저장된 쿠키의 세션 정보를 활용해 웹 서버에 사용자가 의도하지 않은 요청을 전달하는 것
- CSRF 설정이 되어있는 경우 html에서 CSRF 토큰 값을 넘겨주어야 요청을 수신 가능함
- 쿠키 기반의 취약점을 이용한 공격이기 때문에 REST 방식의 API에서는 disable이 가능함
* 해당 강의에서는 POST 요청마다 처리해주는 대신 CSRF protection을 disable함
http.csrf((csrf) -> csrf.disable())

Spring Security 이해하기

Spring에서 모든 호출은 DispatcherServlet을 통과하게 되고 이후에 각 요청을 담당하는 Controller로 분배함
이때, 각 요청에 대해 공통적으로 처리해야할 필요가 있을 때 DispatcherServlet 이전에 단계가 필요하며 이것이 Filter임

Spring Security도 인증 및 인가를 처리하기 위해 Filter를 사용하는데, Spring Security는 FilterChainProxy를 통해서 상세로직을 구현하고 있음

Form Login 기반 인증

Form Login 기반 인증은 인증이 필요한 URL 요청이 들어왔을 때, 인증이 되지 않으면 로그인 페이지를 반환함

UsernamePasswordAuthenticationFilter

Form Login 기반 인증을 사용할 때, 요청된 username과 password를 인증 처리하는 Filter

사용자가 username과 password 제출
UsernamePasswordAuthenticationFilter는 인증된 사용자의 정보가 담긴 Authentication 종류 중 하나인 UsernamePasswordAuthenticationToken을 만듦
만들어진 토큰을 AuthenticationManager에게 넘긴 후, 인증을 시도함
성공하면, SecurityContextHolder에 그 Authentication(UsernamePasswordAuthenticationToken)을 세팅하면서 인증 처리 완료됨
실패하면, SecurityContextHolder를 비움

SecurityContextHolder

SecurityContextHolder 안에 SecurityContext가 존재하고, 그 안에 Authentication이 담김
SecurityContext는 SecurityContextHolder를 통해서 접근 가능함

Authentication

Authentication은 현재 인증된 사용자를 나타내며 SecurityContext에서 가져올 수 있음

principal: 사용자를 식별함
- Username/Password 방식으로 인증을 할 때 일반적으로 UserDetails 인스턴스임
credentials: 주로 비밀번호, 대부분 사용자 인증에 사용한 후 비움
authorities: 사용자에게 부여한 권한을 GrantedAuthority로 추상화해 사용함

<UserDetails>
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
	UserRoleEnum role = user.getRole();
    String authority = role.getAuthority();
    
    SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(authority);
    Collection<GrantedAuthority> authorities = new ArrayList<>();
    authorities.add(simpleGrantedAuthority);
    
    return authorities;
}

Authentication authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());

UserDetailsService는 username/password 인증방식을 사용할 때 사용자를 조회하고 검증한 후 UserDetails를 반환함. Custom하여 Bean으로 등록 후 사용 가능

UserDetails는 UsernamePasswordAuthenticationToken 타입의 Authentication를 만들 때 사용되며 해당 인증객체는 SecurityContextHolder에 세팅됨. Custom해 사용가능함

Spring Security 로그인(Session 방식)

스프링 시큐리티 사용 전/후

스프링 시큐리티 사용 후, Client의 요청은 모두 Spring Security를 거치게됨
Spring Security 역할 → 인증/인가
- 성공 시: Controller로 Client 요청 전달 → Client 요청 + 사용자 정보(UserDetails)
- 실패 시: Controller로 Client 요청 전달되지 않음(Client에게 Error Response 보냄)

로그인 과정

Authentication Manager가 인증 처리를 할 때, UserDetailsService를 사용해서 데이터베이스에 해당하는 username으로 회원 정보를 조회함(이 부분을 커스텀해서 사용 가능)
조회한 유저 정보로 UserDetails 만든 다음에 Authentication Manger에게 전달하면, 인증 처리를 시작함

1. Client

로그인 시도
로그인 시도할 username, password 정보를 HTTP body로 전달(POST 요청)
로그인 시도 URL은 WebSecurityConfig 클래스에서 변경 가능

package com.sparta.springauth.config;

import org.springframework.boot.autoconfigure.security.servlet.PathRequest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity // Spring Security 지원을 가능하게 함
public class WebSecurityConfig {

    // Security 사용할 때, 어떤 URL을 인가할지에 대한 설정과 어떤 기능을 사용하고 사용하지 않겠다는 옵션 설정
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // CSRF 설정
        http.csrf((csrf) -> csrf.disable()); // 'CSRF를 사용하지 않겠다'라고 설정

        http.authorizeHttpRequests((authorizeHttpRequests) ->
                authorizeHttpRequests
                        // 'resources 하위 파일(js, css)로 요청이 들어왔을 때 모든 접근 허용하겠다'라는 의미
                        .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() // resources 접근 허용 설정
                        .requestMatchers("/api/user/**").permitAll() // /api/user/ 형태로 오는 URL은 모든 접근 허용
                        .anyRequest().authenticated() // 그 외 모든 요청 인증처리
                // 여러 옵션 존재함
        );

        // Form Login 설정 사용
        http.formLogin((formLogin) ->
                formLogin
                        // 로그인 View 제공 (GET /api/user/login-page)
                        .loginPage("/api/user/login-page")
                        // 로그인 처리 (POST /api/user/login)
                        // 이전에 Controller 내에 만든 API가 아닌, Spring Security 자체에서 로그인할 때의 url 지정
                        // 즉 Controller 앞단에서 처리
                        .loginProcessingUrl("/api/user/login")
                        // 로그인 처리 후 성공 시 URL
                        .defaultSuccessUrl("/")
                        // 로그인 처리 후 실패 시 URL
                        .failureUrl("/api/user/login-page?error")
                        .permitAll()
        );

        return http.build();
    }
}

UserDetailsService와 UserDetails 구현

UserDetailsServiceImpl과 UserDetailsImpl을 커스텀하게 되면, 'Security의 default 로그인 기능을 사용하지 않겠다'라는 설정이 됨

package com.sparta.springauth.security;

import com.sparta.springauth.entity.User;
import com.sparta.springauth.entity.UserRoleEnum;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;

public class UserDetailsImpl implements UserDetails {

    private final User user;

    public UserDetailsImpl(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        UserRoleEnum role = user.getRole();
        String authority = role.getAuthority();

        SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(authority);
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(simpleGrantedAuthority);

        return authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

package com.sparta.springauth.security;

import com.sparta.springauth.entity.User;
import com.sparta.springauth.repository.UserRepository;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    private final UserRepository userRepository;

    public UserDetailsServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 해당 유저 정보를 가져옴
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("Not Found " + username));

        return new UserDetailsImpl(user); // 정보로 객체 생성해 반환
    }
}

Authentication에 저장한 User 정보 활용하기

package com.sparta.springauth.controller;

import com.sparta.springauth.entity.User;
import com.sparta.springauth.security.UserDetailsImpl;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/api")
public class ProductController {

    @GetMapping("/products")
    public String getProducts(@AuthenticationPrincipal UserDetailsImpl userDetails) {
        // Authentication의 Principle
        User user = userDetails.getUser();
        System.out.println("user.getUsername() = "+user.getUsername());

        return "redirect:/";
    }
}

Spring Security JWT 로그인

JWT 인증 처리 Filter

기존에 Controller과 Service 단에서 처리한 JWT 관련 로직인 login 부분 삭제 → 비즈니스 로직 처리와 인증/인가 처리 분리하는 목적
UsernamePasswordAuthenticationFilter 상속 받아 사용
- UsernamePasswordAuthenticationFilter는 받아온 username과 password를 인증 객체인 UsernamePasswordAuthenticationToken으로 만든 후, AuthenticationManager를 통해 확인하는 작업 수행함
Session 방식이 아닌 JWT 방식을 사용하기 위해 위 작업을 직접 Custom해서 사용

package com.sparta.springauth.jwt;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.sparta.springauth.dto.LoginRequestDto;
import com.sparta.springauth.entity.UserRoleEnum;
import com.sparta.springauth.security.UserDetailsImpl;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import java.io.IOException;

@Slf4j(topic = "로그인 및 JWT 생성")
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    private final JwtUtil jwtUtil;

    public JwtAuthenticationFilter(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
        // WebSecurityConfig에서 loginProcessingUrl 부분에 설정해 놓은 값을
        // Custom하기 위해 생성자 호출 시 같이 메서드 호출
        setFilterProcessesUrl("/api/user/login");
    }

    // 로그인 시도하는 메서드
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        log.info("로그인 시도");
        try {
            LoginRequestDto requestDto = new ObjectMapper().readValue(request.getInputStream(), LoginRequestDto.class);

            // AuthenticationManager는 authenticate 메서드를 가지고 있음
            // authenticate 메서드는 검증(인증 처리)하는 메서드
            return getAuthenticationManager().authenticate(
                    new UsernamePasswordAuthenticationToken(
                            requestDto.getUsername(),
                            requestDto.getPassword(),
                            null
                    )
            );
        } catch (IOException e) {
            log.error(e.getMessage());
            throw new RuntimeException(e.getMessage());
        }
    }

    // 성공했을 때 수행되는 메서드
    // Authentication 인증 객체를 받아옴(UserDetails)
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        log.info("로그인 성공 및 JWT 생성");
        String username = ((UserDetailsImpl) authResult.getPrincipal()).getUsername();
        UserRoleEnum role = ((UserDetailsImpl) authResult.getPrincipal()).getUser().getRole();

        String token = jwtUtil.createToken(username, role); // 토큰 생성
        jwtUtil.addJwtToCookie(token, response); // JWT 토큰을 쿠키에 담기
    }

    // 실패했을 때 수행되는 메서드
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        log.info("로그인 실패");
        response.setStatus(401); // 인증이 되지 않았음 상태코드 전달
    }
}

JWT 인가 처리 Filter

package com.sparta.springauth.jwt;

import com.sparta.springauth.security.UserDetailsServiceImpl;
import io.jsonwebtoken.Claims;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;

import java.io.IOException;

@Slf4j(topic = "JWT 검증 및 인가")
public class JwtAuthorizationFilter extends OncePerRequestFilter {

    private final JwtUtil jwtUtil;
    private final UserDetailsServiceImpl userDetailsService;

    public JwtAuthorizationFilter(JwtUtil jwtUtil, UserDetailsServiceImpl userDetailsService) {
        this.jwtUtil = jwtUtil;
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain filterChain) throws ServletException, IOException {

        String tokenValue = jwtUtil.getTokenFromRequest(req); // 쿠키에서 JWT 토큰 가져오기

        if (StringUtils.hasText(tokenValue)) {
            // JWT 토큰 substring
            tokenValue = jwtUtil.substringToken(tokenValue); // Bearer 떼기
            log.info(tokenValue);

            if (!jwtUtil.validateToken(tokenValue)) {
                log.error("Token Error");
                return;
            }

            Claims info = jwtUtil.getUserInfoFromToken(tokenValue); // JWT 내 정보 가져오기

            try {
                setAuthentication(info.getSubject());
            } catch (Exception e) {
                log.error(e.getMessage());
                return;
            }
        }

        filterChain.doFilter(req, res);
    }

    // 인증 처리
    public void setAuthentication(String username) {
        SecurityContext context = SecurityContextHolder.createEmptyContext();
        Authentication authentication = createAuthentication(username);
        context.setAuthentication(authentication);

        SecurityContextHolder.setContext(context);
    }

    // 인증 객체 생성
    private Authentication createAuthentication(String username) {
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        return new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
    }
}

필터 등록

package com.sparta.springauth.config;

import com.sparta.springauth.jwt.JwtAuthenticationFilter;
import com.sparta.springauth.jwt.JwtAuthorizationFilter;
import com.sparta.springauth.jwt.JwtUtil;
import com.sparta.springauth.security.UserDetailsServiceImpl;
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.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity // Spring Security 지원을 가능하게 함
public class WebSecurityConfig {

    private final JwtUtil jwtUtil;
    private final UserDetailsServiceImpl userDetailsService;
    private final AuthenticationConfiguration authenticationConfiguration;

    public WebSecurityConfig(JwtUtil jwtUtil, UserDetailsServiceImpl userDetailsService, AuthenticationConfiguration authenticationConfiguration) {
        this.jwtUtil = jwtUtil;
        this.userDetailsService = userDetailsService;
        this.authenticationConfiguration = authenticationConfiguration;
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
        return configuration.getAuthenticationManager();
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() throws Exception {
        JwtAuthenticationFilter filter = new JwtAuthenticationFilter(jwtUtil);
        filter.setAuthenticationManager(authenticationManager(authenticationConfiguration));
        return filter;
    }

    @Bean
    public JwtAuthorizationFilter jwtAuthorizationFilter() {
        return new JwtAuthorizationFilter(jwtUtil, userDetailsService);
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        // CSRF 설정
        http.csrf((csrf) -> csrf.disable());

        // 기본 설정인 Session 방식은 사용하지 않고 JWT 방식을 사용하기 위한 설정
        http.sessionManagement((sessionManagement) ->
                sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
        );

        http.authorizeHttpRequests((authorizeHttpRequests) ->
                authorizeHttpRequests
                        .requestMatchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() // resources 접근 허용 설정
                        .requestMatchers("/api/user/**").permitAll() // '/api/user/'로 시작하는 요청 모두 접근 허가
                        .anyRequest().authenticated() // 그 외 모든 요청 인증처리
        );

        http.formLogin((formLogin) ->
                formLogin
                        .loginPage("/api/user/login-page").permitAll()
        );

        // 필터 관리
        // 인가 Filter 먼저 수행
        http.addFilterBefore(jwtAuthorizationFilter(), JwtAuthenticationFilter.class);
        // UsernamePasswordAuthenticationFilter 수행 전에 jwtAuthenticationFilter 먼저 수행
        http.addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }
}

접근 불가 페이지 만들기

접근 불가 페이지는 사용자가 그 해당 페이지에 접근하지 못한다거나 아니면 특정한 API에 접근하지 못하도록 하는 것 → 즉, 사용자의 권한에 따라 제어 설정

Spring Security에서 권한(Authority) 설정 방법

회원 상세정보(UserDetailImpl)를 통한 "권한(Authority)" 설정 가능
권한은 1개 이상 설정 가능
"권한 이름" 규칙
- "ROLE_"로 시작해야 함
  ex) "ADMIN" 권한 부여 → "ROLE_ADMIN"
  "USER" 권한 부여 → "ROLE_USER"

package com.sparta.springauth.entity;

public enum UserRoleEnum {
    USER(Authority.USER),  // 사용자 권한
    ADMIN(Authority.ADMIN);  // 관리자 권한

    private final String authority;

    UserRoleEnum(String authority) {
        this.authority = authority;
    }

    public String getAuthority() {
        return this.authority;
    }

    public static class Authority {
        public static final String USER = "ROLE_USER";
        public static final String ADMIN = "ROLE_ADMIN";
    }
}

// 권한 설정 시 사용
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
    UserRoleEnum role = user.getRole();
    String authority = role.getAuthority();

    SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(authority);
    Collection<GrantedAuthority> authorities = new ArrayList<>();
    authorities.add(simpleGrantedAuthority);

    return authorities;
}

사용자에 저장되어있는 role의 authority 값을 사용해 동적으로 저장

API 별 권한 제어 방법

제어하고 싶은 API Controller 쪽에서 @Secured 어노테이션 사용

@Secured("권한 이름") 선언
권한 1개 이상 설정 가능

@Secured(UserRoleEnum.Authority.ADMIN) // 관리자용
@GetMapping("/products/secured")
public String getProductsByAdmin(@AuthenticationPrincipal UserDetailsImpl userDetails) {
    System.out.println("userDetails.getUsername() = " + userDetails.getUsername());
    for (GrantedAuthority authority : userDetails.getAuthorities()) {
        System.out.println("authority.getAuthority() = " + authority.getAuthority());
    }

    return "redirect:/";
}

@Secured 어노테이션 활성화 방법 → @EnableMethodSecurity(securedEnabled = true)

@EnableMethodSecurity(securedEnabled = true) // @Secured 어노테이션 활성화를 위해 설정
public class WebSecurityConfig {
	...
}

관리자 권한이 아닌 경우 /api/products/secured 입력 시 튕겨나감

접근 불가 페이지 추가 후 핸들링 설정

...

@Configuration
@EnableWebSecurity // Spring Security 지원을 가능하게 함
@EnableMethodSecurity(securedEnabled = true)
public class WebSecurityConfig {
	...

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
		...

        // 접근 불가 페이지
        http.exceptionHandling((exceptionHandling) ->
                exceptionHandling
                        .accessDeniedPage("/forbidden.html")); //접근 불가 페이지 URL 설정

        return http.build();
    }
}

'백엔드 > spring&springboot' 카테고리의 다른 글

[내일배움캠프_Spring Boot 숙련주차] RestTemplate & Open API (0)	2026.06.30
[내일배움캠프_Spring Boot 숙련주차] 데이터 검증하기(Validation) (0)	2026.06.29
[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(회원가입, 로그인 구현 with JWT, 필터) (0)	2026.06.29
[내일배움캠프_Spring Boot 숙련주차] 인증과 인가(+쿠키-세션, JWT) (0)	2026.06.26
[내일배움캠프_Spring Boot 숙련주차] Bean (0)	2026.06.26

차곡차곡🐿️

[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(Spring Security, 접근 불가 페이지 만들기)

Spring Security 프레임워크

Spring Security 이해하기

Form Login 기반 인증

UsernamePasswordAuthenticationFilter

SecurityContextHolder

Spring Security 로그인(Session 방식)

로그인 과정

Spring Security JWT 로그인

JWT 인증 처리 Filter

JWT 인가 처리 Filter

필터 등록

접근 불가 페이지 만들기

Spring Security에서 권한(Authority) 설정 방법

API 별 권한 제어 방법

'백엔드 > spring&springboot' 카테고리의 다른 글

티스토리툴바

[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(Spring Security, 접근 불가 페이지 만들기)

Spring Security 프레임워크

Spring Security 이해하기

Form Login 기반 인증

UsernamePasswordAuthenticationFilter

SecurityContextHolder

Spring Security 로그인(Session 방식)

로그인 과정

Spring Security JWT 로그인

JWT 인증 처리 Filter

JWT 인가 처리 Filter

필터 등록

접근 불가 페이지 만들기

Spring Security에서 권한(Authority) 설정 방법

API 별 권한 제어 방법

'백엔드 > spring&springboot' 카테고리의 다른 글

관련글

티스토리툴바