[Advanced Java] Kiến trúc Layered trong Java: Controller, Service và Repository

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HexFormat;
 
/** Parses the input, applies the rules and writes to the database. All of it. */
public class SignupBefore {
 
    private final Connection conn;
 
    SignupBefore(String dbPath) throws SQLException {
        this.conn = DriverManager.getConnection("jdbc:sqlite:" + dbPath);
        try (Statement s = conn.createStatement()) {
            s.execute("""
                CREATE TABLE IF NOT EXISTS users (
                  id            INTEGER PRIMARY KEY AUTOINCREMENT,
                  email         TEXT NOT NULL UNIQUE,
                  display_name  TEXT NOT NULL,
                  password_hash TEXT NOT NULL)""");
        }
    }
 
    String handle(String[] args) throws SQLException {
        // 1. read the outside world
        if (args.length != 4 || !args[0].equals("register")) {
            return "usage: register <email> <name> <password>";
        }
        String email = args[1].trim().toLowerCase();
        String name = args[2].trim();
        String password = args[3];
 
        // 2. the business rules
        if (!email.contains("@")) return "error: email must contain @";
        if (name.isEmpty()) return "error: name must not be blank";
        if (password.length() < 8) return "error: password must be at least 8 characters";
        try (PreparedStatement ps = conn.prepareStatement("SELECT id FROM users WHERE email = ?")) {
            ps.setString(1, email);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) return "error: email already registered";
            }
        }
 
        // 3. storage
        String hash = sha256(password);
        try (PreparedStatement ps = conn.prepareStatement(
                "INSERT INTO users(email, display_name, password_hash) VALUES (?, ?, ?)",
                Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, email);
            ps.setString(2, name);
            ps.setString(3, hash);
            ps.executeUpdate();
            try (ResultSet keys = ps.getGeneratedKeys()) {
                keys.next();
                return "created #" + keys.getLong(1) + " " + name;
            }
        }
    }
 
    static String sha256(String s) {
        try {
            return HexFormat.of().formatHex(
                MessageDigest.getInstance("SHA-256").digest(s.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }
 
    public static void main(String[] args) throws SQLException {
        System.out.println(new SignupBefore("app.db").handle(args));
    }
}

curl -sSO https://repo1.maven.org/maven2/org/xerial/sqlite-jdbc/3.46.1.3/sqlite-jdbc-3.46.1.3.jar
javac -d out SignupBefore.java
java -cp out:sqlite-jdbc-3.46.1.3.jar SignupBefore register ALICE@example.com Alice hunter2secret

created #1 Alice

java -cp out SignupBefore register not-an-email Alice short

Exception in thread "main" java.sql.SQLException: No suitable driver found for jdbc:sqlite:app.db
	at java.sql/java.sql.DriverManager.getConnection(DriverManager.java:708)
	at java.sql/java.sql.DriverManager.getConnection(DriverManager.java:253)
	at SignupBefore.<init>(SignupBefore.java:17)
	at SignupBefore.main(SignupBefore.java:74)

src/app/
├── Main.java                        the wiring
├── cli/
│   └── RegisterCommand.java         controller
├── users/
│   ├── User.java                    entity
│   ├── UserView.java                DTO
│   ├── UserRepository.java          interface, owned by this package
│   ├── RegistrationDenied.java      a rule said no
│   └── UserService.java             the rules
└── storage/
    ├── InMemoryUserRepository.java
    └── SqliteUserRepository.java

package app.users;
 
/** What the storage layer maps: every column, including the ones nobody outside may see. */
public record User(long id, String email, String displayName, String passwordHash) {
 
    /** A user that has not been stored yet: id 0 means "the repository assigns it". */
    public static User newUser(String email, String displayName, String passwordHash) {
        return new User(0, email, displayName, passwordHash);
    }
 
    public User withId(long id) {
        return new User(id, email, displayName, passwordHash);
    }
}

package app.users;
 
/** What leaves the service: no hash, plus a field that is computed rather than stored. */
public record UserView(long id, String displayName, String email, String initials) {
 
    public static UserView from(User u) {
        return new UserView(u.id(), u.displayName(), u.email(), initials(u.displayName()));
    }
 
    private static String initials(String displayName) {
        StringBuilder sb = new StringBuilder();
        for (String part : displayName.trim().split("\\s+")) {
            if (!part.isEmpty()) sb.append(Character.toUpperCase(part.charAt(0)));
        }
        return sb.toString();
    }
}

package app.cli;
 
import app.users.RegistrationDenied;
import app.users.UserService;
import app.users.UserView;
 
/** Translates one line of argv into a call, and the answer back into a line of text. */
public final class RegisterCommand {
 
    private final UserService users;
 
    public RegisterCommand(UserService users) {
        this.users = users;
    }
 
    public String handle(String[] args) {
        if (args.length != 4 || !args[0].equals("register")) {
            return "usage: register <email> <name> <password>";
        }
        try {
            UserView created = users.register(args[1], args[2], args[3]);
            return "created #" + created.id() + " " + created.displayName()
                 + " (" + created.initials() + ")";
        } catch (RegistrationDenied e) {
            return "error: " + e.getMessage();
        }
    }
}

package app.users;
 
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;
import java.util.List;
 
/** The rules. No parsing, no printing, no SQL. */
public final class UserService {
 
    private final UserRepository users;
 
    public UserService(UserRepository users) {
        this.users = users;
    }
 
    public UserView register(String rawEmail, String rawName, String password) {
        String email = rawEmail.trim().toLowerCase();
        String name = rawName.trim();
 
        if (!email.contains("@")) throw new RegistrationDenied("email must contain @");
        if (name.isEmpty()) throw new RegistrationDenied("name must not be blank");
        if (password.length() < 8) throw new RegistrationDenied("password must be at least 8 characters");
        if (users.findByEmail(email).isPresent()) throw new RegistrationDenied("email already registered");
 
        User stored = users.save(User.newUser(email, name, sha256(password)));
        return UserView.from(stored);
    }
 
    public List<UserView> directory() {
        return users.findAll().stream().map(UserView::from).toList();
    }
 
    private static String sha256(String s) {
        try {
            return HexFormat.of().formatHex(
                MessageDigest.getInstance("SHA-256").digest(s.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }
}

package app.users;
 
import java.util.List;
import java.util.Optional;
 
/**
 * Declared in the service's own package, in the service's own vocabulary.
 * It mentions no driver, no SQL and no connection.
 */
public interface UserRepository {
 
    User save(User user);
 
    Optional<User> findByEmail(String email);
 
    List<User> findAll();
}

package app.storage;
 
import app.users.User;
import app.users.UserRepository;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
 
/** The same interface, backed by a Map. No database, no jar, no setup. */
public final class InMemoryUserRepository implements UserRepository {
 
    private final Map<String, User> byEmail = new LinkedHashMap<>();
    private long nextId = 1;
 
    @Override
    public User save(User user) {
        User stored = user.id() == 0 ? user.withId(nextId++) : user;
        byEmail.put(stored.email(), stored);
        return stored;
    }
 
    @Override
    public Optional<User> findByEmail(String email) {
        return Optional.ofNullable(byEmail.get(email));
    }
 
    @Override
    public List<User> findAll() {
        return new ArrayList<>(byEmail.values());
    }
}

package app.storage;
 
/** The only class in the program that knows SQL exists. */
public final class SqliteUserRepository implements UserRepository {
 
    private final Connection conn;
 
    public SqliteUserRepository(Connection conn) {
        this.conn = conn;
        // CREATE TABLE IF NOT EXISTS users (...) elided
    }
 
    @Override
    public User save(User user) {
        String sql = "INSERT INTO users(email, display_name, password_hash) VALUES (?, ?, ?)";
        try (PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, user.email());
            ps.setString(2, user.displayName());
            ps.setString(3, user.passwordHash());
            ps.executeUpdate();
            try (ResultSet keys = ps.getGeneratedKeys()) {
                keys.next();
                return user.withId(keys.getLong(1));
            }
        } catch (SQLException e) {
            throw new IllegalStateException("cannot save " + user.email(), e);
        }
    }
 
    /** The row stops here. Everything above this method sees a User. */
    private static User map(ResultSet rs) throws SQLException {
        return new User(rs.getLong("id"), rs.getString("email"),
                        rs.getString("display_name"), rs.getString("password_hash"));
    }
}

javac -d out-users   src/app/users/*.java      # the service package, alone
javac -d out-storage src/app/storage/*.java    # the storage package, alone

src/app/storage/InMemoryUserRepository.java:3: error: package app.users does not exist
import app.users.User;
                ^
src/app/storage/InMemoryUserRepository.java:4: error: package app.users does not exist
import app.users.UserRepository;
                ^
25 errors

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.HexFormat;
import java.util.List;
import java.util.Optional;

package app;
 
import app.cli.RegisterCommand;
import app.storage.InMemoryUserRepository;
import app.users.UserRepository;
import app.users.UserService;
 
/** The only place that decides which implementation the program runs with. */
public class Main {
    public static void main(String[] args) {
        UserRepository repository = new InMemoryUserRepository();
        UserService service = new UserService(repository);
        RegisterCommand controller = new RegisterCommand(service);
 
        System.out.println(controller.handle(args));
    }
}

javac -d out $(find src -name '*.java')
java -cp out app.Main register ALICE@Example.com "Alice Nguyen" hunter2secret
java -cp out app.Main register bad-email Alice short

created #1 Alice Nguyen (AN)
error: email must contain @

error: constructor UserService in class UserService cannot be applied to given types;
        UserService service = new UserService();
                              ^
  required: UserRepository
  found:    no arguments

try (Connection conn = DriverManager.getConnection("jdbc:sqlite:app.db")) {
    UserRepository repository = new SqliteUserRepository(conn);   // the one line that changed
    UserService service = new UserService(repository);
    RegisterCommand controller = new RegisterCommand(service);
 
    System.out.println(controller.handle(args));
}

java -cp out:sqlite-jdbc-3.46.1.3.jar app.MainSqlite register alice@example.com "Alice Nguyen" hunter2secret
java -cp out:sqlite-jdbc-3.46.1.3.jar app.MainSqlite register ALICE@example.com "Alice Again" hunter2secret

created #1 Alice Nguyen (AN)
error: email already registered

package app.cli;
 
import app.users.RegistrationDenied;
import app.users.UserService;
import java.util.List;
 
/** A second caller. It adds a file format; it re-states not one rule. */
public final class BulkImport {
 
    private final UserService users;
 
    public BulkImport(UserService users) {
        this.users = users;
    }
 
    public List<String> handle(List<String> csvLines) {
        return csvLines.stream().map(line -> {
            String[] cell = line.split(",", -1);
            if (cell.length != 3) return line + " -> error: expected 3 columns";
            try {
                return line + " -> #" + users.register(cell[0], cell[1], cell[2]).id();
            } catch (RegistrationDenied e) {
                return line + " -> error: " + e.getMessage();
            }
        }).toList();
    }
}

alice@example.com,Alice Nguyen,hunter2secret -> #1
ALICE@example.com,Alice Again,hunter2secret -> error: email already registered
not-an-email,Bob,hunter2secret -> error: email must contain @
carol@example.com,Carol,short -> error: password must be at least 8 characters

UserView view = service.register("alice@example.com", "Alice Nguyen", "hunter2secret");
User entity = repository.findByEmail("alice@example.com").orElseThrow();
 
System.out.println("entity: " + entity);
System.out.println("view:   " + view);

entity: User[id=1, email=alice@example.com, displayName=Alice Nguyen, passwordHash=5ccefdc7743291dfc5bb3825925c70d480198650b125db3ef9e7ccdf38a2e016]
view:   UserView[id=1, displayName=Alice Nguyen, email=alice@example.com, initials=AN]

package app.users;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
 
import app.storage.InMemoryUserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
 
class UserServiceTest {
 
    private UserRepository repository;
    private UserService service;
 
    @BeforeEach
    void setUp() {
        repository = new InMemoryUserRepository();
        service = new UserService(repository);
    }
 
    @Test
    void assignsAnIdAndComputesInitials() {
        UserView v = service.register("alice@example.com", "Alice Nguyen", "hunter2secret");
        assertEquals(1, v.id());
        assertEquals("AN", v.initials());
    }
 
    @Test
    void rejectsAShortPassword() {
        RegistrationDenied e = assertThrows(RegistrationDenied.class,
            () -> service.register("bob@example.com", "Bob", "short"));
        assertEquals("password must be at least 8 characters", e.getMessage());
    }
 
    @Test
    void treatsEmailAsCaseInsensitive() {
        service.register("alice@example.com", "Alice", "hunter2secret");
        RegistrationDenied e = assertThrows(RegistrationDenied.class,
            () -> service.register("ALICE@Example.com", "Alice", "hunter2secret"));
        assertEquals("email already registered", e.getMessage());
    }
 
    @Test
    void storesAHashAndNeverReturnsIt() {
        service.register("alice@example.com", "Alice", "hunter2secret");
        User stored = repository.findByEmail("alice@example.com").orElseThrow();
        assertNotEquals("hunter2secret", stored.passwordHash());
        assertEquals(64, stored.passwordHash().length());
        assertTrue(service.directory().toString().indexOf("hunter2secret") < 0);
    }
}

package app.cli;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
 
import app.storage.InMemoryUserRepository;
import app.users.UserService;
import org.junit.jupiter.api.Test;
 
class RegisterCommandTest {
 
    private final RegisterCommand command =
        new RegisterCommand(new UserService(new InMemoryUserRepository()));
 
    @Test
    void printsUsageWhenTheArgumentsAreWrong() {
        assertEquals("usage: register <email> <name> <password>",
            command.handle(new String[] { "register", "alice@example.com" }));
    }
 
    @Test
    void turnsADeniedRegistrationIntoAnErrorLine() {
        assertEquals("error: email must contain @",
            command.handle(new String[] { "register", "nope", "Alice", "hunter2secret" }));
    }
 
    @Test
    void formatsTheCreatedUser() {
        assertEquals("created #1 Alice Nguyen (AN)",
            command.handle(new String[] { "register", "alice@example.com", "Alice Nguyen", "hunter2secret" }));
    }
}

curl -sSO https://repo1.maven.org/maven2/org/junit/platform/junit-platform-console-standalone/1.11.3/junit-platform-console-standalone-1.11.3.jar
javac -cp junit-platform-console-standalone-1.11.3.jar:out -d out $(find test -name '*.java')
java -jar junit-platform-console-standalone-1.11.3.jar execute -cp out \
  --select-class=app.users.UserServiceTest \
  --select-class=app.cli.RegisterCommandTest --details=summary

[         5 containers found      ]
[         0 containers skipped    ]
[         5 containers started    ]
[         0 containers aborted    ]
[         5 containers successful ]
[         0 containers failed     ]
[         7 tests found           ]
[         0 tests skipped         ]
[         7 tests started         ]
[         0 tests aborted         ]
[         7 tests successful      ]
[         0 tests failed          ]

record Account(long id, String email) {}
 
/** A service that holds no rule. Every method is one line of forwarding. */
final class AccountService {
    private final List<Account> store = new ArrayList<>();
 
    Account create(String email) {                 // no validation anywhere
        Account a = new Account(store.size() + 1, email);
        store.add(a);
        return a;
    }
 
    List<Account> findAll() { return store; }
}
 
/** So the rule ends up here, in one of the two callers. */
final class AccountController {
    private final AccountService accounts;
    AccountController(AccountService accounts) { this.accounts = accounts; }
 
    String handle(String email) {
        if (!email.contains("@")) return "error: email must contain @";   // the rule lives here
        return "created #" + accounts.create(email).id();
    }
}
 
/** The other caller never got the memo. */
final class AccountImporter {
    private final AccountService accounts;
    AccountImporter(AccountService accounts) { this.accounts = accounts; }
 
    String handle(String csvLine) {
        return "imported #" + accounts.create(csvLine.trim()).id();
    }
}
 
public class Anaemic {
    public static void main(String[] args) {
        AccountService service = new AccountService();
        System.out.println(new AccountController(service).handle("not-an-email"));
        System.out.println(new AccountImporter(service).handle("not-an-email"));
        System.out.println("stored: " + service.findAll());
    }
}

error: email must contain @
imported #1
stored: [Account[id=1, email=not-an-email]]

/** A "repository" that returns rows instead of objects. */
class RowRepository {
    private final Connection conn;
    RowRepository(Connection conn) { this.conn = conn; }
 
    /** Leaks the ResultSet, and with it the open cursor it depends on. */
    ResultSet findAll() throws SQLException {
        try (Statement s = conn.createStatement()) {
            return s.executeQuery("SELECT id, email, display_name FROM users ORDER BY id");
        }
    }
}

ResultSet rs = new RowRepository(conn).findAll();
int rows = 0;
while (rs.next()) rows++;
System.out.println("rows seen   = " + rows);
System.out.println("rs.isClosed = " + rs.isClosed());

rows seen   = 0
rs.isClosed = true

/** A "service" that is a bag of static methods over static state. */
final class UserUtils {
    private static final Map<String, String> STORE = new LinkedHashMap<>();
 
    private UserUtils() {}
 
    static String register(String email) {
        if (STORE.containsKey(email)) return "error: email already registered";
        STORE.put(email, email);
        return "created " + email;
    }
}
 
public class StaticBag {
    public static void main(String[] args) {
        System.out.println("test 1: " + UserUtils.register("alice@example.com"));
        System.out.println("test 2: " + UserUtils.register("alice@example.com"));
    }
}

test 1: created alice@example.com
test 2: error: email already registered