커맨드 패턴으로 채팅 명령 분리하기

import java.util.HashMap;
import java.util.Map;

public final class NullableCommandRouter {
    interface Command {
        String execute(String argument);
    }

    private final Map<String, Command> commands = new HashMap<>();

    void register(String key, Command command) {
        commands.put(key, command);
    }

    String route(String frame) {
        String[] parts = frame.split("\\|", 2);
        String argument = parts.length == 2 ? parts[1] : "";
        return commands.get(parts[0]).execute(argument);
    }

    public static void main(String[] args) {
        var router = new NullableCommandRouter();
        router.register("/echo", argument -> "echo=" + argument);

        System.out.println(router.route("/echo|hi"));
        System.out.println(router.route("/ecoh|hi"));
    }
}

echo=hi
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "NullableCommandRouter$Command.execute(String)" because the return value of "java.util.Map.get(Object)" is null
	at NullableCommandRouter.route(NullableCommandRouter.java:18)
	at NullableCommandRouter.main(NullableCommandRouter.java:26)

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

public final class ImmutableCommandRouter {
    sealed interface Result permits Reply, Publish, EndSession, Invalid {
    }

    record Reply(String text) implements Result {
    }

    record Publish(String text) implements Result {
    }

    record EndSession(String text) implements Result {
    }

    record Invalid(String reason) implements Result {
    }

    interface Context {
        String sessionId();

        String username();

        void username(String value);

        List<String> users();
    }

    @FunctionalInterface
    interface Command {
        Result execute(String argument, Context context);
    }

    private final Map<String, Command> commands;
    private final Command defaultCommand;

    ImmutableCommandRouter(Map<String, Command> commands) {
        this.commands = Map.copyOf(commands);
        this.defaultCommand = (argument, context) ->
                new Invalid("unsupported command");
    }

    Result route(String frame, Context context) {
        String[] parts = frame.split("\\|", 2);
        String key = parts[0];
        String argument = parts.length == 2 ? parts[1] : "";
        Command command = commands.getOrDefault(key, defaultCommand);
        return command.execute(argument, context);
    }

    static ImmutableCommandRouter standard() {
        Map<String, Command> commands = new LinkedHashMap<>();
        commands.put("/join", (argument, context) -> {
            if (argument.isBlank()) {
                return new Invalid("name required");
            }
            if (context.username() != null) {
                return new Invalid("already joined");
            }
            context.username(argument);
            return new Publish(argument + " joined");
        });
        commands.put("/message", (argument, context) -> {
            if (context.username() == null) {
                return new Invalid("join first");
            }
            if (argument.isBlank()) {
                return new Invalid("message required");
            }
            return new Publish("[" + context.username() + "] " + argument);
        });
        commands.put("/users", (argument, context) ->
                argument.isEmpty()
                        ? new Reply("users=" + context.users())
                        : new Invalid("users takes no argument"));
        commands.put("/exit", (argument, context) ->
                argument.isEmpty()
                        ? new EndSession("bye")
                        : new Invalid("exit takes no argument"));
        return new ImmutableCommandRouter(commands);
    }

    public static void main(String[] args) {
        final class TestContext implements Context {
            private String username;

            @Override
            public String sessionId() {
                return "s-1";
            }

            @Override
            public String username() {
                return username;
            }

            @Override
            public void username(String value) {
                username = value;
            }

            @Override
            public List<String> users() {
                return username == null ? List.of() : List.of(username);
            }
        }

        var router = standard();
        var context = new TestContext();
        for (String frame : List.of(
                "/message|early",
                "/join|Mina",
                "/message|hello",
                "/unknown|x",
                "/exit")) {
            System.out.println(router.route(frame, context));
        }
    }
}

Invalid[reason=join first]
Publish[text=Mina joined]
Publish[text=[Mina] hello]
Invalid[reason=unsupported command]
EndSession[text=bye]

final class LastSpeakerCommand implements Command {
    private String lastSpeaker; // 모든 세션이 함께 쓰는 필드

    @Override
    public Result execute(String argument, Context context) {
        lastSpeaker = context.username();
        String text = argument.strip();
        return new Publish("[" + lastSpeaker + "] " + text);
    }
}

private final AtomicReference<Map<String, Command>> commands =
        new AtomicReference<>(Map.of());

void install(String key, Command command) {
    commands.updateAndGet(current -> {
        Map<String, Command> next = new HashMap<>(current);
        next.put(key, command);
        return Map.copyOf(next);
    });
}

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

public final class CommandRegistryBuilder {
    @FunctionalInterface
    interface Command {
        String execute(String argument);
    }

    private final Map<String, Command> entries = new LinkedHashMap<>();
    private boolean built;

    CommandRegistryBuilder add(String key, Command command) {
        ensureMutable();
        Objects.requireNonNull(key, "key");
        Objects.requireNonNull(command, "command");
        if (!key.matches("/[a-z][a-z0-9-]{1,30}")) {
            throw new IllegalArgumentException("invalid command key: " + key);
        }
        if (entries.putIfAbsent(key, command) != null) {
            throw new IllegalArgumentException("duplicate command key: " + key);
        }
        return this;
    }

    Map<String, Command> build() {
        ensureMutable();
        built = true;
        if (entries.isEmpty()) {
            throw new IllegalStateException("at least one command is required");
        }
        return Map.copyOf(entries);
    }

    private void ensureMutable() {
        if (built) {
            throw new IllegalStateException("registry already built");
        }
    }

    public static void main(String[] args) {
        var builder = new CommandRegistryBuilder();
        Map<String, Command> commands = builder
                .add("/echo", argument -> "echo=" + argument)
                .add("/health", argument -> "ok")
                .build();

        System.out.println(commands.get("/echo").execute("hello"));
        System.out.println(commands.keySet());
        try {
            builder.add("/late", argument -> argument);
        } catch (IllegalStateException error) {
            System.out.println(error.getMessage());
        }
    }
}

echo=hello
[/echo, /health]
registry already built

javac ImmutableCommandRouter.java ChatServerDemo.java
java ChatServerDemo

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public final class ChatServerDemo {
    private final ImmutableCommandRouter router = ImmutableCommandRouter.standard();
    private final List<Session> sessions = new CopyOnWriteArrayList<>();
    private final AtomicInteger nextId = new AtomicInteger();

    final class Session implements ImmutableCommandRouter.Context, Runnable {
        private final String id;
        private final Socket socket;
        private final DataInputStream in;
        private final DataOutputStream out;
        private volatile String username;

        Session(String id, Socket socket) throws IOException {
            this.id = id;
            this.socket = socket;
            this.in = new DataInputStream(socket.getInputStream());
            this.out = new DataOutputStream(socket.getOutputStream());
        }

        @Override
        public String sessionId() {
            return id;
        }

        @Override
        public String username() {
            return username;
        }

        @Override
        public void username(String value) {
            username = value;
        }

        @Override
        public List<String> users() {
            return sessions.stream()
                    .map(Session::username)
                    .filter(Objects::nonNull)
                    .toList();
        }

        @Override
        public void run() {
            try (socket) {
                while (true) {
                    var result = router.route(in.readUTF(), this);
                    switch (result) {
                        case ImmutableCommandRouter.Reply reply ->
                                send(reply.text());
                        case ImmutableCommandRouter.Publish publish ->
                                broadcast(publish.text());
                        case ImmutableCommandRouter.Invalid invalid ->
                                send("error: " + invalid.reason());
                        case ImmutableCommandRouter.EndSession end -> {
                            send(end.text());
                            return;
                        }
                    }
                }
            } catch (EOFException clientClosed) {
                // 클라이언트가 /exit 없이 연결을 닫았다
            } catch (IOException networkError) {
                // 읽기나 쓰기 중에 연결이 끊겼다
            } catch (RuntimeException bug) {
                System.err.println(id + " failed: " + bug);
            } finally {
                sessions.remove(this);
                if (username != null) {
                    broadcast(username + " left");
                }
            }
        }

        synchronized void send(String text) throws IOException {
            out.writeUTF(text);
            out.flush();
        }
    }

    void broadcast(String text) {
        List<Session> targets = sessions.stream()
                .filter(session -> session.username() != null)
                .toList();
        for (Session target : targets) {
            try {
                target.send(text);
            } catch (IOException ignored) {
                // 그 세션의 읽기 루프가 곧 실패하고 스스로 정리한다
            }
        }
    }

    void acceptLoop(ServerSocket server) {
        while (!server.isClosed()) {
            try {
                Socket socket = server.accept();
                try {
                    var session = new Session("s-" + nextId.incrementAndGet(), socket);
                    sessions.add(session);
                    Thread.ofVirtual().start(session);
                } catch (IOException | RuntimeException error) {
                    socket.close();
                }
            } catch (IOException error) {
                // 서버 소켓이 닫히면 accept가 예외로 끝나고 반복을 빠져나간다
            }
        }
    }

    static final class TestClient implements AutoCloseable {
        private final String name;
        private final Socket socket;
        private final DataOutputStream out;
        private final BlockingQueue<String> inbox = new LinkedBlockingQueue<>();

        TestClient(String name, int port) throws IOException {
            this.name = name;
            this.socket = new Socket(InetAddress.getLoopbackAddress(), port);
            this.out = new DataOutputStream(socket.getOutputStream());
            var in = new DataInputStream(socket.getInputStream());
            Thread.ofVirtual().start(() -> {
                try {
                    while (true) {
                        inbox.add(in.readUTF());
                    }
                } catch (EOFException serverClosed) {
                    inbox.add("(connection closed by server)");
                } catch (IOException closedByTest) {
                    // 테스트가 끝나 소켓을 닫았다
                }
            });
        }

        void send(String frame) throws IOException {
            System.out.println(name + " -> " + frame);
            out.writeUTF(frame);
            out.flush();
        }

        void expect(int count) throws InterruptedException {
            for (int i = 0; i < count; i++) {
                String line = inbox.poll(5, TimeUnit.SECONDS);
                System.out.println(name + " <- " + (line == null ? "(timeout)" : line));
            }
        }

        @Override
        public void close() throws IOException {
            socket.close();
        }
    }

    public static void main(String[] args) throws Exception {
        var demo = new ChatServerDemo();
        try (var server = new ServerSocket(0, 50, InetAddress.getLoopbackAddress())) {
            Thread.ofVirtual().start(() -> demo.acceptLoop(server));
            int port = server.getLocalPort();
            String host = server.getInetAddress().getHostAddress();
            System.out.println("listening on " + host + ":" + port);

            try (var mina = new TestClient("Mina", port);
                 var jin = new TestClient("Jin", port)) {
                mina.send("/join|Mina");
                mina.expect(1);
                jin.send("/message|hi");
                jin.expect(1);
                jin.send("/join|Jin");
                mina.expect(1);
                jin.expect(1);
                mina.send("/message|hello");
                mina.expect(1);
                jin.expect(1);
                jin.send("/users");
                jin.expect(1);
                jin.send("/oops");
                jin.expect(1);
                jin.send("/exit");
                jin.expect(2);
                mina.expect(1);
            }
        }
    }
}

listening on 127.0.0.1:43993
Mina -> /join|Mina
Mina <- Mina joined
Jin -> /message|hi
Jin <- error: join first
Jin -> /join|Jin
Mina <- Jin joined
Jin <- Jin joined
Mina -> /message|hello
Mina <- [Mina] hello
Jin <- [Mina] hello
Jin -> /users
Jin <- users=[Mina, Jin]
Jin -> /oops
Jin <- error: unsupported command
Jin -> /exit
Jin <- bye
Jin <- (connection closed by server)
Mina <- Jin left