회원가입·게시판 첫 흐름

package board.domain;

import java.util.Locale;
import java.util.Objects;

public record Member(
        long id,
        String email,
        String name,
        String passwordHash
) {
    public Member {
        if (id < 0) {
            throw new IllegalArgumentException("id must not be negative");
        }
        email = requireText(email, "email", 254)
                .toLowerCase(Locale.ROOT);
        name = requireText(name, "name", 50);
        passwordHash = requireText(passwordHash, "passwordHash");
    }

    public static Member signUp(
            String email,
            String name,
            String passwordHash
    ) {
        return new Member(0, email, name, passwordHash);
    }

    public Member identifiedBy(long savedId) {
        if (id != 0) {
            throw new IllegalStateException("member already has an id");
        }
        if (savedId < 1) {
            throw new IllegalArgumentException("saved id must be positive");
        }
        return new Member(savedId, email, name, passwordHash);
    }

    private static String requireText(
            String value,
            String field,
            int maxLength
    ) {
        var normalized = requireText(value, field);
        if (normalized.length() > maxLength) {
            throw new IllegalArgumentException(
                    field + " has an invalid length");
        }
        return normalized;
    }

    private static String requireText(String value, String field) {
        Objects.requireNonNull(value, field + " must not be null");
        var normalized = value.strip();
        if (normalized.isEmpty()) {
            throw new IllegalArgumentException(field + " must not be blank");
        }
        return normalized;
    }
}

package board.domain;

public interface MemberRepository {
    boolean existsByEmail(String email);
    Member save(Member member);
}

package board.infrastructure;

import board.domain.Member;
import board.domain.MemberRepository;

import java.util.Locale;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public final class MemoryMemberRepository implements MemberRepository {
    private final AtomicLong sequence = new AtomicLong();
    private final ConcurrentHashMap<Long, Member> store =
            new ConcurrentHashMap<>();

    @Override
    public boolean existsByEmail(String email) {
        var normalized = email.strip().toLowerCase(Locale.ROOT);
        return store.values().stream()
                .anyMatch(member -> member.email().equals(normalized));
    }

    @Override
    public Member save(Member member) {
        Objects.requireNonNull(member, "member must not be null");
        if (member.id() != 0) {
            throw new IllegalArgumentException("member must be unsaved");
        }
        var saved = member.identifiedBy(sequence.incrementAndGet());
        store.put(saved.id(), saved);
        return saved;
    }
}

package board.application;

import java.util.Locale;

public record RegisterMemberCommand(
        String email,
        String name,
        String rawPassword
) {
    public RegisterMemberCommand {
        email = requireText(email, "email", 254)
                .toLowerCase(Locale.ROOT);
        name = requireText(name, "name", 50);
        requireRawPassword(rawPassword);
    }

    private static String requireText(
            String value,
            String field,
            int maxLength
    ) {
        if (value == null) {
            throw new IllegalArgumentException(field + " is required");
        }
        var normalized = value.strip();
        if (normalized.isEmpty() || normalized.length() > maxLength) {
            throw new IllegalArgumentException(
                    field + " has an invalid length");
        }
        return normalized;
    }

    private static void requireRawPassword(String rawPassword) {
        if (rawPassword == null || rawPassword.isBlank()) {
            throw new IllegalArgumentException("rawPassword is required");
        }
        if (rawPassword.length() < 8 || rawPassword.length() > 128) {
            throw new IllegalArgumentException(
                    "rawPassword must be between 8 and 128 UTF-16 code units");
        }
    }
}

package board.application;

public interface PasswordHasher {
    String hash(String rawPassword);
}

package board.application;

public final class DuplicateEmailException extends RuntimeException {
    public DuplicateEmailException(String email) {
        super("email already exists: " + email);
    }
}

package board.application;

import board.domain.Member;
import board.domain.MemberRepository;

import java.util.Objects;

public final class MemberRegistrationService {
    private final MemberRepository members;
    private final PasswordHasher passwordHasher;

    public MemberRegistrationService(
            MemberRepository members,
            PasswordHasher passwordHasher
    ) {
        this.members = Objects.requireNonNull(
                members, "members must not be null");
        this.passwordHasher = Objects.requireNonNull(
                passwordHasher, "passwordHasher must not be null");
    }

    public Member register(RegisterMemberCommand command) {
        Objects.requireNonNull(command, "command must not be null");
        if (members.existsByEmail(command.email())) {
            throw new DuplicateEmailException(command.email());
        }
        var passwordHash = passwordHasher.hash(command.rawPassword());
        var member = Member.signUp(
                command.email(), command.name(), passwordHash);
        return members.save(member);
    }
}

package board.infrastructure;

import board.application.PasswordHasher;

import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Base64;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public final class Pbkdf2PasswordHasher implements PasswordHasher {
    private static final String ALGORITHM = "PBKDF2WithHmacSHA256";
    private static final int ITERATIONS = 600_000;
    private static final int KEY_LENGTH_BITS = 256;
    private static final int SALT_LENGTH_BYTES = 16;

    private final SecureRandom random = new SecureRandom();

    @Override
    public String hash(String rawPassword) {
        requireRawPassword(rawPassword);
        var salt = new byte[SALT_LENGTH_BYTES];
        random.nextBytes(salt);
        var derived = derive(rawPassword, salt, ITERATIONS);
        var encoder = Base64.getUrlEncoder().withoutPadding();
        return "$pbkdf2-sha256$%d$%s$%s".formatted(
                ITERATIONS,
                encoder.encodeToString(salt),
                encoder.encodeToString(derived));
    }

    private static byte[] derive(
            String rawPassword,
            byte[] salt,
            int iterations
    ) {
        var specification = new PBEKeySpec(
                rawPassword.toCharArray(),
                salt,
                iterations,
                KEY_LENGTH_BITS);
        try {
            return SecretKeyFactory.getInstance(ALGORITHM)
                    .generateSecret(specification)
                    .getEncoded();
        } catch (GeneralSecurityException exception) {
            throw new IllegalStateException("PBKDF2 is unavailable", exception);
        } finally {
            specification.clearPassword();
        }
    }

    private static void requireRawPassword(String rawPassword) {
        if (rawPassword == null || rawPassword.isBlank()) {
            throw new IllegalArgumentException("rawPassword is required");
        }
    }
}

package board.web;

import board.application.RegisterMemberCommand;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

public record RegisterMemberRequest(
        @NotBlank @Email @Size(max = 254) String email,
        @NotBlank @Size(max = 50) String name,
        @NotBlank @Size(min = 8, max = 128) String rawPassword
) {
    public RegisterMemberRequest {
        email = stripIfPresent(email);
        name = stripIfPresent(name);
    }

    RegisterMemberCommand toCommand() {
        return new RegisterMemberCommand(email, name, rawPassword);
    }

    private static String stripIfPresent(String value) {
        return value == null ? null : value.strip();
    }
}

package board.web;

import board.domain.Member;

public record MemberResponse(
        long id,
        String authorId,
        String email,
        String name
) {
    static MemberResponse from(Member member) {
        return new MemberResponse(
                member.id(),
                Long.toString(member.id()),
                member.email(),
                member.name());
    }
}

package board.web;

import board.application.MemberRegistrationService;

import jakarta.validation.Valid;
import java.net.URI;
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;

@RestController
@RequestMapping("/api/members")
public final class MemberController {
    private final MemberRegistrationService service;

    public MemberController(MemberRegistrationService service) {
        this.service = service;
    }

    @PostMapping
    public ResponseEntity<MemberResponse> register(
            @Valid @RequestBody RegisterMemberRequest request
    ) {
        var member = service.register(request.toCommand());
        var location = URI.create("/api/members/" + member.id());
        return ResponseEntity.created(location)
                .body(MemberResponse.from(member));
    }
}

package board.web;

import board.application.DuplicateEmailException;
import board.application.DuplicatePostException;
import board.application.PostNotFoundException;

import java.net.URI;
import java.util.Locale;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public final class ApiExceptionHandler {
    @ExceptionHandler(PostNotFoundException.class)
    ProblemDetail notFound(PostNotFoundException exception) {
        return problem(HttpStatus.NOT_FOUND, "POST_NOT_FOUND",
                exception.getMessage());
    }

    @ExceptionHandler(DuplicatePostException.class)
    ProblemDetail duplicatePost(DuplicatePostException exception) {
        return problem(HttpStatus.CONFLICT, "POST_DUPLICATE",
                exception.getMessage());
    }

    @ExceptionHandler(DuplicateEmailException.class)
    ProblemDetail duplicateEmail(DuplicateEmailException exception) {
        return problem(HttpStatus.CONFLICT, "MEMBER_EMAIL_DUPLICATE",
                exception.getMessage());
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail invalidRequest(
            MethodArgumentNotValidException exception
    ) {
        return problem(HttpStatus.BAD_REQUEST, "INVALID_REQUEST",
                "request validation failed");
    }

    @ExceptionHandler(IllegalArgumentException.class)
    ProblemDetail invalidRequest(IllegalArgumentException exception) {
        return problem(HttpStatus.BAD_REQUEST, "INVALID_REQUEST",
                exception.getMessage());
    }

    private ProblemDetail problem(
            HttpStatus status,
            String code,
            String detail
    ) {
        var problem = ProblemDetail.forStatusAndDetail(status, detail);
        problem.setType(URI.create(
                "https://andongmin.com/problems/"
                        + code.toLowerCase(Locale.ROOT)
                        .replace('_', '-')));
        problem.setTitle(status.getReasonPhrase());
        problem.setProperty("code", code);
        return problem;
    }
}

package board.config;

import board.application.MemberRegistrationService;
import board.application.PasswordHasher;
import board.application.PostService;
import board.domain.MemberRepository;
import board.domain.PostRepository;
import board.infrastructure.MemoryMemberRepository;
import board.infrastructure.MemoryPostRepository;
import board.infrastructure.Pbkdf2PasswordHasher;

import java.time.Clock;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class BoardConfig {
    @Bean
    PostRepository postRepository() {
        return new MemoryPostRepository();
    }

    @Bean
    Clock postClock() {
        return Clock.systemUTC();
    }

    @Bean
    PostService postService(
            PostRepository repository,
            Clock postClock
    ) {
        return new PostService(repository, postClock);
    }

    @Bean
    MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

    @Bean
    PasswordHasher passwordHasher() {
        return new Pbkdf2PasswordHasher();
    }

    @Bean
    MemberRegistrationService memberRegistrationService(
            MemberRepository repository,
            PasswordHasher passwordHasher
    ) {
        return new MemberRegistrationService(repository, passwordHasher);
    }
}

curl -i -X POST http://localhost:8080/api/members \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","name":"안동민","rawPassword":"secret-1234"}'

HTTP/1.1 201
Location: /api/members/1
Content-Type: application/json

{"id":1,"authorId":"1","email":"[email protected]","name":"안동민"}

curl -i -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{"authorId":"1","title":"첫 게시글","content":"회원가입 뒤 게시글을 등록합니다.","publishedOn":"2026-07-13"}'

HTTP/1.1 201
Location: /api/posts/1
Content-Type: application/json

{"id":1,"authorId":"1","title":"첫 게시글","content":"회원가입 뒤 게시글을 등록합니다.","publishedOn":"2026-07-13"}

curl -i http://localhost:8080/api/posts/1

HTTP/1.1 200
Content-Type: application/json

{"id":1,"authorId":"1","title":"첫 게시글","content":"회원가입 뒤 게시글을 등록합니다.","publishedOn":"2026-07-13"}