【保存版】Javaデータベース連携の基本から実践まで – 7つの実装手法

// 1. JDBCドライバーの登録
Class.forName("com.mysql.cj.jdbc.Driver");

// 2. データベースへの接続
Connection conn = DriverManager.getConnection(
    "jdbc:mysql://localhost:3306/dbname",
    "username",
    "password"
);

// 3. ステートメントの作成
Statement stmt = conn.createStatement();

// 4. SQLの実行
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

// 5. 結果の処理
while (rs.next()) {
    System.out.println(rs.getString("name"));
}

// 6. リソースのクローズ
rs.close();
stmt.close();
conn.close();

<!-- pom.xmlへの依存関係の追加 -->
<dependencies>
    <!-- MySQLの場合 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>
</dependencies>

// db.propertiesファイルの作成
db.url=jdbc:mysql://localhost:3306/dbname
db.user=username
db.password=password
db.driver=com.mysql.cj.jdbc.Driver

// 設定読み込みクラスの実装
public class DBConfig {
    private static Properties props = new Properties();

    static {
        try (InputStream input = 
            DBConfig.class.getClassLoader().getResourceAsStream("db.properties")) {
            props.load(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String getProperty(String key) {
        return props.getProperty(key);
    }
}

public class DBConnectionTest {
    public static void testConnection() {
        try {
            // ドライバーの登録
            Class.forName(DBConfig.getProperty("db.driver"));

            // 接続テスト
            try (Connection conn = DriverManager.getConnection(
                    DBConfig.getProperty("db.url"),
                    DBConfig.getProperty("db.user"),
                    DBConfig.getProperty("db.password"))) {

                System.out.println("データベース接続成功！");

                // データベースのメタ情報取得
                DatabaseMetaData metaData = conn.getMetaData();
                System.out.println("データベース製品名: " + 
                    metaData.getDatabaseProductName());
                System.out.println("データベースバージョン: " + 
                    metaData.getDatabaseProductVersion());
            }

        } catch (ClassNotFoundException e) {
            System.err.println("JDBCドライバーが見つかりません: " + e.getMessage());
        } catch (SQLException e) {
            System.err.println("データベース接続エラー: " + e.getMessage());
        }
    }
}

<dependencies>
    <!-- MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>

    <!-- PostgreSQL -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.3.1</version>
    </dependency>

    <!-- Oracle -->
    <dependency>
        <groupId>com.oracle.database.jdbc</groupId>
        <artifactId>ojdbc8</artifactId>
        <version>21.5.0.0</version>
    </dependency>
</dependencies>

public class DatabaseDriver {
    // データベースタイプの列挙
    public enum DBType {
        MYSQL("com.mysql.cj.jdbc.Driver"),
        POSTGRESQL("org.postgresql.Driver"),
        ORACLE("oracle.jdbc.OracleDriver");

        private final String driverClassName;

        DBType(String driverClassName) {
            this.driverClassName = driverClassName;
        }

        public String getDriverClassName() {
            return driverClassName;
        }
    }

    // ドライバーの登録
    public static void registerDriver(DBType dbType) throws ClassNotFoundException {
        Class.forName(dbType.getDriverClassName());
        System.out.println(dbType + " ドライバーを登録しました。");
    }
}

public class DatabaseConnection {
    private static DatabaseConnection instance;
    private static Connection connection;

    private DatabaseConnection() {}

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }

    public Connection getConnection() throws SQLException {
        if (connection == null || connection.isClosed()) {
            try {
                DatabaseDriver.registerDriver(DatabaseDriver.DBType.MYSQL);
                connection = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/dbname",
                    "username",
                    "password"
                );
                // 自動コミットを無効化（トランザクション制御のため）
                connection.setAutoCommit(false);
            } catch (ClassNotFoundException | SQLException e) {
                throw new SQLException("データベース接続エラー: " + e.getMessage());
            }
        }
        return connection;
    }

    // リソースの解放
    public void closeConnection() {
        try {
            if (connection != null && !connection.isClosed()) {
                connection.close();
                System.out.println("データベース接続を終了しました。");
            }
        } catch (SQLException e) {
            System.err.println("接続のクローズに失敗: " + e.getMessage());
        }
    }
}

public class SafeDatabaseAccess {
    public static void executeQuery(String sql) {
        try (Connection conn = DatabaseConnection.getInstance().getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery()) {

            while (rs.next()) {
                // 結果の処理
            }

            conn.commit();
        } catch (SQLException e) {
            System.err.println("クエリ実行エラー: " + e.getMessage());
        }
    }
}

<!-- HikariCP依存関係の追加 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

public class ConnectionPool {
    private static HikariDataSource dataSource;

    static {
        // HikariCP設定
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/dbname");
        config.setUsername("username");
        config.setPassword("password");

        // プール設定
        config.setMaximumPoolSize(10);
        config.setMinimumIdle(5);
        config.setIdleTimeout(300000);
        config.setConnectionTimeout(20000);

        // プールの初期化
        dataSource = new HikariDataSource(config);
    }

    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    public static void closePool() {
        if (dataSource != null && !dataSource.isClosed()) {
            dataSource.close();
        }
    }

    // コネクションプールの使用例
    public static void executePooledQuery(String sql) {
        try (Connection conn = getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    // 結果の処理
                }
            }

        } catch (SQLException e) {
            System.err.println("プール接続でのクエリ実行エラー: " + e.getMessage());
        }
    }
}

public class PoolMonitor {
    public static void printPoolStats() {
        HikariPoolMXBean poolProxy = dataSource.getHikariPoolMXBean();

        System.out.println("アクティブな接続数: " + poolProxy.getActiveConnections());
        System.out.println("アイドル状態の接続数: " + poolProxy.getIdleConnections());
        System.out.println("総接続数: " + poolProxy.getTotalConnections());
        System.out.println("待機中のスレッド数: " + poolProxy.getThreadsAwaitingConnection());
    }
}

　● トラブルシューティングの容易化

public class UserRepository {
    // ユーザーデータを表すモデルクラス
    @Getter @Setter
    public static class User {
        private Long id;
        private String name;
        private String email;
        private LocalDateTime createdAt;

        // getters, setters省略
    }

    // 単一レコードの取得
    public Optional<User> findById(Long id) {
        String sql = "SELECT id, name, email, created_at FROM users WHERE id = ?";

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            stmt.setLong(1, id);

            try (ResultSet rs = stmt.executeQuery()) {
                if (rs.next()) {
                    User user = new User();
                    user.setId(rs.getLong("id"));
                    user.setName(rs.getString("name"));
                    user.setEmail(rs.getString("email"));
                    user.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
                    return Optional.of(user);
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("ユーザー取得エラー: " + e.getMessage(), e);
        }

        return Optional.empty();
    }

    // 複数レコードの取得（ページング対応）
    public List<User> findAll(int page, int size) {
        String sql = "SELECT id, name, email, created_at FROM users ORDER BY id LIMIT ? OFFSET ?";
        List<User> users = new ArrayList<>();

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            stmt.setInt(1, size);
            stmt.setInt(2, page * size);

            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    User user = new User();
                    user.setId(rs.getLong("id"));
                    user.setName(rs.getString("name"));
                    user.setEmail(rs.getString("email"));
                    user.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
                    users.add(user);
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("ユーザー一覧取得エラー: " + e.getMessage(), e);
        }

        return users;
    }
}

public class OptimizedQueryExecutor {
    // 結果セットの最大サイズを制限
    private static final int MAX_RESULTS = 1000;

    // ストリームを使用した大量データの効率的な処理
    public void processLargeData(String sql, Consumer<ResultSet> processor) {
        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql,
                 ResultSet.TYPE_FORWARD_ONLY,
                 ResultSet.CONCUR_READ_ONLY)) {

            stmt.setFetchSize(100); // フェッチサイズの最適化

            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    processor.accept(rs);
                }
            }
        } catch (SQLException e) {
            throw new DatabaseException("データ処理エラー: " + e.getMessage(), e);
        }
    }
}

public class UserService {
    private final UserRepository repository = new UserRepository();

    // ユーザー作成（INSERT）
    public User createUser(User user) {
        String sql = "INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)";

        try (Connection conn = ConnectionPool.getConnection()) {
            try (PreparedStatement stmt = conn.prepareStatement(sql, 
                Statement.RETURN_GENERATED_KEYS)) {

                conn.setAutoCommit(false); // トランザクション開始

                stmt.setString(1, user.getName());
                stmt.setString(2, user.getEmail());
                stmt.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));

                int affectedRows = stmt.executeUpdate();

                if (affectedRows == 0) {
                    throw new DatabaseException("ユーザー作成に失敗しました。");
                }

                try (ResultSet generatedKeys = stmt.getGeneratedKeys()) {
                    if (generatedKeys.next()) {
                        user.setId(generatedKeys.getLong(1));
                    }
                }

                conn.commit(); // トランザクションのコミット
                return user;

            } catch (SQLException e) {
                conn.rollback(); // エラー時のロールバック
                throw new DatabaseException("ユーザー作成エラー: " + e.getMessage(), e);
            }
        } catch (SQLException e) {
            throw new DatabaseException("データベース接続エラー: " + e.getMessage(), e);
        }
    }

    // バッチ更新の実装例（UPDATE）
    public void updateUserStatuses(Map<Long, String> userStatuses) {
        String sql = "UPDATE users SET status = ? WHERE id = ?";

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            conn.setAutoCommit(false);

            for (Map.Entry<Long, String> entry : userStatuses.entrySet()) {
                stmt.setString(1, entry.getValue());
                stmt.setLong(2, entry.getKey());
                stmt.addBatch();
            }

            int[] results = stmt.executeBatch();
            conn.commit();

            // 更新結果の確認
            for (int i = 0; i < results.length; i++) {
                if (results[i] == Statement.EXECUTE_FAILED) {
                    System.err.println("更新失敗: index " + i);
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("バッチ更新エラー: " + e.getMessage(), e);
        }
    }
}

public class PreparedStatementExample {
    // 検索条件を動的に構築する例
    public List<User> searchUsers(UserSearchCriteria criteria) {
        StringBuilder sql = new StringBuilder(
            "SELECT * FROM users WHERE 1=1");
        List<Object> params = new ArrayList<>();

        if (criteria.getName() != null) {
            sql.append(" AND name LIKE ?");
            params.add("%" + criteria.getName() + "%");
        }

        if (criteria.getEmail() != null) {
            sql.append(" AND email = ?");
            params.add(criteria.getEmail());
        }

        if (criteria.getCreatedAfter() != null) {
            sql.append(" AND created_at >= ?");
            params.add(Timestamp.valueOf(criteria.getCreatedAfter()));
        }

        List<User> users = new ArrayList<>();

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql.toString())) {

            // パラメータのバインド
            for (int i = 0; i < params.size(); i++) {
                stmt.setObject(i + 1, params.get(i));
            }

            try (ResultSet rs = stmt.executeQuery()) {
                while (rs.next()) {
                    users.add(mapResultSetToUser(rs));
                }
            }

        } catch (SQLException e) {
            throw new DatabaseException("検索エラー: " + e.getMessage(), e);
        }

        return users;
    }

    // ResultSetからUserオブジェクトへのマッピング
    private User mapResultSetToUser(ResultSet rs) throws SQLException {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setEmail(rs.getString("email"));
        user.setCreatedAt(rs.getTimestamp("created_at").toLocalDateTime());
        return user;
    }
}

　● メンテナンス性が向上

public class SecureQueryBuilder {
    public static class QueryParams {
        private final StringBuilder sql;
        private final List<Object> parameters;

        public QueryParams() {
            this.sql = new StringBuilder();
            this.parameters = new ArrayList<>();
        }

        public void append(String sqlPart) {
            sql.append(sqlPart);
        }

        public void addParameter(Object param) {
            parameters.add(param);
        }

        public String getSql() {
            return sql.toString();
        }

        public Object[] getParameters() {
            return parameters.toArray();
        }
    }

    // セキュアなWHERE句の構築
    public static QueryParams buildSecureWhere(Map<String, Object> conditions) {
        QueryParams params = new QueryParams();
        params.append("WHERE 1=1");

        conditions.forEach((key, value) -> {
            params.append(" AND " + key + " = ?");
            params.addParameter(value);
        });

        return params;
    }

    // 使用例
    public List<User> findUsersSecurely(Map<String, Object> conditions) {
        QueryParams params = buildSecureWhere(conditions);
        String baseSql = "SELECT * FROM users ";

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                 baseSql + params.getSql())) {

            // パラメータのバインド
            Object[] parameters = params.getParameters();
            for (int i = 0; i < parameters.length; i++) {
                stmt.setObject(i + 1, parameters[i]);
            }

            return executeAndMapResults(stmt);
        } catch (SQLException e) {
            throw new DatabaseException("検索実行エラー", e);
        }
    }
}

public class InputValidator {
    private static final Pattern ALPHANUMERIC = Pattern.compile("^[a-zA-Z0-9]+$");
    private static final Pattern EMAIL = Pattern.compile("^[A-Za-z0-9+_.-]+@(.+)$");

    public static String sanitizeInput(String input) {
        if (input == null) {
            return null;
        }
        // HTMLエスケープ処理
        return input.replaceAll("<", "&lt;")
                   .replaceAll(">", "&gt;")
                   .replaceAll("\"", "&quot;")
                   .replaceAll("'", "&#x27;")
                   .replaceAll("/", "&#x2F;");
    }

    public static boolean isValidInput(String input, String type) {
        if (input == null) {
            return false;
        }

        switch (type) {
            case "alphanumeric":
                return ALPHANUMERIC.matcher(input).matches();
            case "email":
                return EMAIL.matcher(input).matches();
            default:
                return false;
        }
    }
}

public class EncryptionUtil {
    private static final String ALGORITHM = "AES/GCM/NoPadding";
    private static final int TAG_LENGTH_BIT = 128;
    private static final int IV_LENGTH_BYTE = 12;

    // データベース認証情報の暗号化
    public static String encryptCredential(String plaintext, SecretKey key) 
            throws Exception {
        byte[] iv = generateIv();
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        GCMParameterSpec spec = new GCMParameterSpec(TAG_LENGTH_BIT, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, spec);

        byte[] cipherText = cipher.doFinal(plaintext.getBytes());
        byte[] encrypted = ByteBuffer.allocate(iv.length + cipherText.length)
            .put(iv)
            .put(cipherText)
            .array();

        return Base64.getEncoder().encodeToString(encrypted);
    }

    // 暗号化された認証情報の復号
    public static String decryptCredential(String ciphertext, SecretKey key) 
            throws Exception {
        byte[] decoded = Base64.getDecoder().decode(ciphertext);
        ByteBuffer bb = ByteBuffer.wrap(decoded);

        byte[] iv = new byte[IV_LENGTH_BYTE];
        bb.get(iv);
        byte[] cipherText = new byte[bb.remaining()];
        bb.get(cipherText);

        Cipher cipher = Cipher.getInstance(ALGORITHM);
        GCMParameterSpec spec = new GCMParameterSpec(TAG_LENGTH_BIT, iv);
        cipher.init(Cipher.DECRYPT_MODE, key, spec);

        return new String(cipher.doFinal(cipherText));
    }

    private static byte[] generateIv() {
        byte[] iv = new byte[IV_LENGTH_BYTE];
        new SecureRandom().nextBytes(iv);
        return iv;
    }
}

public class SecureConfigManager {
    private static final Properties props = new Properties();
    private static final SecretKey key = generateKey();

    static {
        try (InputStream input = 
            SecureConfigManager.class.getClassLoader()
                .getResourceAsStream("secure.properties")) {
            props.load(input);
        } catch (IOException e) {
            throw new RuntimeException("設定ファイルの読み込みに失敗", e);
        }
    }

    public static String getDecryptedProperty(String propertyName) {
        try {
            String encrypted = props.getProperty(propertyName);
            return EncryptionUtil.decryptCredential(encrypted, key);
        } catch (Exception e) {
            throw new RuntimeException("プロパティの復号に失敗: " + propertyName, e);
        }
    }

    private static SecretKey generateKey() {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("AES");
            keyGen.init(256);
            return keyGen.generateKey();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("鍵の生成に失敗", e);
        }
    }
}

public class TransactionManager {
    // トランザクション実行用の関数型インターフェース
    @FunctionalInterface
    public interface TransactionBlock<T> {
        T execute(Connection conn) throws SQLException;
    }

    // トランザクション制御付きの処理実行
    public static <T> T executeInTransaction(TransactionBlock<T> block) {
        Connection conn = null;
        try {
            conn = ConnectionPool.getConnection();
            conn.setAutoCommit(false);

            T result = block.execute(conn);

            conn.commit();
            return result;

        } catch (SQLException e) {
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException ex) {
                throw new DatabaseException("ロールバック失敗", ex);
            }
            throw new DatabaseException("トランザクション実行エラー", e);

        } finally {
            try {
                if (conn != null) {
                    conn.setAutoCommit(true);
                    conn.close();
                }
            } catch (SQLException e) {
                System.err.println("接続のクローズに失敗: " + e.getMessage());
            }
        }
    }

    // 使用例
    public void transferMoney(long fromId, long toId, BigDecimal amount) {
        TransactionManager.executeInTransaction(conn -> {
            // 送金元の残高確認と更新
            try (PreparedStatement checkStmt = conn.prepareStatement(
                "SELECT balance FROM accounts WHERE id = ? FOR UPDATE")) {

                checkStmt.setLong(1, fromId);
                ResultSet rs = checkStmt.executeQuery();

                if (!rs.next() || rs.getBigDecimal("balance").compareTo(amount) < 0) {
                    throw new InsufficientBalanceException("残高不足");
                }
            }

            // 送金処理の実行
            try (PreparedStatement updateStmt = conn.prepareStatement(
                "UPDATE accounts SET balance = balance + ? WHERE id = ?")) {

                // 送金元から引き落とし
                updateStmt.setBigDecimal(1, amount.negate());
                updateStmt.setLong(2, fromId);
                updateStmt.executeUpdate();

                // 送金先に入金
                updateStmt.setBigDecimal(1, amount);
                updateStmt.setLong(2, toId);
                updateStmt.executeUpdate();
            }

            return null;
        });
    }
}

　● 異常な動作のトラッキング

public class QueryPerformanceMonitor {
    private static final Logger logger = LoggerFactory.getLogger(QueryPerformanceMonitor.class);

    // クエリ実行時間の計測
    public static <T> T measureQueryPerformance(String queryName, Supplier<T> queryExecution) {
        long startTime = System.nanoTime();
        T result = queryExecution.get();
        long endTime = System.nanoTime();

        long executionTime = (endTime - startTime) / 1_000_000; // ミリ秒に変換
        logger.info("クエリ '{}' の実行時間: {}ms", queryName, executionTime);

        return result;
    }

    // スロークエリの検出
    public static void checkSlowQuery(String sql, long executionTime, long threshold) {
        if (executionTime > threshold) {
            logger.warn("スロークエリ検出: {} (実行時間: {}ms)", sql, executionTime);
            // 実行計画の取得と分析
            analyzeQueryPlan(sql);
        }
    }

    private static void analyzeQueryPlan(String sql) {
        try (Connection conn = ConnectionPool.getConnection()) {
            try (PreparedStatement stmt = conn.prepareStatement("EXPLAIN " + sql)) {
                ResultSet rs = stmt.executeQuery();
                while (rs.next()) {
                    logger.info("実行計画: {}", rs.getString(1));
                }
            }
        } catch (SQLException e) {
            logger.error("実行計画の取得に失敗: {}", e.getMessage());
        }
    }
}

public class QueryOptimizer {
    // インデックスを考慮したクエリ生成
    public static String optimizeSelectQuery(String baseTable, 
                                          List<String> selectedColumns,
                                          Map<String, Object> conditions) {
        StringBuilder sql = new StringBuilder("SELECT ");

        // カラムの選択最適化
        if (selectedColumns.isEmpty()) {
            sql.append("*");
        } else {
            sql.append(String.join(", ", selectedColumns));
        }

        sql.append(" FROM ").append(baseTable);

        // インデックスを活用するWHERE句の構築
        if (!conditions.isEmpty()) {
            sql.append(" WHERE ");
            List<String> whereConditions = new ArrayList<>();

            // インデックス列を優先的に使用
            conditions.forEach((column, value) -> {
                if (value instanceof Collection) {
                    whereConditions.add(column + " IN (?)");
                } else {
                    whereConditions.add(column + " = ?");
                }
            });

            sql.append(String.join(" AND ", whereConditions));
        }

        return sql.toString();
    }
}

public class BatchProcessor {
    private static final int BATCH_SIZE = 1000;

    // バッチインサートの実装
    public void batchInsert(List<User> users) {
        String sql = "INSERT INTO users (name, email, created_at) VALUES (?, ?, ?)";

        try (Connection conn = ConnectionPool.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            conn.setAutoCommit(false);
            int count = 0;

            for (User user : users) {
                stmt.setString(1, user.getName());
                stmt.setString(2, user.getEmail());
                stmt.setTimestamp(3, Timestamp.valueOf(LocalDateTime.now()));
                stmt.addBatch();
                count++;

                if (count % BATCH_SIZE == 0) {
                    stmt.executeBatch();
                    conn.commit();
                    stmt.clearBatch();
                }
            }

            // 残りのバッチを実行
            if (count % BATCH_SIZE != 0) {
                stmt.executeBatch();
                conn.commit();
            }

        } catch (SQLException e) {
            throw new DatabaseException("バッチ処理エラー: " + e.getMessage(), e);
        }
    }

    // 並列バッチ処理の実装
    public void parallelBatchProcess(List<User> users, int threadCount) {
        int batchSize = users.size() / threadCount;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        List<Future<?>> futures = new ArrayList<>();

        for (int i = 0; i < threadCount; i++) {
            int startIndex = i * batchSize;
            int endIndex = (i == threadCount - 1) ? users.size() : (i + 1) * batchSize;

            List<User> batch = users.subList(startIndex, endIndex);
            futures.add(executor.submit(() -> batchInsert(batch)));
        }

        // 全てのバッチ処理の完了を待機
        for (Future<?> future : futures) {
            try {
                future.get();
            } catch (Exception e) {
                throw new DatabaseException("並列バッチ処理エラー", e);
            }
        }

        executor.shutdown();
    }
}

public class ConnectionManager {
    private static final int CONNECTION_TIMEOUT = 30000; // 30秒
    private static final int QUERY_TIMEOUT = 10000; // 10秒
    private static final int VALIDATION_TIMEOUT = 5000; // 5秒

    // 最適化されたコネクションプール設定
    public static HikariConfig createOptimizedConfig() {
        HikariConfig config = new HikariConfig();

        // 基本設定
        config.setJdbcUrl("jdbc:mysql://localhost:3306/dbname");
        config.setUsername("username");
        config.setPassword("password");

        // パフォーマンス設定
        config.setMaximumPoolSize(10);
        config.setMinimumIdle(5);
        config.setIdleTimeout(300000); // 5分
        config.setMaxLifetime(1800000); // 30分

        // タイムアウト設定
        config.setConnectionTimeout(CONNECTION_TIMEOUT);
        config.setValidationTimeout(VALIDATION_TIMEOUT);

        // 接続テスト設定
        config.setConnectionTestQuery("SELECT 1");
        config.setInitializationFailTimeout(1);

        return config;
    }

    // クエリタイムアウト設定を適用したステートメント生成
    public static PreparedStatement createTimedStatement(Connection conn, 
                                                       String sql) 
            throws SQLException {
        PreparedStatement stmt = conn.prepareStatement(sql);
        stmt.setQueryTimeout(QUERY_TIMEOUT / 1000); // 秒単位での設定
        return stmt;
    }
}

public class PerformanceMonitor {
    private static final Logger logger = LoggerFactory.getLogger(PerformanceMonitor.class);

    // コネクションプールの状態監視
    public static void monitorConnectionPool(HikariDataSource dataSource) {
        HikariPoolMXBean poolMXBean = dataSource.getHikariPoolMXBean();

        logger.info("コネクションプール状態:");
        logger.info("アクティブ接続数: {}", poolMXBean.getActiveConnections());
        logger.info("アイドル接続数: {}", poolMXBean.getIdleConnections());
        logger.info("待機スレッド数: {}", poolMXBean.getThreadsAwaitingConnection());
        logger.info("総接続数: {}", poolMXBean.getTotalConnections());
    }

    // メモリ使用状況の監視
    public static void monitorMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        long usedMemory = totalMemory - freeMemory;

        logger.info("メモリ使用状況:");
        logger.info("使用中メモリ: {} MB", usedMemory / 1024 / 1024);
        logger.info("空きメモリ: {} MB", freeMemory / 1024 / 1024);
        logger.info("総メモリ: {} MB", totalMemory / 1024 / 1024);
    }
}

　● リソース枯渇の防止

public class DatabaseTroubleshooter {
    private static final Logger logger = LoggerFactory.getLogger(DatabaseTroubleshooter.class);

    // エラーハンドリングのための列挙型
    public enum DatabaseErrorType {
        CONNECTION_FAILURE,
        AUTHENTICATION_ERROR,
        TIMEOUT_ERROR,
        RESOURCE_EXHAUSTION,
        UNKNOWN_ERROR
    }

    // エラー分類と診断
    public static DatabaseErrorType diagnoseError(SQLException e) {
        String sqlState = e.getSQLState();
        int errorCode = e.getErrorCode();

        // SQLStateに基づくエラー分類
        if (sqlState != null) {
            switch (sqlState.substring(0, 2)) {
                case "08": return DatabaseErrorType.CONNECTION_FAILURE;
                case "28": return DatabaseErrorType.AUTHENTICATION_ERROR;
                case "57": return DatabaseErrorType.RESOURCE_EXHAUSTION;
                default: return DatabaseErrorType.UNKNOWN_ERROR;
            }
        }

        // エラーコードに基づく分類
        if (errorCode == 0) {
            return DatabaseErrorType.TIMEOUT_ERROR;
        }

        return DatabaseErrorType.UNKNOWN_ERROR;
    }

    // 自動リカバリの実装
    public static <T> T executeWithRetry(DatabaseOperation<T> operation, 
                                       int maxRetries) {
        int attempts = 0;
        while (attempts < maxRetries) {
            try {
                return operation.execute();
            } catch (SQLException e) {
                attempts++;
                DatabaseErrorType errorType = diagnoseError(e);

                switch (errorType) {
                    case CONNECTION_FAILURE:
                        handleConnectionFailure(e, attempts, maxRetries);
                        break;
                    case TIMEOUT_ERROR:
                        handleTimeout(e, attempts, maxRetries);
                        break;
                    default:
                        throw new DatabaseException("リカバリ不可能なエラー", e);
                }

                // 再試行前の待機
                try {
                    Thread.sleep(calculateBackoff(attempts));
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new DatabaseException("リトライ中断", ie);
                }
            }
        }
        throw new DatabaseException("最大リトライ回数を超過");
    }

    private static long calculateBackoff(int attempt) {
        return Math.min(1000L * (long) Math.pow(2, attempt), 30000L);
    }
}

public class ConnectionTroubleshooter {
    // 接続テストの実装
    public static boolean testConnection(String jdbcUrl, 
                                       String username, 
                                       String password) {
        try (Connection conn = DriverManager.getConnection(
                jdbcUrl, username, password)) {

            // 基本的な接続テスト
            try (Statement stmt = conn.createStatement()) {
                stmt.execute("SELECT 1");
            }

            // データベースメタデータの取得
            DatabaseMetaData metaData = conn.getMetaData();
            logger.info("データベース製品名: {}", 
                metaData.getDatabaseProductName());
            logger.info("JDBCドライバーバージョン: {}", 
                metaData.getDriverVersion());

            return true;

        } catch (SQLException e) {
            logger.error("接続テスト失敗: {}", e.getMessage());
            logger.error("SQLState: {}", e.getSQLState());
            logger.error("エラーコード: {}", e.getErrorCode());
            return false;
        }
    }
}

public class DeadlockHandler {
    private static final int MAX_RETRIES = 3;
    private static final long RETRY_DELAY = 1000; // 1秒

    // デッドロック対応トランザクション実行
    public static <T> T executeWithDeadlockHandling(
            TransactionOperation<T> operation) {
        int attempts = 0;
        while (true) {
            try {
                return operation.execute();
            } catch (SQLException e) {
                if (isDeadlock(e) && attempts < MAX_RETRIES) {
                    attempts++;
                    logger.warn("デッドロック検出 - 再試行 {}/{}", 
                        attempts, MAX_RETRIES);
                    sleep(RETRY_DELAY);
                    continue;
                }
                throw new DatabaseException("トランザクション失敗", e);
            }
        }
    }

    // デッドロック防止のためのロック取得順序制御
    public static void executeOrderedLocking(Long... ids) {
        // IDを昇順にソート
        Arrays.sort(ids);

        try (Connection conn = ConnectionPool.getConnection()) {
            conn.setAutoCommit(false);

            // ソートされた順序でロックを取得
            for (Long id : ids) {
                try (PreparedStatement stmt = conn.prepareStatement(
                    "SELECT * FROM users WHERE id = ? FOR UPDATE")) {
                    stmt.setLong(1, id);
                    stmt.executeQuery();
                }
            }

            // トランザクション処理
            // ...

            conn.commit();
        } catch (SQLException e) {
            throw new DatabaseException("ロック取得失敗", e);
        }
    }
}

public class ResourceTracker {
    private static final Map<String, Set<AutoCloseable>> resources = 
        new ConcurrentHashMap<>();

    // リソースの登録
    public static void registerResource(String context, 
                                      AutoCloseable resource) {
        resources.computeIfAbsent(context, k -> 
            Collections.newSetFromMap(new ConcurrentHashMap<>()))
            .add(resource);
    }

    // リソースのクリーンアップ
    public static void cleanupResources(String context) {
        Set<AutoCloseable> contextResources = resources.remove(context);
        if (contextResources != null) {
            for (AutoCloseable resource : contextResources) {
                try {
                    resource.close();
                } catch (Exception e) {
                    logger.error("リソースのクローズに失敗: {}", e.getMessage());
                }
            }
        }
    }
}

public class ResourceManager implements AutoCloseable {
    private final Connection connection;
    private final List<Statement> statements = new ArrayList<>();
    private final List<ResultSet> resultSets = new ArrayList<>();

    public ResourceManager(Connection connection) {
        this.connection = connection;
    }

    // ステートメントの作成と追跡
    public PreparedStatement prepareStatement(String sql) 
            throws SQLException {
        PreparedStatement stmt = connection.prepareStatement(sql);
        statements.add(stmt);
        return stmt;
    }

    // 結果セットの追跡
    public void trackResultSet(ResultSet rs) {
        resultSets.add(rs);
    }

    @Override
    public void close() {
        // 結果セットのクローズ
        for (ResultSet rs : resultSets) {
            try {
                if (rs != null && !rs.isClosed()) {
                    rs.close();
                }
            } catch (SQLException e) {
                logger.warn("ResultSetのクローズに失敗: {}", e.getMessage());
            }
        }

        // ステートメントのクローズ
        for (Statement stmt : statements) {
            try {
                if (stmt != null && !stmt.isClosed()) {
                    stmt.close();
                }
            } catch (SQLException e) {
                logger.warn("Statementのクローズに失敗: {}", e.getMessage());
            }
        }

        // コネクションのクローズ
        try {
            if (connection != null && !connection.isClosed()) {
                connection.close();
            }
        } catch (SQLException e) {
            logger.warn("Connectionのクローズに失敗: {}", e.getMessage());
        }
    }

    // 使用例
    public static void executeQuery(String sql) {
        try (ResourceManager manager = new ResourceManager(
                ConnectionPool.getConnection())) {
            PreparedStatement stmt = manager.prepareStatement(sql);
            ResultSet rs = stmt.executeQuery();
            manager.trackResultSet(rs);

            while (rs.next()) {
                // 結果の処理
            }
        } catch (SQLException e) {
            throw new DatabaseException("クエリ実行エラー", e);
        }
    }
}

　● リソース使用状況の追跡

// エンティティクラスの定義
@Entity
@Table(name = "users")
@Getter @Setter
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Email
    @Column(unique = true)
    private String email;

    @CreationTimestamp
    private LocalDateTime createdAt;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders = new ArrayList<>();
}

// リポジトリの実装
@Repository
public class UserRepository {
    @PersistenceContext
    private EntityManager entityManager;

    // カスタムクエリの実装
    public List<User> findActiveUsers(int page, int size) {
        return entityManager.createQuery(
            "SELECT u FROM User u WHERE u.active = true " +
            "ORDER BY u.createdAt DESC", User.class)
            .setFirstResult(page * size)
            .setMaxResults(size)
            .getResultList();
    }

    // 仕様パターンを使用した動的クエリ
    public List<User> findBySpecification(Specification<User> spec) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);

        query.where(spec.toPredicate(root, query, cb));

        return entityManager.createQuery(query)
            .getResultList();
    }
}

// Spring Data JPAリポジトリ
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // メソッド名による自動クエリ生成
    Optional<User> findByEmail(String email);
    List<User> findByCreatedAtAfter(LocalDateTime date);

    // カスタムクエリの定義
    @Query("SELECT u FROM User u WHERE u.lastLoginDate > :date " +
           "AND u.status = :status")
    List<User> findActiveUsersSince(
        @Param("date") LocalDateTime date,
        @Param("status") UserStatus status);

    // ネイティブSQLクエリの使用
    @Query(value = "SELECT * FROM users WHERE " +
           "EXTRACT(year FROM created_at) = :year",
           nativeQuery = true)
    List<User> findUsersCreatedInYear(@Param("year") int year);
}

// MongoDBエンティティの定義
@Document(collection = "users")
@Data
public class UserDocument {
    @Id
    private String id;
    private String name;
    private String email;
    private Map<String, Object> attributes;
    private List<Address> addresses;

    @DBRef
    private List<OrderDocument> orders;
}

// MongoTemplateを使用したリポジトリ
@Repository
public class MongoUserRepository {
    private final MongoTemplate mongoTemplate;

    public MongoUserRepository(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    // 高度なクエリの実装
    public List<UserDocument> findByAttributesAndLocation(
            Map<String, Object> attributes,
            GeoPoint location,
            double maxDistance) {

        Criteria criteria = Criteria.where("attributes")
            .all(attributes.entrySet().stream()
                .map(e -> new BasicDBObject(e.getKey(), e.getValue()))
                .collect(Collectors.toList()));

        criteria.and("addresses.location")
            .nearSphere(new Point(
                location.getLongitude(),
                location.getLatitude()))
            .maxDistance(maxDistance);

        Query query = Query.query(criteria);
        return mongoTemplate.find(query, UserDocument.class);
    }
}

// サービス固有のデータベースアクセス
@Service
public class UserService {
    private final UserRepository userRepository;
    private final OrderServiceClient orderServiceClient;

    // サービス間データ集約
    public UserDetailsDTO getUserDetails(Long userId) {
        // ローカルデータベースからユーザー情報を取得
        User user = userRepository.findById(userId)
            .orElseThrow(() -> new UserNotFoundException(userId));

        // 他サービスから注文情報を取得
        List<OrderDTO> orders = orderServiceClient
            .getOrdersByUserId(userId);

        return new UserDetailsDTO(user, orders);
    }

    // 分散トランザクションの実装
    @Transactional
    public void createUserWithOrder(UserCreateDTO userDTO) {
        // ユーザー作成（ローカルトランザクション）
        User user = userRepository.save(
            new User(userDTO.getName(), userDTO.getEmail()));

        try {
            // 注文作成（サービス間通信）
            OrderDTO order = orderServiceClient
                .createOrder(user.getId(), userDTO.getInitialOrder());

            // 補償トランザクションの実装
            TransactionCompensator.register(() -> {
                orderServiceClient.cancelOrder(order.getId());
                userRepository.delete(user);
            });

        } catch (Exception e) {
            // ロールバック処理
            TransactionCompensator.executeCompensation();
            throw new ServiceException("ユーザー作成失敗", e);
        }
    }
}

public class DataConsistencyManager {
    private final KafkaTemplate<String, Event> kafkaTemplate;
    private final EventRepository eventRepository;

    // イベントソーシング パターンの実装
    public void publishDomainEvent(DomainEvent event) {
        // イベントの永続化
        EventRecord record = eventRepository.save(
            new EventRecord(event));

        // イベントの発行
        kafkaTemplate.send("domain-events", 
            event.getAggregateId(),
            new Event(record.getId(), event));
    }

    // CQRSパターンの実装
    @Service
    public class UserQueryService {
        private final UserReadRepository readRepository;

        @KafkaListener(topics = "user-events")
        public void handleUserEvent(UserEvent event) {
            // 読み取りモデルの更新
            switch (event.getType()) {
                case USER_CREATED:
                    readRepository.createUserView(event.getData());
                    break;
                case USER_UPDATED:
                    readRepository.updateUserView(event.getData());
                    break;
                // その他のイベントハンドリング
            }
        }
    }
}

　● テスト容易性の向上

　● MyBatis公式ドキュメント