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

안녕하세요! 이번 블로그 포스트에서는 스프링 부트를 활용한 백엔드 개발 과정에서 JSON Web Token(JWT)을 사용하여 로그인 및 로그아웃 기능을 구현하는 방법에 대해 자세히 알아보겠습니다. 웹 애플리케이션 개발에서 인증과 권한 부여는 중요한 요소이며, JWT는 이를 효과적으로 관리하는 데 도움을 줍니다. 본 강좌에서는 JWT의 개념, 스프링 부트 설정, 의존성 추가 방법 등을 단계별로 설명하겠습니다.

1. JWT란 무엇인가?

JWT는 JSON Web Token의 약자로, 사용자 인증 정보를 안전하게 전송하기 위한 표준입니다. JWT는 세 가지 부분으로 구성되어 있습니다:

  • Header: 토큰의 타입과 해싱 알고리즘 정보를 담고 있습니다.
  • Payload: 사용자 정보와 같은 클레임을 포함합니다. 이 클레임은 공개된 정보(API 호출 시 필요한 정보)를 포함할 수 있습니다.
  • Signature: 헤더와 페이로드 정보를 기반으로 비밀 키를 사용하여 서명합니다. 이는 데이터의 무결성을 보장하며, 누군가 토큰을 위조했는지를 확인하는 데 사용됩니다.

JWT의 가장 큰 장점은 스테이트리스(stateless) 특성을 가진다는 것입니다. 서버에서 세션 상태를 유지할 필요가 없기 때문에, 확장성과 성능이 뛰어납니다.

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

스프링 부트를 사용하여 새로운 프로젝트를 생성합시다. 먼저, Spring Initializr(https://start.spring.io/)를 방문합니다. 아래의 설정을 적용하여 프로젝트를 생성합니다:

  • Project: Maven Project
  • Language: Java
  • Spring Boot: 2.6.0 (최신 버전 선택)
  • Group: com.example
  • Artifact: jwt-demo
  • Dependencies: Spring Web, Spring Security, Spring Data JPA, H2 Database

프로젝트를 생성한 후, IDE에서 해당 프로젝트를 열고 필요한 디렉토리 구조를 설정합니다.

3. 의존성 추가하기

먼저, pom.xml 파일에 필요한 의존성을 추가합니다:

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jwt</artifactId>
    <version>0.9.1</version>
</dependency>

이외에도 스프링 시큐리티와 데이터 JPA는 이미 추가되어 있으므로 추가 의존성은 필요하지 않습니다. H2 데이터베이스는 개발과 테스트 환경에 유용하게 사용할 수 있습니다.

4. 스프링 시큐리티 설정

JWT를 사용하기 위해 스프링 시큐리티를 설정해야 합니다. 먼저 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();
    }
}

위의 설정에서, 모든 사용자는 /api/auth/** 경로에 접근할 수 있습니다. 다른 모든 요청은 인증을 요구합니다.

5. JWT 생성 및 검증

JWT를 생성하고 검증하는 클래스를 작성합니다. 여기에 필요한 메서드를 정의합니다:

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

import java.util.Date;

@Service
public class JwtUtil {

    private String secretKey = "YourSecretKey"; // 비밀 키는 외부에 노출되지 않게 관리해야 합니다

    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .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) && !isExpired(token));
    }

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

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

    private boolean isExpired(String token) {
        return extractAllClaims(token).getExpiration().before(new Date());
    }
}

위의 JwtUtil 클래스는 토큰 생성, 유효성 검증 및 사용자 이름 추출을 위한 메서드를 포함하고 있습니다.

6. 인증 및 로그아웃 구현

이제 인증 및 로그아웃을 처리할 컨트롤러를 작성해보겠습니다. AuthController 클래스를 생성하세요:

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 JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity login(@RequestBody AuthRequest authRequest) {
        // 사용자 인증 로직 추가
        String token = jwtUtil.generateToken(authRequest.getUsername());
        return ResponseEntity.ok(token);
    }

    @PostMapping("/logout")
    public ResponseEntity logout() {
        // JWT를 블랙리스트에 추가하는 등의 로직 추가
        return ResponseEntity.ok("로그아웃 성공");
    }
}

위의 코드에서 AuthRequest는 사용자 이름과 비밀번호를 담는 DTO 클래스이며, 사용자 인증 로직은 구체적으로 구현해야 합니다. 일반적으로는 데이터베이스에서 인증 정보를 확인합니다.

7. 최종 테스트

이제 모든 설정을 마쳤습니다. Postman과 같은 도구를 사용하여 API를 테스트할 수 있습니다:

  • 로그인: POST /api/auth/login
  • 로그아웃: POST /api/auth/logout

로그인 API의 요청 본문에서 사용자 이름과 비밀번호를 전달하면, 성공적으로 JWT를 반환받을 수 있습니다. 반환된 JWT는 이후 API 호출 시 Authorization 헤더에 포함하여 전달해야 합니다.

8. 마무리

스프링 부트를 사용한 JWT 기반의 로그인 및 로그아웃 기능 구현에 대해 알아보았습니다. 인증 및 권한 부여는 웹 애플리케이션 개발에서 중요한 부분이며, JWT는 이를 간편하고 안전하게 처리할 수 있도록 돕습니다. 추가 기능으로는 JWT 블랙리스트 처리, 리프레시 토큰 구현 등을 고려해볼 수 있습니다.

이번 강좌가 스프링 부트 백엔드 개발에 도움이 되었기를 바랍니다. 더 많은 정보와 자료는 공식 문서와 커뮤니티를 통해 확인할 수 있습니다. 감사합니다!

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, 리프레시 토큰 도메인 구현하기

최근 몇 년간 마이크로서비스 아키텍처와 SPA(Single Page Application)가 점점 더 많은 인기를 끌면서, 웹 애플리케이션에서 보안 방안을 찾는 것이 매우 중요해졌습니다. 이 글에서는 스프링 부트를 활용해 JWT(JSON Web Token)를 이용한 로그인/로그아웃 기능과 리프레시 토큰을 사용하는 도메인을 구현하는 방법에 대해 자세히 설명하겠습니다.

목차

  1. 1. 서론
  2. 2. 스프링 부트란?
  3. 3. JWT란?
  4. 4. 개발 환경 설정
  5. 5. 로그인/로그아웃 기능 구현
  6. 6. 리프레시 토큰 구현
  7. 7. 결론

1. 서론

사용자 인증(authentication)과 인가(authorization)는 현대 웹 애플리케이션에서 중요한 문제입니다. 이러한 문제를 해결하기 위한 여러 가지 기술이 있지만, JWT는 그 중 가장 많이 사용되는 방법 중 하나입니다. 본 강좌에서는 스프링 부트를 활용하여 사용자 로그인 및 로그아웃 기능을 구축하고, JWT와 리프레시 토큰을 이용한 인증 메커니즘을 구현하는 방법을 배우게 됩니다.

2. 스프링 부트란?

스프링 부트(Spring Boot)는 스프링 프레임워크의 확장으로, Spring 기반의 애플리케이션을 쉽게 개발할 수 있도록 도와주는 편리한 도구입니다. 초기 설정이나 복잡한 XML 설정 없이 간단한 어노테이션으로 구현이 가능하여, 개발자들이 자주 사용하는 기능을 미리 구성해놓은 상태로 제공됩니다.

스프링 부트의 주요 특징은 다음과 같습니다:

  • 자체 내장 서버: 톰캣, 제티 등의 웹 서버를 포함하여, 별도의 서버 설치 없이 실행할 수 있습니다.
  • 자동 구성: 프로젝트에 포함된 라이브러리와 빈 설정에 따라 필요한 설정을 자동으로 구성합니다.
  • 쉬운 배포: Jar 파일로 패키징하여 쉽게 배포 가능하며, 클라우드 환경에서도 용이하게 사용할 수 있습니다.
  • 강력한 커뮤니티: 풍부한 문서와 예제, 다양한 플러그인으로 지원되는 큰 커뮤니티를 갖추고 있습니다.

3. JWT란?

JWT(JSON Web Token)는 주로 인증과 인가를 위한 솔루션으로 사용되는 compact, URL-safe means of representing claims to be transferred between two parties. 여기서 ‘claims’는 사용자에 대한 정보로, 이를 통해 서버와 클라이언트 간의 신뢰 관계를 유지할 수 있습니다.

JWT는 크게 세 부분으로 구성됩니다:

  1. Header: 토큰의 타입(typ)과 해싱 알고리즘(alg)의 정보가 포함됩니다.
  2. Payload: 사용자에 대한 정보와 클레임 데이터를 포함합니다. 여기서는 사용자 ID, 권한 등의 정보가 들어갑니다.
  3. Signature: Header와 Payload를 조합한 후, 비밀키를 사용해 서명합니다. 이로써 토큰의 무결성과 진위를 보장할 수 있습니다.

JWT의 장점으로는 다음과 같은 것들이 있습니다:

  • 무상태적 특징: 서버는 JWT를 변조할 수 없으므로 상태를 유지하지 않고, 인증이 필요할 때마다 클라이언트가 JWT를 전송합니다.
  • 보안성: 클라이언트가 JWT를 보유하므로 서버의 데이터베이스를 조회할 필요가 없어, 데이터베이스의 부하를 줄일 수 있습니다.
  • CRUD 작업의 단순화: 인증 정보와 상태를 쉽게 관리할 수 있으며, IAM(Identity and access management)과 같은 복잡한 로직을 단순화할 수 있습니다.

4. 개발 환경 설정

이제 스프링 부트를 이용한 프로젝트를 위한 개발 환경을 설정해보겠습니다. 이를 위해 다음과 같은 도구를 사용합니다:

  • Java 11: JDK 11 이상을 설치합니다.
  • IDE: IntelliJ IDEA 또는 Eclipse를 사용하는 것이 좋습니다.
  • Gradle 또는 Maven: 의존성 관리를 위해 Gradle 또는 Maven을 선택합니다.
  • Postman: API 테스트 도구로 Postman을 이용합니다.

프로젝트를 생성할 때는 Spring Initializr(start.spring.io)를 통해 기본 설정을 해줄 수 있습니다. 필요한 의존성으로는 다음과 같은 것들을 추가합니다:

  • Spring Web
  • Spring Security
  • Spring Data JPA
  • H2 Database (또는 여러분이 선택한 RDBMS)
  • Spring Boot DevTools (개발 편의를 위한 도구)
  • jjwt (Java JWT 라이브러리)

프로젝트 생성 후 Viewer, Controller, Service, Repository 등 필요한 클래스를 생성합니다. `application.yml` 파일에 데이터베이스 관련 설정을 추가해야 합니다.

5. 로그인/로그아웃 기능 구현

로그인 및 로그아웃 기능을 구현하기 위해 다음의 구성 요소가 필요합니다:

5.1. User Entity

사용자 정보를 저장하기 위해 User 엔티티를 생성합니다.


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

    private String username;
    private String password;
    private String role;

    // Getter, Setter, Constructor
}

5.2. User Repository

User 엔티티에 대한 CRUD 작업을 수행할 UserRepository를 생성합니다.


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

5.3. User Service

사용자 등록 및 인증 로직을 구현하기 위한 UserService를 생성합니다.


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

    public User register(User user) {
        // 여기에 비밀번호 암호화 로직을 추가하고 사용자 정보를 저장합니다.
    }

    public Optional findByUsername(String username) {
        return userRepository.findByUsername(username);
    }
}

5.4. Security Configuration

스프링 시큐리티를 설정하여 JWT 인증을 수행할 수 있도록 합니다.


@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // 사용자 인증 및 보안 관련 설정을 정의합니다.
}

5.5. JWT Utility 클래스

JWT를 생성하고 검증하는 역할을 하는 JWTUtil 클래스를 작성합니다.


@Component
public class JwtUtil {
    private String secretKey = "yourSecretKey"; // 비밀키를 안전하게 관리해야 합니다.

    public String generateToken(String username) {
        // JWT 생성 로직 구현
    }

    public boolean validateToken(String token, String username) {
        // JWT 유효성 검사
    }
}

5.6. Authentication Controller

API 엔드포인트를 정의하여 로그인 및 로그아웃 기능을 제공합니다.


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

    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity<String> login(@RequestBody UserCredentials userCredentials) {
        // 로그인 로직
    }

    @PostMapping("/logout")
    public ResponseEntity<String> logout() {
        // 로그아웃 로직
    }
}

6. 리프레시 토큰 구현

리프레시 토큰은 액세스 토큰과 별도로 사용되며, 사용자가 계속해서 로그인 상태를 유지하도록 도와줍니다. 리프레시 토큰을 구현하기 위해 다음과 같은 단계를 수행합니다:

6.1. Refresh Token Entity

새로운 엔티티를 생성하여 리프레시 토큰을 관리합니다.


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

    private String token;

    @ManyToOne
    private User user;

    private LocalDateTime expiryDate;

    // Getter, Setter, Constructor
}

6.2. RefreshToken Repository

리프레시 토큰에 대한 CRUD 작업을 수행하기 위한 리포지토리를 생성합니다.


@Repository
public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
    Optional<RefreshToken> findByToken(String token);
}

6.3. Refresh Token Service

리프레시 토큰의 생성을 관리하는 서비스를 생성합니다.


@Service
public class RefreshTokenService {
    @Autowired
    private RefreshTokenRepository refreshTokenRepository;

    public RefreshToken createRefreshToken(User user) {
        // 새로운 리프레시 토큰 생성 로직
    }

    public boolean validateRefreshToken(String token) {
        // 리프레시 토큰 유효성 검사
    }
}

6.4. Refresh Token Controller

리프레시 토큰을 이용하여 새로운 액세스 토큰을 생성하는 API를 추가합니다.


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

    @PostMapping("/refresh-token")
    public ResponseEntity<String> refreshToken(@RequestBody String refreshToken) {
        // 리프레시 토큰을 이용한 새로운 액세스 토큰 생성 로직
    }
}

7. 결론

이 강좌에서는 스프링 부트를 활용하여 JWT 기반의 로그인/로그아웃 기능을 구현하고, 추가적으로 리프레시 토큰을 이용하여 액세스 토큰을 관리하는 방법을 살펴보았습니다. 이런 방식으로 구현한 인증 시스템은 더욱 안전하고 유연하게 다양한 클라이언트 요청을 처리할 수 있습니다.

이제 여러분의 애플리케이션에서 JWT와 리프레시 토큰을 구현하여 보다 향상된 사용자 경험을 제공할 수 있게 될 것입니다. 더 나아가 이 기술을 활용해 다양한 추가적인 보안 기법들과 통합할 수 있습니다. 앞으로의 발전을 기대합니다!

스프링 부트 백엔드 개발 강좌, JWT로 로그인 로그아웃 구현, JWT

안녕하세요! 이번 블로그에서는 스프링 부트로 백엔드 서비스를 개발하는 방법과 JSON Web Token (JWT)을 사용하여 로그인 및 로그아웃 기능을 구현하는 방법에 대해 설명하겠습니다. JWT는 웹 애플리케이션에서 인증 정보를 전송하고 검증하는 데 널리 사용되는 방법입니다. 본 강좌를 통해 JWT의 개념부터 구현까지 자세히 알아보겠습니다.

목차

  1. 1. JWT 개념
  2. 2. 스프링 부트 프로젝트 설정
  3. 3. 엔티티 구성
  4. 4. JWT 생성 및 검증
  5. 5. 로그인 기능 구현
  6. 6. 로그아웃 기능 구현
  7. 7. 종합 테스트
  8. 8. 결론

1. JWT 개념

JWT(JSON Web Token)는 두 당사자 간의 인증 정보를 안전하게 전송하는 데 사용되는 대표적인 방법입니다. JWT는 세 부분으로 구성되어 있습니다:

  • Header: 토큰의 유형(JWT)과 알고리즘 정보를 담고 있습니다.
  • Payload: 사용자 정보 및 기타 클레임(Claims) 정보를 포함합니다.
  • Signature: Header와 Payload를 바탕으로 생성된 서명으로, 무결성을 보장합니다.

JWT의 주요 장점은 클라이언트 측에서 정보를 유지하고, 서버가 상태를 관리할 필요가 없다는 것입니다. 이는 분산 시스템이나 마이크로서비스 아키텍처에서 매우 유용합니다.

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

스프링 부트를 사용하여 간단한 RESTful API를 만드는 것부터 시작하겠습니다. 우리는 Maven을 사용하여 라이브러리를 관리할 것입니다.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>jwt-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>jwt-demo</name>
    <description>JWT Demo Project</description>

    <properties>
        <java.version>17</java.version>
        <spring-boot.version>2.6.6</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

위와 같이 필요한 의존성을 설정한 후, 프로젝트 디렉토리를 생성하고 애플리케이션 클래스를 작성합니다.

src/main/java/com/example/jwtdemo/JwtDemoApplication.java

package com.example.jwtdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JwtDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(JwtDemoApplication.class, args);
    }
}

3. 엔티티 구성

사용자를 관리하기 위해 User 엔티티를 구성합니다. 이 엔티티는 사용자 정보를 저장하는데 필요합니다.

src/main/java/com/example/jwtdemo/model/User.java

package com.example.jwtdemo.model;

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

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

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

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

4. JWT 생성 및 검증

이제 JWT를 생성하고 검증하는 유틸리티 클래스를 작성합니다. 이 클래스는 JWT 토큰을 만들고 검증하는 메소드를 포함합니다.

src/main/java/com/example/jwtdemo/util/JwtUtil.java

package com.example.jwtdemo.util;

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"; // 비밀 키
    private final int EXPIRATION_TIME = 1000 * 60 * 60; // 1시간

    // JWT 생성
    public String generateToken(String username) {
        Map claims = new HashMap<>();
        return createToken(claims, username);
    }

    private String createToken(Map 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();
    }

    // JWT 검증
    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 extractAllClaims(token).getExpiration();
    }

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

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

5. 로그인 기능 구현

이제 로그인 기능을 구현합니다. 사용자가 유효한 자격 증명을 제공하면 JWT를 생성하여 반환합니다.

src/main/java/com/example/jwtdemo/controller/AuthController.java

package com.example.jwtdemo.controller;

import com.example.jwtdemo.model.User;
import com.example.jwtdemo.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/auth")
public class AuthController {
    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public Map login(@RequestBody User user) {
        // 이 부분은 데이터베이스에서 유저 정보 확인하는 로직이 필요합니다.
        if ("test".equals(user.getUsername()) && "password".equals(user.getPassword())) {
            String token = jwtUtil.generateToken(user.getUsername());
            Map response = new HashMap<>();
            response.put("token", token);
            return response;
        } else {
            throw new RuntimeException("Invalid credentials");
        }
    }
}

6. 로그아웃 기능 구현

로그아웃에는 실제로 클라이언트에서 JWT를 삭제하거나 무효화하는 방법을 사용합니다. 일반적으로 로그아웃은 클라이언트 측에서 수행됩니다.

다음은 클라이언트에서 JWT를 삭제하는 방법의 예시입니다:


localStorage.removeItem('token');

서버측에서는 사용자 상태를 관리하지 않기 때문에 별도의 로그아웃 엔드포인트가 필요하지 않습니다.

7. 종합 테스트

이제 모든 구현이 완료되었습니다. Postman 또는 CURL을 사용하여 API를 테스트할 수 있습니다.

  • 로그인 요청: POST http://localhost:8080/auth/login – Body에 JSON 형태로 사용자 정보를 전달합니다.

{
    "username": "test",
    "password": "password"
}
response

{
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

받은 JWT를 Authorization 헤더에 Bearer 형식으로 추가하여 다른 API 호출을 할 수 있습니다.

8. 결론

이번 강좌에서는 스프링 부트를 사용하여 JWT를 통한 로그인 및 로그아웃 기능을 구현하는 방법에 대해 알아보았습니다. JWT는 경량의 인증 메커니즘으로, 다양한 상황에 유용하게 적용할 수 있습니다. 실무에서 JWT를 사용하면 효율적인 인증과 권한 관리를 통해 보안을 강화할 수 있습니다. 앞으로 JWT를 기반으로 한 다양한 기능들을 경험해 보는 것을 추천합니다.

감사합니다! 아래 댓글로 질문이나 피드백 환영합니다.

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

JWT로 로그인/로그아웃 구현하기

목차

  1. 서론
  2. Spring Boot 소개
  3. JWT란?
  4. 프로젝트 설정
  5. 회원 가입 기능 구현
  6. 로그인 기능 구현
  7. JWT를 이용한 인증 및 인가
  8. JWT 토큰 생성 및 검증
  9. 로그아웃 기능 구현
  10. 결론

서론

요즘 웹 어플리케이션의 인증(authentication)과 인가(authorization)는 매우 중요한 이슈입니다. 특히, RESTful API를 개발할 때는 다양한 클라이언트를 지원해야 하기 때문에, 사용자 인증을 처리하는 방식에도 고려해야 할 사항이 많습니다. 오늘은 스프링 부트를 사용하여 JWT(JSON Web Token) 기반의 로그인 및 로그아웃 시스템을 구현하는 방법에 대해 알아보겠습니다.

Spring Boot 소개

스프링 부트(Spring Boot)는 자바 기반의 웹 애플리케이션 프레임워크인 스프링(Spring)에서 애플리케이션 초기화 및 설정을 간소화하기 위해 만들어진 프로젝트입니다. 스프링 부트는 필요한 설정과 종속성을 자동으로 관리하여 개발자는 비즈니스 로직에 집중할 수 있도록 도와줍니다.

스프링 부트는 다음과 같은 장점을 제공합니다:

  • 빠른 프로토타입 개발이 가능하다.
  • 기본적인 설정이 자동으로 이루어진다.
  • 내장 서버 톰캣을 내장하고 있어 별도의 서버 설정이 필요 없다.

JWT란?

JWT(JSON Web Token)는 JSON 포맷을 사용하여 정보를 안전하게 전송하기 위한 컴팩트하고 독립적인 표준입니다. JWT는 주로 웹 애플리케이션에서 사용자 인증 및 인가를 처리하는데 많이 사용됩니다. JWT의 특징은 다음과 같습니다:

  • 자체적으로 신뢰성을 가지고 있다: 전송되는 데이터가 서명되어 검증이 가능하다.
  • 구조가 간단하여 쉽게 분석할 수 있다.
  • HTTP 헤더를 통해 전송이 가능해 다양한 클라이언트와 호환성이 좋다.

JWT는 세 가지 구성요소로 이루어져 있습니다:

  • 헤더(Header): 토큰 타입과 서명 알고리즘 정보를 포함합니다.
  • 페이로드(Payload): 사용자 정보 및 클레임(Claims)을 포함하는 부분입니다.
  • 서명(Signature): 헤더와 페이로드를 기반으로 서명하여 데이터의 무결성을 보장합니다.

프로젝트 설정

스프링 부트 프로젝트를 생성하기 위해 Spring Initializr 를 사용합니다. 필요한 의존성으로는 웹, JPA, Spring Security, Lombok, 그리고 JWT 라이브러리를 선택합니다.


        com.example
        jwt-demo
        0.0.1-SNAPSHOT
        jar

        
            
                org.springframework.boot
                spring-boot-starter-web
            
            
                org.springframework.boot
                spring-boot-starter-data-jpa
            
            
                org.springframework.boot
                spring-boot-starter-security
            
            
                io.jsonwebtoken
                jjwt
                0.9.1
            
            
                org.projectlombok
                lombok
                1.18.12
                provided
            
            
                com.h2database
                h2
                runtime
            
        
        

build.gradle 파일에 위 의존성을 추가한 후, 스프링 부트 애플리케이션을 설정합니다. application.properties 파일에 데이터베이스 연결 및 JPA 설정을 작성합니다.

회원 가입 기능 구현

회원 가입 기능은 기본적으로 사용자가 제공한 정보를 데이터베이스에 저장하는 기능입니다. 회원 정보를 저장하기 위해 JPA 엔티티 클래스를 생성합니다.


        import lombok.AllArgsConstructor;
        import lombok.Getter;
        import lombok.NoArgsConstructor;
        import lombok.Setter;

        import javax.persistence.*;

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

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

            @Column(nullable = false)
            private String password;

            private String role;
        }
        

사용자가 회원가입 시 제공하는 사용자 정보를 처리하기 위한 리포지토리 인터페이스를 생성합니다.


        import org.springframework.data.jpa.repository.JpaRepository;

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

회원가입 요청을 처리하는 서비스 클래스를 생성합니다.


        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.security.crypto.password.PasswordEncoder;
        import org.springframework.stereotype.Service;

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

            @Autowired
            private PasswordEncoder passwordEncoder;

            public void registerUser(User user) {
                user.setPassword(passwordEncoder.encode(user.getPassword()));
                user.setRole("ROLE_USER");
                userRepository.save(user);
            }
        }
        

로그인 기능 구현

로그인 기능은 사용자가 인증 정보를 제공하여 서버에서 JWT 토큰을 발급받는 과정입니다. 이를 위해 인증을 처리하는 필터 클래스를 작성합니다.


        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.security.authentication.AuthenticationManager;
        import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
        import org.springframework.security.core.Authentication;
        import org.springframework.security.core.userdetails.UserDetails;
        import org.springframework.security.core.userdetails.UserDetailsService;
        import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

        public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
            @Autowired
            private AuthenticationManager authenticationManager;

            @Autowired
            private JwtTokenProvider jwtTokenProvider;

            @Override
            public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) {
                String username = request.getParameter("username");
                String password = request.getParameter("password");
                UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);
                return authenticationManager.authenticate(authRequest);
            }

            @Override
            protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
                String token = jwtTokenProvider.createToken(authResult.getName());
                response.addHeader("Authorization", "Bearer " + token);
                response.getWriter().write("로그인 성공");
            }
        }
        

JWT를 이용한 인증 및 인가

JWT를 사용하여 API 호출 시 사용자를 인증하는 방법을 구현합니다. JWT 토큰이 없거나 유효하지 않은 경우 요청을 차단하는 필터를 생성합니다.


        import org.springframework.security.core.Authentication;
        import org.springframework.security.core.context.SecurityContextHolder;
        import org.springframework.stereotype.Component;
        import org.springframework.web.filter.GenericFilterBean;

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

        @Component
        public class JwtAuthenticationFilter extends GenericFilterBean {
            @Autowired
            private JwtTokenProvider jwtTokenProvider;

            @Override
            public void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
                String token = request.getHeader("Authorization");

                if (token != null && jwtTokenProvider.validateToken(token)) {
                    Authentication authentication = jwtTokenProvider.getAuthentication(token);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }

                chain.doFilter(request, response);
            }
        }
        

JWT 토큰 생성 및 검증

JWT 토큰을 생성하고 검증하기 위한 유틸리티 클래스를 생성합니다. 이 클래스는 JWT를 처리하는 다양한 메소드를 포함합니다.


        import io.jsonwebtoken.Claims;
        import io.jsonwebtoken.JwtBuilder;
        import io.jsonwebtoken.JwtParser;
        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 JwtTokenProvider {
            private final String SECRET_KEY = "mySecretKey";

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

            public boolean validateToken(String token) {
                try {
                    Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
                    return true;
                } catch (Exception e) {
                    return false;
                }
            }
            
            public Authentication getAuthentication(String token) {
                // 사용자 인증 논리 구현
            }
        }
        

로그아웃 기능 구현

로그아웃 기능은 사용자가 인증을 종료하는 것으로, 보통 클라이언트에서 JWT 토큰을 삭제하는 방식으로 구현합니다. 더 나아가, 만약 서버에서 토큰을 무효화해야 한다면 블랙리스트를 관리해야 합니다.


        import org.springframework.web.bind.annotation.*;

        @RestController
        @RequestMapping("/auth")
        public class AuthController {
            @PostMapping("/logout")
            public ResponseEntity logout(HttpServletRequest request) {
                String token = request.getHeader("Authorization");
                // 토큰 블랙리스트 등록 로직
                return ResponseEntity.ok("로그아웃 성공");
            }
        }
        

결론

이번 강좌를 통해 스프링 부트를 사용하여 JWT 기반의 로그인/로그아웃 기능을 구현하는 방법에 대해 살펴보았습니다. JWT는 웹 서비스의 인증 및 인가를 처리하는데 유용한 도구이며, 향후 애플리케이션을 개발할 때 큰 도움이 될 것입니다. 추가적으로, 보안 및 세션 관리에 관한 더 많은 정보를 연구하여 더 나은 보안성을 확보할 수 있습니다.

JW이 인증 및 인가와 관련된 지식을 확장하길 원하신다면, 보안 모범 사례와 더불어 OAuth2 및 OpenID Connect 같은 프로토콜을 학습하는 것을 추천합니다.

스프링 부트 백엔드 개발 강좌, JPA와 하이버네이트

스프링 부트와 JPA, 그리고 하이버네이트(ORM)에 대한 깊이 있는 이해를 통해 현대적인 백엔드 애플리케이션을 개발하는 방법을 배우십시오.

1. 스프링 부트란?

스프링 부트는 스프링 프레임워크를 기반으로 한 경량 애플리케이션 개발 프레임워크입니다. 설정을 최소화하고 빠른 개발을 가능하게 하기 위해 설계된 스프링 부트는 마이크로서비스 아키텍처에 적합한 프레임워크로 자리잡고 있습니다. 스프링 부트는 기존의 복잡한 스프링 XML 설정을 대체하여 개발자가 더 쉬운 방식으로 애플리케이션을 개발할 수 있도록 도와줍니다.

스프링 부트의 주요 특징은 다음과 같습니다:

  • 자동 구성: 애플리케이션에 필요한 설정을 자동으로 구성해 줍니다.
  • 독립 실행 가능: 내장 서블릿 컨테이너를 지원하여 별도의 서버 없이도 실행할 수 있습니다.
  • 생산자 친화적: 애플리케이션의 운영을 위한 다양한 도구와 설정들이 기본적으로 제공됩니다.

2. JPA(JAVA Persistence API)란?

JPA는 자바에서 ORM(Object-Relational Mapping) 프레임워크를 통해 데이터베이스와의 상호작용을 더 쉽게 만들어주는 표준 API입니다. JPA는 객체지향 프로그래밍 환경을 기반으로 데이터베이스와의 작업을 추상화하여 개발자가 SQL 쿼리를 작성하지 않고도 데이터베이스에 접근할 수 있게 합니다.

JPA는 다음과 같은 주요 기능을 제공합니다:

  • 객체와 관계형 데이터베이스 간의 매핑: 자바 객체와 데이터베이스 테이블 간의 매핑을 간편하게 설정할 수 있습니다.
  • 트랜잭션 관리: 데이터베이스 상태 변화에 대한 트랜잭션 관리를 쉽게 할 수 있습니다.
  • 쿼리 언어: JPA와 함께 JPQL(Java Persistence Query Language)이라는 객체 지향 쿼리 언어를 제공합니다.

3. 하이버네이트란?

하이버네이트는 가장 널리 사용되는 JPA 구현체 중 하나로, 고급 ORM 도구입니다. 자바 객체를 관계형 데이터베이스에 매핑하여 쉽고 효율적으로 데이터를 처리할 수 있도록 도와주는 프레임워크입니다. 하이버네이트는 성능 최적화 및 다양한 기능을 제공하여 대규모 애플리케이션에서도 빠르고 안정적으로 데이터를 관리할 수 있습니다.

하이버네이트의 주요 특징은 다음과 같습니다:

  • 자동 매핑: 객체와 데이터베이스 간의 관계를 자동으로 처리합니다.
  • 캐시 관리: 성능을 향상시키는 다양한 캐싱 메커니즘을 지원합니다.
  • 다양한 데이터베이스 지원: 다양한 SQL 데이터베이스를 지원하며, 다중 데이터베이스 환경에서도 안정성을 제공합니다.

4. 스프링 부트와 JPA, 하이버네이트의 통합

스프링 부트에서는 JPA와 하이버네이트를 간편하게 통합하여 사용할 수 있습니다. 스프링 부트의 spring-boot-starter-data-jpa를 의존성으로 추가하고, 애플리케이션의 설정 파일에 데이터베이스 연결 정보를 추가하면 됩니다. 이렇게 하면 복잡한 설정 없이도 JPA와 하이버네이트를 사용할 수 있습니다.

예를 들어, application.properties 파일에 다음과 같이 설정할 수 있습니다:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=pass
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
            

5. 스프링 부트로 간단한 CRUD 구현하기

5.1 프로젝트 생성하기

스프링 Initializr(https://start.spring.io/)를 통해 새로운 스프링 부트 프로젝트를 생성합니다. 필요한 의존성을 추가하고, 프로젝트를 다운로드하여 IDE에서 엽니다.

5.2 엔티티 클래스 생성하기

JPA를 사용하여 데이터베이스 테이블과 매핑할 엔티티 클래스를 생성합니다. 예를 들어, User라는 엔티티 클래스를 만들어보겠습니다.

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

    private String name;
    private String email;

    // getters and setters
}
            

5.3 레포지토리 인터페이스 생성하기

User 클래스를 위한 레포지토리 인터페이스를 생성합니다. 스프링 데이터 JPA를 사용하여 CRUD 기능을 자동으로 생성합니다.

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository {
}
            

5.4 서비스 클래스 생성하기

비즈니스 로직을 처리할 서비스 클래스를 생성합니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

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

    public List findAll() {
        return userRepository.findAll();
    }

    public User save(User user) {
        return userRepository.save(user);
    }
}
            

5.5 REST 컨트롤러 생성하기

RESTful API를 제공할 컨트롤러를 생성합니다. 사용자의 요청을 처리하고 서비스를 호출합니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

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

    @GetMapping
    public List getAllUsers() {
        return userService.findAll();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}
            

6. JPA의 고급 기능

JPA를 사용하면 기본적인 CRUD 외에도 다양한 기능들을 사용할 수 있습니다. 몇 가지 주요 기능들을 살펴보겠습니다:

6.1 JPQL(Java Persistence Query Language)

JPQL은 JPA에서 제공하는 객체 지향 쿼리 언어입니다. JPQL을 사용하면 객체를 기준으로 쿼리를 작성할 수 있어, SQL 쿼리보다 더 직관적입니다.

List users = entityManager.createQuery("SELECT u FROM User u WHERE u.name = :name", User.class)
        .setParameter("name", "John")
        .getResultList();
            

6.2 @Query 어노테이션

JPA에서는 메서드에 @Query 어노테이션을 사용하여 커스텀 쿼리를 정의할 수 있습니다.

import org.springframework.data.jpa.repository.Query;

public interface UserRepository extends JpaRepository {
    @Query("SELECT u FROM User u WHERE u.email = ?1")
    User findByEmail(String email);
}
            

6.3 페이징과 정렬

스프링 데이터 JPA는 페이징 및 정렬을 쉽게 처리할 수 있는 기능을 제공합니다. 만든 레포지토리 인터페이스에서 PagingAndSortingRepository를 상속받아 메서드를 사용할 수 있습니다.

public interface UserRepository extends PagingAndSortingRepository {
}
            

7. 하이버네이트의 고급 기능

하이버네이트는 성능 튜닝 및 데이터베이스 관련 다양한 기능들을 제공합니다. 예를 들어, 캐시 관리, 배치 처리, 다중 데이터베이스 지원 등을 통해 애플리케이션의 성능을 대폭 향상시킬 수 있습니다.

7.1 1차 캐시와 2차 캐시

하이버네이트는 기본적으로 1차 캐시를 사용하여 동일한 세션 내에서 조회한 데이터는 메모리에 저장하여 성능을 향상시킵니다. 2차 캐시는 여러 세션에서 공유할 수 있는 캐시로, 성능을 최적화할 수 있습니다.

7.2 배치 처리

하이버네이트는 대량의 데이터를 한 번에 처리할 때 배치 처리(batch processing)를 지원합니다. 이를 통해 데이터베이스 연결 수를 최소화하고 성능을 개선합니다.

8. 결론

스프링 부트와 JPA, 하이버네이트는 현대적인 백엔드 애플리케이션 개발을 위한 강력한 도구입니다. 이 강좌를 통해 여러분은 스프링 부트의 기본적인 이해부터 시작하여 JPA와 하이버네이트를 활용한 데이터베이스 처리까지 폭넓은 지식을 갖출 수 있을 것입니다. 실제 프로젝트에 적용해 보면서 더 깊이 있는 경험을 쌓기를 바랍니다.