Path·Files와 텍스트 파일 저장소

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

public final class RepositoryContractSolution {
    record Member(String id, String name) {}
    interface Repository {
        void add(Member member) throws IOException;
        List<Member> findAll() throws IOException;
    }

    static void rejectDuplicate(List<Member> members, Member member) {
        if (members.stream().anyMatch(value -> value.id().equals(member.id()))) {
            throw new IllegalArgumentException("duplicate");
        }
    }

    static final class MemoryRepository implements Repository {
        private final List<Member> state = new ArrayList<>();
        public void add(Member member) {
            rejectDuplicate(state, member);
            state.add(member);
        }
        public List<Member> findAll() { return List.copyOf(state); }
    }

    static final class FileRepository implements Repository {
        private final Path file;

        FileRepository(Path file) throws IOException {
            this.file = file;
            try {
                Files.createFile(file);
            } catch (FileAlreadyExistsException existing) {
                // Reopening the same file keeps its current contents.
            }
        }

        private static String encode(String value) {
            return Base64.getUrlEncoder().withoutPadding()
                    .encodeToString(value.getBytes(StandardCharsets.UTF_8));
        }

        private static String decode(String value) {
            return new String(Base64.getUrlDecoder().decode(value), StandardCharsets.UTF_8);
        }

        public List<Member> findAll() throws IOException {
            List<Member> members = new ArrayList<>();
            for (String row : Files.readAllLines(file, StandardCharsets.UTF_8)) {
                String[] fields = row.split("\t", -1);
                if (fields.length != 2) throw new IllegalArgumentException("field count");
                members.add(new Member(decode(fields[0]), decode(fields[1])));
            }
            return List.copyOf(members);
        }

        public void add(Member member) throws IOException {
            List<Member> members = new ArrayList<>(findAll());
            rejectDuplicate(members, member);
            members.add(member);
            List<String> rows = new ArrayList<>();
            for (Member value : members) {
                rows.add(encode(value.id()) + "\t" + encode(value.name()));
            }
            Files.write(file, rows, StandardCharsets.UTF_8);
        }
    }

    static List<Member> verify(Repository repository) throws IOException {
        Member alice = new Member("a", "Alice");
        Member bob = new Member("b", "Bob");
        List<Member> firstTwo = List.of(alice, bob);
        repository.add(alice);
        repository.add(bob);
        List<Member> snapshot = repository.findAll();
        if (!snapshot.equals(firstTwo)) throw new AssertionError("registration order");

        try {
            repository.add(new Member("a", "Again"));
            throw new AssertionError("duplicate accepted");
        } catch (IllegalArgumentException expected) {
            if (!repository.findAll().equals(firstTwo)) {
                throw new AssertionError("duplicate changed state");
            }
        }

        try {
            snapshot.clear();
            throw new AssertionError("mutable result");
        } catch (UnsupportedOperationException expected) {
            if (!repository.findAll().equals(firstTwo)) {
                throw new AssertionError("clear changed state");
            }
        }

        Member special = new Member("c\t3", "김, 미나\n팀장");
        repository.add(special);
        if (!snapshot.equals(firstTwo)) throw new AssertionError("old snapshot changed");
        List<Member> expected = List.of(alice, bob, special);
        if (!repository.findAll().equals(expected)) throw new AssertionError("new member");
        return expected;
    }

    public static void main(String[] args) throws IOException {
        List<Member> memoryResult = verify(new MemoryRepository());
        System.out.println("memory contract passed");
        Path directory = Files.createTempDirectory("repository-contract-");
        Path file = directory.resolve("members.txt");
        try {
            List<Member> fileResult = verify(new FileRepository(file));
            if (!fileResult.equals(memoryResult)) throw new AssertionError("results differ");
            System.out.println("file contract passed");
            if (!new FileRepository(file).findAll().equals(fileResult)) {
                throw new AssertionError("reopen changed state");
            }
            System.out.println("file reopen passed");
        } finally {
            Files.deleteIfExists(file);
            Files.deleteIfExists(directory);
        }
        if (Files.exists(directory)) throw new AssertionError("temporary directory remained");
        System.out.println("temporary files removed");
    }
}

javac --release 25 -encoding UTF-8 -d out exercise/RepositoryContractSolution.java
java -cp out RepositoryContractSolution

memory contract passed
file contract passed
file reopen passed
temporary files removed