First we define our tables, data types, and relationships before writing any Java Logic.  SQL is acting as our blueprint for the entire application. Every other part of a the application gets its building blocks from this stage.

Key concepts: primary keys  to identify each row. Foreign keys to link tables together. Password hashes to act as additional Security.

Now that our database tables exist, we need a Java class that mirrors them. That class is called a Model. Think of it as the Java version of our table. Every column becomes a field. Every field gets a getter and a setter.

The Model class does not talk to the database, It just holds data. It is the shape our application uses to pass a user around from layer to layer.

Key Concepts:

POJO - Plain Old Java Object. A class that only holds data. No logic, no database calls.

private fields - Each column in your table becomes a private field in your class. Direct access is blocked.

Getters / Setters - The only way to read or write a field. This is encapsulation, a core OOP principle.

Big Decimal - Used for money values instead of double or float. Avoids rounding errors in financial math.

We have our database and we have our Model. Now we need to define how our application is going to talk to that database. That is what the DAO does. DAO stands for Data Access Object.

But before we write any actual database logic, we write an interface first. An interface is a contract. It says here are the operations that must exist. It does not say how they work. That comes in the next step.

This is one of the most important OOP principles we use. Our service layer will only ever talk to this interface. It will never care whether the data is coming from PostgreSQL, MySQL, or a test mock. That separation is what makes our application clean and easy to maintain.

Key Concepts:

DAO - Data Access Object. The layer responsible for all database communication.

interface - A contract that defines what methods must exist, without saying how they work.

program to an interface - Our service calls the interface, not the implementation. Swap the database out later without touching anything else.

CRUD - Create, Read, Update, Delete. The four fundamental database operations. Our interface covers all four.

In Step 3 we defined the contract. Now we fulfill it. The JDBC DAO is the class that implements our UserDao interface and writes the actual SQL logic that talks to the database.

JDBC stands for Java Database Connectivity. It is the underlying technology that makes the connection between our Java application and our database possible. Think of it as the bridge. Our DAO walks across that bridge every time it needs data.

This is also where we protect ourselves from SQL injection. We use prepared statements with the ? placeholder instead of concatenating user input directly into our SQL. The database treats everything bound to a ? as pure data, never as executable code.

We also write a private helper method called mapRowToUser. Its only job is to take a row from the database result and turn it into a User object. This keeps our query methods clean and avoids repeating the same mapping logic everywhere.

Key Concepts:

JDBC - Java Database Connectivity. The driver that enables our Java app to communicate with the database.

implements - The keyword that tells Java this class is fulfilling the contract we defined in the interface.

Prepared Statement - A precompiled SQL statement that uses ? placeholders to safely bind user input.

Result Set - The object that holds the rows returned from a database query. We iterate through it to get our data.

mapRowToUser - A private helper that converts one database row into a User object. Reused by every read method.