[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(회원가입, 로그인 구현 with JWT, 필터)

회원가입 구현

1. 프로젝트 설정 추가

// build.gradle 내 JPA, MySQL 추가
// JPA
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
// MySQL
runtimeOnly 'com.mysql:mysql-connector-j'

// application.properties 내 데이터베이스 정보 추가
spring.datasource.url=jdbc:mysql://localhost:3306/auth
spring.datasource.username=root
spring.datasource.password={비밀번호}
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update

spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true

2. auth 데이터베이스 생성 후 인텔리제이 연동

CREATE DATABASE auth;

3. HTML, CSS, JS 코드 추가

src > main > resources > templates 아래 HTML 코드 추가(index.html, login.html, signup.html)

src > main > resources > static 내 css, js 폴더 추가 후 style.css과 basic.js 생성

4. 페이지 Controller 생성

HomeController

package com.sparta.springauth.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("username", "username");
        return "index"; // templates > index.html인 메인 페이지 반환
    }
}

UserController

package com.sparta.springauth.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/api")
public class UserController {

    @GetMapping("/user/login-page")
    public String loginPage() {
        return "login"; // 로그인 페이지 반환
    }

    @GetMapping("/user/signup")
    public String signupPage() {
        return "signup"; // 회원가입 페이지 반환
    }
}

5. User 엔티티 생성

package com.sparta.springauth.entity;

public enum UserRoleEnum {
    USER(Authority.USER),  // 사용자 권한
    ADMIN(Authority.ADMIN);  // 관리자 권한

    private final String authority;

    UserRoleEnum(String authority) {
        this.authority = authority;
    }

    public String getAuthority() {
        return this.authority;
    }

    public static class Authority {
        public static final String USER = "ROLE_USER";
        public static final String ADMIN = "ROLE_ADMIN";
    }
}

package com.sparta.springauth.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Entity
@Getter
@Setter
@NoArgsConstructor
@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;

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

    @Column(nullable = false)
    @Enumerated(value = EnumType.STRING)
    private UserRoleEnum role;
}

@Enumerated 어노테이션은 데이터 enum 타입을 데이터베이스 컬럼에 저장할 때 사용하는 어노테이션
- 옵션으로 EnumType.STRING을 사용하면 enum의 이름 그대로를 데이터베이스에 저장함

패스워드 암호화

회원 등록 시 비밀번호는 사용자가 입력한 문자 그대로 DB에 등록하면 안됨! '정보통신망법, 개인정보보호법'에 의해 비밀번호 암호화(Encryption)가 의무임

'평문 → (암호화 알고리즘) → 암호문'로 암호화 후 패스워드 저장 필요함
해커가 DB에 있는 패스워드 정보를 갈취하더라도 실제 암호를 알 수 없고, 복호화가 불가능한 단방향 암호 알고리즘 사용이 필요함

양방향 암호 알고리즘

암호화: 평문 → (암호화 알고리즘) → 암호문
복호화: 암호문 → (암호화 알고리즘) → 평문
즉, 암호화와 복호화가 모두 가능한 알고리즘

단방향 암호 알고리즘

암호화: 평문 → (암호화 알고리즘) → 암호문
복호화: ~~암호문→ (암호화 알고리즘)→ 평문~~ ► 불가능
즉, 암호화는 가능하지만 복호화는 불가능한 알고리즘

❓ 사용자는 로그인할 때 암호화된 패스워드를 기억해야 할까?

Spring Security라는 프레임워크에서 boolean matches(CharSequence rawPassword, String encodedPassword);를 제공해 사용자가 입력한 비밀번호를 암호화해 저장된 비밀번호와 비교해 일치여부 확인할 수 있음

1. 사용자가 로그인을 위해 "아이디, 패스워드 (평문)" 입력해 서버에 로그인 요청
2. 서버에서 패스워드 (평문)을 암호화 수행: 평문 → (암호화 알고리즘) → 암호문
3. DB에 저장된 "아이디, 패스워드 (암호문)"와 일치 여부 확인

회원가입 API 구현

Name	Method	URL	설명
회원가입 페이지	GET	/api/user/signup	회원가입 페이지 호출
회원가입	POST	/api/user/signup	회원가입

6. 회원가입 API 만들기

6-1) RequestDto 생성

package com.sparta.springauth.dto;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class SignupRequestDto {
    private String username;
    private String password;
    private String email;
    private boolean admin = false;
    private String adminToken = "";
}

6-2) 비즈니스 로직 처리할 Service 만들기

package com.sparta.springauth.service;

import com.sparta.springauth.dto.SignupRequestDto;
import com.sparta.springauth.entity.User;
import com.sparta.springauth.entity.UserRoleEnum;
import com.sparta.springauth.repository.UserRepository;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class UserService {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

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

    // ADMIN_TOKEN
    private final String ADMIN_TOKEN = "AAABnvxRVklrnYxKZ0aHgTBcXukeZygoC";

    public void signup(SignupRequestDto requestDto) {
        String username = requestDto.getUsername();
        String password = passwordEncoder.encode(requestDto.getPassword());

        // 회원 중복 확인
        Optional<User> checkUsername = userRepository.findByUsername(username);
        if (checkUsername.isPresent()) {
            throw new IllegalArgumentException("중복된 사용자가 존재합니다.");
        }

        // email 중복확인
        String email = requestDto.getEmail();
        Optional<User> checkEmail = userRepository.findByEmail(email);
        if (checkEmail.isPresent()) {
            throw new IllegalArgumentException("중복된 Email 입니다.");
        }

        // 사용자 ROLE 확인
        UserRoleEnum role = UserRoleEnum.USER;
        if (requestDto.isAdmin()) {
            if (!ADMIN_TOKEN.equals(requestDto.getAdminToken())) {
                throw new IllegalArgumentException("관리자 암호가 틀려 등록이 불가능합니다.");
            }
            role = UserRoleEnum.ADMIN;
        }

        // 사용자 등록
        User user = new User(username, password, email, role);
        userRepository.save(user);
    }
}

ADMIN_TOKEN은 일반 사용자인지 관리자인지 구분할 때 사용
실제로 현업에서는 관리자 권한을 줄 때 저런식으로 주지 않고, 관리자 페이지를 따로 구현하거나 승인자에 의해서 결재하는 과정을 구현함

6-3) Repository 생성

package com.sparta.springauth.repository;

import com.sparta.springauth.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByUsername(String username);
    Optional<User> findByEmail(String email);

}

6-4) Controller 내 회원가입 API 추가

@PostMapping("/user/signup")
public String signup(@ModelAttribute SignupRequestDto signupRequestDto) {
    userService.signup(signupRequestDto);

    return "redirect:/api/user/login-page"; // 로그인 화면 리턴
}

로그인 구현: JWT

로그인 API 구현

Name	Method	URL	설명
로그인 페이지	GET	/api/user/login-page	로그인 페이지 호출
로그인	POST	/api/user/login	로그인

7. 로그인 API 만들기

7-1) 로그인 RequestDto 생성

package com.sparta.springauth.dto;

import lombok.Getter;
import lombok.Setter;

@Setter
@Getter
public class LoginRequestDto {
    private String username;
    private String password;
}

7-2) 로그인 Controller 생성

@PostMapping("/user/login")
public String login(@ModelAttribute LoginRequestDto requestDto, HttpServletResponse res) {
    try {
        userService.login(requestDto, res);
    } catch (Exception e) {
        return "redirect:/api/user/login-page?error";
    }

    return "redirect:/"; // 메인 화면으로 리다이렉트
}

7-3) 로그인 비즈니스 로직 Service에 추기

public void login(LoginRequestDto requestDto, HttpServletResponse res) {
    String username = requestDto.getUsername();
    String password = requestDto.getPassword();

    // 사용자 확인
    User user = userRepository.findByUsername(username).orElseThrow(
            () -> new IllegalArgumentException("등록된 사용자가 없습니다.")
    );

    // 비밀번호 확인
    if(!passwordEncoder.matches(password, user.getPassword())) {
        throw new IllegalArgumentException("비밀번호가 일치하지 않습니다.");
    }

    // JWT 생성 및 쿠키에 저장 후 Response 객체에 추가
    String token = jwtUtil.createToken(user.getUsername(), user.getRole());
    jwtUtil.addJwtToCookie(token, res);
}

필터(Filter)

필터(Filter)는 Web Application에서 관리되는 영역으로, 클라이언트로부터 오는 요청과 응답에 대해서 최초, 최총 단계에 위치해 이를 통해서 요청과 응답의 정보를 변경하거나 부가적인 기능 추가할 수 있음

주로 범용적으로 처리하는 작업인 Logging 혹은 보안 처리에 활용함
인증, 인가와 관련된 로직 처리도 가능함. 즉, 필터를 사용하면 인증/인가와 관련된 로직을 처리함으로써 비즈니스 로직과 분리할 수 있다는 장점 존재
Filter는 하나만 존재하는 것이 아니라 여러 개로 Chain 형식으로 묶여서 처리되고 있음

URL을 Logging하는 Filter

package com.sparta.springauth.filter;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Slf4j(topic = "LoggingFilter") // 로깅관련 라이브러리로, 로깅 옆에 topic 이름으로 찍힘
@Component
@Order(1) // Chain 형식으로 되어있는 Filter에 순서 지정 가능
public class LoggingFilter implements Filter {
    // Filter 인터페이스 내에 doFilter 메서드 존재함
    // FilterChain은 Filter를 이동할 때 사용하려고 받아옴
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 전처리
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String url = httpServletRequest.getRequestURI(); // URL 정보 가져옴
        log.info(url); // log 찍기

        chain.doFilter(request, response); // 다음 Filter 로 이동

        // 후처리
        log.info("비즈니스 로직 완료");
    }
}

인증 및 인가를 처리하는 Filter

이전에 Filter를 거치지 않고 Controller로 요청이 들어올 때는, @CookieValue 어노테이션을 사용할 수 있어서 Request 객체의 Cookie에 들어있는 Value를 가져올 수 있었음
Filter는 DispatcherServlet보다 앞단이기 때문에 @CookieValue 어노테이션 사용이 불가능하기 때문에, Cookie를 뽑아내는 메서드 직접 구현 필요함

JwtUtil에 Cookie 가져오는 메서드 추가

// HttpServletRequest 에서 Cookie Value : JWT 가져오기
public String getTokenFromRequest(HttpServletRequest req) {
    Cookie[] cookies = req.getCookies();
    if(cookies != null) {
        for (Cookie cookie : cookies) {
            if (cookie.getName().equals(AUTHORIZATION_HEADER)) {
                try {
                    return URLDecoder.decode(cookie.getValue(), "UTF-8"); // Encode 되어 넘어간 Value 다시 Decode
                } catch (UnsupportedEncodingException e) {
                    return null;
                }
            }
        }
    }
    return null;
}

인증 FIlter 생성

package com.sparta.springauth.filter;

import com.sparta.springauth.entity.User;
import com.sparta.springauth.jwt.JwtUtil;
import com.sparta.springauth.repository.UserRepository;
import io.jsonwebtoken.Claims;
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.io.IOException;

@Slf4j(topic = "AuthFilter")
@Component
@Order(2)
public class AuthFilter implements Filter {

    private final UserRepository userRepository;
    private final JwtUtil jwtUtil;

    public AuthFilter(UserRepository userRepository, JwtUtil jwtUtil) {
        this.userRepository = userRepository;
        this.jwtUtil = jwtUtil;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String url = httpServletRequest.getRequestURI();

        if (StringUtils.hasText(url) &&
                (url.startsWith("/api/user") || url.startsWith("/css") || url.startsWith("/js"))
        ) {
            // 회원가입, 로그인 관련 API 는 인증 필요없이 요청 진행
            chain.doFilter(request, response); // 다음 Filter 로 이동
        } else {
            // 나머지 API 요청은 인증 처리 진행
            // 토큰 확인

            // 이전에 Filter를 거치지 않고 Controller로 요청이 들어올 때는,
            // @CookieValue 어노테이션을 사용할 수 있어서 Request 객체의 Cookie에 들어있는 Value를 가져올 수 있었음
            // Filter는 DispatcherServlet보다 앞단이기 때문에 @CookieValue 어노테이션 사용이 불가능하기 때문에,
            // Cookie를 뽑아내는 메서드 직접 구현 필요함
            String tokenValue = jwtUtil.getTokenFromRequest(httpServletRequest);

            if (StringUtils.hasText(tokenValue)) { // 토큰이 존재하면 검증 시작
                // JWT 토큰 substring
                String token = jwtUtil.substringToken(tokenValue);

                // 토큰 검증
                if (!jwtUtil.validateToken(token)) {
                    throw new IllegalArgumentException("Token Error");
                }

                // 토큰에서 사용자 정보 가져오기
                Claims info = jwtUtil.getUserInfoFromToken(token);

                User user = userRepository.findByUsername(info.getSubject()).orElseThrow(() ->
                        new NullPointerException("Not Found User")
                );

                request.setAttribute("user", user);
                chain.doFilter(request, response); // 다음 Filter 로 이동
            } else {
                throw new IllegalArgumentException("Not Found Token");
            }
        }
    }

}

'백엔드 > spring&springboot' 카테고리의 다른 글

[내일배움캠프_Spring Boot 숙련주차] 데이터 검증하기(Validation) (0)	2026.06.29
[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(Spring Security, 접근 불가 페이지 만들기) (0)	2026.06.29
[내일배움캠프_Spring Boot 숙련주차] 인증과 인가(+쿠키-세션, JWT) (0)	2026.06.26
[내일배움캠프_Spring Boot 숙련주차] Bean (0)	2026.06.26
[내일배움캠프_Spring Boot 입문주차] Spring Data JPA (0)	2026.06.26

차곡차곡🐿️

[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(회원가입, 로그인 구현 with JWT, 필터)

회원가입 구현

패스워드 암호화

회원가입 API 구현

로그인 구현: JWT

로그인 API 구현

필터(Filter)

URL을 Logging하는 Filter

인증 및 인가를 처리하는 Filter

'백엔드 > spring&springboot' 카테고리의 다른 글

티스토리툴바

[내일배움캠프_Spring Boot 숙련주차] 사용자 관리하기(회원가입, 로그인 구현 with JWT, 필터)

회원가입 구현

패스워드 암호화

회원가입 API 구현

로그인 구현: JWT

로그인 API 구현

필터(Filter)

URL을 Logging하는 Filter

인증 및 인가를 처리하는 Filter

'백엔드 > spring&springboot' 카테고리의 다른 글

관련글

티스토리툴바