Efficiently Managing Commits with git rebase​

Rebasing is one of Git’s most powerful features, allowing you to clean up and restructure your commit history. It helps you keep your commit timeline more concise by combining or reordering commits, making the project history easier to understand and maintain.

Here’s a basic example of how to rebase your feature branch onto the latest state of the main branch:

git checkout main
git pull --all
git checkout <feature-branch>
git rebase -i main

This command opens an interactive rebase session (-i), where you can choose to squash, reorder, or edit individual commits. In the interactive rebase editor, you’ll see options like pick, reword, squash, and edit, giving you control over how each commit should be handled.

Once you’ve made your adjustments, save and close the editor (Esc, followed by :wq). If there are no conflicts, Git will automatically reapply your changes on top of the main branch.

However, if conflicts arise during the rebase process, Git will pause and allow you to resolve them manually. After resolving conflicts, use:

git rebase --continue

Repeat this process until the rebase is complete. Once finished, you’ll see a message like Successfully rebased.... At this point, you’ll need to push your changes with a force push:

git push origin <feature-branch> --force

This is necessary because you have rewritten the commit history, and a standard push would result in conflicts.

Why Use Rebasing?​

The primary advantage of rebasing is maintaining a cleaner and linear commit history. Instead of creating "merge commits" that branch off, rebasing applies your commits directly on top of the target branch, creating a straight line of progress. This makes it easier to follow the evolution of the project and track changes back to their origins without needing to navigate through branches and merge commits.

Using git bisect to Find Bugs​

When you're trying to locate the commit that introduced a bug in a large codebase, git bisect is incredibly useful. It performs a binary search through your commit history to pinpoint where things went wrong.

To use git bisect:

git bisect start
git bisect bad #mark the current commit as bad
git bisect good <commit-SHA> #mark a known good commit (like a tag or SHA)

Git will start checking commits between the good and bad points, allowing you to test each one. You can mark each commit as "good" or "bad" until you find the problematic commit. After you’ve found it:

git bisect reset

Using git reflog to Recover Lost Commits​

git reflog keeps a log of every action you’ve taken in Git, even after commits are deleted or reset. It’s useful for recovering commits that you may have thought were lost.

For example, if you accidentally reset a branch or force-pushed to the wrong branch, you can find your lost commits with:

git reflog

Once you find the SHA of the lost commit, you can restore it with:

git checkout <commit-SHA>

Cherry-Picking Specific Commits (git cherry-pick)​

If you need to apply a specific commit from one branch to another without merging the entire branch, you can use git cherry-pick. This command applies individual commits to your current branch:

git cherry-pick <commit-SHA>

This is helpful when you need to bring over a bug fix or a feature that’s present in one branch but not another.

Custom Exception Handling​

Custom exception handling is invaluable as it allows us to define and throw exceptions specific to our application's needs. By creating custom exceptions, we can handle specific conditions and scenarios more effectively. This not only makes our codebase cleaner and more maintainable but also simplifies debugging by providing clear, meaningful error messages. Additionally, custom exceptions enhance the user experience by offering precise and understandable feedback when errors occur.

We will create a custom exception class named BookNotFoundException that extends the RuntimeException class. This exception will be unchecked, meaning it occurs at runtime. It will be thrown when a user searches for or attempts to update a book that is not found in the database.

Update the updateBook(int id, Book updatedBook) method in the BookService class to throw a BookNotFoundException if the book is not found in the database.

  public Book updateBook(int id, Book updatedBook) {
      if (updatedBook.getId() != id) {
          throw new RuntimeException("The ID in the request body does not match the ID in the URL.");
      }
      Optional<Book> optionalBook = bookLibraryRepository.findById(id);
      if (optionalBook.isPresent()) {
          Book existingBook = optionalBook.get();
          existingBook.setName(updatedBook.getName());
          existingBook.setAuthor(updatedBook.getAuthor());
          existingBook.setDescription(updatedBook.getDescription());
          return bookLibraryRepository.save(existingBook);
      } else {
          throw new BookNotFoundException(id);
      }
  }

If we run the application and attempt to update a book that does not exist in the database, a BookNotFoundException will be thrown, displaying a message in the console logs indicating that the book was not found. However, the response displayed in Hoppscotch.io will still be unclear and generic.

To provide a more user-friendly message in the response body, we need to create a custom error response class. This class will contain the error message and status code that will be returned to the user when an exception occurs.

Create a new class named CustomExceptionHandler. This class will be annotated with @ControllerAdvice and will contain methods to handle specific exceptions. In this case, we will create a method to handle the BookNotFoundException.

Re-run the application and attempt to update a book that does not exist in the database. The response will now include a custom error message indicating that the book was not found.

Similarly, you can create custom exception classes and handlers for other scenarios in your application. For example, I have implemented a service and controller method to GET a book by its ID and used the BookNotFoundException to handle cases where the book is not found in the database. You can check the Service class on my GitHub repository.

API Documentation with Swagger​

API documentation is essential for developers using your API. It provides detailed information about the endpoints, request and response formats, error codes, and other relevant details. By creating API documentation, you make it easier for developers to understand and interact with your API, reducing the learning curve and enabling faster integration.

Swagger is a popular tool for generating API documentation. It allows you to define your API using the OpenAPI Specification (formerly known as Swagger Specification) and automatically generates interactive documentation based on your API definition. Swagger provides a user-friendly interface that displays all your endpoints, request and response formats, and other details in an organized and visually appealing manner.

To generate the Swagger documentation for our Spring Boot project, we will use the springdoc-openapi library. This library integrates Swagger with Spring Boot v3, allowing you to create API documentation easily and efficiently. Add the following code to the build.gradle file.

  implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.5.0'

Run the application and navigate to http://localhost:8080/v3/api-docs to view the generated OpenAPI JSON documentation.

You can now navigate to http://localhost:8080/swagger-ui.html to view the Swagger UI interface, which offers an interactive documentation view of your API. The springdoc-openapi library includes Swagger UI out-of-the-box, so no additional setup is required. Currently, since we haven't added any custom annotations or descriptions to our endpoints, Swagger UI will display the default information based on the request and response objects. To enhance the documentation, you can add custom annotations and descriptions to your controllers and endpoints. You can check the Swagger code on my GitHub repository.

Unit Testing with JUnit and Mockito​

Unit testing is a critical aspect of software development. It allows you to test individual units or components of your codebase in isolation, ensuring that each unit functions correctly and meets the specified requirements. By writing unit tests, you can identify bugs and issues early in the development process, improve code quality, and increase the reliability and maintainability of your application.

We will use Mockito to mock dependencies and JUnit to write test cases for our service and controller classes. Mockito is a popular mocking framework that allows you to create mock objects for dependencies, enabling you to test your code in isolation. JUnit is a widely used testing framework for Java that provides annotations and assertions to write test cases and validate the behavior of your code.

For the Controller class, we will write test cases using MockMvc to test the CRUD operations. MockMvc is a Spring testing framework that allows you to test Spring MVC controllers without starting a full HTTP server. It provides a fluent API for making requests and validating responses, making it easy to write comprehensive tests for your controllers.

Create a BookLibraryControllerTest class in the src/test/java/com/example/booklibrary/controller package.

package com.shahpreetk.javaSpringBootBookLibrary.controller;

import com.shahpreetk.javaSpringBootBookLibrary.Book;
import com.shahpreetk.javaSpringBootBookLibrary.exceptions.BookNotFoundException;
import com.shahpreetk.javaSpringBootBookLibrary.exceptions.CustomExceptionHandler;
import com.shahpreetk.javaSpringBootBookLibrary.service.BookLibraryService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import java.util.List;

import static org.hamcrest.Matchers.hasSize;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

public class BookLibraryControllerTest {

    private MockMvc mockMvc;

    @Mock
    private BookLibraryService bookLibraryService;

    @InjectMocks
    private BookLibraryController bookLibraryController;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
        mockMvc = MockMvcBuilders.standaloneSetup(bookLibraryController)
                .setControllerAdvice(new CustomExceptionHandler())
                .build();
    }

    private Book createBook(int id, String name, String author, String description) {
        Book book = new Book();
        book.setId(id);
        book.setName(name);
        book.setAuthor(author);
        book.setDescription(description);
        return book;
    }

    @Test
    public void testGetAllBooks() throws Exception {
        Book book1 = createBook(1, "Book1", "Author1", "Description1");
        Book book2 = createBook(2, "Book2", "Author2", "Description2");
        List<Book> books = List.of(book1, book2);

        when(bookLibraryService.getAllBooks()).thenReturn(books);

        mockMvc.perform(get("/api/books"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$", hasSize(2)))
                .andExpect(jsonPath("$[0].id").value(1))
                .andExpect(jsonPath("$[0].name").value("Book1"))
                .andExpect(jsonPath("$[0].author").value("Author1"))
                .andExpect(jsonPath("$[0].description").value("Description1"))
                .andExpect(jsonPath("$[1].id").value(2))
                .andExpect(jsonPath("$[1].name").value("Book2"))
                .andExpect(jsonPath("$[1].author").value("Author2"))
                .andExpect(jsonPath("$[1].description").value("Description2"));
    }
}

In the BookLibraryControllerTest class, we have created a test case for the getAllBooks() method in the BookLibraryController class. We have mocked the BookLibraryService dependency using Mockito and defined the behavior of the getAllBooks() method to return a list of books. We then use MockMvc to perform a GET request to the /api/books endpoint and validate the response using assertions.

You can write similar test cases for other controller methods and service classes to ensure that your code functions correctly and handles various scenarios effectively. You can find more tests for the Controller on my GitHub repository.

package com.shahpreetk.javaSpringBootBookLibrary.service;

import com.shahpreetk.javaSpringBootBookLibrary.Book;
import com.shahpreetk.javaSpringBootBookLibrary.BookLibraryRepository;
import com.shahpreetk.javaSpringBootBookLibrary.exceptions.BookNotFoundException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.List;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

public class BookLibraryServiceTest {

    @Mock
    private BookLibraryRepository bookLibraryRepository;

    @InjectMocks
    private BookLibraryService bookLibraryService;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    private Book createBook(int id, String name, String author, String description) {
        Book book = new Book();
        book.setId(id);
        book.setName(name);
        book.setAuthor(author);
        book.setDescription(description);
        return book;
    }

    @Test
    public void testGetAllBooks() {
        Book book1 = createBook(1, "Book1", "Author1", "Description1");
        Book book2 = createBook(2, "Book2", "Author2", "Description2");

        when(bookLibraryRepository.findAll()).thenReturn(java.util.List.of(book1, book2));

        List<Book> result = bookLibraryService.getAllBooks();

        assertEquals(2, result.size());
        assertEquals("Book1", result.getFirst().getName());
        assertEquals("Author1", result.get(0).getAuthor());
        assertEquals("Description1", result.get(0).getDescription());
        assertEquals("Book2", result.get(1).getName());
        assertEquals("Author2", result.get(1).getAuthor());
        assertEquals("Description2", result.get(1).getDescription());
    }
}

@Mock annotation is used to create and initialize mock instances of the fields it is applied to. When a field is annotated with @Mock, Mockito will create a mock implementation of that field which can then be used in your tests to simulate the behavior of the actual dependency. This allows you to define how the mock should behave when certain methods are called, without actually invoking the real methods. It's particularly useful for isolating the class under test from its dependencies.

@InjectMocks annotation is used to create an instance of the class under test and inject the mock dependencies into it. When a class field is annotated with @InjectMocks, Mockito will automatically inject the mocks created with @Mock (or @Spy) into this instance. This simplifies the setup process by automatically performing dependency injection, ensuring that the class under test is properly initialized with all its dependencies mocked. This allows you to focus on testing the behavior of the class without worrying about the initialization of its dependencies.

MockitoAnnotations.openMocks(this) is a method used in Mockito to initialize the mocks and inject them into the annotated fields of the test class. This method is typically used in the @BeforeEach setup method to ensure that the mocks are properly set up before each test case runs.

You can write similar test cases for other service methods to ensure that your code functions correctly and handles various scenarios effectively. You can find the entire test suite on my GitHub repository.

This is how you can write unit tests for your Spring Boot application using JUnit and Mockito, create API documentation using Swagger, and update your codebase with custom exception handling. By following these best practices, you can improve the quality, reliability, and maintainability of your codebase, making it easier to develop, test, and deploy your applications.

Things You Can Learn Next (Intermediate to Advanced)​

As you continue to develop your Book Library application, here are some advanced topics you can explore to enhance its functionality and performance:

• Add Actuator Endpoints: Expose health and metrics endpoints to monitor and manage your application more effectively.
• Creating Docker Setup: Containerize your Book Library app for easier deployment and scalability using Docker.
• Deploying to a Cloud Platform: Learn how to deploy your Spring Boot application to cloud platforms like AWS, Azure, or Google Cloud.
• Implementing Logging: Enhance your application with effective logging strategies to monitor and debug more efficiently.
• Add Authentication and Authorization: Protect your endpoints and enhance API security by implementing authentication and authorization mechanisms.
• Add Features like Pagination, Sorting, and Rate Limiting: Improve your API by adding advanced features such as pagination, sorting, and rate limiting.
• Implement Caching: Boost performance by implementing caching strategies to reduce load times and database queries.
• Add Internationalization (i18n): Make your application accessible to a global audience by adding support for multiple languages.

These topics will help you take your Book Library application to the next level, ensuring it is robust, secure, and scalable.

Conclusion​

In this three-part blog series, we explored building a Book Library application with Java Spring Boot. We started with project setup and dependencies, then used Lombok for simplifying entity classes and implemented CRUD operations. Finally, we covered unit testing and custom exception handling, emphasizing their importance for robust application development. By following these steps, you’ve created a scalable and maintainable Spring Boot application.

Happy coding! 🚀

Using Lombok for the Book Entity​

Lombok is a library that helps reduce boilerplate code in Java classes by providing annotations to generate getters, setters, constructors, and other common methods automatically. In this blog post, we will leverage Lombok to simplify the creation of the Book Entity class in our Java Spring Boot project.

• Step 1: Add Lombok Dependency

  To use Lombok in your project, you need to add the Lombok dependency to your build.gradle file. You can copy the latest version from the Maven Central Repository or add the following line in the dependencies block:

  compileOnly 'org.projectlombok:lombok:1.18.32'
  

  After adding the dependency, sync your Gradle project to download the Lombok library.

• Step 2: Create the Book Entity Class

  The Lombok @Getter and @Setter annotations automatically generate getter and setter methods for the fields in a Java class. @Getter creates a public method to retrieve the value of a field, while @Setter creates a public method to set the value of a field. This reduces boilerplate code, making the class definitions cleaner and easier to read.

  We will use these annotations to create the Book entity class. Open the Book.java file and add the following code:

Get All Books​

• Step 3: Create the Book Repository

  Next, we will create a repository interface to interact with the Book entity. Create a new interface named BookLibraryRepository in the package and extend it with the JpaRepository interface provided by Spring Data JPA:

• Step 4: Create the Book Service

  Now, we will create a service class to handle business logic related to the Book entity. Create a new class named BookLibraryService in the service package and annotate it with @Service:

• Step 5: Create the Book Controller

  Finally, we will create a controller class to expose RESTful endpoints for CRUD operations on the Book entity. Create a new class named BookLibraryController in the controller package and annotate it with @RestController:

• Step 6: Start the server and test the API in the browser

  Run the project and navigate to http://localhost:8080/api/books in your browser. You will see an empty ouput:

  Even though we have data in our H2 database, the browser shows an array with multiple empty objects. This is because the BookLibraryRepository is not mapping the data from the database to the JSON we are trying to return.

  I tried multiple StackOverflow solutions, such as adding a Lombok Plugin or the jackson-databind dependency, but none worked because the plugin doesn't help at runtime and the jackson-databind dependency was already present in the project as a default part of the spring-boot-starter-web dependency.

• Step 7: Solution to the JSON issue

  The solution was to add the Lombok dependency to the build.gradle file as a annotationProcessor along with the compileOnly. This is because the annotationProcessor scope is used to process annotations at compile time, necessary for Lombok to generate the necessary methods in the compiled class files. Sync the Gradle project after adding the annotationProcessor scope.

  The compileOnly part of the dependency is needed to compile the project, without which the import statements for the Lombok annotations would not be recognized by the compiler.

  note

  • Please install the Lombok Plugin from the IntelliJ IDEA marketplace (Settings -> Plugins ) to enable the IDE to recognize the Lombok annotations.
  • Then go into the Settings -> Build, Execution, Deployment -> Compiler -> Annotation Processors and check the box for Enable annotation processing.

  Run the project again and navigate to http://localhost:8080/api/books in your browser. You should now see the list of books displayed correctly in JSON format.

• Step 8: Testing the GET API using Hoppscotch.io

  In the past, I used Postman to test the API, but now it requires users to create an account.I recently discovered Hoppscotch.io, a free and open-source, lightweight, web-based API development suite. You can use it to test the GET API by entering the URL http://localhost:8080/api/books and clicking on the Send button.

  Since our app runs on http, Hoppscotch.io will throw an error. To solve this, you can use the Hoppscotch browser extension. It can be downloaded from the following links:

  Hoppscotch Chrome Extension

  Hoppscotch Firefox Extension

  Once you have the extension installed, reload the page and re-send the request. Then choose the Browser extension option from the error and click on the Send button. You should see the list of books displayed in JSON format.

CRUD Operations on the Book Entity​

In the above section, we saw how to GET all the books from the database. Now, let's implement the remaining CRUD operations on the Book entity.

Create a New Book​

To create a new book, we need to implement a POST API that accepts a JSON payload containing the book details. Add the following method to the BookLibraryController class:

// In BookLibraryController.java
  @PostMapping
  @ResponseStatus(HttpStatus.CREATED)
  public Book addBook(@RequestBody Book book) {
      return bookLibraryService.addBook(book);
  }

We now create the Service method which will make the repository call to save the book.

// In BookLibraryService.java
  public Book addBook(Book book) {
      return bookLibraryRepository.save(book);
  }

When you try to send a POST request you will encounter the following SqlExceptionHelper error.

  2024-06-01T17:33:42.470+01:00 ERROR 68886 --- [javaSpringBootBookLibrary] [nio-8080-exec-2] o.h.engine.jdbc.spi.SqlExceptionHelper   : Unique index or primary key violation: "PRIMARY KEY ON PUBLIC.BOOK(ID) ( /* key:1 */ 1, 'Harper Lee', 'A gripping novel about racial injustice.', 'To Kill a Mockingbird')"; SQL statement:
insert into book (author,description,name,id) values (?,?,?,default) [23505-224]

This error occurs because even though we are asking the database to auto-generate the id, the id field in the Book class, we are filling it with a value in the data.sql file. This causes a conflict when we try to insert a new book. To resolve this, remove the id field from the data.sql file.

INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('To Kill a Mockingbird', 'Harper Lee', 'A gripping novel about racial injustice.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('Pride and Prejudice', 'Jane Austen', 'A classic romance novel.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('The Great Gatsby', 'F. Scott Fitzgerald', 'A story of the American dream gone wrong.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('Moby Dick', 'Herman Melville', 'A thrilling adventure of the whaling industry.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('The Catcher in the Rye', 'J.D. Salinger', 'A novel about teenage rebellion.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('The Hobbit', 'J.R.R. Tolkien', 'A fantasy adventure of a reluctant hero.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('Crime and Punishment', 'Fyodor Dostoevsky', 'A psychological drama about guilt and redemption.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('The Odyssey', 'Homer', 'An ancient epic of a hero''s journey home.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('The Adventures of Sherlock Holmes', 'Arthur Conan Doyle', 'Mysteries solved by the famous detective.');
INSERT INTO BOOK (NAME, AUTHOR, DESCRIPTION) VALUES ('Harry Potter and the Philosopher''s Stone', 'J.K. Rowling', 'The beginning of a young wizard''s journey.');

Re-run your app and re-send the POST request on Hoppscotch.io. You should see a success message with the newly created book details.

Update an Existing Book​

To update an existing book, we need to implement a PUT API that accepts the book id and the updated book details. Add the following method to the BookLibraryController class:

// In BookLibraryController.java
  @PutMapping(value = "/{id}")
  public ResponseEntity<Book> updateBook(@PathVariable int id, @RequestBody Book updatedBook) {
      Book updated = bookLibraryService.updateBook(id, updatedBook);
      return new ResponseEntity<>(updated, HttpStatus.OK);
  }

We now create the Service method which will make the repository call to update the book.

// In BookLibraryService.java
  public Book updateBook(int id, Book updatedBook) {
      if (updatedBook.getId() != id) {
          throw new RuntimeException("The ID in the request body does not match the ID in the URL.");
      }
      Optional<Book> optionalBook = bookLibraryRepository.findById(id);
      if (optionalBook.isPresent()) {
          Book existingBook = optionalBook.get();
          existingBook.setName(updatedBook.getName());
          existingBook.setAuthor(updatedBook.getAuthor());
          existingBook.setDescription(updatedBook.getDescription());
          return bookLibraryRepository.save(existingBook);
      } else {
          throw new RuntimeException(String.format("Book with id {%s} not found", id));
      }
  }

Delete a Book​

To delete a book, we need to implement a DELETE API that accepts the book id. Add the following method to the BookLibraryController class:

// In BookLibraryController.java
  @DeleteMapping(value = "/{id}")
  @ResponseStatus(HttpStatus.NO_CONTENT)
  public void deleteBook(@PathVariable int id) {
      bookLibraryService.deleteBook(id);
  }

We now create the Service method which will make the repository call to delete the book.

// In BookLibraryService.java
  public void deleteBook(int id) {
      bookLibraryRepository.deleteById(id);
  }

With that, we have successfully implemented the CRUD operations on the Book entity in our Java Spring Boot project.

In this blog post, we will cover the initial steps to set up a Java Spring Boot project using Gradle and IntelliJ IDEA. Spring Boot is a popular framework for building Java applications, providing a robust and efficient platform for developing web applications, RESTful APIs, and microservices.

• It is not possible to directly create a new Spring Boot application in IntelliJ IDEA Community Edition. However, you can create a new Spring Boot project using the Spring Initializr website and then import it into IntelliJ IDEA.

• Add the following dependencies as shown in the image below:

  • Spring Web: Provides tools and features to build web applications, including RESTful APIs, using Spring MVC.

  • Spring Data JDBC: Simplifies database access by providing a simple, lightweight approach to using JDBC with Spring, focusing on SQL queries.

  • Spring Data JPA: Eases database access by providing a repository abstraction layer on top of JPA (Java Persistence API) to simplify CRUD operations and data access patterns.

  • H2 Database: A fast, lightweight, in-memory relational database management system that is commonly used for development and testing purposes.

  • MySQL Driver: Enables Java applications to connect to and interact with MySQL databases by providing the necessary JDBC (Java Database Connectivity) implementation.

• After adding the dependencies, click on the Generate button to download the project as a zip file.

• Extract the downloaded zip file and open the project in IntelliJ IDEA.

• Run the DemoApplication file to start the project. By default, the project will run on port 8080.

• In the folder containing the DemoApplication file, create a new class named HelloWorld.
  • Annotate the HelloWorld class as a @RestController from the org.springframework.web.bind.annotation package.
  • In the HelloWorld class, create a method named helloWorld that returns a String "Hello World".
  • Annotate the method with @GetMapping and provide the path as "/hello".

• Run the project and navigate to http://localhost:8080/hello in your browser. You should see the message "Hello World" displayed on the screen.

Setup of a Book Library Project​

In this section, we will set up a Book Library project created with Java Spring Boot and Gradle, allowing us to perform CRUD operations on a collection of books. We will use an in-memory H2 database to store the book data.

• First, create a new project for the book library using Spring Initializr with the following dependencies:
  • Spring Web
  • Spring Data JDBC
  • Spring Data JPA
  • H2 Database
  • MySQL Driver

• Generate and extract the project, then open it in IntelliJ IDEA.

• In the src/main/resources/application.properties file, add the following configuration to use the H2 in-memory database:

spring.application.name=javaSpringBootBookLibrary

# H2 in-memory database. It can also be a file path.
spring.datasource.url=jdbc:h2:mem:testdb

spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# Defer the datasource initialization
spring.jpa.defer-datasource-initialization=true

# Always run the SQL scripts
spring.sql.init.mode=always

# Create and drop the tables on startup
spring.jpa.hibernate.ddl-auto=create-drop

# Enable H2 console
spring.h2.console.enabled=true

• Create the Book class to represent a book entity in the library. The Book class will have the following fields:

  • id of type int. Annotation @Id and @GeneratedValue to auto-generate the id.
  • name of type String
  • author of type String
  • description of type String

• Annotate the Book class with @Entity and @NoArgsConstructor to map it to the database table.

• Generate the getters and setters for the fields using the Generate option in IntelliJ IDEA.

• In the src/main/resources folder, create a new file named data.sql to insert some sample data into the book table. Add the following SQL script to insert books into the table:

INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (1, 'To Kill a Mockingbird', 'Harper Lee', 'A gripping novel about racial injustice.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (2, 'Pride and Prejudice', 'Jane Austen', 'A classic romance novel.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (3, 'The Great Gatsby', 'F. Scott Fitzgerald', 'A story of the American dream gone wrong.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (4, 'Moby Dick', 'Herman Melville', 'A thrilling adventure of the whaling industry.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (5, 'The Catcher in the Rye', 'J.D. Salinger', 'A novel about teenage rebellion.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (6, 'The Hobbit', 'J.R.R. Tolkien', 'A fantasy adventure of a reluctant hero.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (7, 'Crime and Punishment', 'Fyodor Dostoevsky', 'A psychological drama about guilt and redemption.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (8, 'The Odyssey', 'Homer', 'An ancient epic of a hero''s journey home.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (9, 'The Adventures of Sherlock Holmes', 'Arthur Conan Doyle', 'Mysteries solved by the famous detective.');
INSERT INTO BOOK (ID, NAME, AUTHOR, DESCRIPTION) VALUES (10, 'Harry Potter and the Philosopher''s Stone', 'J.K. Rowling', 'The beginning of a young wizard''s journey.');

• Run the project, and the H2 console can be accessed at http://localhost:8080/h2-console. The JDBC URL should be jdbc:h2:mem:testdb, and the username and password should be sa and password respectively.

Multi-threading in Java enables a single process to manage multiple threads concurrently, allowing tasks to be executed in parallel. This is achieved through the Thread class or the Runnable interface, empowering developers to create and oversee threads for parallel task execution.

Thread Class Example​

class MyThread extends Thread {
    public void run() {
        // Task to be performed concurrently
        System.out.println("Thread running..."); // Printing a message indicating that the thread is running
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread(); // Creating an instance of MyThread
        MyThread thread2 = new MyThread(); // Creating another instance of MyThread

        // Starting threads
        thread1.start(); // Starting the first thread
        thread2.start(); // Starting the second thread
    }
}

Race Condition​

However, multi-threading can introduce race conditions, where program behavior depends on the timing of events, such as the order in which threads execute instructions. This unpredictability may lead to unexpected outcomes as threads concurrently access and modify shared resources, risking data corruption and program state inconsistencies.

Race Condition Example​

class Counter {
    private int count = 0; // Initializing the counter

    // Method to increment the counter
    public void increment() {
        /**
         * Since this method is accessed by multiple threads (thread1 and thread2), there is a possibility that both threads may execute this line concurrently.
         * If both threads execute count++ at the same time, it can lead to a race condition where the final value of count may not be the expected result.
         * This is because both threads are reading the current value of count, incrementing it, and then writing the updated value back to count.
         * If these operations are not synchronized, the final result may be inconsistent due to interleaving of operations from different threads.
        */
        count++; // This operation leads to race condition
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter(); // Creating an instance of Counter

        // Creating multiple threads to increment the counter
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment(); // Incrementing the counter
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment(); // Incrementing the counter
            }
        });

        // Starting the threads
        thread1.start(); // Starting the first thread
        thread2.start(); // Starting the second thread

        // Waiting for threads to complete
        try {
            thread1.join(); // Waiting for the first thread to complete
            thread2.join(); // Waiting for the second thread to complete
        } catch (InterruptedException e) {
            e.printStackTrace(); // Handling InterruptedException
        }

        // Displaying the final count
        System.out.println("Final count: " + counter.getCount()); // Printing the final count
    }
}

Mitigating Race Conditions​

To mitigate race conditions in Java, synchronization mechanisms like locks, semaphores, and monitors are utilized. These mechanisms control access to shared resources, ensuring that only one thread can access and modify the resource at a time. By preventing simultaneous access and modification of shared resources, these measures diminish the likelihood of data corruption and enhance program reliability.

Lock Example​

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0; // Initializing the counter

    // Creating a lock for synchronization
    private Lock lock = new ReentrantLock(); // Creating a lock

    // Method to increment the counter using a lock
    public void increment() {
        lock.lock(); // Acquiring the lock
        try {
            count++; // Incrementing the counter
        } finally {
            lock.unlock(); // Releasing the lock
        }
    }

    // Method to get the current value of the counter
    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter(); // Creating an instance of Counter

        // Creating multiple threads to increment the counter
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment(); // Incrementing the counter
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment(); // Incrementing the counter
            }
        });

        // Starting the threads
        thread1.start();
        thread2.start();

        // Waiting for threads to complete
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Displaying the final count
        System.out.println("Final count: " + counter.getCount());
    }
}

Conclusion​

Multithreading and concurrency are crucial in Java for creating scalable and responsive apps. However, dealing with issues like race conditions requires careful attention. By using synchronization mechanisms, developers can handle these challenges and ensure their multithreaded apps run smoothly.

In languages like C/C++, managing memory manually is a crucial task for programmers. Forgetting to deallocate memory can lead to memory leaks and program crashes due to insufficient memory. However, Java provides an automatic memory management system known as the Garbage Collector (GC), which handles memory deallocation for you.

The garbage collection process operates within the JVM. Its job is to clean up heap memory by getting rid of objects that are no longer needed/referenced.

Therefore, memory occupied by an unreferenced object can be reclaimed. Programmers don't have to specify objects for deletion explicitly.

How to invoke the garbage collector?​

You can request the JVM to run the garbage collector using - System.gc() or Runtime.getRuntime().gc(). However, it's not guaranteed that the garbage collector will run immediately after calling these methods. The garbage collector runs when the JVM thinks it's necessary. Before an object is destroyed, the Garbage Collector triggers the finalize() method for cleanup. Once done, the Garbage Collector disposes of the object.

The finalize() method​

The finalize() method, found in the Object class, can be overridden for custom cleanup tasks like closing database connections. Although called by the Garbage Collector, it's part of the JVM. It's advised to override finalize() for resource disposal since the default implementation is empty. finalize() is only invoked once per object and ignores uncaught exceptions during execution.

How does the Garbage Collector work?​

Here's a simplified overview of how Java garbage collection works:

• Memory Allocation: When you create objects in Java using the new keyword, memory is allocated for those objects on the heap. The heap is the region of memory where Java objects are stored.

• Marking Phase: Java garbage collection uses a process called mark and sweep. During the marking phase, the garbage collector identifies which objects in the heap are still reachable, starting from the root objects (e.g., objects referenced by active threads, static variables, and local variables on the stack) and recursively marking all objects that are reachable from them. Any objects not marked as reachable are considered garbage.

• Sweeping Phase: In the sweeping phase, the garbage collector removes (sweeps) the memory occupied by the unreferenced objects, effectively reclaiming it for future use. This reclaimed memory becomes available for allocating new objects.

• Compacting (Optional): Some garbage collectors, such as the G1 Garbage Collector, may perform an optional compaction phase after marking and sweeping. Compaction rearranges the memory to reduce fragmentation, which can improve memory allocation efficiency and reduce memory usage.

• Finalization: Before an object is reclaimed by the Garbage Collector, it invokes the finalize() method if it's overridden. This method allows for any necessary cleanup operations to be performed. Once the finalize() method completes, the Garbage Collector proceeds to dispose of the object.

Types of Garbage Collectors​

There are several types of garbage collectors in Java, each designed to handle memory management differently. Here are some common types:

• Serial Garbage Collector:

  • Uses a single thread for garbage collection.
  • Suitable for applications with smaller heaps or those that prioritize low CPU usage.
  • Freezes the application thread during garbage collection.

• Parallel Garbage Collector (also known as the Throughput Collector):

  • Utilizes multiple threads to perform garbage collection tasks in parallel.
  • Significantly reduce pause times for large-scale applications.
  • Freezes the application thread during garbage collection, but it utilizes multiple threads to reduce the duration of the pause.

• CMS (Concurrent Mark-Sweep) Garbage Collector:

  • Aims to minimize pause times by running most of its operations concurrently with the application threads.
  • Suitable for applications where low latency is critical.
  • May still freeze the application briefly during certain phases.

• G1 (Garbage-First) Garbage Collector:

  • Engineered to achieve low pause times and high throughput, it divides the heap into smaller regions and prioritizes garbage collection on those regions with the most garbage, all while running concurrently with the application threads.
  • May still pause the application briefly during mixed garbage collection phases.

• Z Garbage Collector (ZGC):

  • Introduced in Java 11.
  • Scalable garbage collector designed for large heaps and low-latency applications.
  • Operates concurrently to the application threads.
  • Aims to minimize pause times without freezing the application thread for extended periods.

Conclusion​

Understanding Java's Garbage Collector is essential for Java developers to write efficient and reliable applications. With its automatic memory management capabilities, Java simplifies memory management and reduces the risk of memory-related issues.

References​

• Garbage Collection in Java

Java access modifiers are fundamental to Java's object-oriented nature, providing various levels of encapsulation by controlling access to classes, fields, methods, and constructors. Understanding these is crucial for designing secure, well-structured, and maintainable Java applications. Here's a more detailed dive into each of the Java access modifiers:

No Modifier (Default Access)​

• Scope: Accessible within the same package only.
• Usage Context: Used when you want to share data or methods among classes that are bundled together in the same package, without exposing them to the entire universe of your application.
• Example: If you have a class DefaultClass with default access in a package com.example, this class can be accessed by any other class within com.example but not outside of it.

class DefaultClass {
    int defaultVariable;
    void defaultMethod() {
        // Code...
    }
}

Private​

• Scope: Accessible within the class only.
• Usage Context: Typically used for utility methods or variables that are only meant to be used internally by the enclosing class. It's a way to hide the internal details and mechanics of a class.
• Example: Private member variables in a class are often used in conjunction with public getter and setter methods to provide controlled access (encapsulation).

class PrivateClass {
    private int privateVariable;
    private void privateMethod() {
        // Code...
    }

    public int getPrivateVariable() {
        return privateVariable;
    }

    public void setPrivateVariable(int privateVariable) {
        this.privateVariable = privateVariable;
    }
}

Protected​

• Scope: Accessible within the same package and by subclasses (even if they are located in different packages).
• Usage Context: Used when you want to hide a class, method, or field from other code except for subclasses, which might need to use or override the protected members.
• Example: In a class hierarchy, if a method in the superclass is marked as protected, then only subclasses (and other classes in the same package) can access it.

class ProtectedClass {
    protected int protectedVariable;
    protected void protectedMethod() {
        // Code...
    }
}

@override
class SubClass extends ProtectedClass {
    void subClassMethod() {
        protectedMethod(); // Accessible
    }
}

Public​

• Scope: Accessible from any other class.
• Usage Context: Used when you need to provide a broad access level. Typically, public access is used for API definitions, where you want to expose functionalities to the outside world.
• Example: Public methods or constants which are intended to be used by any other classes.

public class PublicClass {
    public int publicVariable;
    public void publicMethod() {
        // Code...
    }
}

Additional Notes​

• Class Level Access: Note that top-level Java classes (those not inner classes) can only be public or package-private (no access modifier). Inner classes, however, can also be private or protected.

• Constructors: Like methods and variables, constructors can also have access modifiers. For instance, a private constructor means that a class cannot be instantiated outside of its own context, a common pattern in singleton classes.

• Interface Methods: All methods in an interface are implicitly public, so when you implement an interface, the implementing methods must be declared public.

• Inheritance and Access Modifiers: Access levels affect how classes inherit from one another. For example, a subclass cannot narrow the access of a method it inherits (e.g., cannot override a public method with a protected one).

• Best Practices: It's considered good practice to make fields private unless there is a good reason not to. This encapsulation principle helps in maintaining the integrity of an object's state. Similarly, always use the least permissive access level necessary for functionality to enhance security and robustness.

Conclusion​

By using access modifiers sensibly, Java developers can ensure that their classes are used correctly and that internal data remains protected from unintended access and modification.

Data types in Java specify the size, type, and operations of data that can be stored in a variable. In Java, a statically-typed language, every variable must be declared with a data type. The data type of a variable determines how much space it occupies in memory and what kind of operations can be performed on it.

Java categorizes data types into primitive types, reference types, and wrapper classes.

Primitive Data Types​

Primitive data types are built-in Java types that are not objects; they represent raw values. They include:

1. byte: 8-bit signed integer
2. short: 16-bit signed integer
3. int: 32-bit signed integer
4. long: 64-bit signed integer
5. float: 32-bit floating-point number
6. double: 64-bit floating-point number
7. char: 16-bit Unicode character
8. boolean: true or false

byte exampleByte = 100;
short exampleShort = 5000;
int exampleInt = 123456;
long exampleLong = 12345678910L;
float exampleFloat = 3.14f;
double exampleDouble = 3.14159;
char exampleChar = 'A';
boolean exampleBoolean = true;

Reference Data Types​

Reference data types refer to objects and hence they are stored by reference. Examples include:

• Basic Reference Types:

  1. class: Holds a reference to a class.
  2. interface: A reference to an implemented interface.
  3. enum: A special data type that enables for variables to be a set of predefined constants.
  4. lambda: A reference to a lambda expression.
  5. String: A reference to a string.
  6. Runnable: A reference to a runnable object.
  7. Record: A reference to a record.

  // Class
  class ExampleClass {
      // Code...
  }

  // Interface
  interface ExampleInterface {
      // Code...
  }

  // Enum
  enum Size {SMALL, MEDIUM, LARGE}
  Size exampleSize = Size.MEDIUM;

  // Lambda
  Runnable exampleRunnable = () -> System.out.println("Running");

  // Lambda with parameters
  Comparator<Integer> exampleComparator = (a, b) -> a - b;

  // Lambda with return statement
  Function<Integer, Integer> exampleFunction = (a) -> {
      return a * a;
  };

  // String
  String exampleString = "Hello, World!";

  // Runnable
  Runnable exampleRunnable = () -> {
      // Code...
  };

  // Record
  record ExampleRecord(int id, String name) {
      // Code...
  }

• Collections and Iterators:

  1. array: A reference to a dynamically allocated array.
  2. List: A reference to a dynamically sized collection of elements.
  3. Map: A reference to a collection of key-value pairs.
  4. Set: A reference to a collection that contains no duplicate elements.
  5. Iterator: A reference to an object that enables traversal through a collection.

  // array
  int[] exampleArray = new int[5];

  // List
  List<String> exampleList = new ArrayList<>();

  // Map
  Map<String, Integer> exampleMap = new HashMap<>();

  // Set
  Set<String> exampleSet = new HashSet<>();

  // Iterator
  Iterator<String> exampleIterator = exampleList.iterator();

• Concurrency and IO:

  1. Thread: A reference to a thread of execution.
  2. Exception: A reference to an exception object.
  3. Annotation: A reference to an annotation.
  4. Socket: A reference to a network communication endpoint.
  5. File: A reference to a file or directory in the file system.
  6. Scanner: A reference to an object used to parse primitive types and strings from an input stream.

  // Thread
  Thread exampleThread = new Thread(() -> {
      // Code...
  });

  // Exception
  try {
      // Code...
  } catch (Exception e) {
      // Code...
  }

  // Annotation
  @interface ExampleAnnotation {
      // Code...
  }

  // Socket
  Socket exampleSocket = new Socket("localhost", 8080);

  // File
  File exampleFile = new File("example.txt");

  // Scanner
  Scanner exampleScanner = new Scanner(System.in);

Wrapper Classes​

Java also provides a set of wrapper classes that correspond to the primitive data types. These wrapper classes are used to create objects from primitive data types, and to perform operations on primitive data types. The wrapper classes are:

1. Byte: Wrapper class for byte
2. Short: Wrapper class for short
3. Integer: Wrapper class for int
4. Long: Wrapper class for long
5. Float: Wrapper class for float

Byte exampleWrappedByte = 100;
Short exampleWrappedShort = 5000;
Integer exampleWrappedInt = 123456;
Long exampleWrappedLong = 12345678910L;
Float exampleWrappedFloat = 3.14f;
Double exampleWrappedDouble = 3.14159;
Character exampleWrappedChar = 'A';
Boolean exampleWrappedBoolean = true;

Autoboxing is the automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes. For example, converting an int to an Integer, a double to a Double, etc. Similarly, unboxing is the reverse process:

// Autoboxing
Integer autoBoxedInt = 10; // int to Integer

// Unboxing
int unboxedInt = autoBoxedInt; // Integer to int

Differences Between Primitive and Wrapper Classes​

Conclusion​

In this article, we discussed the different data types and access modifiers in Java. We learned about primitive types, reference types, and wrapper classes, and how they differ from each other. We also explored the four access modifiers in Java and their use cases. Understanding these concepts is essential for writing efficient and secure Java code.

This guide is a collection of resources to prepare for Java interviews.

2. The guide had lots of useful links that really helped me grasp the concepts.

3. Installing Android Studio was easy, and its templates made setting up my first project quick, which was great for a beginner like me.

4. I finished the entire guide in one day, which shows how good the instructions were.

5. Coming from using React for frontend, using XML for UI felt a bit odd to me, but I'm going to explore alternative ways to style the UI. I came across Jetpack Compose a lot, which I'm going to check out next.

6. I had a small issue with the app name not showing, maybe because of using a different Android version or template for Java, but my app worked well on the emulator without any major problems.

A demo of the app -

Launch the Command Prompt (cmd) terminal and navigate to the directory where the chrome.exe is situated.

Typically, it can be found in either the Program Files or Program Files (x86) directories. Executing the following commands will initiate a new Chrome window with the security policy disabled:

C:\Users\shahpreetk> cd C:\Program Files\Google\Chrome\Application

⁠
C:\Program Files\Google\Chrome\Application> chrome.exe --user-data-dir="C:/temp/chrome" -—disable-web-security 

OR

C:\Users\shahpreetk> cd C:\Program Files (x86)\Google\Chrome\Application

⁠
C:\Program Files (x86)\Google\Chrome\Application\> ⁠ chrome.exe --user-data-dir="C:/temp/chrome" --disable-web-security ⁠

For Mac, you can achieve the same testing setup with the following commands:

• To open a new Chrome session/window with CORS disabled:

open -na "Google Chrome" --args --user-data-dir=/tmp/temporary-chrome-profile-dir --disable-web-security

• To open a new Chrome tab in an open Chrome session/window with CORS disabled:

open -a "Google Chrome" --args --disable-web-security --user-data-dir

0. Sign up for a Linode account

1. Click on Create Linode

2. Choose Ubuntu LTS for the distribution

3. Choose a Region closest to you

4. In the Linode Plan section, choose Shared CPU and then choose Nanode 1GB.

5. Create a Root Password

6. Add an SSH key or choose one from your existing keys

7. Click Create Linode

8. Wait for the Linode to show Running

9. Copy the Linode SSH Access, paste it in the terminal and run it

10. When it prompts you asking -> "Are you sure you want to continue connecting (yes/no/fingerprint)?", type "yes"

11. Now, run the following commands ->

        apt-get update
        apt-get upgrade
        apt-get install npm
        npm i -g n
        n install lts
        exit
    

12. Restart the server by entering your SSH Access. The server will now be using the latest node version

13. Make sure your latest project code is pushed to a GitHub repository.

14. Create a SSH key on your server and copy and upload to GitHub.

15. Git clone the repository using SSH.

16. cd into your project and run npm install

17. (optional) If you want to copy the .env file from your local machine to the remote server, run the following command: scp <location_of_file_in_local_machine>/.env root@<server_ip_address>:~/<location_of_project> You can add a -r flag to the command to copy an entire folder.

18. Run the node project to ensure it's running correctly.

19. Then run the following commands:

npm i -g pm2 // install pm2
pm2 start <entry_file_name>.js -n <project_name> // start the project
pm2 startup ubuntu // to restart API by itself, in case of crash
apt-get install nginx // install nginx for reverse-proxy
cd ~/etc/nginx/sites-available
nano default

20. In this file make the following changes:

    • a. At "server*name *;" replace the underscore with your domain name(with and without www prefix) or server IP address.

    • b. In the "location /" block, remove the existing code and add the following:

      location / {
      proxy_pass http://localhost:5000;
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection 'upgrade';
      proxy_set_header Host $host;
      proxy_cache_bypass $http_upgrade;
      }
      

    • c. [Ctrl] + S to save the file. [Ctrl] + X to exit the file.

21. Run nginx -t to check if the changes are correct.

22. Restart nginx by running systemctl restart nginx.

23. cd ~ and then ufw enable to enable the firewall.

24. Run ufw allow ssh, ufw allow http and ufw allow https to allow using these methods through the firewall. The firewall restricts access trough other ports like 5000.

25. Run snap install --classic certbot to install the Let's Encrypt certificate manager.

26. Run ln -s /snap/bin/certbot /usr/bin/certbot to link the certificate manager to the /usr/bin/certbot folder.

27. Setup Domain on Linode by ->

    1. Go to Domains tab in sidebar.
    2. Create a new domain.
    3. In the "Domain" section, type the domain name.
    4. Provide an email address.
    5. In Insert Default Records, select Insert Default Records from one of my Linodes
    6. Select the Linode you want to use.
    7. Click Create Domain
    8. Copy the NS(name servers) and add them to your domain name provider (example: namecheap) as Custom DNS
    9. Click Save
    10. Check if your domain (without https) now shows your project.

28. Run certbot --nginx

29. (optional) Run certbot renew --dry-run to check if the SSL certificate gets renewed successfully.

30. Reload your domain to check if it is now secure.

You have now successfully deployed your project to a Linode with a SSL certificate.

References​

• Creating and Using SSH keys

In the terminal, navigate to the root of your project and follow the steps below:

npm install -g heroku
heroku login
heroku apps:create <project_name> // Example, heroku apps:create vikhyaat
git push heroku main

You can now access your backend on https://<project_name>.herokuapp.com

Example, https://vikhyaat.herokuapp.com/

References​

• Deploying Node.js Apps on Heroku

{
  background: black;
  overflow: hidden;
  background: -webkit-linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)),url("<IMAGEURL_COMES_HERE>");
  object-fit: cover;
}

References​

• Overlay with JavaScript

/Users/<username>/mongodb/bin/mongod --dbpath=/Users/<username>/mongodb-data

Example of terminal command to start MongoDB local connection with MongoDB Compass in macOS:

/Users/preetshah/mongodb/bin/mongod --dbpath=/Users/preetshah/mongodb-data

This command takes you to the MongoDB path and starts the MongoDB server.

References​

• Installing MongoDB on macOS

cd <folder_name>
code .

Alternatively, you can use the following command to open the folder in an Open VSCode window:

code . -r

References​

• VSCode Core CLI options

Originally, when requesting a Strapi API endpoint, you can only get the information of the table you requested without the information of tables it is related to.

In order to get the details of tables joined to the requested table, you can try requesting the endpoint by using - http://localhost:1337/api/tablename?populate=*

Example: If you have a supplier to whom you owe many payments and wish to see the payments information in the supplier information, you can request this link --> http://localhost:1337/api/suppliers?populate=*

So populate here, populates the API with relations, components or dynamic zones.

References​

• Strapi Documentation

git log // copy the commit reference you like to go back to from the log
git reset <commit_ref> // reset git to the commit reference
git stash // stash/store the local changes from the wrong commit if you want to keep the commit changes
git push -f // push the changes to remote repository, (-f or --force)
git stash apply // get back the stored changes to local repository
git add . // if you have untracked/new files in the changes, you need to add them to git
git commit -m '<your_commit_message>' // commit the changes

References​

• How can I remove a commit on GitHub?

Streamlining Image Handling in React:

One common method involves creating an assets/images folder within your src directory and importing images throughout your project. However, optimizing this process can further enhance performance.

Using the Public Folder for Images (or Files):

1. Create an assets or images folder in your project's public directory.
2. Store your images/files here for easy access.
3. Within React components, reference images directly using /assets/<image_name> in the src attribute.

Optimizing Image Size:

Utilize tools like TinyPNG to compress image files while maintaining quality. This reduces load times and enhances user experience, contributing to improved overall performance.

References​

• Storing images in react

1. Install gh-pages as a dev depedency: npm install -D gh-pages
2. In package.json add the following in scripts:

"predeploy": "npm run build",
"deploy": "gh-pages -d build",
"build": "react-scripts build && cp build/index.html build/404.html",

3. Run npm run deploy to deploy the site to GitHub Pages.

NOTE: On Windows cmd, it will be copy instead of cp.

References​

• Creating a GitHub Pages site