[Spring MVC(인증)] 정원영 미션 제출합니다.

src/main/java/roomescape/auth/AuthController.java

@@ -0,0 +1,40 @@
+package roomescape.auth;
+
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+public class AuthController {
+
+    private static final String ACCESS_TOKEN_NAME = "token";
+
+    private final AuthService authService;
+
+    public AuthController(AuthService authService) {
+        this.authService = authService;
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity login(@RequestBody LoginRequest loginRequest, HttpServletResponse response) {
+        String token = authService.loginWithEmailAndPassword(loginRequest.email(), loginRequest.password());
+        addCookie(response, ACCESS_TOKEN_NAME, token);
+
+        return ResponseEntity.ok().build();
+    }
+
+    @GetMapping("/login/check")
+    public ResponseEntity loginCheck(@CookieValue(ACCESS_TOKEN_NAME) String accessToken) {
+        return ResponseEntity.ok().body(authService.loginCheckWithToken(accessToken));
+    }
+
+    private void addCookie(HttpServletResponse response, String cookieName, String cookieValue) {
+        Cookie cookie = new Cookie(cookieName, cookieValue);
+        cookie.setHttpOnly(true);
+        cookie.setPath("/");
+        response.addCookie(cookie);
+    }
+}

src/main/java/roomescape/auth/AuthService.java

@@ -0,0 +1,54 @@
+package roomescape.auth;
+
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.stereotype.Service;
+import roomescape.auth.jwt.MemberTokenDto;
+import roomescape.auth.jwt.TokenService;
+import roomescape.member.Member;
+import roomescape.member.MemberDao;
+
+@Service
+public class AuthService {
+
+    public static final String WRONG_PASSWORD_EXCEPTION_MESSAGE = "잘못된 비밀번호입니다.";
+    public static final String INVALID_EMAIL_EXCEPTION_MESSAGE = "없는 이메일 입니다.";
+    public static final String INVALID_TOKEN_EXCEPTION_MESSAGE = "잘못된 토큰입니다.";
+    private final MemberDao memberDao;
+    private final TokenService tokenService;
+
+
+    public AuthService(MemberDao memberDao, TokenService tokenService) {
+        this.memberDao = memberDao;
+        this.tokenService = tokenService;
+    }
+
+    public String loginWithEmailAndPassword(String email, String password) {
+
+        Member member = null;
+        try {
+            validatePasswordByEmail(email, password);
+        } catch (EmptyResultDataAccessException e) {
+            throw new IllegalArgumentException(INVALID_EMAIL_EXCEPTION_MESSAGE, e);
+        }
+
+        return tokenService.createToken(
+                new MemberTokenDto(member.getId(), member.getName(), member.getEmail(), member.getRole()));
+    }
+
+    public MemberDetailResponse loginCheckWithToken(String token) {
+        //유효기간 확인을 위해 필요
+        if (!tokenService.checkValidToken(token)) {
+            throw new IllegalArgumentException(INVALID_TOKEN_EXCEPTION_MESSAGE);
+        }
+
+        MemberTokenDto member = tokenService.getMemberClaims(token);
+        return new MemberDetailResponse(member.id(), member.name(), member.email(), member.role());
+    }
+
+    private void validatePasswordByEmail(String email, String password) {
+        String findPassword = memberDao.findPasswordByEmail(email);
+        if (!findPassword.equals(password)) {
+            throw new IllegalArgumentException(WRONG_PASSWORD_EXCEPTION_MESSAGE);
+        }
+    }
+}

src/main/java/roomescape/auth/LoginRequest.java

@@ -0,0 +1,7 @@
+package roomescape.auth;
+
+public record LoginRequest(
+        String email,
+        String password
+) {
+}

src/main/java/roomescape/auth/MemberDetailResponse.java

@@ -0,0 +1,9 @@
+package roomescape.auth;
+
+public record MemberDetailResponse(
+        Long id,
+        String name,
+        String email,
+        String role
+) {
+}

src/main/java/roomescape/auth/jwt/JwtConfig.java

@@ -0,0 +1,27 @@
+package roomescape.auth.jwt;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties("roomescape.auth.jwt")
+public class JwtConfig {
+    private String secret;
+    private long expiration;
+
+    public String getSecret() {
+        return secret;
+    }
+
+    public long getExpiration() {
+        return expiration;
+    }
+
+    public void setSecret(String secret) {
+        this.secret = secret;
+    }
+
+    public void setExpiration(long expiration) {
+        this.expiration = expiration;
+    }
+}

src/main/java/roomescape/auth/jwt/MemberTokenDto.java

@@ -0,0 +1,9 @@
+package roomescape.auth.jwt;
+
+public record MemberTokenDto(
+        long id,
+        String name,
+        String email,
+        String role
+) {
+}

src/main/java/roomescape/auth/jwt/TokenService.java

@@ -0,0 +1,69 @@
+package roomescape.auth.jwt;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jws;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.stereotype.Service;
+
+import java.security.Key;
+import java.util.Date;
+
+@Service
+public class TokenService {
+
+    private static final String NAME_CLAIM = "name";
+    private static final String EMAIL_CLAIM = "email";
+    private static final String ROLE_CLAIM = "role";
+
+    private final JwtConfig jwtConfig;
+    private Key key;
+
+    public TokenService(JwtConfig jwtConfig) {
+        this.jwtConfig = jwtConfig;
+        this.key = Keys.hmacShaKeyFor(jwtConfig.getSecret().getBytes());
+    }
+
+    public String createToken(MemberTokenDto memberTokenDto) {
+        return Jwts.builder()
+                .setSubject(String.valueOf(memberTokenDto.id()))
+                .claim(NAME_CLAIM, memberTokenDto.name())
+                .claim(EMAIL_CLAIM, memberTokenDto.email())
+                .claim(ROLE_CLAIM, memberTokenDto.role())
+                .setExpiration(new Date(System.currentTimeMillis() + jwtConfig.getExpiration()))
+                .signWith(key)
+                .compact();
+    }
+
+    public boolean checkValidToken(String token) {
+        try {
+            Jws<Claims> claims = Jwts.parserBuilder()
+                    .setSigningKey(key)
+                    .build()
+                    .parseClaimsJws(token);
+
+            return claims.getBody().getExpiration().after(new Date());
+        } catch (JwtException | IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public MemberTokenDto getMemberClaims(String token) {
+        try {
+            Claims claims = Jwts.parserBuilder()
+                    .setSigningKey(key)
+                    .build()
+                    .parseClaimsJws(token)
+                    .getBody();
+
+            return new MemberTokenDto(
+                    Long.valueOf(claims.getSubject()),
+                    claims.get(NAME_CLAIM).toString(),
+                    claims.get(EMAIL_CLAIM).toString(),
+                    claims.get(ROLE_CLAIM).toString());
+        } catch (JwtException | IllegalArgumentException e) {
+            throw new IllegalArgumentException("잘못된 토큰입니다.");
+        }
+    }
+}

src/main/java/roomescape/member/MemberDao.java

@@ -40,6 +40,14 @@ public Member findByEmailAndPassword(String email, String password) {
         );
     }
 
+    public String findPasswordByEmail(String email) {
+        return jdbcTemplate.queryForObject(
+                "SELECT password FROM member WHERE email = ?",
+                String.class,
+                email
+        );
+    }
+
     public Member findByName(String name) {
         return jdbcTemplate.queryForObject(
                 "SELECT id, name, email, role FROM member WHERE name = ?",

src/test/java/roomescape/auth/AuthServiceTest.java

@@ -0,0 +1,79 @@
+package roomescape.auth;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.transaction.annotation.Transactional;
+import roomescape.member.Member;
+import roomescape.member.MemberDao;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@SpringBootTest
+@Transactional
+class AuthServiceTest {
+
+    @Autowired
+    private MemberDao memberDao;
+    @Autowired
+    private AuthService authService;
+
+    private Member member;
+
+    @BeforeEach
+    void setUp() {
+        member = new Member("testName", "[email protected]", "testPassword", "user");
+        memberDao.save(member);
+    }
+
+    @Test
+    @DisplayName("이메일 및 비밀번호로 로그인 성공")
+    void loginWithEmailAndPassword_Success() {
+        String actualToken = authService.loginWithEmailAndPassword(member.getEmail(), member.getPassword());
+
+        assertThat(actualToken).isNotBlank();
+    }
+
+    @Test
+    @DisplayName("유효하지 않은 이메일")
+    void loginWithEmailAndPassword_Failure_InvalidEmail() {
+        assertThatThrownBy(() -> authService.loginWithEmailAndPassword("invalid_email", "invalid_password"))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage(AuthService.INVALID_EMAIL_EXCEPTION_MESSAGE);
+    }
+
+    @Test
+    @DisplayName("이메일은 맞으나 잘못된 비밀번호")
+    void loginWithEmailAndPassword_Failure_WrongPassword() {
+        assertThatThrownBy(() -> authService.loginWithEmailAndPassword(member.getEmail(), "invalid_password"))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage(AuthService.WRONG_PASSWORD_EXCEPTION_MESSAGE);
+    }
+
+    @Test
+    @DisplayName("토큰으로 로그인 성공")
+    void loginCheckWithToken_Success() {
+        String token = authService.loginWithEmailAndPassword(member.getEmail(), member.getPassword());
+
+        MemberDetailResponse response = authService.loginCheckWithToken(token);
+
+        assertThat(response).isNotNull();
+        assertThat(response.id()).isNotNull();
+        assertThat(response.name()).isEqualTo(member.getName());
+        assertThat(response.email()).isEqualTo(member.getEmail());
+        assertThat(response.role()).isEqualTo(member.getRole());
+    }
+
+    @Test
+    @DisplayName("잘못된 토큰으로 로그인시 실패")
+    void loginCheckWithToken_Failure_InvalidToken() {
+        String token = "invalid_token";
+
+        assertThatThrownBy(() -> authService.loginCheckWithToken(token))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("잘못된 토큰입니다.");
+    }
+}