[Feature] - 자체 회원 가입과 로그인 구현

backend/src/main/java/kr/touroot/authentication/controller/LoginController.java

@@ -6,12 +6,15 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import kr.touroot.authentication.dto.request.LoginRequest;
 import kr.touroot.authentication.dto.response.LoginResponse;
 import kr.touroot.authentication.service.LoginService;
 import kr.touroot.global.exception.dto.ExceptionResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -44,4 +47,22 @@ public ResponseEntity<LoginResponse> login(
         return ResponseEntity.ok()
                 .body(loginService.login(authorizationCode, encodedRedirectUri));
     }
+
+    @Operation(summary = "투룻 서비스 자체 로그인")
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "요청이 정상적으로 처리되었을 때"
+            ),
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "요청 Body에 올바르지 않은 이메일 또는 비밀번호가 전달되었을 때",
+                    content = @Content(schema = @Schema(implementation = ExceptionResponse.class))
+            )
+    })
+    @PostMapping
+    public ResponseEntity<LoginResponse> defaultLogin(@Valid @RequestBody LoginRequest request) {
+        return ResponseEntity.ok()
+                .body(loginService.login(request));
+    }
 }

backend/src/main/java/kr/touroot/authentication/dto/request/LoginRequest.java

@@ -0,0 +1,16 @@
+package kr.touroot.authentication.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public record LoginRequest(
+        @Schema(description = "사용자 이메일", example = "email@gmail.com")
+        @NotBlank(message = "이메일은 비어있을 수 없습니다.")
+        @Email
+        String email,
+        @Schema(description = "사용자 비밀번호", example = "@testpassword1234")
+        @NotBlank(message = "비밀번호는 비어있을 수 없습니다.")
+        String password
+) {
+}

backend/src/main/java/kr/touroot/authentication/dto/response/OauthUserInformationResponse.java

@@ -2,6 +2,7 @@
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 import kr.touroot.authentication.dto.response.kakao.KakaoAccount;
+import kr.touroot.member.domain.LoginType;
 import kr.touroot.member.domain.Member;
 
 public record OauthUserInformationResponse(
@@ -12,7 +13,7 @@ public record OauthUserInformationResponse(
 ) {
 
     public Member toMember() {
-        return new Member(socialLoginId, nickname(), profileImage());
+        return new Member(socialLoginId, nickname(), profileImage(), LoginType.KAKAO);
     }
 
     public String nickname() {

backend/src/main/java/kr/touroot/authentication/infrastructure/PasswordEncryptor.java

@@ -0,0 +1,25 @@
+package kr.touroot.authentication.infrastructure;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PasswordEncryptor {
+
+    public static final int HEXADECIMAL = 16;
+
+    public String encrypt(String password) {
+        try {
+            MessageDigest md = MessageDigest.getInstance("SHA-512");
+
+            byte[] message = md.digest(password.getBytes());
+            BigInteger number = new BigInteger(1, message);
+
+            return number.toString(HEXADECIMAL);
+        } catch (NoSuchAlgorithmException exception) {
+            throw new RuntimeException();
+        }
+    }
+}

backend/src/main/java/kr/touroot/authentication/service/LoginService.java

@@ -1,11 +1,14 @@
 package kr.touroot.authentication.service;
 
+import kr.touroot.authentication.dto.request.LoginRequest;
 import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
 import kr.touroot.authentication.dto.response.LoginResponse;
 import kr.touroot.authentication.dto.response.OauthUserInformationResponse;
 import kr.touroot.authentication.infrastructure.JwtTokenProvider;
 import kr.touroot.authentication.infrastructure.KakaoOauthProvider;
+import kr.touroot.authentication.infrastructure.PasswordEncryptor;
+import kr.touroot.global.exception.BadRequestException;
 import kr.touroot.member.domain.Member;
 import kr.touroot.member.repository.MemberRepository;
 import lombok.RequiredArgsConstructor;
@@ -18,6 +21,7 @@ public class LoginService {
     private final MemberRepository memberRepository;
     private final KakaoOauthProvider oauthProvider;
     private final JwtTokenProvider tokenProvider;
+    private final PasswordEncryptor passwordEncryptor;
 
     public LoginResponse login(String code, String encodedRedirectUri) {
         String redirectUri = URLDecoder.decode(encodedRedirectUri, StandardCharsets.UTF_8);
@@ -31,4 +35,12 @@ public LoginResponse login(String code, String encodedRedirectUri) {
     private Member signUp(OauthUserInformationResponse userInformation) {
         return memberRepository.save(userInformation.toMember());
     }
+
+    public LoginResponse login(LoginRequest request) {
+        String encryptPassword = passwordEncryptor.encrypt(request.password());
+        Member member = memberRepository.findByEmailAndPassword(request.email(), encryptPassword)
+                .orElseThrow(() -> new BadRequestException("잘못된 이메일 또는 비밀번호입니다."));
+
+        return LoginResponse.of(member, tokenProvider.createToken(member.getId()));
+    }
 }

backend/src/main/java/kr/touroot/global/auth/JwtAuthFilter.java

@@ -39,6 +39,7 @@ public class JwtAuthFilter extends OncePerRequestFilter {
             new HttpRequestInfo(HttpMethod.GET, "/api/v1/travelogues/**"),
             new HttpRequestInfo(HttpMethod.POST, "/api/v1/login/**"),
             new HttpRequestInfo(HttpMethod.GET, "/api/v1/travel-plans/shared/**"),
+            new HttpRequestInfo(HttpMethod.POST, "/api/v1/members"),
             new HttpRequestInfo(HttpMethod.OPTIONS, "/**")
     );
 

backend/src/main/java/kr/touroot/image/infrastructure/AwsS3Provider.java

@@ -95,7 +95,7 @@ public String copyImageToPermanentStorage(String imageUrl) {
 
     private void validateS3Path(String imageKey) {
         if (!imageKey.startsWith(imageBaseUri + temporaryStoragePath)) {
-            throw new BadRequestException("이미지 url 형식이 잘못되었습니다.");
+            throw new BadRequestException("S3 이미지 url 형식이 잘못되었습니다.");
         }
     }
 

backend/src/main/java/kr/touroot/member/controller/MemberController.java

@@ -0,0 +1,48 @@
+package kr.touroot.member.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import java.net.URI;
+import kr.touroot.global.exception.dto.ExceptionResponse;
+import kr.touroot.member.dto.request.MemberRequest;
+import kr.touroot.member.service.MemberService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@Tag(name = "사용자")
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/members")
+public class MemberController {
+
+    private final MemberService memberService;
+
+    @Operation(summary = "회원 가입")
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "201",
+                    description = "요청이 정상적으로 처리되었을 때"
+            ),
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "요청 Body에 올바르지 않은 값이 전달되었을 때",
+                    content = @Content(schema = @Schema(implementation = ExceptionResponse.class))
+            ),
+    })
+    @PostMapping
+    public ResponseEntity<Void> createMember(@Valid @RequestBody MemberRequest request) {
+        Long id = memberService.createMember(request);
+
+        return ResponseEntity.created(URI.create("/api/v1/members/" + id))
+                .build();
+    }
+}

backend/src/main/java/kr/touroot/member/domain/LoginType.java

@@ -0,0 +1,5 @@
+package kr.touroot.member.domain;
+
+public enum LoginType {
+    KAKAO, DEFAULT
+}

backend/src/main/java/kr/touroot/member/domain/Member.java

@@ -2,6 +2,8 @@
 
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
@@ -24,37 +26,70 @@ public class Member extends BaseEntity {
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
-    @Column(nullable = false)
     private Long kakaoId;
 
+    private String email;
+
+    private String password;
+
     @Column(nullable = false)
     private String nickname;
 
     @Column(nullable = false)
     private String profileImageUrl;
 
-    public Member(Long id, Long kakaoId, String nickname, String profileImageUrl) {
-        validate(kakaoId, nickname, profileImageUrl);
+    @Column(nullable = false)
+    @Enumerated(EnumType.STRING)
+    private LoginType loginType;
+
+    public Member(
+            Long id, Long kakaoId, String email, String password, String nickname, String url, LoginType loginType
+    ) {
+        validate(kakaoId, email, password, nickname, url, loginType);
         this.id = id;
         this.kakaoId = kakaoId;
+        this.email = email;
+        this.password = password;
         this.nickname = nickname;
-        this.profileImageUrl = profileImageUrl;
+        this.profileImageUrl = url;
+        this.loginType = loginType;
+    }
+
+    public Member(Long kakaoId, String nickname, String profileImageUrl, LoginType loginType) {
+        this(null, kakaoId, null, null, nickname, profileImageUrl, loginType);
     }
 
-    public Member(Long kakaoId, String nickname, String profileImageUrl) {
-        this(null, kakaoId, nickname, profileImageUrl);
+    public Member(String email, String password, String nickname, String profileImageUrl, LoginType loginType) {
+        this(null, null, email, password, nickname, profileImageUrl, loginType);
     }
 
-    private void validate(Long kakaoId, String nickname, String profileImageUrl) {
-        validateNotNull(kakaoId, nickname, profileImageUrl);
+    private void validate(
+            Long kakaoId, String email, String password, String nickname, String profileImageUrl, LoginType loginType
+    ) {
+        validateByLoginType(kakaoId, email, password, loginType);
+        validateNotNull(nickname, profileImageUrl);
         validateNotBlank(nickname, profileImageUrl);
         validateNicknameLength(nickname);
         validateProfileImageUrl(profileImageUrl);
     }
 
-    private void validateNotNull(Long kakaoId, String nickname, String profileImageUrl) {
-        if (kakaoId == null || nickname == null || profileImageUrl == null) {
-            throw new BadRequestException("카카오 아이디, 닉네임, 프로필 이미지는 비어 있을 수 없습니다");
+    private void validateByLoginType(Long kakaoId, String email, String password, LoginType loginType) {
+        if (loginType.equals(LoginType.KAKAO) && kakaoId == null) {
+            throw new BadRequestException("카카오 ID는 비어 있을 수 없습니다");
+        }
+
+        if (loginType.equals(LoginType.DEFAULT) && (email == null || password == null)) {
+            throw new BadRequestException("이메일과 비밀번호는 비어 있을 수 없습니다.");
+        }
+
+        if (loginType.equals(LoginType.DEFAULT) && (email.isBlank() || password.isBlank())) {
+            throw new BadRequestException("이메일과 비밀번호는 비어 있을 수 없습니다.");
+        }
+    }
+
+    private void validateNotNull(String nickname, String profileImageUrl) {
+        if (nickname == null || profileImageUrl == null) {
+            throw new BadRequestException("닉네임, 프로필 이미지는 비어 있을 수 없습니다");
         }
     }
 

backend/src/main/java/kr/touroot/member/dto/request/MemberRequest.java

@@ -0,0 +1,28 @@
+package kr.touroot.member.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import kr.touroot.member.domain.LoginType;
+import kr.touroot.member.domain.Member;
+
+public record MemberRequest(
+        @Schema(description = "사용자 이메일", example = "email@gmail.com")
+        @NotBlank(message = "이메일은 비어있을 수 없습니다.")
+        @Email
+        String email,
+        @Schema(description = "사용자 비밀번호", example = "@testpassword1234")
+        @NotBlank(message = "비밀번호는 비어있을 수 없습니다.")
+        String password,
+        @Schema(description = "사용자 닉네임", example = "뚜리")
+        @NotBlank(message = "닉네임은 비어있을 수 없습니다.")
+        String nickname,
+        @Schema(description = "사용자 프로필 사진 URL", example = "S3 이미지 URL")
+        @NotBlank(message = "프로필 사진 URL은 비어있을 수 없습니다.")
+        String profileImageUrl
+) {
+
+    public Member toMember(String password) {
+        return new Member(email, password, nickname, profileImageUrl, LoginType.DEFAULT);
+    }
+}

backend/src/main/java/kr/touroot/member/repository/MemberRepository.java

@@ -1,10 +1,16 @@
 package kr.touroot.member.repository;
 
 import java.util.Optional;
-import org.springframework.data.jpa.repository.JpaRepository;
 import kr.touroot.member.domain.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface MemberRepository extends JpaRepository<Member, Long> {
 
     Optional<Member> findByKakaoId(Long kakaoId);
+
+    Optional<Member> findByEmailAndPassword(String email, String password);
+
+    Optional<Member> findByEmail(String email);
+
+    Optional<Object> findByNickname(String nickname);
 }

backend/src/main/java/kr/touroot/member/service/MemberService.java

@@ -1,7 +1,9 @@
 package kr.touroot.member.service;
 
+import kr.touroot.authentication.infrastructure.PasswordEncryptor;
 import kr.touroot.global.exception.BadRequestException;
 import kr.touroot.member.domain.Member;
+import kr.touroot.member.dto.request.MemberRequest;
 import kr.touroot.member.repository.MemberRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -11,9 +13,35 @@
 public class MemberService {
 
     private final MemberRepository memberRepository;
+    private final PasswordEncryptor passwordEncryptor;
 
     public Member getById(Long memberId) {
         return memberRepository.findById(memberId)
                 .orElseThrow(() -> new BadRequestException("존재하지 않는 사용자입니다."));
     }
+
+    public Long createMember(MemberRequest request) {
+        validateRequest(request);
+        String encryptedPassword = passwordEncryptor.encrypt(request.password());
+        Member member = request.toMember(encryptedPassword);
+
+        return memberRepository.save(member).getId();
+    }
+
+    private void validateRequest(MemberRequest request) {
+        validateEmailDuplication(request.email());
+        validateNicknameDuplicationr(request.nickname());
+    }
+
+    private void validateEmailDuplication(String email) {
+        if (memberRepository.findByEmail(email).isPresent()) {
+            throw new BadRequestException("이미 회원 가입되어 있는 이메일입니다.");
+        }
+    }
+
+    private void validateNicknameDuplicationr(String nickname) {
+        if (memberRepository.findByNickname(nickname).isPresent()) {
+            throw new BadRequestException("이미 사용 중인 닉네임입니다.");
+        }
+    }
 }