[인실리코젠] Spring Security + JWT + JPA

지난 포스팅에서 로그인 기술에 세션 로그인을 사용하였고 추가적으로 Spring Security 공부와 동시에 기록을 남겨두고자 글을 작성합니다.

Spring Security란?
Spring 기반의 애플리케이션 보안을 담당하는 Spring 하위 프레임워크이다. Spring Security는 인증과 권한에 대한 부분을 Filter 흐름에 따라 처리한다. Filter는 Dispatcher Servlet으로 가기 전에 적용되므로 가장 먼저 URL 요청을 받지만, Interceptor는 Dispatcher와 Controller사이에 위치한다는 점에서 적용 시기의 차이가 있다. Spring Security는 보안과 관련해서 체계적으로 많은 옵션을 제공해주기 때문에 개발자 입장에서는 일일이 보안관련 로직을 작성하지 않아도 된다는 장점이 있다.

위에서 했던 말을 요약하면 아래와 같다.

Client (request) → Filter → DispatcherServlet → Interceptor → Controller
(실제로 Interceptor가 Controller로 요청을 위임하는 것은 아님, Interceptor를 거쳐서 가는 것)

위 그림은 "Spring Security" 단어를 검색하면 대부분의 블로그에서 참조하고 있는 그림이다.

각 번호 별로 처리 과정을 알아보자.

사용자가 로그인 정보와 함께 인증 요청(Http Request)
AuthenticationFilter가 요청을 가로챔
1. 가로챈 정보를 통해 UsernamePasswordAuthenticationToken의 인증용 객체 생성
AuthenticationManage의 구현체인 ProviderManager에게 생성한 UsernamePasswordToken 객체 전달
AuthenticationManage는 등록된 AuthenticationProvider들을 조회하여 인증 요구
실제 DB에서 사용자 인증 정보를 가져오는 UserDetailsService에 사용자 정보를 넘겨줌
넘겨받은 사용자 정보를 통해 DB에서 찾은 사용자 정보인 UserDetails 객체 생성
AuthenticationProvider들은 UserDetails를 넘겨 받고 사용자 정보 비교
인증 완료 -> 권한 등의 사용자 정보를 담은 Authentication 객체 반환
다시 최초의 AuthenticationFilter에 Authentication 객체 반환
Authentication 객체를 SecurityContext에 저장

최종적으로 SecurityContextHolder는 세션 영역에 있는 SecurityContext에 Authentication 객체를 저장한다.
사용자 정보를 저장한다는 것은 Spring Security가 전통적인 세션-쿠키 기반의 인증 방식을 사용한다는 것을 의미한다.

흐름에 대해서 파악했으니 Spring Security의 주요 모듈에 대해 알아보자.

이 그림도 흔히 볼 수 있는 그림이다.

SecurityContextHolder, SecurityContext, Authentication
- 세가지 클래스는 스프링 시큐리티의 주요 컴포넌트로, 각 컴포넌트의 관계를 간단히 표현하겠다.
  - 유저의 아이디와 패스워드 사용자 정보를 넣고 실제 가입된 사용자인지 체크한 후 인증에 성공하면 우리는 사용자의 principal과 credential정보를 Authentication안에 담는다.
    - principal: 아이디 (username)
    - credential: 비밀번호 (password)
  - 스프링 시큐리티에서 방금 담은 Authentication을 SecurityContext에 보관한다.
  - 이 SecurityContext를 SecurityContextHolder에 담아 보관하게 되는 것이다.
- Authentication 클래스는 현재 접근하는 주체의 정보와 권한을 담는 인터페이스고 SecurityContext 저장되며 SecurityContextHolder를 통해 SecurityContext에 접근하고, SecurityContext를 통해 Authentication에 접근할 수 있다.

전체적인 폴더 구조

해당 프로젝트는 이전에 사용했던 MAVEN이 아닌 gradle을 사용해보았다. 어떠한 이유가 있는 것은 아니고 그저 gradle을 사용해보고 싶었다.

build.gradle

plugins {
	id 'java'
	id "nebula.integtest" version "8.2.0"
	id 'org.springframework.boot' version '2.6.3'
	id 'io.spring.dependency-management' version '1.1.4'
}

group = 'hello'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '17'
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-validation'
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-security'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	testImplementation 'org.springframework.security:spring-security-test'

	compileOnly 'org.projectlombok:lombok'
	annotationProcessor 'org.projectlombok:lombok'

	implementation group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.2'
	runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.2'
	runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.2'
	// db
	implementation 'org.mariadb.jdbc:mariadb-java-client:2.7.1'
	// log4j
	implementation 'org.slf4j:slf4j-api:1.7.32'
}

repositories {
	mavenCentral()
}

tasks.named('test') {
	useJUnitPlatform()
}

사용도구 및 버전
Develop Tool : IntelliJ
Spring Boot : 2.6.3
DB : mariaDB
build : gradle

프로젝트 흐름 ※ 도커 제외

사용된 기술 중 짚고 넘어가야할 부분은 JWT이다.

node를 사용할 당시에 jwt를 사용하였지만 기억이 드문드문 나는 것을 느껴 다시 기록하며 공부하려 한다.

JWT (JSON Web Token)

jwt는 header, playload, signature 3 부분으로 이루어져 있다.
이를 base64 encoding 한 후 concat, 즉 문자열을 합친 것이 jwt이다.
토큰에 포함된 내용들은 암호화 되어있지 않기 때문에 누구나 확인 가능하다.
signature를 이용하여 해당 토큰이 실제로 원래 발급자가 발급했던 유효한 토큰인지 검증 할 수 있다.
signature 생성을 위한 알고리즘은 발급 시에 선택 가능하다 (RS256, ES256, HS256 등)
jwt.io 에서 볼 수 있는 예제

HEADER

"alg" : signature 생성을 위해 사용한 알고리즘을 명시한다.
"typ" : 타입을 나타낸다.
"kid" : 서명 시 사용하는 키 (public / private Key)를 식별하는 값이다. 혹은 key가 계속 변경되는 경우 kid를 사용한다.

PAYLOAD

jwt의 내용으로, payload에 있는 속성들을 Claim 이라고 한다.
"iss" : jwt 생성한 곳
"iat" : jwt 생성 시간
"exp" : jwt 만료 시간
"aud" : 유저 인증을 위해 jwt를 사용하는 경우 payload에 토큰을 발급 받은 사용자ID 값을 포함한다.
> jwt를 이용하여 application server에 요청, server에서 jwt signature 유효성을 확인하고, 유효하다면 payload에서 사용자ID 값을 읽어 들여서 요청을 보낸 사람이 어떤 사용자 인지 인증 할 수 있다. (애플로그인에서 사용하는 방법)
등등 key, value의 형태로 이루어져있고 생성하는 사용자가 직접 필드를 추가해서 정보를 추가할 수 있다.
base64 url-safe로 인코딩한다.

SIGNATURE

header, payload의 값이 변조되지 않았는지 확인하기 위해 필요한 서명이다.
RS256 : 비대칭키 방식으로 private Key를 사용해서 암호화 한다.
jwt를 발급한 서버뿐만 아니라, jwt를 받아서 사용하는 어떤 주체라도 signature 유효성 검증이 가능하다.
일반적으로 public key는 jwt를 발급한 서버에서 JWK (JSON Web Key)에 정의된 방식을 통해 공개적으로 제공한다.
애플이 이 JWK를 제공하고 있고, 로그인 검증시에 필요하다.

JWK (JSON Web Key)

JWT 서명 검증을 위한 정보를 담은 JSON 표준이다.
JWT를 사용하는 서비스들이 public key를 제공하기 위해 key에 접근할 수 있는 URL을 제공하고있다.

JWT 등록

TokenProvider

/jwt/TokenProvider.java

package hello.hellospring.user.jwt;

import hello.hellospring.user.DTO.TokenDTO;
import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;
import io.jsonwebtoken.security.Keys;

import java.security.Key;
import java.util.*;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
public class TokenProvider {
    private static final String AUTHORITIES_KEY = "auth";
    private static final String BEARER_TYPE = "bearer";
    private static final long ACCESS_TOKEN_EXPIRE_TIME = 1000 * 60 * 30;
    private final Key key;

    @Autowired
    public TokenProvider(@Value("${jwt.secret}") String secretKey) {
        byte[] keyBytes = Base64.getDecoder().decode(secretKey);
        this.key = Keys.secretKeyFor(SignatureAlgorithm.HS512);
    }

    public TokenDTO generateTokenDto(Authentication authentication) {
        String authorities = authentication.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.joining(","));

        long now = System.currentTimeMillis();
        Date tokenExpiresIn = new Date(now + ACCESS_TOKEN_EXPIRE_TIME);

        String accessToken = Jwts.builder()
                .setSubject(authentication.getName())
                .claim(AUTHORITIES_KEY, authorities)
                .setExpiration(tokenExpiresIn)
                .signWith(key, SignatureAlgorithm.HS512)
                .compact();

        return TokenDTO.builder()
                .grantType(BEARER_TYPE)
                .accessToken(accessToken)
                .tokenExpiresIn(tokenExpiresIn.getTime())
                .build();
    }

    public Authentication getAuthentication(String accessToken) {
        Claims claims = parseClaims(accessToken);

        if (claims.get(AUTHORITIES_KEY) == null) {
            throw new RuntimeException("권한 정보가 없는 토큰입니다.");
        }

        Collection<? extends GrantedAuthority> authorities =
                Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(","))
                        .map(SimpleGrantedAuthority::new)
                        .collect(Collectors.toList());

        UserDetails principal = new User(claims.getSubject(), "", authorities);

        return new UsernamePasswordAuthenticationToken(principal, "", authorities);
    }

    public boolean validateToken(String token) {
        Logger log = LoggerFactory.getLogger(TokenProvider.class);

        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;
        } catch (io.jsonwebtoken.security.SecurityException | MalformedJwtException e) {
            log.info("잘못된 JWT 서명입니다.");
        } catch (ExpiredJwtException e) {
            log.info("만료된 JWT 토큰입니다.");
        } catch (UnsupportedJwtException e) {
            log.info("지원되지 않는 JWT 토큰입니다.");
        } catch (IllegalArgumentException e) {
            log.info("JWT 토큰이 잘못되었습니다.");
        }
        return false;
    }

    private Claims parseClaims(String accessToken) {
        try {
            return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(accessToken).getBody();
        } catch (ExpiredJwtException e) {
            return e.getClaims();
        }
    }
}

해당 클래스는 JWT 토큰을 생성하고, 유효성을 검증하며, 사용자의 인증 정보를 추출하는 등의 기능을 수행

의존성 주입 및 키 생성:
- TokenProvider 클래스는 @Component 어노테이션이 지정되어 Spring의 빈으로 등록
- 생성자에서 secretKey를 입력으로 받아 Key 객체를 생성 => 해당 키는 JWT 서명에 사용
JWT 토큰 생성:
- generateTokenDto 메서드는 주어진 인증 정보를 사용하여 JWT 토큰을 생성
- 사용자의 권한 정보를 JWT의 클레임에 추가하고, 토큰 만료 시간을 설정
- 키를 사용하여 JWT를 서명하고 생성된 토큰을 DTO에 포함시켜 반환
JWT 토큰 검증:
- validateToken 메서드는 주어진 토큰의 유효성을 검사
- JWT 토큰의 서명을 확인하고, 만료 여부를 확인하여 유효한 토큰인지를 판단
- 예외가 발생한 경우에는 해당 예외에 대한 로깅을 수행
인증 정보 추출:
- getAuthentication 메서드는 JWT 토큰에서 사용자 인증 정보를 추출
- JWT 토큰의 클레임에서 사용자의 권한 정보를 추출하여 Spring Security의 Authentication 객체로 변환

JwtFilter

/jwt/JwtFilter.java

package hello.hellospring.user.jwt;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;

import java.io.IOException;

@RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {
    public static final String AUTHORIZATION_HEADER = "Authorization";
    public static final String BEARER_PREFIX = "Bearer ";
    private final TokenProvider tokenProvider;

    private String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader(AUTHORIZATION_HEADER);
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(BEARER_PREFIX)) {
            return bearerToken.substring(7);
        }
        return null;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException, ServletException, IOException {
        String jwt = resolveToken(request);

        if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
            Authentication authentication = tokenProvider.getAuthentication(jwt);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }

        filterChain.doFilter(request, response);
    }
}

Spring Security를 사용하여 JWT(Json Web Token)를 처리하는데 필요한 필터인 JwtFilter를 구현

이 필터는 HTTP 요청이 들어올 때마다 실행되어 JWT 토큰을 추출하고, 해당 토큰을 사용하여 사용자를 인증하며, 사용자 정보를 Spring Security의 SecurityContextHolder에 저장

resolveToken(HttpServletRequest request):
1. 이 메서드는 HTTP 요청에서 JWT 토큰을 추출하는 역할
2. 요청 헤더에서 "Authorization" 헤더를 찾고, 해당 헤더의 값이 "Bearer "로 시작하는지 확인한 후에 JWT 토큰을 반환
doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain):
1. 이 메서드로 실제 필터의 로직을 처리
2. 먼저 resolveToken 메서드를 사용하여 JWT 토큰을 추출하고, 추출된 토큰이 유효한지 확인
3. 유효한 토큰이면 tokenProvider를 사용하여 해당 토큰으로부터 사용자를 인증하고, 인증된 사용자 정보를 SecurityContextHolder에 설정
4. 요청을 다음 필터로 전달
tokenProvider:
1. 이 필터가 의존하는 TokenProvider는 JWT 토큰을 생성하고 유효성을 검증하는 데 사용.

위 방식으로 JwtFilter는 Spring Security의 인증 및 인가 메커니즘에 JWT 토큰을 통합하여 보안을 강화하고, 클라이언트의 요청이 안전하게 처리되도록 한다.

JwtAccessDenideHandler

/jwt/JwtAccessDeniedHandler.java

package hello.hellospring.user.jwt;

import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        // 필요한 권한이 없이 접근하려 할때 403
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
    }
}

Spring Security에서 사용자가 리소스에 접근하는 데 필요한 권한이 없을 때 호출되는 커스텀 AccessDeniedHandler의 구현체인 JwtAccessDeniedHandler 클래스

AccessDeniedHandler 인터페이스 구현:
- JwtAccessDeniedHandler 클래스는 AccessDeniedHandler 인터페이스를 구현
- 사용자가 리소스에 접근하는 데 필요한 권한이 없을 때 호출되는 메서드를 정의
handle 메서드:
- 사용자가 필요한 권한 없이 접근하려고 할 때 호출
- HTTP 응답에 403 Forbidden 상태 코드를 설정하여 클라이언트에게 권한 부족 상태를 알림
컴포넌트 등록:
- @Component 어노테이션을 통해 JwtAccessDeniedHandler 클래스를 Spring의 빈으로 등록
- Spring Security에서 자동으로 해당 핸들러를 사용할 수 있도록 함

JwtAuthenticationEntryPoint

/jwt/JwtAuthenticationEntryPoint

package hello.hellospring.user.jwt;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
        // 유효한 자격증명을 제공하지 않고 접근하려 할때 401
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
    }
}

Spring Security에서 인증되지 않은 사용자가 보호된 리소스에 액세스하려고 할 때 호출되는 커스텀AuthenticationEntryPoint의 구현체인 JwtAuthenticationEntryPoint 클래스

AuthenticationEntryPoint 인터페이스 구현:
- JwtAuthenticationEntryPoint 클래스는 AuthenticationEntryPoint 인터페이스를 구현
- 인증되지 않은 사용자가 보호된 리소스에 액세스하려고 할 때 호출되는 메서드를 정의
commence 메서드:
- commence 메서드는 인증되지 않은 사용자가 보호된 리소스에 액세스하려고 할 때 호출
- HTTP 응답에 401 Unauthorized 상태 코드를 설정하여 클라이언트에게 인증이 필요한 상태임을 알림
컴포넌트 등록:
- @Component 어노테이션을 사용하여 JwtAuthenticationEntryPoint 클래스를 Spring의 빈으로 등록
- Spring Security에서 자동으로 해당 진입점을 사용할 수 있도록 함

Config 구현

JwtSecurityConfig

/config/JwtSecurityConfig.java

package hello.hellospring.user.config;

import hello.hellospring.user.jwt.JwtFilter;
import hello.hellospring.user.jwt.TokenProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.DefaultSecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@RequiredArgsConstructor
public class JwtSecurityConfig extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {
    private final TokenProvider tokenProvider;

    @Override
    public void configure(HttpSecurity http) {
        JwtFilter customFilter = new JwtFilter(tokenProvider);
        http.addFilterBefore(customFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> 인터페이스를 구현하는 구현체

직접 만든 TokenProvider와 JwtFilter를 SecurityConfig에 적용할 때 사용

메인 메소드인 configure은TokenProvider를 주입받아서 JwtFilter를 통해 SecurityConfig 안에 필터를 등록하게 되고, 스프링 시큐리티 전반적인 필터에 적용

WebSecurityConfig

/config/WebSecurityConfig.java

package hello.hellospring.user.config;

import hello.hellospring.user.jwt.JwtAccessDeniedHandler;
import hello.hellospring.user.jwt.JwtAuthenticationEntryPoint;
import hello.hellospring.user.jwt.TokenProvider;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.stereotype.Component;

@RequiredArgsConstructor
@Configuration
@EnableWebSecurity
@Component
public class WebSecurityConfig {

    private final TokenProvider tokenProvider;
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final JwtAccessDeniedHandler jwtAccessDeniedHandler;
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }


    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .httpBasic().disable()
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

                .and()
                .exceptionHandling()
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .accessDeniedHandler(jwtAccessDeniedHandler)

                .and()
                .authorizeRequests()
                .antMatchers("/auth/**").permitAll()
                .anyRequest().authenticated()

                .and()
                .apply(new JwtSecurityConfig(tokenProvider));

        return http.build();
    }
}

WebSecurityConfig 클래스의 필드:
- TokenProvider: JWT 토큰을 생성 및 검증하는 데 사용되는 클래스
- JwtAuthenticationEntryPoint: 인증되지 않은 요청이 발생했을 때 처리하기 위한 클래스
- JwtAccessDeniedHandler: 권한이 없는 요청이 발생했을 때 처리하기 위한 클래스
passwordEncoder() 메서드:
1. PasswordEncoder 인터페이스의 구현체를 빈으로 등록
2. 사용자의 비밀번호를 해시화하여 저장하고 검증하는 데 사용
filterChain() 메서드:
- SecurityFilterChain 빈을 생성
- HttpSecurity를 매개변수로 받아서 보안 구성을 정의
  - httpBasic().disable(): HTTP 기본 인증을 비활성화
  - csrf().disable(): CSRF(Cross-Site Request Forgery) 보호를 비활성화
  - sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS):
    - 세션 생성 정책을 STATELESS로 설정하여 세션을 사용하지 않음을 나타냄
  - exceptionHandling(): 예외 처리 설정을 정의
    - authenticationEntryPoint(jwtAuthenticationEntryPoint):
      - 인증되지 않은 요청이 발생했을 때 처리할 클래스를 설정
    - accessDeniedHandler(jwtAccessDeniedHandler):
      - 권한이 없는 요청이 발생했을 때 처리할 클래스를 설정
  - authorizeRequests(): 요청에 대한 인가 규칙을 설정
    - antMatchers("/auth/**").permitAll():
      - "/auth/**" 패턴으로 시작하는 요청은 모두 인증 없이 허용
    - anyRequest().authenticated():
      - 그 외의 모든 요청은 인증이 필요
  - apply(new JwtSecurityConfig(tokenProvider)):
    - JwtSecurityConfig 클래스를 적용하여 JWT 관련 보안 구성을 설정
return http.build(): 보안 구성이 완료된 HttpSecurity 객체를 반환

엔터티(Entity) 및 Repository 구현

Member

/entity/Member.java

package hello.hellospring.user.entity;

import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Entity
@Getter
@Builder
@NoArgsConstructor
public class Member {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String email;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private String nickname;

    @Enumerated(EnumType.STRING)
    private Authority authority;

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public void setPassword(String password) { this.password = password; }

    @Builder
    public Member(Long id, String email, String password, String nickname, Authority authority) {
        this.id = id;
        this.email = email;
        this.password = password;
        this.nickname = nickname;
        this.authority = authority;
    }
}

처음 접한 개념으로 Builder 패턴 개념이 있다.

간략하게 짚고 넘어가자면,

Builder 패턴이란?

복합 객체의 생성 과정과 표현 방법을 분리하여 동일한 생성 절차에서 서로 다른 표현 결과를 만들 수 있게 하는 패턴

생성자 인자로 너무 많은 인자가 사용되는 경우, 어떠한 인자가 어떠한 값을 나타내는지 확인하기 힘들다. 또 어떠한 인스턴스의 경우에는 특정 인자만 생성해야 하는 경우가 발생한다. 이러한 문제를 해결하기 위해서 빌더 패턴을 사용할 수 있다.

@Builder 어노테이션을 사용하면 따로 Builder Class를 만들지 않고 사용할 수 있음

이외에 개념들은 앞선 글에서 포스팅했기 때문에 생략하겠다.

MemberRepository

/entity/MemberRepository.java

package hello.hellospring.user.repository;

import java.util.Optional;

import hello.hellospring.user.entity.Member;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface MemberRepository extends JpaRepository<Member,Long> {
    Optional<Member> findByEmail(String email);
    boolean existsByEmail(String email);
}

findByEmail 메서드:
1. 주어진 이메일에 해당하는 Member 엔티티를 찾음
2. 이메일은 고유한 값이므로 Optional<Member>를 반환
3. 이메일에 해당하는 멤버가 존재하지 않을 수 있음
existsByEmail 메서드
1. 주어진 이메일이 데이터베이스에 이미 존재하는지 여부를 확인
2. 존재하면 true를 반환하고, 그렇지 않으면 false를 반환

Service 구현

CustomUserDetailsService

/service/CustomUserDetailsService

package hello.hellospring.user.service;

import hello.hellospring.user.entity.Member;
import hello.hellospring.user.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
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;

import java.util.Collections;

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {
    private final MemberRepository memberRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{
        return memberRepository.findByEmail(username)
                .map(this::createUserDetails)
                .orElseThrow(()->new UsernameNotFoundException(username + "DB에서 찾을 수 없음"));


    }

    private UserDetails createUserDetails(Member member) {
        GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(member.getAuthority().toString());

        return new User(
                String.valueOf(member.getId()),
                member.getPassword(),
                Collections.singleton(grantedAuthority)
        );
    }
}

UserDetailsService를 구현한 커스텀 클래스이다.

loadUserByUsername(String username): 이메일을 받아 해당 사용자를 조회하고, UserDetails 객체를 반환
- memberRepository.findByEmail(username): 사용자 이메일을 이용하여 회원 정보를 조회
- .map(this::createUserDetails): 회원 정보가 있으면 createUserDetails() 메서드를 불러와 UserDetails 객체 생성
- .orElseThrow(() -> new UsernameNotFoundException(username + "DB에서 찾을 수 없음")): 조회된 회원 정보가 없다면 UsernameNotFoundException을 던진다.
createUserDetails(Member member): 회원 엔티티를 기반으로 UserDetails 객체를 생성
- SimpleGrantedAuthority(member.getAuthority().toString()): 회원 권한을 기반으로 GrantedAuthority 객체를 생성
- Collections.singleton(grantedAuthority): 회원의 권한을 담은 컬렉션을 생성
- return new User(...): 생성된 회원 정보로부터 User 객체를 생성하여 반환

AuthService

/service/AuthService.java

package hello.hellospring.user.service;

import hello.hellospring.user.DTO.MemberRequestDTO;
import hello.hellospring.user.DTO.MemberResponseDTO;
import hello.hellospring.user.DTO.TokenDTO;
import hello.hellospring.user.entity.Member;
import hello.hellospring.user.jwt.TokenProvider;
import hello.hellospring.user.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.core.Authentication;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;

@Service
@RequiredArgsConstructor
@Transactional
public class AuthService {
    private final AuthenticationManagerBuilder managerBuilder;
    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;
    private final TokenProvider tokenProvider;

    public MemberResponseDTO signup(MemberRequestDTO requestDto) {
        if (memberRepository.existsByEmail(requestDto.getEmail())) {
            throw new RuntimeException("이미 가입되어 있는 유저입니다");
        }

        Member member = requestDto.toMember(passwordEncoder);
        return MemberResponseDTO.of(memberRepository.save(member));
    }

    public TokenDTO login(MemberRequestDTO requestDto) {
        UsernamePasswordAuthenticationToken authenticationToken = requestDto.toAuthentication();

        Authentication authentication = managerBuilder.getObject().authenticate(authenticationToken);

        return tokenProvider.generateTokenDto(authentication);
    }

}

AuthService 클래스 필드 :

AuthenticationManagerBuilder: 스프링 시큐리티의 인증 매니저를 구성
MemberRepository: 회원 정보를 처리
PasswordEncoder: 비밀번호를 해시하여 저장하고 검증하는 데 사용
TokenProvider: JWT 토큰을 생성하고 검증하는 데 사용

AuthService 메서드 :

signup(MemberRequestDTO requestDto): 회원 가입
- existsByEmail(requestDto.getEmail()): 이메일이 이미 존재하는지 확인하고 이미 가입된 이메일이라면 예외처리
- requestDto.toMember(passwordEncoder): 요청 DTO를 회원 엔티티로 변환하고 비밀번호는 인코딩
- MemberResponseDTO.of(memberRepository.save(member)): 회원 엔티티를 저장하고 저장된 회원 정보를 응답 DTO로 변환하여 반환
login(MemberRequestDTO requestDto): 로그인
- requestDto.toAuthentication(): 요청 DTO를 스프링 시큐리티의 인증 객체로 변환
- managerBuilder.getObject().authenticate(authenticationToken): 변환된 인증 객체를 사용하여 사용자를 인증
- tokenProvider.generateTokenDto(authentication): 사용자의 인증 정보를 기반으로 JWT 토큰을 생성하고, 토큰을 포함한 DTO를 반환

MemberService

/service/MemberService

서비스 클래스는 회원 정보 조회 및 수정에 관한 비즈니스 로직을 담당

package hello.hellospring.user.service;

import hello.hellospring.user.config.SecurityUtil;
import hello.hellospring.user.DTO.MemberResponseDTO;
import hello.hellospring.user.entity.Member;
import hello.hellospring.user.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class MemberService {
    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    public MemberResponseDTO getMyInfoBySecurity() {
        return memberRepository.findById(SecurityUtil.getCurrentMemberId())
                .map(MemberResponseDTO::of)
                .orElseThrow(() -> new RuntimeException("로그인 유저 정보가 없습니다"));
    }

    @Transactional
    public MemberResponseDTO changeMemberNickname(String email, String nickname) {
        Member member = memberRepository.findByEmail(email).orElseThrow(() -> new RuntimeException("로그인 유저 정보가 없습니다"));
        member.setNickname(nickname);
        return MemberResponseDTO.of(memberRepository.save(member));
    }

    @Transactional
    public MemberResponseDTO changeMemberPassword(String email, String exPassword, String newPassword) {
        Member member = memberRepository.findById(SecurityUtil.getCurrentMemberId()).orElseThrow(() -> new RuntimeException("로그인 유저 정보가 없습니다"));
        if (!passwordEncoder.matches(exPassword, member.getPassword())) {
            throw new RuntimeException("비밀번호가 맞지 않습니다");
        }
        member.setPassword(passwordEncoder.encode((newPassword)));
        return MemberResponseDTO.of(memberRepository.save(member));
    }
}

getMyInfoBySecurity(): 헤더에 있는 token값을 토대로 Member의 data를 건내주는 메서드
changeMemberNickname() : 회원 닉네임 변경
changeMemberPassword () : 회원 비밀번호 변경

컨트롤러 구현

AuthController

/controller/AuthController.java

package hello.hellospring.user.controller;

import hello.hellospring.user.DTO.MemberRequestDTO;
import hello.hellospring.user.DTO.MemberResponseDTO;
import hello.hellospring.user.DTO.TokenDTO;
import hello.hellospring.user.service.AuthService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/auth")
@RequiredArgsConstructor
public class AuthController {
    private final AuthService authService;

    @PostMapping("/signup")
    public ResponseEntity<MemberResponseDTO> signup(@RequestBody MemberRequestDTO requestDto) {
        return ResponseEntity.ok(authService.signup(requestDto));
    }

    @PostMapping("/login")
    public ResponseEntity<TokenDTO> login(@RequestBody MemberRequestDTO requestDto) {
        return ResponseEntity.ok(authService.login(requestDto));
    }
}

MemberController

/controller/MemberController.java

package hello.hellospring.user.controller;

import hello.hellospring.user.DTO.ChangePasswordRequestDTO;
import hello.hellospring.user.DTO.MemberRequestDTO;
import hello.hellospring.user.DTO.MemberResponseDTO;
import hello.hellospring.user.service.MemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController

@RequiredArgsConstructor
@RequestMapping("/member")
public class MemberController {

    private final MemberService memberService;

    @GetMapping("/me")
    public ResponseEntity<MemberResponseDTO> getMyMemberInfo() {
        MemberResponseDTO myInfoBySecurity = memberService.getMyInfoBySecurity();
        System.out.println(myInfoBySecurity.getEmail());
        return ResponseEntity.ok((myInfoBySecurity));
        // return ResponseEntity.ok(memberService.getMyInfoBySecurity());
    }

    @PostMapping("/nickname")
    public ResponseEntity<MemberResponseDTO> setMemberNickname(@RequestBody MemberRequestDTO request) {
        return ResponseEntity.ok(memberService.changeMemberNickname(request.getEmail(), request.getNickname()));
    }

    @PostMapping("/password")
    public ResponseEntity<MemberResponseDTO> setMemberPassword(@RequestBody ChangePasswordRequestDTO request) {
        return ResponseEntity.ok(memberService.changeMemberPassword(request.getEmail(),request.getExPassword(), request.getNewPassword()));
    }

}

컨트롤러는 @RestController 라는 어노테이션을 사용하여 RESTful 하게 작성해보았다. @RestController는 @Controller에 @ResponseBody가 추가된 것이다. @RestController의 주용도는 Json 형태로 객체 데이터를 반환하는 것이다. 데이터를 응답으로 제공하는 REST API를 개발할 때 주로 사용하며 객체를 ResponseEntity로 감싸 반환한다.

동작 과정

Client는 URI 형식으로 웹 서비스에 요청
DispatcherServlet이 요청을 처리할 대상 탐색
HandlerAdapter를 통해 요청을 Controller에 위임
Controller는 요청 처리 후 객체 반환
반환되는 객체는 Json으로 Serialize되어 사용자에게 반환

API 명세서

회원가입

Method	기능	REST API	Request	Response
POST	회원가입	/auth/signup	MemberRequestDTO :{ "email" : "token-test3@naver.com", "password" : "test33", "nickname" : "닉네임3" }	MemberResponseDTO :{ "email": "token-test3@naver.com", "nickname": "닉네임3" }

로그인

Method	기능	REST API	Request	Response
POST	로그인	/auth/login	MemberRequestDTO :{ "email" : "token-test3@naver.com", "password" : "test33", "nickname" : "닉네임3" }	TokenDTO :{ "grantType": "bearer", "accessToken": "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiIzIiwiYXV0aCI6IlJPTEVfVVNFUiIsImV4cCI6MTcxMDI5Nzg5NH0.1CKQXy2aJnaxdjQgWKCkkpLwajE9XNODyu_LS-qLW1blSrWGKOzNPpDxZkUAdA3ZC7OjLWR7BdH9odVmTXs-QQ", "tokenExpiresIn": 1710297894971 }

내 정보 조회

Method	기능	REST API	Request	Response
GET	내 정보 조회	/member/me	Authorization : 로그인 시 발급 받는 Access Token	MemberResponseDTO :{ "email": "token-test3@naver.com", "nickname": "닉네임3" }

'인실리코젠' 카테고리의 다른 글

[인실리코젠] Spring Security Interceptor 와 JSESSION ID에 대하여 (1)	2024.09.22
[인실리코젠] Spring CRUD - 게시글 조회 구현 중 겪은 트러블 슈팅 (0)	2024.06.17
[인실리코젠] Spring CRUD - 회원 가입 (0)	2024.02.16
[인실리코젠] Spring CRUD 프로젝트 요구 사항 분석 및 데이터베이스 설계 (1)	2024.02.16
[인실리코젠] Web Crawling - Finish (1)	2024.02.02

프로젝트 흐름 ※ 도커 제외

JWT (JSON Web Token)

JWT 등록

TokenProvider

JwtFilter

JwtAccessDenideHandler

JwtAuthenticationEntryPoint

Config 구현

JwtSecurityConfig

WebSecurityConfig

엔터티(Entity) 및 Repository 구현

Member

Builder 패턴이란?

MemberRepository

Service 구현

CustomUserDetailsService

AuthService

MemberService

컨트롤러 구현

AuthController

MemberController

API 명세서

'인실리코젠' 카테고리의 다른 글

티스토리툴바