[volume-1] 회원가입, 내 정보 조회, 비밀번호 수정 기능 구현

apps/commerce-api/build.gradle.kts

@@ -9,6 +9,9 @@ dependencies {
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
+
+    // security
+    implementation("org.springframework.boot:spring-boot-starter-security")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
     // querydsl

apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java

@@ -0,0 +1,29 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class MemberFacade {
+
+    private final MemberService memberService;
+
+    public MemberInfo register(String loginId, String rawPassword, String name,
+                               LocalDate birthDate, String email) {
+        Member member = memberService.register(loginId, rawPassword, name, birthDate, email);
+        return MemberInfo.from(member);
+    }
+
+    public MemberInfo getMe(Member authenticatedMember) {
+        return MemberInfo.fromWithMaskedName(authenticatedMember);
+    }
+
+    public void changePassword(Member authenticatedMember, String currentPassword, String newPassword) {
+        memberService.changePassword(authenticatedMember, currentPassword, newPassword);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java

@@ -0,0 +1,35 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.Member;
+
+import java.time.LocalDate;
+
+public record MemberInfo(String loginId, String name, LocalDate birthDate, String email) {
+    public static MemberInfo from(Member member) {
+        return new MemberInfo(
+            member.getLoginId(),
+            member.getName(),
+            member.getBirthDate(),
+            member.getEmail()
+        );
+    }
+
+    public static MemberInfo fromWithMaskedName(Member member) {
+        return new MemberInfo(
+            member.getLoginId(),
+            maskName(member.getName()),
+            member.getBirthDate(),
+            member.getEmail()
+        );
+    }
+
+    private static String maskName(String name) {
+        if (name == null || name.isEmpty()) {
+            return "";
+        }
+        if (name.length() == 1) {
+            return "*";
+        }
+        return name.substring(0, name.length() - 1) + "*";
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java

@@ -0,0 +1,142 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+import java.time.LocalDate;
+
+@Entity
+@Table(name = "member")
+public class Member extends BaseEntity {
+
+    @Column(unique = true, nullable = false)
+    private String loginId;
+    private String password;
+    private String name;
+    private LocalDate birthDate;
+    private String email;
+
+    protected Member() {}
+
+    private Member(String loginId, String password, String name,
+                   LocalDate birthDate, String email) {
+        this.loginId = loginId;
+        this.password = password;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    public static Member create(String loginId, String rawPassword,
+                                String name, LocalDate birthDate,
+                                String email, PasswordEncoder encoder) {
+        validateNotBlank(loginId, "로그인ID는 필수입니다.");
+        validateNotBlank(rawPassword, "비밀번호는 필수입니다.");
+        validateNotBlank(name, "이름은 필수입니다.");
+        validateNotNull(birthDate, "생년월일은 필수입니다.");
+        validateNotBlank(email, "이메일은 필수입니다.");
+
+        validateLoginId(loginId);
+        validatePassword(rawPassword, birthDate);
+        String normalizedName = normalizeName(name);
+        validateName(normalizedName);
+        validateEmail(email);
+
+        String encodedPassword = encoder.encode(rawPassword);
+        return new Member(loginId, encodedPassword, normalizedName, birthDate, email);
+    }
+
+    private static void validateNotNull(Object value, String message) {
+        if (value == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, message);
+        }
+    }
+
+    private static void validateNotBlank(String value, String message) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, message);
+        }
+    }
+
+    private static void validatePassword(String password, LocalDate birthDate) {
+        if (password.length() < 8 || password.length() > 16) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자여야 합니다.");
+        }
+        if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문 대소문자, 숫자, 특수문자만 허용됩니다.");
+        }
+        String birthDateStr = birthDate.toString().replace("-", ""); // 19900115
+        if (password.contains(birthDateStr)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+
+    private static void validateLoginId(String loginId) {
+        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인ID는 영문과 숫자만 허용됩니다.");
+        }
+    }
+
+    private static String normalizeName(String name) {
+        return name.trim().replaceAll("\\s+", " ");
+    }
+
+    private static void validateName(String name) {
+        boolean isKorean = name.matches("^[가-힣]+$");
+        boolean isEnglish = name.matches("^[a-zA-Z]+( [a-zA-Z]+)*$");
+
+        if (!isKorean && !isEnglish) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 한글만 또는 영문만 허용됩니다.");
+        }
+    }
+
+    private static void validateEmail(String email) {
+        if (!email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "올바른 이메일 형식이 아닙니다.");
+        }
+    }
+
+    public void changePassword(String currentPassword, String newRawPassword,
+                               PasswordEncoder encoder) {
+        validateNotBlank(currentPassword, "현재 비밀번호는 필수입니다.");
+        validateNotBlank(newRawPassword, "새 비밀번호는 필수입니다.");
+
+        // 현재 비밀번호 확인
+        if (!encoder.matches(currentPassword, this.password)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+        // 새 비밀번호가 현재와 동일한지 확인
+        if (encoder.matches(newRawPassword, this.password)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 현재 비밀번호와 달라야 합니다.");
+        }
+        // 새 비밀번호 규칙 검증
+        validatePassword(newRawPassword, this.birthDate);
+        // 비밀번호 변경
+        this.password = encoder.encode(newRawPassword);
+    }
+
+    // Getter
+    public String getLoginId() {
+        return loginId;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public LocalDate getBirthDate() {
+        return birthDate;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/member/MemberReader.java

@@ -0,0 +1,8 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberReader {
+    boolean existsByLoginId(String loginId);
+    Optional<Member> findByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java

@@ -0,0 +1,5 @@
+package com.loopers.domain.member;
+
+public interface MemberRepository {
+    Member save(Member member);
+}

apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java

@@ -0,0 +1,32 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class MemberService {
+
+    private final MemberReader memberReader;
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public Member register(String loginId, String rawPassword, String name,
+                           LocalDate birthDate, String email) {
+        if (memberReader.existsByLoginId(loginId)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이미 존재하는 로그인ID입니다.");
+        }
+
+        Member member = Member.create(loginId, rawPassword, name, birthDate, email, passwordEncoder);
+        return memberRepository.save(member);
+    }
+
+    public void changePassword(Member member, String currentPassword, String newPassword) {
+        member.changePassword(currentPassword, newPassword, passwordEncoder);
+        memberRepository.save(member);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java

@@ -0,0 +1,6 @@
+package com.loopers.domain.member;
+
+public interface PasswordEncoder {
+    String encode(String rawPassword);
+    boolean matches(String rawPassword, String encodedPassword);
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java

@@ -0,0 +1,11 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MemberJpaRepository extends JpaRepository<Member, Long> {
+    boolean existsByLoginId(String loginId);
+    Optional<Member> findByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberReaderImpl.java

@@ -0,0 +1,24 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberReader;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberReaderImpl implements MemberReader {
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public boolean existsByLoginId(String loginId) {
+        return memberJpaRepository.existsByLoginId(loginId);
+    }
+
+    @Override
+    public Optional<Member> findByLoginId(String loginId) {
+        return memberJpaRepository.findByLoginId(loginId);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java

@@ -0,0 +1,17 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberRepositoryImpl implements MemberRepository {
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public Member save(Member member) {
+        return memberJpaRepository.save(member);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/member/PasswordEncoderImpl.java

@@ -0,0 +1,20 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.PasswordEncoder;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class PasswordEncoderImpl implements PasswordEncoder {
+    private final BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
+
+    @Override
+    public String encode(String rawPassword) {
+        return bCryptPasswordEncoder.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return bCryptPasswordEncoder.matches(rawPassword, encodedPassword);
+    }
+}