스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 토큰 제공자 추가하기

1. 서론

최근 마이크로서비스 아키텍처와 RESTful API의 발전으로 인해 백엔드 개발의 중요성이 더욱 부각되고 있습니다. 오늘 강좌에서는 스프링 부트를 이용한 백엔드 개발을 통해 JSON Web Token(JWT)을 사용하여 사용자 인증을 구현하는 방법에 대해 알아보겠습니다. 이 강좌는 로그인 및 로그아웃 기능을 포함한 JWT 기반의 토큰 제공자를 추가하는 것에 중점을 두고 있습니다.

2. 스프링 부트란?

스프링 부트는 스프링 프레임워크를 기반으로 하여 빠르고 쉽게 스프링 애플리케이션을 개발할 수 있도록 돕는 도구입니다. 복잡한 XML 설정 없이 데모 및 실제 애플리케이션을 손쉽게 개발할 수 있게 해줍니다. 또한, 스프링 부트는 내장형 서버를 지원하여 외부 서버에 배포하지 않고도 로컬에서 애플리케이션을 실행할 수 있습니다.

3. JWT의 이해

JSON Web Token(JWT)은 데이터 전송을 위한 개방형 표준으로, 클라이언트와 서버 간에 안전하게 정보를 전송하는 데 사용됩니다. JWT는 주로 인증 및 정보 교환에 사용됩니다. JWT는 세 부분으로 구성됩니다:

  • Header (헤더): 토큰의 유형과 암호화 알고리즘을 정의합니다.
  • Payload (페이로드): 사용자 정보를 저장하는 부분으로, 사용자 ID와 같은 정보가 포함됩니다.
  • Signature (서명): 헤더와 페이로드를 조합하여 비밀 키로 서명한 부분입니다.

4. 스프링 부트 프로젝트 설정

우선, 스프링 부트 프로젝트를 설정해야 합니다. Spring Initializr 웹사이트를 방문하여 새 프로젝트를 생성합니다. 다음의 종속성을 추가해야 합니다:

  • Spring Web
  • Spring Security
  • Spring Data JPA
  • H2 Database (또는 원하는 데이터베이스)
  • jjwt (JWT 사용을 위한 라이브러리)

5. 사용자의 엔티티 클래스 생성

사용자 정보를 저장하기 위한 엔티티 클래스를 생성합니다. 다음은 User 엔티티 클래스의 예입니다:


@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String username;

    private String password;

    // Getter and Setter methods
}

            

6. JWT 유틸리티 클래스 작성

JWT를 생성하고 검증하기 위한 유틸리티 클래스를 작성합니다.


@Component
public class JwtUtil {
    private String secretKey = "mySecretKey"; // 비밀 키

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 10 * 60 * 1000)) // 만료 시간 설정
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }

    public boolean validateToken(String token, String username) {
        final String extractedUsername = extractUsername(token);
        return (extractedUsername.equals(username) && !isTokenExpired(token));
    }

    public String extractUsername(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();
    }

    private boolean isTokenExpired(String token) {
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getExpiration().before(new Date());
    }
}

            

7. 스프링 시큐리티 설정

Spring Security를 설정하여 JWT 기반의 인증 프로세스를 구현합니다. 먼저, SecurityFilterChain을 설정합니다.


@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests().antMatchers("/authenticate").permitAll()
            .anyRequest().authenticated();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().withUser("user").password(passwordEncoder().encode("password")).roles("USER");
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

            

8. JWT 요청 필터 작성

사용자 요청에서 JWT를 필터링하여 인증 여부를 확인하는 JWT Request Filter를 작성합니다.


@Component
public class JwtRequestFilter extends OncePerRequestFilter {
    @Autowired
    private JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        final String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 명시된 사용자 인증 처리
        }
        chain.doFilter(request, response);
    }
}

            

9. 로그인 및 토큰 생성 컨트롤러 작성

사용자의 로그인 요청을 처리하고, JWT를 생성하는 컨트롤러를 작성합니다.


@RestController
public class AuthController {
    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/authenticate")
    public ResponseEntity authenticate(@RequestBody AuthRequest authRequest) throws Exception {
        try {
            authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(authRequest.getUsername(), authRequest.getPassword()));
        } catch (BadCredentialsException e) {
            throw new Exception("잘못된 사용자 이름 또는 비밀번호", e);
        }

        final String jwt = jwtUtil.generateToken(authRequest.getUsername());
        return ResponseEntity.ok(new AuthResponse(jwt));
    }
}

            

10. 로그아웃 관리

JWT은 클라이언트 측에서 관리되기 때문에 로그아웃 기능은 클라이언트에서 토큰을 삭제하여 단순히 수행할 수 있습니다. 하지만, 서버 측에서 로그아웃을 구현하는 방법도 있습니다. 예를 들어, 블랙리스트를 유지하여 만료되기 전에 로그아웃된 토큰을 차단할 수 있습니다.

11. 미들웨어 구성

미들웨어를 사용하여 요청을 전처리하고 후처리하는 기능을 추가할 수 있습니다. 예를 들어, 모든 요청에 대해 JWT를 검사하거나, 특정 엔드포인트에 대한 접근을 제한할 수 있습니다.

12. 테스트와 디버깅

상당한 수준의 테스트를 적용하여 코드의 품질을 보장해야 합니다. 각 서비스, 컨트롤러 및 리포지토리에 대한 단위 테스트를 작성합니다. 스프링 부트는 Junit과 Mockito를 통해 효과적인 테스트 환경을 제공합니다.

13. 결론

이 강좌에서는 스프링 부트와 JWT를 사용하는 로그인 및 로그아웃 구현 방법에 대해 자세히 살펴보았습니다. JWT는 클라이언트와 서버 간의 통신을 안전하게 처리하는 좋은 방법이며, 이를 통해 웹 애플리케이션의 보안을 한층 강화할 수 있습니다. 이러한 방식으로 백엔드 개발에 대한 이해도를 높이고, 실제 프로젝트에서는 이러한 구현을 통해 사용자 인증 기능을 보다 효율적으로 관리할 수 있을 것입니다.

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 토큰 필터 구현하기

1. 서론

스프링 부트(Spring Boot)는 Java 기반 웹 애플리케이션을 손쉽게 개발할 수 있도록 도와주는 프레임워크입니다. 최근 들어 웹 애플리케이션에 대한 수요가 급증하면서, 보안 및 인증에 대한 이해가 중요해졌습니다. 이 강좌에서는 JSON Web Token(JWT)을 사용하여 로그인 및 로그아웃 기능을 구현하고, 필터를 통해 JWT 토큰을 검증하는 방법을 알아보겠습니다. 이 과정에서 스프링 부트의 다양한 기능을 활용하여 더 안전하고 효율적인 백엔드 애플리케이션을 구축하는 법을 배우게 될 것입니다.

2. JWT란 무엇인가?

JSON Web Token(JWT)은 두 개의 엔티티 간에 정보를 안전하게 전송하기 위해 사용하는 JSON 기반의 오브젝트입니다. JWT는 사용자 인증뿐만 아니라, 클레임 기반의 정보 전송을 위한 표준으로 자리 잡고 있습니다. JWT는 다음과 같이 세 가지 구성 요소로 나뉩니다:

  • 헤더(Header): JWT의 타입과 해싱 알고리즘을 정의합니다.
  • 페이로드(Payload): 전송하려는 클레임 정보가 포함됩니다.
  • 서명(Signature): 헤더와 페이로드를 결합한 후 비밀 키를 사용하여 생성됩니다. 이를 통해 JWT의 무결성을 확인할 수 있습니다.

3. 스프링 부트 프로젝트 설정하기

스프링 부트 프로젝트를 시작하려면 기본적인 설정부터 해야 합니다. 이러한 설정을 위해 스프링 이니셜라이저(Spring Initializr)를 이용할 수 있습니다. 프로젝트 생성 시 선택해야 할 사항은 다음과 같습니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: Stable version (Latest)
  • Dependencies: Spring Web, Spring Security, Spring Data JPA, Spring Boot DevTools, H2 Database

프로젝트가 생성되면 IDE에서 열고, 필요한 의존성을 추가할 수 있습니다.

4. 엔티티 클래스 및 리포지토리 생성하기

우선 유저(User) 엔티티를 정의해야 합니다. 간단한 User 엔티티는 사용자 정보를 저장하는 클래스입니다. 이를 통해 우리는 데이터베이스와 상호작용할 수 있습니다.

package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    
    // Getters and Setters
}

리포지토리는 엔티티와 데이터베이스의 CRUD 작업을 수행하는 데 필요합니다.

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

5. 서비스 클래스 생성하기

비즈니스 로직을 처리하는 서비스 클래스가 필요합니다. 이 클래스에서는 사용자 등록, 로그인 등의 기능을 구현합니다.

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private BCryptPasswordEncoder passwordEncoder;
    
    public User register(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userRepository.save(user);
    }
    
    public User findUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }
}

6. 보안 설정 및 JWT 생성하기

스프링 시큐리티를 사용하여 애플리케이션의 보안을 강화할 수 있습니다. 이를 위해 SecurityConfig 클래스를 생성하고, JWT 토큰을 생성하는 클래스를 추가해야 합니다.

package com.example.demo.config;

import com.example.demo.security.JwtAuthenticationFilter;
import org.springframework.beans.factory.annotation.Autowired;
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.builders.AuthenticationManagerBuilder;
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.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

7. JWT 생성 및 검증 구현하기

로그인 시 사용자의 정보를 바탕으로 JWT를 생성하여 클라이언트에 전달합니다. 이를 위해 JWT 유틸리티 클래스를 생성하여 토큰 생성 및 검증 작업을 수행합니다.

package com.example.demo.security;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Component
public class JwtUtil {
    
    private final String SECRET_KEY = "secret_key";
    private final long EXPIRATION_TIME = 86400000; // 1 day

    public String generateToken(String username) {
        Map<String, Object> claims = new HashMap<>();
        return createToken(claims, username);
    }

    private String createToken(Map<String, Object> claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public boolean validateToken(String token, String username) {
        final String extractedUsername = extractUsername(token);
        return (extractedUsername.equals(username) && !isTokenExpired(token));
    }

    private boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    private Date extractExpiration(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getExpiration();
    }

    public String extractUsername(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getSubject();
    }
}

8. 로그인 및 로그아웃 기능 구현하기

이제 사용자가 로그인하면 JWT를 발급받고, 로그아웃 시에는 클라이언트가 토큰을 삭제하는 방식으로 구현합니다. 아래는 로그인 API의 예시입니다.

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.security.JwtUtil;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @Autowired
    private UserService userService;

    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity<String> login(@RequestBody User user) {
        User foundUser = userService.findUserByUsername(user.getUsername());
        if (foundUser != null && passwordEncoder.matches(user.getPassword(), foundUser.getPassword())) {
            return ResponseEntity.ok(jwtUtil.generateToken(foundUser.getUsername()));
        }
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid credentials");
    }

    @PostMapping("/logout")
    public ResponseEntity<String> logout() {
        // 로그아웃 기능은 클라이언트 측에서 구현하도록 합니다.
        return ResponseEntity.ok("Successfully logged out.");
    }
}

9. JWT 필터 구현하기

JWT 필터를 구현하여 모든 요청에서 JWT를 검증하고, 인증을 처리하는 과정이 필요합니다. 이를 위해 JwtAuthenticationFilter 클래스를 생성합니다.

package com.example.demo.security;

import io.jsonwebtoken.ExpiredJwtException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;

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

public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private UserDetailsService userDetailsService;

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

        String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            try {
                username = jwtUtil.extractUsername(jwt);
            } catch (ExpiredJwtException e) {
                System.out.println("JWT is expired");
            }

            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                if (jwtUtil.validateToken(jwt, userDetails.getUsername())) {
                    UsernamePasswordAuthenticationToken authenticationToken = 
                            new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
                }
            }
        }
        filterChain.doFilter(request, response);
    }
}

10. 결론

이번 강좌에서는 스프링 부트를 이용하여 JWT를 통한 로그인 및 로그아웃 기능을 구현하는 방법을 배웠습니다. 우리는 JWT 토큰을 생성하고 검증하는 방법, 그리고 스프링 시큐리티를 활용하여 애플리케이션의 보안을 강화하는 방법에 대해서도 알아보았습니다. 이 과정을 통해 백엔드 애플리케이션의 인증 및 권한 관리를 더 안전하게 처리할 수 있는 기반을 마련할 수 있습니다. 더불어, 스프링 부트의 다양한 기능을 활용하여 효율적이고 안전한 웹 애플리케이션 개발을 실현할 수 있을 것입니다.

11. 참고 자료

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 토큰 기반 인증이란

1. 서론

현대 웹 애플리케이션에서는 사용자 인증과 권한 관리를 효율적으로 수행하기 위한 여러 가지 방법이 존재합니다. 이 중에서 JSON Web Token(JWT)은 널리 사용되는 인증 방법 중 하나입니다. 특히 스프링 부트(Spring Boot)를 사용하는 백엔드 개발자에게는 JWT를 통해 로그인과 로그아웃 기능을 구현하여 보다 안전하고 효율적인 사용자 인증 시스템을 구축할 수 있습니다. 본 강좌에서는 JWT의 개념, 스프링 부트를 이용한 JWT 기반 인증 구현 방법, 로그인과 로그아웃의 절차에 대해 상세히 설명하겠습니다.

2. JWT란 무엇인가?

JWT는 JSON 웹 토큰의 약자로, 사용자와 서버 간의 정보를 안전하게 전송하기 위한 개방형 표준(RFC 7519)입니다. JWT는 보통 다음과 같은 경우에 사용됩니다:

  • 사용자 인증
  • 정보 교환
  • 권한 부여

JWT의 특징은 다음과 같습니다:

  • 자체적으로 정보를 담을 수 있다.
  • 서명(Signature)으로 변조를 방지할 수 있다.
  • HTTP 전송에서 쉽게 사용할 수 있다.

JWT는 세 부분으로 구성되어 있습니다: 헤더(Header), 페이로드(Payload), 서명(Signature). 이들 각각에 대한 자세한 설명은 다음과 같습니다.

2.1 헤더 (Header)

JWT의 헤더는 두 가지 정보를 포함합니다. 즉, 토큰의 유형(type)과 사용할 알고리즘(예: HMAC SHA256 또는 RSA) 입니다.

{
    "alg": "HS256",
    "typ": "JWT"
}

2.2 페이로드 (Payload)

페이로드는 JWT의 두 번째 부분으로, 사용자에 대한 정보와 클레임(claims)을 담고 있습니다. 클레임은 사용자의 정보, 권한 및 기타 메타데이터를 포함할 수 있습니다. 예를 들어:

{
    "sub": "1234567890",
    "name": "John Doe",
    "iat": 1516239022
}

이 예시에서 “sub”는 사용자의 고유 ID, “name”은 사용자명, “iat”는 발행된 시간을 나타냅니다.

2.3 서명 (Signature)

마지막으로 서명은 헤더와 페이로드를 결합하고 비밀 키를 사용하여 해시를 생성한 것입니다. 이렇게 하면 데이터의 무결성을 확인할 수 있습니다. 예를 들어:

HMACSHA256(
    base64UrlEncode(header) + "." +
    base64UrlEncode(payload),
    secret)

이 과정을 통해 JWT를 생성하고, 수신자는 소유한 비밀 키를 사용하여 토큰의 유효성을 검사할 수 있습니다.

3. 스프링 부트 설정

스프링 부트를 이용하여 JWT 기반의 사용자 인증 시스템을 구현하기 위해, 먼저 스프링 부트 프로젝트를 설정해야 합니다. Spring Initializr를 사용하여 새로운 프로젝트를 생성하고 필요한 종속성(Ddependencies)을 추가해야 합니다. 이번 강좌에서는 Spring Web, Spring Security, 그리고 jjwt 라이브러리를 사용할 것입니다.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'io.jsonwebtoken:jjwt:0.9.1'
}

4. 스프링 시큐리티와 JWT 설정

스프링 시큐리티(Spring Security)를 사용하여 기본 인증 및 권한 부여를 설정할 수 있습니다. 이를 위해 SecurityConfig 클래스를 작성하고 HTTP 요청에 대한 보안 규칙을 정의해야 합니다.

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

위 설정에서는 /api/auth/** 라우트를 모든 요청에 대해 허용하고, 나머지 요청은 인증이 필요하도록 설정했습니다. 세션 관리는 STATLESS로 설정하여 JWT를 사용한 토큰 기반 인증을 활용합니다.

5. 사용자 인증과 JWT 발급

사용자가 로그인하면, 서버는 해당 사용자의 정보를 기반으로 JWT를 발급합니다. 사용자 인증을 위한 AuthController 클래스를 작성하고, 로그인 요청을 처리하는 메서드를 구현해야 합니다.

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtProvider jwtProvider;

    @PostMapping("/login")
    public ResponseEntity authenticateUser(@RequestBody LoginRequest loginRequest) {
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword()));

        SecurityContextHolder.getContext().setAuthentication(authentication);

        String jwt = jwtProvider.generateToken(authentication);
        return ResponseEntity.ok(new JwtResponse(jwt));
    }
}

6. 로그아웃 구현

JWT는 상태 값을 서버에 저장하지 않기 때문에 로그아웃 구현이 다른 방식과는 다릅니다. 일반적으로 클라이언트 측에서 JWT를 삭제하거나 만료시키는 방식으로 로그아웃을 처리합니다. 예를 들어 클라이언트가 로그아웃 요청을 보내면, JWT 토큰을 삭제하고 이후 요청에서는 더 이상 이 토큰을 사용하지 않도록 합니다.

@PostMapping("/logout")
    public ResponseEntity logoutUser() {
        // 클라이언트 토큰 삭제를 위한 응답 처리 전달
        return ResponseEntity.ok(new MessageResponse("User logged out successfully!"));
    }

7. JWT 유효성 검증

서버에서 JWT를 검증하는 방법은 토큰의 서명을 확인하고, 유효 기간(expiration)을 체크하는 것입니다. 이 과정을 위해 JwtProvider를 작성할 수 있습니다.

@Component
public class JwtProvider {
    @Value("${jwt.secret}")
    private String jwtSecret;

    public String generateToken(Authentication authentication) {
        return Jwts.builder()
            .setSubject(authentication.getName())
            .setIssuedAt(new Date())
            .setExpiration(new Date((new Date()).getTime() + 86400000)) // 1일
            .signWith(SignatureAlgorithm.HS512, jwtSecret)
            .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

8. 결론

JWT를 통해 스프링 부트에서 효율적으로 사용자 인증을 구현할 수 있음을 보았습니다. 이와 같은 토큰 기반 인증 방식을 통해 서버의 상태를 유지하지 않고도 보다 유연한 애플리케이션 구조를 만들 수 있습니다. 본 강좌에서 설명한 내용을 바탕으로 여러분의 프로젝트에 JWT를 활용하여 사용자 인증 시스템을 구현해 보시기 바랍니다.

앞으로도 다양한 웹 개발 관련 주제로 여러분께 유익한 정보와 강좌를 제공할 예정입니다. 감사합니다.

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 토큰 서비스 추가하기

스프링 부트는 현대적인 웹 애플리케이션 개발을 위한 강력한 프레임워크입니다. 본 강좌에서는 JWT(Json Web Token)를 사용하여 사용자 인증을 구현하고, 이를 통해 로그인 및 로그아웃 기능을 구현하는 방법에 대해 단계별로 설명하겠습니다. 이 과정에서는 토큰 서비스를 추가하여 보안 및 사용자 관리 기능을 향상시키는 방법도 다룰 것입니다.

1. JWT란 무엇인가?

JWT는 JSON을 기반으로 한 개방형 표준으로, 정보를 안전하게 전달하기 위한 방식을 제공합니다. JWT는 세 부분으로 구성되어 있습니다: Header, Payload, Signature.

1.1 Header

Header는 JWT의 타입과 해싱 알고리즘을 지정합니다. 예를 들어:

    {
      "alg": "HS256",
      "typ": "JWT"
    }

1.2 Payload

Payload 부분은 사용자의 정보와 사용자 ID, 만료 시간 등을 포함하는 본문입니다. 이 부분은 알아보기 쉬운 JSON 형식으로 구성되어 있습니다.

1.3 Signature

Signature는 인코딩된 Header와 Payload를 조합하여 비밀키로 서명한 값입니다. 이 값은 토큰의 무결성을 보장하고, 서버가 토큰을 검증하는 데 사용됩니다.

2. 프로젝트 설정

이 강좌에서는 스프링 부트와 Maven을 사용하여 프로젝트를 생성합니다. IntelliJ IDEA 또는 Eclipse와 같은 IDE를 이용하여 프로젝트를 설정할 수 있습니다.

2.1 Maven 프로젝트 생성

이클립스 또는 IntelliJ IDEA에서 Maven 프로젝트를 생성한 후, pom.xml 파일에 다음 의존성을 추가합니다.

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjsonwebtoken</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

2.2 Spring Security 설정

Spring Security를 사용하여 기본적인 보안 설정을 해줍니다. SecurityConfig 클래스를 생성하고, 사용자 인증 및 권한 설정을 추가합니다.

    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.annotation.web.configuration.WebSecurityConfigurerAdapter;

    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated();
        }
    }
    

3. JWT 생성 및 검증

이제 JWT를 생성하고 검증하는 방법을 살펴보겠습니다. JWTUtil 클래스를 생성하여 필요한 메서드를 구현합니다.

    import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import org.springframework.stereotype.Component;

    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;

    @Component
    public class JWTUtil {
        private String secretKey = "secret";

        public String generateToken(String username) {
            Map<String, Object> claims = new HashMap<>();
            return createToken(claims, username);
        }

        private String createToken(Map<String, Object> claims, String subject) {
            return Jwts.builder()
                    .setClaims(claims)
                    .setSubject(subject)
                    .setIssuedAt(new Date(System.currentTimeMillis()))
                    .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // 10시간
                    .signWith(SignatureAlgorithm.HS256, secretKey)
                    .compact();
        }

        public Boolean validateToken(String token, String username) {
            final String extractedUsername = extractUsername(token);
            return (extractedUsername.equals(username) && !isTokenExpired(token));
        }

        private String extractUsername(String token) {
            return extractAllClaims(token).getSubject();
        }

        private Claims extractAllClaims(String token) {
            return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody();
        }

        private Boolean isTokenExpired(String token) {
            return extractAllClaims(token).getExpiration().before(new Date());
        }
    }
    

4. 사용자 인증 및 로그인 API 구현

이제 사용자 인증 및 로그인 API를 구현할 차례입니다. AuthController 클래스를 생성하여 필요한 메서드를 추가합니다.

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.ResponseEntity;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    import org.springframework.web.bind.annotation.*;

    @RestController
    @RequestMapping("/api/auth")
    public class AuthController {

        @Autowired
        private AuthenticationManager authenticationManager;

        @Autowired
        private JWTUtil jwtUtil;

        @PostMapping("/login")
        public ResponseEntity<String> login(@RequestBody AuthRequest authRequest) {
            authenticationManager.authenticate(
                    new UsernamePasswordAuthenticationToken(authRequest.getUsername(), authRequest.getPassword())
            );
            final String token = jwtUtil.generateToken(authRequest.getUsername());
            return ResponseEntity.ok(token);
        }
    }

    class AuthRequest {
        private String username;
        private String password;

        // getters and setters
    }
    

5. 로그아웃 API 구현

로그아웃 API는 클라이언트에서 JWT 토큰을 삭제하여 구현합니다. 별도의 로그아웃 API가 필요하지 않지만 이 부분에 대한 예제를 추가할 수 있습니다.

6. 토큰 서비스 추가하기

토큰 서비스를 추가하여 사용자 정보를 관리하고, 필요한 경우 사용자 세션을 관리하는 기능을 추가합니다. TokenService 클래스를 생성하여 이 기능을 구현합니다.

    import org.springframework.stereotype.Service;

    @Service
    public class TokenService {

        @Autowired
        private JWTUtil jwtUtil;

        public String refreshToken(String token) {
            if (jwtUtil.isTokenExpired(token)) {
                String username = jwtUtil.extractUsername(token);
                return jwtUtil.generateToken(username);
            }
            return token;
        }
    }
    

7. 기타 고려사항 및 마무리

본 강좌에서는 JWT를 사용하여 로그인 및 로그아웃 기능을 구현하고, 사용자 인증을 위한 토큰 서비스를 추가하는 방법을 살펴보았습니다. 실제 애플리케이션에서는 JWT의 유효성 검사를 강화하고 사용자 권한 관리, 토큰 저장소 구현 등 추가적인 보안 조치가 필요합니다.

8. 결론

스프링 부트를 활용한 JWT 기반의 인증 시스템 구현은 현대 웹 애플리케이션의 보안을 강화하는 데 필수적인 요소가 되었습니다. 본 강좌를 통해 JWT의 기본 개념과 이를 활용한 인증 시스템 구현의 기초를 이해하시기 바랍니다. 더 나아가, 실제 프로젝트에서 요구되는 다양한 기능을 구현하고 최적화하는 경험을 쌓아보시기 바랍니다.

이 강좌가 여러분의 스프링 부트 백엔드 개발에 도움이 되길 바랍니다!

© 2023 Your Blog Name. All rights reserved.

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 컨트롤러 추가하기

1. 서론

현대 웹 애플리케이션에서 보안은 가장 중요한 요소 중 하나입니다. 사용자 인증 및 권한 부여는 이러한 보안을 유지하는 핵심 기능입니다.
이번 강좌에서는 스프링 부트를 이용한 백엔드 개발에서 JWT(JSON Web Token)를 사용하여 로그인 및 로그아웃 기능을 구현하는 방법을 자세히 알아보겠습니다.
이 강좌에서는 기본적인 스프링 부트 애플리케이션을 설정하고, JWT 기반 인증 시스템을 구현하며, 컨트롤러를 추가하여 RESTful API를 완성하는 과정을 다룹니다.

2. 스프링 부트란?

스프링 부트는 자바 기반의 프레임워크인 스프링(SPRING)을 보다 쉽게 사용할 수 있도록 도와주는 도구입니다.
이를 통해 개발자는 설정과 구성을 최소화하고, 빠르게 애플리케이션을 구축할 수 있습니다.
스프링 부트는 독립 실행 가능한 JAR 파일로 패키징되어 실행될 수 있으며, RESTful 서비스를 효율적으로 개발할 수 있습니다.
스프링 부트의 주요 특성은 다음과 같습니다:

  • 자동 구성: 스프링 부트는 개발자가 필요로 하는 기본 설정을 자동으로 구성해 줍니다.
  • 스타터 패키지: 개발자는 필요한 기능을 빠르게 추가할 수 있는 스타터 패키지를 사용할 수 있습니다.
  • 내장 서버: 스프링 부트는 톰캣, 제트티, 언더타우 등과 같은 내장 서버를 제공하여, 쉽게 애플리케이션을 실행할 수 있습니다.
  • 의존성 관리: Maven 또는 Gradle을 사용해 의존성을 소스 코드 내에서 간편하게 관리할 수 있습니다.

3. JWT란?

JWT( JSON Web Token)는 안전한 정보 전송을 위한 인터넷 표준 RFC 7519입니다. JWT는 JSON 객체를 사용하여 주체(sub), 발행자(iss), 만료 시간(exp) 등의 정보를 암호화하여 전달합니다.
JWT는 세 부분으로 구성됩니다:

  1. 헤더(header): JWT의 유형과 사용할 서명 알고리즘을 지정합니다.
  2. 페이로드(payload): 전송할 정보와 그 정보를 설명하는 메타데이터를 포함합니다.
  3. 서명(signature): 헤더와 페이로드를 안전하게 하여 변조를 방지합니다. 비밀 키를 사용하여 생성됩니다.

JWT는 트래픽이 높은 환경에서 API 인증으로 많이 사용됩니다. 세션을 서버에 저장할 필요가 없기 때문에 효율적이며, 클라이언트에 상태 정보를 보관할 수 있어
서버의 부하를 줄일 수 있습니다.

4. 프로젝트 설정

4.1. 스프링 부트 프로젝트 생성

스프링 부트 프로젝트를 생성하기 위해 Spring Initializr를 사용합니다.
필요한 설정을 다음과 같이 입력합니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.6.6 (가장 최신 버전)
  • Project Metadata:
    • Group: com.example
    • Artifact: jwt-demo
    • Name: jwt-demo
    • Description: JWT Authentication Demo
    • Packaging: Jar
    • Java: 11

그리고 다음의 의존성을 추가합니다:

  • Spring Web
  • Spring Security
  • Spring Data JPA
  • H2 Database
  • jjwt (Java JWT)

4.2. 프로젝트 구조

프로젝트 생성 후, 기본 패키지 구조는 다음과 같습니다:

    └── src
        └── main
            ├── java
            │   └── com
            │       └── example
            │           └── jwt_demo
            │               ├── JwtDemoApplication.java
            │               ├── controller
            │               ├── model
            │               ├── repository
            │               ├── security
            │               └── service
            └── resources
                ├── application.properties
                └── static
    

5. 데이터베이스 설정

H2 데이터베이스를 사용하여 사용자 정보를 저장할 수 있습니다.
application.properties 파일에 다음과 같이 설정합니다:

    spring.h2.console.enabled=true
    spring.datasource.url=jdbc:h2:mem:testdb
    spring.datasource.driverClassName=org.h2.Driver
    spring.datasource.username=sa
    spring.datasource.password=
    spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
    

6. 사용자 모델 만들기

사용자의 정보를 담기 위한 User 모델 클래스를 생성합니다.

    package com.example.jwt_demo.model;

    import javax.persistence.*;

    @Entity
    @Table(name = "users")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;

        @Column(nullable = false, unique = true)
        private String username;

        @Column(nullable = false)
        private String password;

        // Getters and Setters...

        public User() {}

        public User(String username, String password) {
            this.username = username;
            this.password = password;
        }
    }
    

7. 사용자 리포지토리 생성하기

사용자 정보를 데이터베이스에서 관리하기 위해 JPA 리포지토리 인터페이스를 생성합니다.

    package com.example.jwt_demo.repository;

    import com.example.jwt_demo.model.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;

    @Repository
    public interface UserRepository extends JpaRepository {
        User findByUsername(String username);
    }
    

8. 보안 설정

스프링 시큐리티를 통해 JWT 인증을 구현하겠습니다. 이를 위해 WebSecurityConfigurerAdapter을 상속하는 SecurityConfig 클래스를 생성합니다.

    package com.example.jwt_demo.security;

    import com.example.jwt_demo.filter.JwtRequestFilter;
    import com.example.jwt_demo.service.UserDetailsServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    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.WebSecurityConfigurerAdapter;
    import org.springframework.security.config.http.SessionCreationPolicy;
    import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {

        @Autowired
        private UserDetailsServiceImpl userDetailsService;

        @Autowired
        private JwtRequestFilter jwtRequestFilter;

        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.userDetailsService(userDetailsService);
        }

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/authenticate").permitAll()
                .anyRequest().