@@ -0,0 +1,111 @@
+# Defining Entity Characteristics
+
+## Introduction
+
+This guide focuses on defining entity columns or characteristics in a Spring Boot project using JPA (Java Persistence API).
+
+## Goal
+The goal of this guide is to provide clear instructions for defining the characteristics of entities in a Spring Boot project with JPA, utilizing annotations to enforce constraints and behaviors for each attribute.
+
+
+## Entity Characteristics
+
+### Student Entity Characteristics:
+- `id` (UUID): Primary key for the entity.
+- `name` (String): Name of the student (must not be blank).
+- `email` (String): Email address of the student (must be a valid email address).
+- `major` (String): Major or field of study of the student (must not be blank).
+- `year` (int): Year of study for the student (must not be null).
+- `international` (boolean): Indicates if the student is international (must not be null).
+
+### Define `id` Attribute
+
+Add the `id` attribute to the `Student` class. This attribute will serve as the primary key for the entity.
+
+```java
+@Id
+@GeneratedValue(strategy = GenerationType.AUTO)
+private UUID id;
+```
+
+- `@Id`: Indicates that this field is the primary key for the entity.
+- `@GeneratedValue`: Specifies the strategy for generating primary key values automatically.
+
+### Define `name` Attribute
+
+Add the `name` attribute to the `Student` class. This attribute represents the name of the student and must not be blank.
+
+```java
+@NotBlank
+private String name;
+```
+
+- `@NotBlank`: Ensures that the value of `name` is not null and contains at least one non-whitespace character.
+
+### Define `email` Attribute
+
+Add the `email` attribute to the `Student` class. This attribute represents the email address of the student and must be a valid email address.
+
+```java
+@NotBlank
+@Email
+private String email;
+```
+
+- `@Email`: Validates that the value of `email` is a valid email address.
+
+### Define `major` Attribute
+
+Add the `major` attribute to the `Student` class. This attribute represents the major or field of study of the student and must not be blank.
+
+```java
+@NotBlank
+private String major;
+```
+
+- `@NotBlank`: Ensures that the value of `major` is not null and contains at least one non-whitespace character.
+
+### Define `year` Attribute
+
+Add the `year` attribute to the `Student` class. This attribute represents the year of study for the student and must not be null.
+
+```java
+@NotNull
+private int year;
+```
+
+- `@NotNull`: Ensures that the value of `year` is not null.
+
+### Define `international` Attribute
+
+Add the `international` attribute to the `Student` class. This attribute indicates whether the student is international and must not be null.
+
+```java
+@NotNull
+private boolean international;
+```
+
+- `@NotNull`: Ensures that the value of `international` is not null.
+
+
+You can repeat the previous steps to create entity characteristics for the `Course` and `Enrollment` entities, ensuring appropriate annotations are applied to each attribute.
+
+### Enrollment Entity Characteristics:
+
+- `id` (UUID): Primary key for the entity.
+- `enrollmentDate` (Date): Date of enrollment.
+- `grade` (int): Grade achieved in the course.
+
+### Course Entity Characteristics:
+
+- `id` (UUID): Primary key for the entity.
+- `name` (String): Name of the course.
+- `instructor` (String): Name of the course instructor.
+- `schedule` (String): Schedule details of the course.
+- `capacity` (int): Maximum capacity of the course.
+- `online` (boolean): Indicates if the course is online.
+- `startDate` (Date): Start date of the course.
+
+---
+
+# [Next: Managing Relationships](relationships.md)
@@ -0,0 +1,60 @@
+# Creating Entities
+
+## Introduction
+
+This guide focuses on creating entities in a Spring Boot project using JPA (Java Persistence API). It provides step-by-step instructions for setting up the folder structure and creating entity classes.
+
+## Goal
+
+The goal of this guide is to demonstrate how to create entity classes in a Spring Boot project, following best practices and utilizing JPA for data persistence.
+
+## Folder Structure
+
+To ensure a well-organized project, it's essential to establish a proper folder structure. Follow these guidelines:
+
+```
+src/
+└── main/
+    └── java/
+        └── com/
+            └── example/
+                └── demo/
+                    └── entity/
+                        ├── Student.java
+                        ├── Enrollment.java
+                        └── Course.java
+
+```
+
+In this structure:
+- The `src/main/java` directory contains your Java source files.
+- The `com/example/demo/entity` directory is where you'll create your entity classes.
+
+## Creating Entity Classes
+
+To create entity classes, follow these steps:
+
+1. Navigate to the `com/example/demo/entity` directory in your project.
+2. Create a new Java class file for each entity. You can repeat the following steps for each entity (e.g., Student, Enrollment, Course).
+3. Define your entity class with the `@Entity` annotation.
+
+### Example:
+
+```java
+package com.example.demo.entity;
+
+import javax.persistence.Entity;
+
+@Entity
+public class Student {
+
+}
+```
+
+The `@Entity` annotation indicates that this class is a JPA entity.
+
+Repeat the above steps to create `Enrollment` and `Course` entity classes.
+
+---
+
+# [Next: Entity Characteristics Definition](characteristics.md)
@@ -0,0 +1,49 @@
+Understood. Here's the revised document with the code combined with the scenario:
+
+---
+
+# Fetching Strategies in Spring Boot with JPA: Understanding Lazy and Eager Loading
+
+## Introduction
+
+This guide explores the fetching strategies in a Spring Boot project with JPA (Java Persistence API). Specifically, we will delve into the concepts of Lazy and Eager loading and how they are applied in entity relationships.
+
+## Goal
+
+The goal of this guide is to provide a comprehensive understanding of fetching strategies in JPA. By the end of this guide, you will comprehend when to use Lazy and Eager loading and how to implement them in your application.
+
+## Fetching Strategies
+
+### Scenario
+
+In our entity relationships, we have a One-to-Many relationship between the `Student` entity and the `Enrollment` entity. Similarly, there is a One-to-Many relationship between the `Course` entity and the `Enrollment` entity.
+
+#### Student Entity
+
+In the `Student` entity, we have a One-to-Many relationship with the `Enrollment` entity. Each student can have multiple enrollments.
+
+To represent this relationship, we use the `@OneToMany` annotation with `mappedBy = "student"` in the `Student` entity. Here, we have a choice between Lazy and Eager loading strategies for fetching the associated enrollments.
+
+```java
+@OneToMany(mappedBy = "student", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
+private List<Enrollment> enrollments;
+```
+
+We opt for Eager loading (`FetchType.EAGER`) in this scenario. Since we typically expect to access all enrollments of a student together, Eager loading ensures that all enrollments are fetched immediately when loading the student.
+
+#### Course Entity
+
+Similarly, in the `Course` entity, we also have a One-to-Many relationship with the `Enrollment` entity. Each course can have multiple enrollments.
+
+To represent this relationship, we use the `@OneToMany` annotation with `mappedBy = "course"` in the `Course` entity. Here, we have another choice between Lazy and Eager loading strategies for fetching the associated enrollments.
+
+```java
+@OneToMany(mappedBy = "course", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+private List<Enrollment> enrollments;
+```
+
+We opt for Lazy loading (`FetchType.LAZY`) in this scenario. Since we may not always need to access all enrollments of a course, Lazy loading ensures that enrollments are fetched only when explicitly requested.
+
+---
+
+# [Next: Create Repository](../interacting/repository.md)
@@ -0,0 +1,44 @@
+# Defining Entity Relationships
+
+## Introduction
+
+This guide delves into understanding and implementing relationships between entities in a Spring Boot project using JPA (Java Persistence API). Specifically, we will explore the relationship between the `Enrollment` entity and its associated entities `Student` and `Course`.
+
+## Goal
+
+The goal of this guide is to provide clear instructions for defining and understanding entity relationships in a Spring Boot project with JPA. By the end of this guide, you will comprehend how to establish associations between entities and implement them in your application.
+
+## Entity Associations
+
+![img.png](../../../../srcs/jpa/er-diagram.png)
+### Enrollment Entity Characteristics:
+
+- `id` (UUID): Primary key for the entity.
+- `student` (Student): Student associated with the enrollment.
+- `course` (Course): Course associated with the enrollment.
+- `enrollmentDate` (Date): Date of enrollment.
+- `grade` (int): Grade achieved in the course.
+
+#### Student Relationship
+
+The relationship between the `Enrollment` entity and the `Student` entity represents a scenario where a student enrolls in a course. This is a Many-to-One relationship, where many enrollments can be associated with one student. To establish this relationship, annotate the `student` attribute in the `Enrollment` entity with `@ManyToOne`.
+
+```java
+@ManyToOne
+@JoinColumn(name = "student_id")
+private Student student;
+```
+
+#### Course Relationship
+
+Similarly, the relationship between the `Enrollment` entity and the `Course` entity signifies a scenario where a course is enrolled by multiple students. This is also a Many-to-One relationship, where many enrollments can be associated with one course. Annotate the `course` attribute in the `Enrollment` entity with `@ManyToOne`.
+
+```java
+@ManyToOne
+@JoinColumn(name = "course_id")
+private Course course;
+```
+
+---
+
+# [Next: Fetching Strategies](fetching.md)
@@ -0,0 +1,100 @@
+# JPA: Setup Dependencies
+
+## Introduction
+
+This guide focuses on setting up dependencies for a Spring Boot project with JPA (Java Persistence API). It covers the necessary steps to include database drivers for various databases such as PostgreSQL, MySQL, Oracle, MongoDB, and Microsoft SQL Server. By following this guide, you will configure all the required dependencies to establish connections with these databases in your Spring Boot application.
+
+## Goal
+The goal of this guide is to provide clear instructions for setting up the necessary dependencies for Spring Boot and JPA, specifically focusing on database drivers for different databases.
+
+## Setup Dependencies
+
+### Database Drivers
+
+To connect to different databases in your Spring Boot application, include the appropriate database drivers.
+
+#### PostgreSQL
+
+**For Gradle:**
+```groovy
+implementation "org.postgresql:postgresql"
+```
+
+**For Maven:**
+```xml
+<dependency>
+    <groupId>org.postgresql</groupId>
+    <artifactId>postgresql</artifactId>
+    <version>INSERT_VERSION_HERE</version>
+</dependency>
+```
+
+#### MySQL
+
+**For Gradle:**
+```groovy
+implementation "mysql:mysql-connector-java"
+```
+
+**For Maven:**
+```xml
+<dependency>
+    <groupId>mysql</groupId>
+    <artifactId>mysql-connector-java</artifactId>
+    <version>INSERT_VERSION_HERE</version>
+</dependency>
+```
+
+#### Oracle Database Driver
+
+**For Gradle:**
+```groovy
+implementation 'com.oracle.database.jdbc:ojdbc8'
+```
+
+**For Maven:**
+```xml
+<dependency>
+    <groupId>com.oracle.database.jdbc</groupId>
+    <artifactId>ojdbc8</artifactId>
+</dependency>
+```
+
+#### MongoDB Driver (MongoDB Java Driver)
+
+**For Gradle:**
+```groovy
+implementation 'org.mongodb:mongodb-driver-sync:4.4.3'
+```
+
+**For Maven:**
+```xml
+<dependency>
+    <groupId>org.mongodb</groupId>
+    <artifactId>mongodb-driver-sync</artifactId>
+    <version>4.4.3</version>
+</dependency>
+```
+
+#### Microsoft SQL Server JDBC Driver
+
+**For Gradle:**
+```groovy
+implementation 'com.microsoft.sqlserver:mssql-jdbc:9.4.0.jre11'
+```
+
+**For Maven:**
+```xml
+<dependency>
+    <groupId>com.microsoft.sqlserver</groupId>
+    <artifactId>mssql-jdbc</artifactId>
+    <version>9.4.0.jre11</version>
+</dependency>
+```
+
+These dependencies facilitate database connectivity.
+
+---
+
+# [Next: Spring Boot and JPA Dependencies](jpa.md)
+