Feat/#11 로그인 API 구현

build.gradle

@@ -41,6 +41,9 @@ dependencies {
 	annotationProcessor 'org.projectlombok:lombok'
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
+	runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
+	runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'
 }
 
 tasks.named('test') {

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/AuthController.java

@@ -0,0 +1,26 @@
+package kr.ac.ks.cs_web_back.domain.auth.controller;
+
+import jakarta.validation.Valid;
+import kr.ac.ks.cs_web_back.domain.auth.controller.code.AuthSuccessCode;
+import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
+import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
+import kr.ac.ks.cs_web_back.domain.auth.service.AuthService;
+import kr.ac.ks.cs_web_back.global.response.CsResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/auth")
+@RequiredArgsConstructor
+public class AuthController implements SpringDocAuthController{
+
+    private final AuthService authService;
+
+    @PostMapping("/login")
+    public CsResponse<AuthLoginResponse> login(
+            @Valid @RequestBody AuthLoginRequest request
+    ) {
+        AuthLoginResponse token = authService.loginMember(request);
+        return CsResponse.of(AuthSuccessCode.LOGIN_SUCCESS, token);
+    }
+}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/SpringDocAuthController.java

@@ -0,0 +1,33 @@
+package kr.ac.ks.cs_web_back.domain.auth.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.parameters.RequestBody;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
+import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
+import kr.ac.ks.cs_web_back.global.response.CsResponse;
+import kr.ac.ks.cs_web_back.global.swagger.error.ApiErrorResponse;
+import kr.ac.ks.cs_web_back.global.swagger.error.ErrorCase;
+import org.springframework.http.HttpStatus;
+
+@Tag(name = "인증 API", description = "인증 관련 API")
+public interface SpringDocAuthController {
+
+    @Operation(summary = "로그인", description = "사용자의 이메일과 비밀번호로 로그인하고, 성공시 JWT 토큰을 반환합니다.")
+    @ApiResponse(responseCode = "200", description = "로그인에 성공했습니다.")
+    @ApiErrorResponse(status = HttpStatus.BAD_REQUEST, instance = "/auth/login", errorCases = {
+            @ErrorCase(description = "이메일 없음", code = 9010, exampleMessage = "이메일이 입력되지 않았습니다."),
+            @ErrorCase(description = "비밀번호 없음", code = 9011, exampleMessage = "비밀번호가 입력되지 않았습니다.")
+    })
+    @ApiErrorResponse(status = HttpStatus.UNAUTHORIZED, instance = "/auth/login", errorCases = {
+            @ErrorCase(description = "비밀번호 불일치", code = 8011, exampleMessage = "비밀번호가 일치하지 않습니다.")
+    })
+    @ApiErrorResponse(status = HttpStatus.NOT_FOUND, instance = "/auth/login", errorCases = {
+            @ErrorCase(description = "사용자 없음", code = 6001, exampleMessage = "일치하는 사용자가 존재하지 않습니다.")
+    })
+    CsResponse<AuthLoginResponse> login(
+            @RequestBody AuthLoginRequest request
+    );
+
+}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/code/AuthExceptionCode.java

@@ -0,0 +1,19 @@
+package kr.ac.ks.cs_web_back.domain.auth.controller.code;
+
+import kr.ac.ks.cs_web_back.global.exeption.dto.ExceptionCode;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum AuthExceptionCode implements ExceptionCode {
+
+    BAD_REQUEST_NO_EMAIL(9010, "이메일이 입력되지 않았습니다."),
+    BAD_REQUEST_NO_PASSWORD(9010, "비밀번호가 입력되지 않았습니다."),
+    UNAUTHORIZED_PASSWORD(8011, "비밀번호가 일치하지 않습니다."),
+    NOT_FOUND_USER(6001, "일치하는 사용자가 존재하지 않습니다."),
+    ;
+
+    private final int code;
+    private final String message;
+}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/controller/code/AuthSuccessCode.java

@@ -0,0 +1,16 @@
+package kr.ac.ks.cs_web_back.domain.auth.controller.code;
+
+import kr.ac.ks.cs_web_back.global.response.SuccessCode;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum AuthSuccessCode implements SuccessCode {
+
+    LOGIN_SUCCESS(2001, "로그인에 성공했습니다."),
+    ;
+
+    private final int code;
+    private final String message;
+}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/dto/request/AuthLoginRequest.java

@@ -0,0 +1,15 @@
+package kr.ac.ks.cs_web_back.domain.auth.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public record AuthLoginRequest(
+        @Schema(description = "이메일", example = "example@ks.ac.kr")
+        @NotBlank(message = "이메일이 입력되지 않았습니다.")
+        @Email(message = "이메일 형식이 올바르지 않습니다.")
+        String email,
+        @Schema(description = "비밀번호", example = "examplePassword123")
+        @NotBlank(message = "비밀번호가 입력되지 않았습니다.")
+        String password
+) {}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/dto/response/AuthLoginResponse.java

@@ -0,0 +1,13 @@
+package kr.ac.ks.cs_web_back.domain.auth.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+
+@Builder
+public record AuthLoginResponse(
+        @Schema(description = "액세스 토큰", example = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJle...")
+        String authorization,
+        @Schema(description = "리프레시 토큰", example = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJle...")
+        String authorizationRefresh
+) {
+}

src/main/java/kr/ac/ks/cs_web_back/domain/auth/service/AuthService.java

@@ -0,0 +1,39 @@
+package kr.ac.ks.cs_web_back.domain.auth.service;
+
+import kr.ac.ks.cs_web_back.domain.auth.controller.code.AuthExceptionCode;
+import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
+import kr.ac.ks.cs_web_back.domain.auth.dto.response.AuthLoginResponse;
+import kr.ac.ks.cs_web_back.domain.member.model.Member;
+import kr.ac.ks.cs_web_back.domain.member.repository.MemberRepository;
+import kr.ac.ks.cs_web_back.global.exeption.domain.NotFoundException;
+import kr.ac.ks.cs_web_back.global.exeption.domain.UnauthorizedException;
+import kr.ac.ks.cs_web_back.global.jwt.JwtUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class AuthService {
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final JwtUtil jwtUtil;
+
+    public AuthLoginResponse loginMember(AuthLoginRequest request) {
+        Member member = memberRepository.findByEmail(request.email())
+                .orElseThrow(() -> new NotFoundException(AuthExceptionCode.NOT_FOUND_USER));
+
+        if(!passwordEncoder.matches(request.password(), member.getPassword()))
+            throw new UnauthorizedException(AuthExceptionCode.UNAUTHORIZED_PASSWORD);
+        // 24 hours
+        String accessToken = jwtUtil.generateAccessToken(member.getEmail());
+        String refreshToken = jwtUtil.generateRefreshToken(member.getEmail());
+        return AuthLoginResponse.builder()
+                .authorization(accessToken)
+                .authorizationRefresh(refreshToken)
+                .build();
+    }
+}

src/main/java/kr/ac/ks/cs_web_back/domain/member/controller/MemberController.java

@@ -3,6 +3,7 @@
 import jakarta.validation.Valid;
 import kr.ac.ks.cs_web_back.domain.member.controller.code.MemberSuccessCode;
 import kr.ac.ks.cs_web_back.domain.member.dto.request.MemberCreateRequest;
+import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
 import kr.ac.ks.cs_web_back.domain.member.service.MemberService;
 import kr.ac.ks.cs_web_back.global.response.CsResponse;
 import lombok.RequiredArgsConstructor;

src/main/java/kr/ac/ks/cs_web_back/domain/member/controller/code/MemberExceptionCode.java

@@ -13,6 +13,7 @@ public enum MemberExceptionCode implements ExceptionCode {
     BAD_REQUEST_NO_USERNAME(9012, "사용자명이 입력되지 않았습니다."),
     CONFLICT_EMAIL(5010, "이미 존재하는 이메일입니다."),
     CONFLICT_USERNAME(5012, "이미 존재하는 사용자명입니다."),
+    NOT_FOUND_USER(6001, "일치하는 사용자가 존재하지 않습니다."),
     ;
 
     private final int code;

src/main/java/kr/ac/ks/cs_web_back/domain/member/repository/MemberRepository.java

@@ -3,7 +3,11 @@
 import kr.ac.ks.cs_web_back.domain.member.model.Member;
 import org.springframework.data.jpa.repository.JpaRepository;
 
+import java.util.Optional;
+
 public interface MemberRepository extends JpaRepository<Member, Long> {
     boolean existsByEmail(String email);
     boolean existsByUsername(String username);
+
+    Optional<Member> findByEmail(String email);
 }

src/main/java/kr/ac/ks/cs_web_back/domain/member/service/MemberService.java

@@ -2,9 +2,13 @@
 
 import kr.ac.ks.cs_web_back.domain.member.controller.code.MemberExceptionCode;
 import kr.ac.ks.cs_web_back.domain.member.dto.request.MemberCreateRequest;
+import kr.ac.ks.cs_web_back.domain.auth.dto.request.AuthLoginRequest;
 import kr.ac.ks.cs_web_back.domain.member.model.Member;
 import kr.ac.ks.cs_web_back.domain.member.repository.MemberRepository;
 import kr.ac.ks.cs_web_back.global.exeption.domain.ConflictException;
+import kr.ac.ks.cs_web_back.global.exeption.domain.NotFoundException;
+import kr.ac.ks.cs_web_back.global.exeption.domain.UnauthorizedException;
+import kr.ac.ks.cs_web_back.global.jwt.JwtUtil;
 import lombok.RequiredArgsConstructor;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;

src/main/java/kr/ac/ks/cs_web_back/global/config/SecurityConfig.java

@@ -29,7 +29,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                 .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                 .authorizeHttpRequests(authz -> authz
                         .requestMatchers(PathRequest.toH2Console()).permitAll() // H2 콘솔 경로 허용
-                        .requestMatchers("/member/register", "/swagger-ui/**", "/v3/api-docs/**").permitAll()
+                        .requestMatchers("/member/register", "/auth/login", "/swagger-ui/**", "/v3/api-docs/**").permitAll()
                         .anyRequest().authenticated()
                 );
 

src/main/java/kr/ac/ks/cs_web_back/global/jwt/JwtUtil.java

@@ -0,0 +1,49 @@
+package kr.ac.ks.cs_web_back.global.jwt;
+
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import jakarta.annotation.PostConstruct;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.spec.SecretKeySpec;
+import java.security.Key;
+import java.util.Base64;
+import java.util.Date;
+
+@Component
+public class JwtUtil {
+    @Value("${jwt.secret}")
+    private String secret;
+
+    @Value("${jwt.accessTokenExpireTime}")
+    private Long accessTokenExpireTime;
+
+    @Value("${jwt.refreshTokenExpireTime}")
+    private Long refreshTokenExpireTime;
+
+    private Key hmacKey;
+
+    @PostConstruct
+    public void init() {
+        byte[] decodedKey = Base64.getDecoder().decode(secret);
+        this.hmacKey = new SecretKeySpec(decodedKey, SignatureAlgorithm.HS256.getJcaName());
+    }
+    public String generateAccessToken(String email) {
+        return generateToken(email, accessTokenExpireTime);
+    }
+
+    public String generateRefreshToken(String email) {
+        return generateToken(email, refreshTokenExpireTime);
+    }
+
+    public String generateToken(String email, Long expireTime) {
+        Date now = new Date();
+        Date expiryDate = new Date(now.getTime() + expireTime);
+        return Jwts.builder().setSubject(email)
+                .setIssuedAt(now)
+                .setExpiration(expiryDate)
+                .signWith(hmacKey)
+                .compact();
+    }
+}