DriverManager

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DriverManagerBasics {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/storedb";
        String user = "app_user";
        String password = "secret";

        // Three overloads of getConnection():
        try (Connection c1 = DriverManager.getConnection(url, user, password)) {
            System.out.println("Connected: " + c1.getCatalog());
        } catch (SQLException e) {
            // Thrown if no registered driver accepts the URL, or auth fails,
            // or the database is unreachable
            System.err.println("Connection failed: " + e.getMessage());
        }

        // URL with embedded credentials (driver-specific support varies)
        String urlWithCreds = "jdbc:postgresql://app_user:secret@localhost:5432/storedb";
        try (Connection c2 = DriverManager.getConnection(urlWithCreds)) {
            System.out.println("Connected via embedded credentials");
        } catch (SQLException e) {
            System.err.println("Connection failed: " + e.getMessage());
        }

        // Properties-based overload, useful for driver-specific extra settings
        java.util.Properties props = new java.util.Properties();
        props.setProperty("user", user);
        props.setProperty("password", password);
        props.setProperty("sslmode", "require");
        try (Connection c3 = DriverManager.getConnection(url, props)) {
            System.out.println("Connected with extra properties");
        } catch (SQLException e) {
            System.err.println("Connection failed: " + e.getMessage());
        }
    }
}

import java.sql.Driver;
import java.sql.DriverManager;
import java.util.Enumeration;

public class DriverManagerInspection {
    public static void main(String[] args) throws Exception {
        // List every driver currently registered via SPI auto-discovery
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver d = drivers.nextElement();
            System.out.println(d.getClass().getName()
                    + " v" + d.getMajorVersion() + "." + d.getMinorVersion());
        }

        // Find which driver would handle a specific URL, without connecting
        Driver chosen = DriverManager.getDriver("jdbc:postgresql://localhost:5432/storedb");
        System.out.println("Would use: " + chosen.getClass().getName());

        // Set a global timeout for all subsequent getConnection() calls
        DriverManager.setLoginTimeout(5);  // seconds

        // Deregistering a driver — relevant mainly in app-server hot-redeploy
        // scenarios to avoid classloader leaks when a webapp is undeployed:
        Enumeration<Driver> toClean = DriverManager.getDrivers();
        while (toClean.hasMoreElements()) {
            Driver d = toClean.nextElement();
            if (d.getClass().getClassLoader() == DriverManagerInspection.class.getClassLoader()) {
                DriverManager.deregisterDriver(d);
            }
        }
    }
}

// ── DriverManager: fine for scripts, CLI tools, and tests ──────────────────
import java.sql.Connection;
import java.sql.DriverManager;

public class QuickScript {
    public static void main(String[] args) throws Exception {
        try (Connection conn = DriverManager.getConnection(
                "jdbc:postgresql://localhost:5432/storedb", "app_user", "secret")) {
            // one-off connection, used once, then discarded — acceptable here
        }
    }
}

// ── DataSource + pool: the production pattern for request-handling code ───
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.sql.Connection;

public class ProductionService {
    private final DataSource dataSource;

    public ProductionService() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost:5432/storedb");
        config.setUsername("app_user");
        config.setPassword("secret");
        config.setMaximumPoolSize(20);
        this.dataSource = new HikariDataSource(config);  // built once
    }

    public void handleRequest() throws Exception {
        // Borrows an already-open connection from the pool instead of
        // paying for a new TCP + auth handshake on every request
        try (Connection conn = dataSource.getConnection()) {
            // ... do work ...
        } // returns the connection to the pool rather than closing the socket
    }
}