[Spring 강의 작성] JWT 토큰 인증방식 적용하기

[SpringBoot]/[Spring 강의]

[Spring 강의 작성] JWT 토큰 인증방식 적용하기 - 4

Hevton 2023. 1. 8. 01:22

우선 exception 패키지를 생성해주고, 두 exception 클래스를 설계한다.

DupilcateMemberException.java

package io.spring.hevton.Team.exception;

public class DuplicateMemberException extends RuntimeException {
    public DuplicateMemberException() {
        super();
    }
    public DuplicateMemberException(String message, Throwable cause) {
        super(message, cause);
    }
    public DuplicateMemberException(String message) {
        super(message);
    }
    public DuplicateMemberException(Throwable cause) {
        super(cause);
    }
}

데이터베이스에 해당 이름을 가진 유저가 이미 있는 경우 뿜는 에러를 위한 Exception이다.

NotFoundMemberException.java

public class NotFoundMemberException extends RuntimeException {
    public NotFoundMemberException() {
        super();
    }
    public NotFoundMemberException(String message, Throwable cause) {
        super(message, cause);
    }
    public NotFoundMemberException(String message) {
        super(message);
    }
    public NotFoundMemberException(Throwable cause) {
        super(cause);
    }
}

util 패키지 아래에

SecurityUtil.java

package io.spring.hevton.Team.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() {}

    // SecurityContext의 Authentication 객체를 이용해 UserName을 리턴해줌
    // SecurityContext에 Authentication 객체가 저장되는 시점은, JwtFilter의 doFilter 메소드에서 Request가 들어올 때
    // SecurityContext에 Authentication 객체를 저장해서 사용하게 된다.
    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);
    }
}

service 패키지 아래에

UserService.java

package io.spring.hevton.Team.service;


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

import io.spring.hevton.Team.dto.UserDto;
import io.spring.hevton.Team.entity.Authority;
import io.spring.hevton.Team.entity.User;
import io.spring.hevton.Team.exception.DuplicateMemberException;
import io.spring.hevton.Team.exception.NotFoundMemberException;
import io.spring.hevton.Team.repository.UserRepository;
import io.spring.hevton.Team.util.SecurityUtil;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@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 UserDto signup(UserDto userDto) { // 회원가입 로직 수행

        // 이미 이 username으로 저장된 유저가 데이터베이스에 있는지
        if (userRepository.findOneWithAuthoritiesByUsername(userDto.getUsername()).orElse(null) != null) {
            throw new DuplicateMemberException("이미 가입되어 있는 유저입니다.");
        }

        // 권한정보 생성
        Authority authority = Authority.builder()
                .authorityName("ROLE_USER") // 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 UserDto.from(userRepository.save(user));
    }

    @Transactional(readOnly = true)
    public UserDto getUserWithAuthorities(String username) { // username을 기준으로 가져옴
        return UserDto.from(userRepository.findOneWithAuthoritiesByUsername(username).orElse(null));
    }

    @Transactional(readOnly = true)
    public UserDto getMyUserWithAuthorities() { // 현재 SecurityContext에 저장되어있는 것만
        return UserDto.from(
                SecurityUtil.getCurrentUsername()
                        .flatMap(userRepository::findOneWithAuthoritiesByUsername)
                        .orElseThrow(() -> new NotFoundMemberException("Member not found"))
        );
    }
}

controller 패키지 아래

UserController.java

package io.spring.hevton.Team.controller;


import io.spring.hevton.Team.dto.UserDto;
import io.spring.hevton.Team.service.UserService;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;


import javax.servlet.http.HttpServletRequest;


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

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


    @PostMapping("/signup") // userDto를 파라미터로 받아서, signup 수행
    public ResponseEntity<UserDto> signup(
            @Validated @RequestBody UserDto userDto
    ) {
        return ResponseEntity.ok(userService.signup(userDto));
    }

    // 내 정보
    @GetMapping("/user")
    @PreAuthorize("hasAnyRole('USER','ADMIN')") // 두가지 권한 모두 호출가능한 API
    public ResponseEntity<UserDto> getMyUserInfo(HttpServletRequest request) {
        return ResponseEntity.ok(userService.getMyUserWithAuthorities());
    }

    // 특정 유저 정보
    @GetMapping("/user/{username}")
    @PreAuthorize("hasAnyRole('ADMIN')") // 어드민 권한만 호출가능한 API
    public ResponseEntity<UserDto> getUserInfo(@PathVariable String username) {
        return ResponseEntity.ok(userService.getUserWithAuthorities(username));
    }
}

이제 Insomnia를 이용해 테스트해본다.