الاتصال: المشغّل وURL وبيانات الاعتماد من متغيرات البيئة

Written Explanation

The JDBC URL

A JDBC URL tells DriverManager which driver to use and where the database lives. For PostgreSQL the documented form is:

jdbc:postgresql://host:port/database

The driver documentation says the host defaults to localhost and the port to 5432 if you leave them out. We will write them out, because explicit is easier to debug. A complete URL for this module: jdbc:postgresql://localhost:5432/library.

Why credentials do not belong in code

Anything in your source ends up in Git, and Git remembers every commit. A password committed once is visible to everyone who can read the repository, including after you delete the line, because the old commit still contains it. Source code is also copied to laptops, build servers, and code-review tools.

The fix is simple: the code never contains the secret. It reads it from outside, when it starts. The first outside place we use is environment variables: named values that the operating system hands to a process when it starts. The JDK reads one with System.getenv("NAME"). This is the same idea as keeping your house key out of the blueprint of the house.

Two details from the JDK documentation matter:

• System.getenv returns null if the variable is not set. Always check.
• Whether the name is case-sensitive depends on the operating system (typically yes on Unix-like systems, typically no on Windows). Use the same exact upper-case name everywhere.

For this module we use three names, as the course specifies: DB_URL, DB_USER, and DB_PASSWORD. Environment variables are a good start, not a perfect vault: other processes of the same user may be able to see them. Production teams use secret managers; the principle (no secrets in the repository) is identical.

Connecting: one method call

Connection c = DriverManager.getConnection(url, user, password);

It returns an open Connection, or throws SQLException. A Connection holds a real network session and a server-side process, so it is a resource to close: put it in a try-with-resources header (BEG-029).

A small helper that reads the environment

We will reuse one helper in every later lesson:

package lib;

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

public final class Db {
    private Db() { }

    private static String require(String name) {
        String value = System.getenv(name);
        if (value == null || value.isBlank()) {
            throw new IllegalStateException("Missing environment variable: " + name);
        }
        return value;
    }

    public static Connection open() throws SQLException {
        return DriverManager.getConnection(
                require("DB_URL"), require("DB_USER"), require("DB_PASSWORD"));
    }
}

require turns a silent null into a clear message. Failing early with the name of the missing variable saves a lot of guessing.

Setting the variables

How you set variables depends on your system, so treat these as typical examples and check your own tools:

• Bash-style terminal: export DB_URL=jdbc:postgresql://localhost:5432/library, then the same for DB_USER and DB_PASSWORD.
• PowerShell: $env:DB_URL = "jdbc:postgresql://localhost:5432/library", and so on.
• IDE: most IDEs have a run configuration with an "environment variables" field. Menu names differ between IDEs and versions.

Variables set this way last for that terminal session or run configuration. Keep the actual values out of the repository. If you keep a helper file such as env.sh for convenience, list it in .gitignore so Git never picks it up. The Git documentation notes that .gitignore does not affect files that are already tracked, so add the ignore rule before the first commit.

Reading the three common failures

When the connection fails you get an SQLException. Its getSQLState() gives a five-character code and getMessage() a description. These three cover most of what you will see:

Read the message first. It nearly always names the problem.