When we talk about programming with databases, the design pattern DAO is often mentioned. You may not be familiar with the term " design pattern ", so let me briefly explain it.

Design Patterns

It's worth noting that design patterns are a very important part of programming, so I recommend studying them in more detail, as you will need them in your career!

The primary goals of using design patterns are:

1. Code Reusability: Instead of inventing a solution from scratch for every problem, developers can utilize proven and reliable patterns;
2. Simplifying the Design Process: Patterns offer ready-made templates for solving complex design challenges;
3. Enhancing Code Readability and Maintainability: Patterns make the code structure clearer and more understandable, making it easier to support and evolve.

Main types of design patterns

1. Creational Patterns: These patterns are related to the process of object creation, providing flexibility and reusability of existing code;
2. Structural Patterns: They assist in organizing classes and objects into larger structures;
3. Behavioral Patterns: Behavioral patterns manage complex control flows between objects.

It's also worth noting that design patterns are learned through practice. It will be challenging to memorize them purely in theory, so every time we use a particular design pattern, I will provide more information about it, and you will remember its usage through practical experience.

Significance in software development

The use of design patterns contributes to the creation of cleaner, more understandable, and maintainable code. They are fundamental tools in the arsenal of an experienced developer and play a key role in software architecture.

Data Access Object

The DAO pattern tells us that we should abstract and restrict database access from the code, separating the application's business logic and data access.

Advantages of using the DAO pattern:

• Allows separating business logic and data operations into different components, making it easier to develop and maintain the program;
• Changes in the database structure do not affect other parts of the program since data access is done through DAO interfaces, and vice versa;
• DAO can be easily tested using mock objects or simulation instead of a real database.

Understanding the DAO Pattern

Using the DAO pattern is akin to adopting a three-tier architecture for an application. Let's break down the roles of each tier:

First Tier: Data Access

• Responsibility: Interacts directly with the database;
• Function: Retrieves data and passes it to the service layer.

Second Tier: Service Layer

• Responsibility: Processes the retrieved data;
• Operations: For instance, it might involve decrypting an encrypted user password for usage in other service classes.

Note

All sensitive information, such as user passwords, is stored in the database in an encrypted format. We'll delve deeper into this when we explore Spring Security.

Third Tier: Controller Layer

• Responsibility: Prepares data for user transmission with minimal processing;
• Details: More information on the controller layer will be provided during our study of the Spring framework.

From this structural overview, it's evident that:

• Direct database access is confined to the first tier;
• Business logic resides in the service layer, as recommended by the DAO pattern.

Main Components of the DAO Pattern

In the upcoming sections of this course, we'll be looking at the main components of the DAO pattern that we'll utilize in our application development:

From this structure, it's clear that direct database access is limited to the lowest and first tier, while business logic is isolated in the service layer. This is roughly what the DAO pattern suggests.

Let's also take a look at the main components of the DAO pattern that we'll use when writing applications in this course:

• DAO interfaces are interfaces that describe the operations that can be performed with a database. They define the structure of methods for creating, reading, updating, and deleting data;
• DAO implementations are classes that implement DAO interfaces. They contain specific code for interacting with the database. These classes can use JDBC or other technologies to interact with data;
• Entities are classes that reflect the structure of database tables. They contain fields that represent the data that the program works with;
• DAO Factory is a factory method or a factory class responsible for creating instances of DAO implementations. It helps isolate the program code from specific DAO implementations.

Example

Let's take a look at the approximate project structure where we're working with the employees table. We need to implement components such as:

1. An interface that will specify the methods to be implemented for working with the database;
2. A class that implements this interface;
3. An entity class that will represent an object instance from the database.

Here, at the top, you can see an interface that defines the methods to be used for interacting with the database.

Above, you can see a class that implements the interface and provides the methods for interacting with the database.

Here, you can see an entity class whose attributes correspond to the columns of the employees table.

Summary

In this course, we will strive to use the DAO design pattern for developing our applications. Moving forward, we will explore more advanced techniques to make working with Java code and databases more convenient!