[Spring Security] JWT Tutorial (5) 회원가입, 권한 검증

SecurityUtil 클래스 생성

package com.oliviarla.tutorial.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Optional;

public class SecurityUtil {

    private static final Logger logger = LoggerFactory.getLogger(SecurityUtil.class);

    private SecurityUtil() {
    }

    public static Optional<String> getCurrentUsername() {
        final Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        if (authentication == null) {
            logger.debug("Security Context에 인증 정보가 없습니다.");
            return Optional.empty();
        }

        String username = null;
        if (authentication.getPrincipal() instanceof UserDetails) {
            UserDetails springSecurityUser = (UserDetails) authentication.getPrincipal();
            username = springSecurityUser.getUsername();
        } else if (authentication.getPrincipal() instanceof String) {
            username = (String) authentication.getPrincipal();
        }

        return Optional.ofNullable(username);
    }
}

JwtFilter 클래스의 DoFilter 메소드에서 저장한 Security Context의 인증 정보에서 username을 반환

UserSerivice 클래스 생성

package com.oliviarla.tutorial.service;

import com.oliviarla.tutorial.dto.UserDto;
import com.oliviarla.tutorial.entity.Authority;
import com.oliviarla.tutorial.entity.User;
import com.oliviarla.tutorial.repository.UserRepository;
import com.oliviarla.tutorial.util.SecurityUtil;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collections;
import java.util.Optional;

@Service
public class UserService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
    }

    @Transactional
    public User signup(UserDto userDto) {
        if (userRepository.findOneWithAuthoritiesByUsername(userDto.getUsername()).orElse(null) != null) {
            throw new RuntimeException("이미 가입되어 있는 유저입니다.");
        }

        Authority authority = Authority.builder()
                .authorityName("ROLE_USER")
                .build();

        User user = User.builder()
                .username(userDto.getUsername())
                .password(passwordEncoder.encode(userDto.getPassword()))
                .nickname(userDto.getNickname())
                .authorities(Collections.singleton(authority))
                .activated(true)
                .build();

        return userRepository.save(user);
    }

    @Transactional(readOnly = true)
    public Optional<User> getUserWithAuthorities(String username) {
        return userRepository.findOneWithAuthoritiesByUsername(username);
    }

    @Transactional(readOnly = true)
    public Optional<User> getMyUserWithAuthorities() {
        return SecurityUtil.getCurrentUsername().flatMap(userRepository::findOneWithAuthoritiesByUsername);
    }
}

UserRepository, PasswordEncoder를 주입받음

signup(): 가입되어 있는 사용자인지 확인하고 UserDto 객체의 정보를 기반으로 Authority, User 객체 생성해 DB에 저장, 이 메소드로 생성된 사용자는 ROLE_USER 권한만 소유 가능

getUserWithAuthorities(): username으로 사용자와 권한 정보를 검색

getMyUserWithAuthorities(): 현재 사용자의 username 가져와 사용자 정보, 권한 정보 반환

UserController 클래스 생성

package com.oliviarla.tutorial.controller;

import com.oliviarla.tutorial.dto.UserDto;
import com.oliviarla.tutorial.entity.User;
import com.oliviarla.tutorial.service.UserService;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@RestController
@RequestMapping("/api")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/signup")
    public ResponseEntity<User> signup(
            @Valid @RequestBody UserDto userDto
    ) {
        return ResponseEntity.ok(userService.signup(userDto));
    }

    @GetMapping("/user")
    @PreAuthorize("hasAnyRole('USER','ADMIN')")
    public ResponseEntity<User> getMyUserInfo() {
        return ResponseEntity.ok(userService.getMyUserWithAuthorities().get());
    }

    @GetMapping("/user/{username}")
    @PreAuthorize("hasAnyRole('ADMIN')")
    public ResponseEntity<User> getUserInfo(@PathVariable String username) {
        return ResponseEntity.ok(userService.getUserWithAuthorities(username).get());
    }
}

signup(): 회원가입 API, permitAll으로 권한 없이 호출 가능

getMyUserInfo(): 현재 Security Context에 저장되어 있는 인증 정보의 username을 기준으로 한 사용자 정보 및 권한 정보 반환

getUserInfo(): username을 파라미터로 입력받아 사용자와 권한 정보 반환, @PreAuthorize를 사용해 ROLE_ADMIN 권한을 소유한 토큰만 호출할 수 있도록 함

 

회원 가입 테스트

권한 검증 테스트

authenticate API를 통해 oliviarla 유저의 토큰 획득

 

Authenticate API 호출 시 Tests 코드를 사용해 담아둔 전역변수 jwt_tutorial_token으로 유저 정보 및 권한 정보 반환받음

var jsonData = JSON.parse(responseBody)

pm.globals.set("jwt_tutorial_token", jsonData.token);

 

 

 

/api/user/{username}은 ROLE_ADMIN 권한 가진 사용자만 접근 가능하므로 403 에러 반환

 

 

출처: https://silvernine.me/wp/?p=1178