Coding

Customer CRUD API

Category: Coding
Platform: Windows
Length: 48 min
Resolution: 1920 × 1080
Software: Spring Tools for Eclipse, MySQL Workbench, Postman, Google Chrome

Samples play on a computer

48min

419clicks

5Kkeys

Spring Tools for Eclipse, MySQL Workbench, Postman, Google Chrome · Windows

00:00 / 48:09

Events2,601

00:00.000AppSpringToolsForEclipse

00:00.820KeyAlt+Tab

00:00.822AppWindows Explorer

00:00.890AppMySQL Workbench

00:03.999KeyAlt+Tab

00:04.002AppWindows Explorer

00:04.058AppSpringToolsForEclipse

00:04.061AppWindows Explorer

00:04.312AppSpringToolsForEclipse

00:05.140Typed"name;"

00:05.782KeyEnter

00:07.485Typed"@Column"

00:09.496KeyEnter

00:10.244Typed"private String address;"

00:15.959KeyCtrl+A

00:16.271KeyCtrl+Shift+S

00:16.302KeyCtrl+Shift+O

00:17.503KeyEnter

00:18.512KeyCtrl+A

00:18.723KeyCtrl+S

00:19.273Click892, 309

00:19.666ScrollDown

00:20.091Move892, 323 → 984, 459

00:21.058Click984, 459

00:21.372KeyEnter

00:21.829ScrollDown

00:22.260Move965, 456 → 862, 468

00:25.191KeyEnter

00:25.806Move864, 468 → 860, 421

00:26.534Click860, 421

00:26.909Move869, 421 → 959, 407

00:27.669Click959, 407

00:27.906KeyEnter

00:28.401ScrollDown

00:28.879Move937, 408 → 797, 450

00:29.448Click797, 450

00:30.041KeyEnter

00:30.911Typed"public Customer(){}"

00:36.252KeyEnter

00:38.277KeyEnter

Loading events

Narration266

00:00
Switched from Spring Tools for Eclipse through the task switcher to MySQL Workbench, where a customer table query and its single returned row were visible; then continued switching applications.
Move between the open development and database applications.
00:04
Returned to Spring Tools for Eclipse and edited Customer.java, adding a `name` field and beginning an annotated `address` field; corrected the partially typed declaration as the code changed.
Define customer entity fields in the Java class.
00:16
Completed the `address` field as `private String address;`, selected the class contents briefly, and then left the caret on a blank line below the fields.
Complete and review the customer entity field declarations.
00:27
Added a public no-argument `Customer()` constructor, then opened the editor context menu and navigated to the constructor-generation command.
Create a constructor for the Customer entity.
00:44
Applied the constructor-generation command to add a parameterized constructor assigning `id`, `name`, and `address` to the corresponding fields, then opened the editor context menu and selected the getters-and-setters generation command.
Generate a fields-based constructor and accessors for the customer entity.
00:55
Reviewed the Generate Getters and Setters dialog, which had getter and setter options selected for `address`, `id`, and `name`, then clicked Generate.
Generate accessors for the Customer entity fields.
01:00
Scrolled down through the open Customer.java file, moving from the constructor and ID getter to the name and address getter/setter methods near the end of the class.
Review the remaining Customer class methods.
01:11
Made several keyboard edits near the closing lines of Customer.java, then opened the package context menu and chose the option to create a Java interface.
Start creating an interface in the repository package.
01:29
Typed and corrected the interface name in the New Java Interface wizard's Name field.
Name the new repository interface.
01:35
Switched to the newly created CustomerRepository.java editor and entered an annotation above the interface; the visible text was left incomplete as @T.
Begin defining the repository interface.
01:45
Added repository-related imports and an @Repository annotation, then changed the interface declaration to extend JpaRepository and supplied Customer and Integer as type parameters.
Set up CustomerRepository as a Spring Data JPA repository for Customer entities.
01:58
Clicked within the repository code, closed its editor tab, and returned to Customer.java; then selected CustomerRepository.java in the project tree.
Return to the Customer class and inspect the repository file in the project.
02:08
Clicked through the project/package tree, then opened the package context menu and chose New > Class to start creating a Java class.
Create a Java class in the selected package.
02:18
Entered and corrected a name in the New Java Class dialog, then pressed Enter to create the class.
Create a class in the Services package.
02:25
Typed and edited the class contents, adding the Spring Service import and @Service annotation; selected the code and continued editing.
Set up the new class as a Spring service.
02:35
Typed and corrected an @Autowired annotation beneath the class declaration.
Prepare a field for dependency injection.
02:41
Typed a CustomerRepository field declaration below @Autowired, then selected the code and invoked editor commands to organize or complete the source.
Add a repository dependency to CustomerService.
02:51
Clicked in the editor and pressed Enter to add blank lines inside the class, then began typing a public declaration.
Continue implementing CustomerService.
02:57
Typed a `List<Customer> getAllCustomers()` method in `CustomerService` and began its return statement.
Add a service method to retrieve all customers.
03:10
Continued the return statement with `repo.findAll();` and invoked import organization; the editor then showed the file selected and a `List` resolution error.
Complete the all-customers repository call and resolve imports.
03:18
Returned to the editor, moved the caret below the all-customers method, and began typing a new public method declaration.
Continue adding customer service methods.
03:29
Typed a `getCustomerById` method signature with an `int id` parameter, opened its body, and began a repository return call; the editor displayed completion suggestions.
Add a service method to retrieve a customer by ID.
03:49
Completed the repository call as `repo.findById(id);` and reviewed the resulting type error indicating that an `Optional<Customer>` could not be converted to `Customer`.
Finish the lookup-by-ID implementation and inspect its type issue.
03:59
Changed the ID lookup return expression to `repo.findById(id).orElse(null);`, then started another public `Customer` method declaration.
Handle the optional lookup result and begin another customer service method.
04:14
Selected the repository file in the project tree, opening CustomerRepository.java after briefly showing CustomerService.java and its reported type-mismatch error.
Inspect the customer repository while addressing the service compilation issue.
04:24
Added the declaration `Customer getCustomerByName(String name);` to CustomerRepository.java, then selected text in the editor and copied it.
Define a repository query method for finding a customer by name.
04:43
Switched through the open applications, briefly viewing MySQL Workbench with the customer table query and result, then opened ChatGPT and began composing a question about the repository method.
Ask for help understanding the customer repository method.
04:59
Continued typing and correcting the ChatGPT prompt, describing the Customer bean and the autogenerated repository method created by extending JpaRepository.
Explain the repository method setup to get guidance on its behavior.
05:10
Submitted the prompt and waited while ChatGPT generated a response explaining that the repository can use a derived query method.
Get confirmation about the derived query method declaration.
05:17
Read the generated explanation and scrolled down through its examples, reviewing how `getCustomerByName` maps to the Customer entity's name property and how it can be called from a service.
Understand the derived query method and its example usage.
05:37
Switched among MySQL Workbench, Chrome, and Spring Tools for Eclipse, then returned to the Java project and opened CustomerService.java. Scrolled slightly and positioned the editor to continue editing the service class.
Return to the Spring project and work on the customer service code.
05:46
Edited the customer service method to call the repository's getCustomerByName method, using code completion while entering the repository call. Then selected the visible source code.
Implement the service method that retrieves a customer by name.
05:56
Adjusted the `getCustomerByName` return statement and moved to a new line in the service class, beginning to type another declaration.
Continue editing the customer service methods.
06:07
Typed a new method declaration, entering `public Customer addNewCustomer(` beneath the existing customer lookup methods.
Start adding a customer-creation method to the service class.
06:18
Continued the method signature by entering `@RequestBody Customer customer` and opening the method body.
Define the input parameter for the customer-creation method.
06:29
Selected the visible service source, then clicked in the method body and scrolled the editor slightly to position the incomplete customer-creation method for further editing.
Review and position the new method for implementation.
06:37
Completed the `addNewCustomer` method by replacing the incomplete return expression with `return repo.save(customer);`, then clicked in the editor and pressed Enter to continue below it.
Finish the customer-creation method in the service class.
06:47
Started a new public method beneath `addNewCustomer`, correcting typing as the incomplete declaration was entered.
Add a customer-update method to the service class.
07:04
Continued typing and correcting the declaration until it read `public Customer updateCustomer()`, then clicked and dragged over the `addNewCustomer` parameter area.
Define the update method signature and reposition the editing selection.
07:18
Dragged across the editor text, clicked near the method declaration, deleted two characters, and entered `int id` in the update method parameter list before pressing Enter.
Add an identifier parameter to the customer-update method.
07:25
Typed a return expression inside `updateCustomer(int id)`, entering `return repo.sa`; the repository completion suggestions appeared, and two backspaces were entered afterward.
Begin implementing the update method using the customer repository.
07:34
Viewed the repository content-assist list and documentation for the suggested `getReferenceById` method, then clicked in the editor and the suggestions closed.
Review repository method options while continuing the update implementation.
07:43
Typed `,Customer customer` into the `updateCustomer` method, then clicked and dragged in the editor and scrolled slightly; the method signature remained incomplete and a syntax error was visible.
Continue implementing the customer update method.
07:52
Typed a `for` loop header in the method body, correcting the entry with backspaces and continuing with `Customer c:customer`; the incomplete line triggered a syntax error.
Add iteration logic within the customer update method.
08:06
Paused without interacting while the incomplete loop header remained open in the editor.
Review the unfinished customer update method.
08:26
Clicked in the project tree and resized the Eclipse window; the project tree expanded to show more of the workspace files.
Navigate the project tree to another source file.
08:37
Expanded and collapsed entries in the project tree, then opened `EmployeeService.java` and scrolled in the workspace.
Inspect the employee service source file.
08:47
Selected the `CustomerService.java` tab, then dragged across the editor to highlight the `updateCustomer` method declaration and its unfinished loop line.
Return to and select the incomplete customer update code.
08:57
Made brief edits in the open Java service code, then switched between the EmployeeService.java and CustomerService.java editor tabs.
Navigate between service files while working on the customer service implementation.
09:11
Typed and corrected text on the updateCustomer method line, beginning a Customer variable declaration and repository lookup.
Implement the customer update method.

09:23
Continued editing the Customer variable and typed a repository `findById` lookup, using the code-completion popup while entering the method call.
Retrieve the customer record by ID for the update method.
09:34
Changed the ID parameter type in the customer lookup method from `int` to `Integer`, then continued editing the repository lookup line.
Align the update method's ID type with the repository lookup.
09:46
Completed the lookup expression with `.orElse(null);` and added a new line in the update method, beginning an `if` condition.
Handle a missing customer result before proceeding with the update.
09:59
Added braces to form the body of the `if(c!=null)` condition, then left the editor with the block empty.
Set up the conditional block for the customer update logic.
10:05
Switched from Chrome to Spring Tools for Eclipse, alternated between CustomerService.java and EmployeeService.java, and scrolled through the employee service code.
Review the service implementation and move between open Java files.
10:16
Switched between CustomerService.java and EmployeeService.java, briefly typed a character, and scrolled through the employee service code.
Inspect the open service files and navigate their code.
10:27
Edited the updateCustomer method, correcting a partial entry and typing a fragment beginning with “customer.setI”; pressed Enter.
Continue implementing the customer update method.
10:36
Used Tab and Enter in the editor, then switched to EmployeeService.java and back to CustomerService.java.
Navigate between the service implementations while editing.
10:48
Typed a return statement and continued entering a repository call in updateCustomer, using Enter and Tab while editing.
Add the return behavior to the customer update method.
10:58
Scrolled through the code, switched briefly to EmployeeService.java and back to CustomerService.java, then clicked in the updateCustomer method and pressed Enter.
Review and continue editing the customer update implementation.
11:09
Edited the end of `updateCustomer` in `CustomerService.java`, correcting the return statement to `return null;` and selecting the method text; then moved the editor window and scrolled slightly.
Complete the update method so it returns a `Customer` result on all paths.
11:19
Scrolled within the Java editor, moved to a new line below `updateCustomer`, and began typing a new declaration, leaving `public Customer` unfinished.
Start adding another method to `CustomerService.java`.
11:25
Corrected the unfinished declaration by deleting and retyping its return type, leaving `public Message` on the line.
Change the return type of the new declaration.
11:36
Selected the `com.sp.www.Beans` package in the project tree and opened the New Java Class wizard.
Create a Java class in the Beans package.
11:46
Completed the class name as `Message` and opened the resulting `Message.java` file; then clicked in the editor area and initiated a save.
Create and save the `Message` class.
11:53
Dismissed the save prompt, returned to `CustomerService.java`, and typed `deleteCustomer(id{` followed by Enter at the existing incomplete `public Message` line.
Continue editing the service file, apparently beginning a delete-customer method call or declaration.
12:04
Typed and corrected text in the `CustomerService.java` editor while extending the `deleteCustomer` method, then invoked the Organize Imports command; the method remained incomplete with syntax errors visible.
Edit the customer deletion method in the service class.
12:20
Returned to the Java editor, selected the source text, scrolled to the lower part of `deleteCustomer`, and edited the method signature and body with several corrections.
Continue implementing the customer deletion method.
12:30
Corrected the `deleteCustomer` parameter to `Integer id`, then adjusted the caret and typed further edits around the repository lookup.
Repair the method signature and continue editing its body.
12:40
Pressed Enter after the repository lookup, then began an `if` condition on the next line and continued typing to form a null check.
Add a conditional branch to the deletion method.
12:51
Completed the `if(c!=null)` condition, entered its block, and typed a repository deletion call, correcting the text before accepting it.
Delete the customer record when the lookup returns a non-null customer.
12:59
Typed a `Message` variable declaration and constructor call beneath the repository deletion statement, correcting the text as the line was completed.
Add a message object to the customer deletion method.
13:11
Opened the `Message.java` editor, positioned the caret inside the `Message` class, and began adding a `String msg` field and a public declaration.
Start defining a message field in the `Message` class.
13:23
Continued editing `Message.java`, completing the `String msg` field and typing a `Message(String msg)` constructor with an assignment to `this.msg`.
Add a constructor that initializes the message field.
13:36
Added an empty `Message()` constructor, then opened the editor context menu and chose `Generate Constructors from Superclass`.
Add a no-argument constructor and open constructor-generation options.
13:52
Returned to the `Message.java` editor, opened the context menu, and selected `Generate Getters and Setters`.
Generate accessor methods for the message field.
13:58
In the `Generate Getters and Setters` dialog, selected the `msg` field for generation and proceeded to generate its accessor methods.
Create getter and setter methods for `msg`.
14:02
Returned to the editor with generated `getMsg()` and `setMsg(String msg)` methods, then switched to `CustomerService.java` and typed `Message m=new Message();` inside `deleteCustomer`.
Generate message accessors and begin using a `Message` instance in the customer deletion method.
14:11
Typed and edited the message string in the `deleteCustomer` method, beginning a customer-ID status message.
Add a status message for the customer deletion operation.
14:20
Continued composing the message string, adding the customer ID expression and beginning the deletion-result text.
Construct a deletion confirmation message that includes the customer ID.
14:30
Completed the message text as `Customer With Id:` plus the ID and `Deleted Successfully !`, then started a return statement.
Finish the customer-deletion confirmation and return a response message.
14:42
Selected and edited code in `CustomerService.java`, adding `return null;` after the conditional block; then switched to `Customer.java` and selected its code.
Correct the delete method's return paths and inspect or copy customer model code.
14:57
Switched to the Chrome tab containing the ChatGPT conversation and continued typing in the message composer, extending the draft with `fro this` and a dash; then switched away.
Draft a note or question referencing the displayed Java service code.
15:02
Returned briefly to Spring Tools for Eclipse, switched from `Customer.java` to `CustomerService.java`, and selected code; then returned to the ChatGPT conversation and continued editing the draft, correcting text and pressing Enter.
Refer to the Java code while composing a message in the conversation.
15:11
Scrolled down through the ChatGPT response, moving from the Customer entity discussion to the recommended update-method improvements.
Review the suggested changes to the customer service code.
15:24
Continued scrolling through the response and reviewed the revised `updateCustomer` example and its explanation.
Understand how to update customer fields without replacing the entire entity.
15:36
Scrolled farther down the response, passing the delete-method suggestion and reaching the dependency-injection section.
Review additional recommendations for the customer service code.
15:51
Scrolled back to the update-method example, clicked its copy control, and clicked in the response area.
Copy the suggested update-method code for reference.
15:58
Switched to Spring Tools for Eclipse, scrolled within `CustomerService.java`, and selected the `Message m=new Message();` line in the delete method.
Inspect the existing customer service implementation alongside the recommendation.
16:06
Switched back to the ChatGPT response, clicked the copy control on the update-method code block, and pressed Tab.
Copy the suggested update method for use in the code editor.
16:15
Returned to Spring Tools for Eclipse, selected and edited the customer update code, then began typing `c.setN` and pressed Enter.
Edit the customer update method in the service class.
16:24
Typed through the customer name and address setter calls, using Enter to continue editing; the code showed an unresolved-symbol error while the edits were in progress.
Add customer field updates to the existing update method.
16:33
Corrected the setter expressions by deleting and retyping text, changing the name assignment to use `customer.getName()` and beginning an address getter expression.
Fix the customer update assignments in the service method.
16:46
Used Tab several times while editing the service method, clicked within the code, and pressed Backspace; then switched away from the editor.
Continue adjusting the customer update code.
16:54
Switched to the Chrome tab showing the Spring JPA derived-query discussion, briefly pressed Tab, then returned to Spring Tools for Eclipse.
Consult the displayed code guidance while editing the service method.
16:59
Switched between the Chrome guidance and the Eclipse editor, then clicked in the update method and used Backspace and typing to adjust text around the customer references.
Continue refining the customer update method using the code example as reference.
17:09
Scrolled down in the CustomerService.java editor to review the update and delete methods, then switched away from Spring Tools for Eclipse.
Review the customer service implementation.
17:20
Switched to the Chrome conversation and scrolled through the Spring JPA guidance, reviewing the update, delete-message, and dependency-injection examples; clicked a code-block copy control.
Review suggested changes for the customer service code.
17:34
Returned to Spring Tools for Eclipse, selected the visible CustomerService.java code, and used keyboard shortcuts while the code remained highlighted; then hid the application window.
Select and work with the customer service implementation.
17:45
Restored and rearranged the Spring Tools for Eclipse window, switched between application.properties and CustomerService.java, and right-clicked the Controllers package in the project tree.
Navigate the project and prepare to add a controller class.

Build and test the Spring Boot customer CRUD API for the Customers_CrudAndTesting_Application project.

Built and tested a Spring Boot customer CRUD application, creating the entity, repository, service, and REST controller, then using Postman and MySQL Workbench to verify customer retrieval, creation, update, and deletion. Consulted ChatGPT for code guidance and reviewed the remaining add-customer endpoint error.

clip.mp4The screen recording93 MB events.jsonEvery input logged, synced to the video clock21 MB frame_events.jsonEvery input logged, synced per frame45 MB narration.jsonDescriptions of what happened, and why104 KB metadata.jsonThe session's facts3 KB

More from this set

All 21 samples →

Browser · Windows27 min

Browse Myntra menswear

27 minGoogle Chrome

Chrome

Productivity · Windows35 min

ML Results Document

35 minMicrosoft Word, PyCharm

Word +1

Video editing · Windows52 min

FL Studio Music Production

52 minFL Studio

FL Studio

All 21 samples→