회원 서비스 계층

import java.util.LinkedHashMap;
import java.util.Map;

public final class FatMemberController {
    record Member(String id, String name, int age) {
    }

    private final Map<String, Member> members = new LinkedHashMap<>();

    String add(Map<String, String> parameters) {
        int age = Integer.parseInt(parameters.get("age"));
        Member member = new Member(parameters.get("id"), parameters.get("name"), age);
        members.put(member.id(), member);
        return "<h1>saved " + member.name() + "</h1>";
    }

    public static void main(String[] args) {
        System.out.println("compile-only mixed controller counterexample");
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public final class MemberApplicationService {
    record Member(String id, String name, int age) {
    }

    interface MemberRepository {
        boolean insertIfAbsent(Member member);

        Optional<Member> findById(String id);

        List<Member> findAll();
    }

    static final class InMemoryMemberRepository implements MemberRepository {
        private final Map<String, Member> members = new LinkedHashMap<>();

        @Override
        public synchronized boolean insertIfAbsent(Member member) {
            if (members.containsKey(member.id())) {
                return false;
            }
            members.put(member.id(), member);
            return true;
        }

        @Override
        public synchronized Optional<Member> findById(String id) {
            return Optional.ofNullable(members.get(id));
        }

        @Override
        public synchronized List<Member> findAll() {
            return List.copyOf(members.values());
        }
    }

    sealed interface Registration permits Created, Rejected, Duplicate {
    }

    record Created(Member member) implements Registration {
    }

    record Rejected(List<String> violations) implements Registration {
        Rejected {
            violations = List.copyOf(violations);
        }
    }

    record Duplicate(String id) implements Registration {
    }

    private final MemberRepository repository;

    MemberApplicationService(MemberRepository repository) {
        this.repository = repository;
    }

    Registration register(String rawId, String rawName, int age) {
        String id = rawId == null ? "" : rawId.trim();
        String name = rawName == null ? "" : rawName.trim();
        List<String> violations = new ArrayList<>();
        if (!id.matches("[a-z0-9-]{3,20}")) {
            violations.add("id must use 3 to 20 lowercase letters, digits, or hyphens");
        }
        if (name.isBlank() || name.length() > 40) {
            violations.add("name must contain 1 to 40 characters");
        }
        if (age < 1 || age > 120) {
            violations.add("age must be between 1 and 120");
        }
        if (!violations.isEmpty()) {
            return new Rejected(violations);
        }

        Member member = new Member(id, name, age);
        return repository.insertIfAbsent(member)
                ? new Created(member)
                : new Duplicate(id);
    }

    List<Member> listMembers() {
        return repository.findAll().stream()
                .sorted(Comparator.comparing(Member::id))
                .toList();
    }

    public static void main(String[] args) {
        MemberApplicationService service = new MemberApplicationService(
                new InMemoryMemberRepository());
        System.out.println(service.register("min-1", "Min", 31));
        System.out.println(service.register("min-1", "Other", 20));
        System.out.println(service.register("?", "", 0));
        System.out.println(service.listMembers());
    }
}

import java.nio.charset.StandardCharsets;
import java.util.List;

public final class SafeMemberPageRenderer {
    record Member(String id, String name, int age) {
    }

    record Representation(String contentType, byte[] body) {
        int contentLength() {
            return body.length;
        }

        String text() {
            return new String(body, StandardCharsets.UTF_8);
        }
    }

    static String escapeText(String value) {
        return value
                .replace("&", "&")
                .replace("<", "&lt;")
                .replace(">", "&gt;")
                .replace("\"", "&quot;")
                .replace("'", "&#39;");
    }

    static Representation render(List<Member> members) {
        StringBuilder html = new StringBuilder();
        html.append("<!doctype html><html><body>");
        html.append("<h1>Members</h1><ul>");
        for (Member member : members) {
            html.append("<li>")
                    .append(escapeText(member.id()))
                    .append(" | ")
                    .append(escapeText(member.name()))
                    .append(" | ")
                    .append(member.age())
                    .append("</li>");
        }
        html.append("</ul></body></html>");
        byte[] body = html.toString().getBytes(StandardCharsets.UTF_8);
        return new Representation("text/html; charset=UTF-8", body);
    }

    public static void main(String[] args) {
        Representation page = render(List.of(
                new Member("min-1", "<Admin>", 31),
                new Member("jin-2", "진", 27)));
        System.out.println(page.contentType());
        System.out.println("bytes=" + page.contentLength());
        System.out.println(page.text());
    }
}