Java Full Stack Session 02 || IntelleQAcademy

Review and Purpose of the Session

The instructor briefly reviewed how a frontend sends requests to a backend through an API. Backend operations are needed to create, retrieve, update, or delete data. The session focused on understanding the backend request flow before beginning Spring Boot in a later lesson.

Object-Oriented Programming (OOP)

The instructor described OOP as a way to represent real-world entities in code using classes and objects.

• Applications may model entities such as users, students, teachers, or products.
• A class can hold properties shared by related entities. For example, a User class might contain a name and date of birth.
• Specialized classes can extend a general class. For example, a Student class could inherit common properties from User and add student-specific fields, such as an ID or enrollment details.
• Inheritance, method overloading, overriding, and polymorphism are features of OOP. The instructor emphasized understanding their purpose rather than memorizing terminology first.
• The instructor contrasted OOP with functional programming, which organizes programs around functions.

Typical Backend Layers

The instructor introduced a simplified Spring Boot backend flow:

Frontend → API → Controller → Service → JPA/repository → Database

• API: The frontend uses an API to send a request to the backend.
• Controller: Receives the request and routes it to the appropriate operation.
• Service: Contains the application’s business logic.
• JPA/repository: Handles persistence operations and communication with the database.
• Database: Stores or returns the data.

A controller may expose operations such as creating, retrieving, updating, or deleting a user. The request’s HTTP method and endpoint help identify which operation should run.

Example: Creating a User

The instructor walked through a signup scenario:

1. A user enters details such as a name, email, password, and possibly a phone number in a frontend form.
2. When the user submits the form, the frontend packages the values as key-value data, commonly in JSON format.
3. To create a new record, the frontend sends a POST request to the appropriate backend URL and endpoint.
4. The controller receives the request and converts the incoming data into a Java object.
5. The controller passes that object to the service layer.
6. The service passes it to JPA/repository functionality.
7. JPA, using Hibernate internally, maps the Java object to database storage and performs the insert.
8. The data is ultimately saved as a record in the database.

The instructor stressed that the same logical data changes representation as it moves through the system—for example, from frontend JSON to a Java object, then to a database representation.

Example: Retrieving Data

A product-listing example illustrated how data is read:

1. A user requests a list of mobile phones from a frontend.
2. The frontend sends a GET request to the relevant endpoint.
3. The request passes through the controller and service to JPA/repository functionality.
4. A database query retrieves the matching records.
5. The backend returns product details—such as name, price, company, and image-related data—to the frontend.

Unlike a create request, a basic retrieval request may not need to send a new object or form payload.

HTTP Requests and Endpoint Selection

The instructor used CRUD—Create, Read, Update, Delete—to explain common backend operations. The examples associated creation with POST and retrieval with GET, and also mentioned update and delete operations.

To route a request correctly, the backend uses both the request method and the endpoint or path. Multiple methods can use the same HTTP verb but different paths.

The instructor also demonstrated using a browser’s developer tools, particularly the Network tab, to inspect requests sent by a frontend, including the endpoint, HTTP method, and request data.

JPA and Dependencies

In response to a question, the instructor compared JPA to using a ready-made library such as Math.pow: developers use functionality that has already been implemented instead of writing its internals from scratch.

• A Spring Boot application is configured with database connection details.
• JPA works with Java objects and, through Hibernate ORM, maps them to database tables.
• The instructor said JPA can handle common insert, select, and update operations without developers writing each SQL query directly. The details of this mapping would be covered later.

Frontends and Backends Are Independent

The instructor clarified that a backend is not tied to one frontend technology. A shared backend can receive API requests from Angular, React, Flutter, React Native, plain HTML, mobile applications, or Postman. Different platforms can have different interfaces while using the same backend.

Postman was described as a way to call an API without building a user-facing interface.

Tools and Learning Guidance

The instructor recommended or discussed these tools:

• Eclipse or Spring Tool Suite (STS) for backend work, partly because the instructor could provide support with them.
• IntelliJ as another usable option.
• Postman for testing API requests.
• MySQL and MySQL Workbench for database work.
• Git for version control.
• VS Code for frontend work; the instructor advised against using it for the course’s backend demonstrations.

The instructor encouraged learners to ask questions, consult reference materials, and use AI tools to clarify concepts. The suggested task was to use ChatGPT or another chatbot to understand the frontend-to-backend-to-database flow through a simple example, without writing code yet. NotebookLM was also suggested as a way to summarize lesson videos and create notes.

Projects and AI Discussion

Students discussed projects they had already built, including websites made with React, WordPress, and AI assistance. The instructor encouraged learners with project experience to start building rather than wait for every course topic to be covered.

The instructor’s proposed project goal was for each learner to choose a problem to solve, build its backend with Spring Boot, and later add a frontend, potentially with AI assistance.

One student described an open-source Java package for connecting to AI models. The student said it reduces what would otherwise be a lengthy Java integration to a few lines, supports Java 17 and Core Java as well as Spring-related use, and is available through Maven Central under an Apache 2.0 license. The student presented the package as a way for Java developers to experiment with AI and LLM concepts without switching to Python. The instructor asked what problem it addressed given the existence of Spring AI and said they would look into it.

Speakers and Sources Featured

• Instructor: Led the lesson and explained OOP, backend architecture, APIs, JPA, tooling, and project guidance. The instructor’s name is not clear in the subtitles.
• Sakshi: Student credited by the instructor with describing OOP as representing real-world entities.
• Manju: Student addressed during a question about JPA; the question itself is not fully captured.
• Gayatri: Student who asked questions during the session; the exact questions are not consistently clear in the subtitles.
• Robin: Student addressed in a discussion about assignments or program-related matters.
• Prabhu: Student addressed during discussion of Spring Boot and IDEs.
• Garshini: Student involved in discussion about NetBeans and backend IDE choices.
• Nandini: Student who said the group had already completed Java full-stack projects and asked whether they could begin a project immediately.
• Naveen: Student who presented an open-source Java AI package and discussed a portfolio.
• Kiran / Kieran: Student addressed in the discussion about taking notes from videos with NotebookLM; the subtitles spell the name both ways.
• Tarun: Student whose project was mentioned by the instructor.
• Hariom: Student thanked near the end of the session.
• Other students: Several brief questions and responses are audible but cannot be reliably attributed from the subtitles.
• ChatGPT and NotebookLM: Mentioned as tools for explanations and video summaries; ChatGPT was also shown during the lesson.