Spring Boot: Best Practices for Scalable Applications

1. Generate a Spring Boot Project: Use Spring Initializr to generate a new Spring Boot project. Select the necessary dependencies. In our example, we will add these dependencies: Spring Web, Spring Data JPA, and H2 Database.
2. Import the Project into Your IDE: Open your favorite IDE (IntelliJ IDEA, Eclipse, etc.) and import the Spring Boot project.
3. Create a Simple REST Controller: Create a simple REST controller to test your setup. Create a new Java class `HelloController.java` :

   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class HelloController {
   
     @GetMapping("/hello")
     public String sayHello() {
     return "Hello World";
     }
   }

   Copy code snippet
   
4. Run the Spring Boot Application: Run your Spring Boot application. You can do this from your IDE
   
   or by using the command line:

   ./mvnw spring-boot:run

5. Test the Endpoint: Open your browser and navigate to http://localhost:8080/hello to see the message "Hello World".

1. Layered Architecture: This traditional approach separates the project into layers (controller, service, repository, model), ensuring a clear separation of concerns. Each layer has a specific responsibility, making the codebase more organized and easier to maintain.
   
2. Package by Feature: Organizes code by feature rather than by layer. This structure makes it easier to find all related code for a specific feature in one place, which can be beneficial for developing and scaling larger applications.
   
3. Hexagonal Architecture (Ports and Adapters): Also known as the ports and adapters architecture, this structure separates the core business logic from the external systems (like databases and web frameworks). It promotes a more flexible and testable codebase by allowing easy swapping of external components without affecting the core logic.
   

1. Follow the Single Responsibility Principle

• The Single Responsibility Principle (SRP) is one of the SOLID principles of object-oriented design. It states that a class should have only one reason to change, meaning it should have only one job or responsibility.
• Applying SRP in your Spring Boot application ensures that your classes are more modular, easier to maintain, test, and extend.
• Example:

@Service
public class UserService {

  @Autowired
  private UserRepository userRepository;
    
  @Autowired
  private NotificationService notificationService;
    
    public User createUser(User user) {
      // validate user
      if (user.getName() == null || user.getEmail() == null) {
        throw new IllegalArgumentException("Invalid user data");
       }
        
     // save user to the database
     User savedUser = userRepository.save(user);
        
     // send notification
     notificationService.sendNotification(savedUser);
        
     return savedUser;
     }
}

In this example, UserService is responsible for user validation, saving the user, and sending notifications, which violates the SRP.

With SRP:-

// UserService.java
@Service
public class UserService {

  private final UserRepository userRepository;
  private final UserValidator userValidator;
  private final NotificationService notificationService;

  @Autowired
  public UserService(UserRepository userRepository, UserValidator userValidator, NotificationService notificationService) {
    this.userRepository = userRepository;
    this.userValidator = userValidator;
    this.notificationService = notificationService;
  }

    public User createUser(User user) {
      userValidator.validate(user);
      User savedUser = userRepository.save(user);
      notificationService.sendNotification(savedUser);
      return savedUser;
      }
  

  // UserValidator.java
  @Component
  public class UserValidator {

    public void validate(User user) {
      if (user.getName() == null || user.getEmail() == null) {
        throw new IllegalArgumentException("Invalid user data");
        }
    }
  }

  // NotificationService.java
  @Service
  public class NotificationService {

    public void sendNotification(User user) {
      // logic to send notification
    }
}

public class UserService {
 
  private UserRepository userRepository = new UserRepository(new ProductService(new OrderService()));
 
  public User createUser(User user) { 
    return userRepository.save(user); 
  } 
  }

@Service
public class UserService {
  private final UserRepository userRepository;

  @Autowired
  public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
    }

   public User createUser(User user) {
     return userRepository.save(user);
     }
}

   @Repository
   public class UserRepository {
     private final ProductService productService;

     @Autowired
     public UserRepository(ProductService productService) {
       this.productService = productService;
     }

     public User save(User user) {
       // Save user logic (commented)
       productService.processProduct(user.getProductId());
       return user;
       }
     }

   @Service
   public class ProductService {
     private final OrderService orderService;

   @Autowired
   public ProductService(OrderService orderService) {
     this.orderService = orderService;
     }

    public void processProduct(Long productId) {
      orderService.createOrder(productId);
      }
    }

     @Service
     public class OrderService {
       public void createOrder(Long productId) {
         // Order creation logic (commented)
         }
        }

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // toString method
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    // equals and hashCode methods
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) &&
                Objects.equals(name, user.name) &&
                Objects.equals(email, user.email);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, email);
    }
}

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
@Data
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

• Using Lombok, you can reduce the boilerplate code significantly:
• @Data: This Lombok annotation generates getters for all fields, setters for all non-final fields, toString(), equals(), and hashCode() methods, as well as a constructor that initializes all final fields.
• The code is more concise and easier to read, with Lombok handling the generation of repetitive methods.
• @Builder: Lombok's @Builder annotation implements the Builder pattern, allowing you to create complex objects step-by-step. It provides a fluent API for setting properties, which improves code readability and reduces the need for multiple constructors.

Example:

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class User {
  private Long id;
  private String name;
  private String email;
}

Copy code snippet


In this example, the @Builder annotation generates a builder for the User class, allowing you to create User instances with a fluent API:

User user = User.builder()
.id(1L)
.name("John Doe")
.email("john.doe@example.com")
.build();

Copy code snippet

• Other lombok annotations you can try out are @Getter, @Setter, @ToString, @EqualsAndHashCode, @NoArgsConstructor, @AllArgsConstructor, @RequiredArgsConstructor, etc

1. Define Custom Exceptions:- Custom exceptions provide specific error details and make the error handling code more readable.

public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

public class InvalidUserDataException extends RuntimeException {
    public InvalidUserDataException(String message) {
        super(message);
    }
}

Copy code snippet

2. Service Layer with Exception Throwing:- The service layer throws custom exceptions when specific conditions are met.

       @Service
       public class UserService {
   
       private final UserRepository userRepository;
   
       @Autowired
       public UserService(UserRepository userRepository) {
           this.userRepository = userRepository;
       }
   
       public User createUser(User user) {
           if (user.getName() == null || user.getEmail() == null) {
               throw new InvalidUserDataException("User data is invalid");
           }
           return userRepository.save(user);
       }
   
       public User getUserById(Long id) {
           return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("User not found"));
       }
   }

   Copy code snippet
   
3. Global Exception Handling with @ControllerAdvice:- @ControllerAdvice allows you to handle exceptions across the whole application in one global handling component.

       @ControllerAdvice
       public class GlobalExceptionHandler {
   
       @ExceptionHandler(UserNotFoundException.class)
       public ResponseEntity<String> handleUserNotFoundException(UserNotFoundException ex) {
           return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
       }
   
       @ExceptionHandler(InvalidUserDataException.class)
       public ResponseEntity<String> handleInvalidUserDataException(InvalidUserDataException ex) {
           return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
       }
   
       @ExceptionHandler(Exception.class)
       public ResponseEntity<String> handleGeneralException(Exception ex) {
           return new ResponseEntity<>("An error occurred: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
       }
   }

   Copy code snippet
   
4. Controller Layer:- The controller layer remains clean and focuses on handling HTTP requests and responses, while exceptions are handled by the global exception handler.

       @RestController
       @RequestMapping("/users")
       public class UserController {
   
       private final UserService userService;
   
       @Autowired
       public UserController(UserService userService) {
           this.userService = userService;
       }
   
       @PostMapping
       public ResponseEntity<User> createUser(@RequestBody User user) {
           User createdUser = userService.createUser(user);
           return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
       }
   
       @GetMapping("/{id}")
       public ResponseEntity<User> getUserById(@PathVariable Long id) {
           User user = userService.getUserById(id);
           return new ResponseEntity<>(user, HttpStatus.OK);
       }
   }

   Copy code snippet
   

This approach ensures that your application is robust, user-friendly, and maintainable.

@SpringBootTest
public class UserServiceTests {

  @Autowired
  private UserService userService;

  @MockBean
  private UserRepository userRepository;

  @Test
  public void testCreateUser() {
    User user = new User("John Doe");
    Mockito.when(userRepository.save(user)).thenReturn(user);
    
    User createdUser = userService.createUser(user);
    
    assertNotNull(createdUser.getId());
    assertEquals("John Doe", createdUser.getName());
  }
}

/**
 * Service for managing users.
 */
@Service
public class UserService {

  /**
   * Creates a new user.
   * @param user the user to create
   */
  public void createUser(User user) {
    // logic to create a user
  }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <scope>test</scope>
</dependency>

• Controller Test

// UserController.java
@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUserById(id));
    }
}

// UserControllerTest.java
@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testGetUserById() throws Exception {
        User user = new User(1L, "John Doe", "john.doe@example.com");
        Mockito.when(userService.getUserById(1L)).thenReturn(user);

        mockMvc.perform(MockMvcRequestBuilders.get("/users/1"))
               .andExpect(MockMvcResultMatchers.status().isOk())
               .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("John Doe"));
    }
}

Copy code snippet

• Explanation:
  • UserController.java: A simple REST controller that handles user-related requests.
  • UserControllerTest.java: Tests for the UserController class.
  • The test verifies that the getUserById endpoint returns the correct user data.
• Service Test

// UserService.java
@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

// UserServiceTest.java
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @MockBean
    private UserRepository userRepository;

    @Test
    public void testGetUserById() {
        User user = new User(1L, "John Doe", "john.doe@example.com");
        Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));

        User foundUser = userService.getUserById(1L);
        Assertions.assertEquals(user.getName(), foundUser.getName());
    }
}

Copy code snippet

• Explanation:
  • UserService.java: A service class that handles business logic for user-related operations.
  • UserServiceTest.java: Tests for the UserService class.
  • The test verifies that the getUserById method returns the correct user data.
• Repository Test

// UserRepositoryTest.java
@DataJpaTest
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindByEmail() {
        User user = new User("John Doe", "john.doe@example.com");
        userRepository.save(user);

        User foundUser = userRepository.findByEmail("john.doe@example.com");
        Assertions.assertNotNull(foundUser);
        Assertions.assertEquals(user.getEmail(), foundUser.getEmail());
    }
}

Copy code snippet

• Explanation:
  • UserRepositoryTest.java: Tests for the UserRepository interface.
  • The test verifies that the findByEmail method correctly retrieves user data based on the email address.

// UserControllerIntegrationTest.java
@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private UserRepository userRepository;

    @BeforeEach
    public void setUp() {
        userRepository.deleteAll();
        userRepository.save(new User("John Doe", "john.doe@example.com"));
    }

    @Test
    public void testGetUserById() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/users/1"))
               .andExpect(MockMvcResultMatchers.status().isOk())
               .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("John Doe"));
    }
}

// Use indexing in your entities
@Entity
@Table(indexes = @Index(name = "idx_name", columnList = "name"))
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Other fields, getters, and setters
}

@Service
public class UserService {

    @Cacheable("users")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users");
    }
}

@Service
public class EmailService {

    @Async
    public void sendEmail(String email) {
        // Simulate email sending
    }
}

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        return new SimpleAsyncTaskExecutor();
    }
}

• Tune application properties and JVM settings for optimal performance. Configuration tuning can include server settings, memory management, and compression settings.
• How It Works:
• Server Compression: Enabling compression for HTTP responses reduces the size of the data sent over the network.
• JVM Tuning: Adjust JVM settings such as heap size, garbage collection, and thread management for better performance.
• Configuration Properties: Fine-tune application-specific properties to optimize performance based on the application's requirements.
• Examples:
  • Server Compression:

    // application.yml
    server:
    compression:
    enabled: true
    mime-types: text/html, text/xml, text/plain, application/json, application/xml, text/css, text/javascript, application/javascript
    min-response-size: 1024

    Copy code snippet
    
    • server.compression.enabled=true: Enables HTTP response compression.
    • server.compression.mime-types: Specifies the MIME types that should be compressed.
    • server.compression.min-response-size: Defines the minimum response size (in bytes) that should be compressed.
  • JVM Tuning: JVM tuning parameters can be set in the startup scripts or as environment variables.

    -Xms512m -Xmx2g // Heap size management
    
    -XX:+UseG1GC -XX:MaxGCPauseMillis=200 // Garbage Collection
    
    -XX:ParallelGCThreads=4 -XX:ConcGCThreads=2 // Thread Management

    Copy code snippet
    
    • -Xms512m: Sets the initial heap size to 512 MB. -Xmx2g: Sets the maximum heap size to 2 GB.
    • -XX:+UseG1GC: Enables the G1 garbage collector, which is designed for applications with large heaps and aims for low pause times.
    • -XX:MaxGCPauseMillis=200: Sets the target for maximum GC pause time to 200 milliseconds.
    • -XX:ParallelGCThreads=4: Sets the number of threads used by the garbage collector for parallel work.
    • -XX:ConcGCThreads=2: Sets the number of threads used by the concurrent phase of the G1 garbage collector.
  • Configuration Properties: Adjusting application-specific properties can help optimize the performance of your application by fine-tuning various parameters based on your specific requirements and workload characteristics.
    • Database Connection Pooling:

    spring.datasource.hikari.maximum-pool-size=20
    spring.datasource.hikari.minimum-idle=5
    spring.datasource.hikari.idle-timeout=30000
    spring.datasource.hikari.max-lifetime=1800000

    Copy code snippet
    
  • spring.datasource.hikari.maximum-pool-size=20: Sets the maximum size of the connection pool to 20 connections.
  • spring.datasource.hikari.minimum-idle=5: Sets the minimum number of idle connections in the pool to 5.
  • spring.datasource.hikari.idle-timeout=30000: Sets the maximum idle time for a connection in the pool to 30 seconds.
  • spring.datasource.hikari.max-lifetime=1800000: Sets the maximum lifetime of a connection in the pool to 30 minutes.
  • Caching:

    spring.cache.type=caffeine
    spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s

    Copy code snippet
    
  • spring.cache.type=caffeine: Configures the cache type to use Caffeine, a high-performance caching library.
  • spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s: Sets the cache specification with a maximum size of 500 entries and an expiration time of 600 seconds after the last access.

• Steps to Enable Actuator:
  • Add Actuator Dependency:

  <dependency>
    <groupId>org.springframework.boot </groupId>
    <artifactId>spring-boot-starter-actuator </artifactId>
  </dependency>

  Copy code snippet
  
  • Expose Actuator Endpoints: Configure the endpoints you want to expose in your application.properties file:
  • Access Actuator Endpoints: Access the endpoints via URLs like http://localhost:8080/actuator/health.

• Steps to Set Up Logging:
  • Configure Logback: Create a logback-spring.xml file in the src/main/resources directory:

  <configuration>
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
    </encoder>
    </appender>
  
    <root level="info">
      <appender-ref ref="console" />
    </root>
  </configuration>

  Copy code snippet
  
  • Use SLF4J in Your Application:

  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.stereotype.Service;
  
  @Service
  public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
  
    public User getUserById(Long id) {
      logger.info("Fetching user with id: {}", id);
      // Fetch user logic
      }
  }

  Copy code snippet
  

• Prometheus: An open-source systems monitoring and alerting toolkit that collects and stores metrics as time series data.
• Add Prometheus Dependency:

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Copy code snippet

• Configure Prometheus Endpoint: In application.properties, enable Prometheus metrics collection and expose the endpoint:

management.metrics.export.prometheus.enabled=true
management.endpoints.web.exposure.include=prometheus

Copy code snippet

• Access Prometheus Metrics: Once configured, Prometheus metrics can be accessed at http://localhost:8080/actuator/prometheus. Prometheus scrapes this endpoint at regular intervals to collect metrics.
• Grafana: A popular open-source platform for monitoring and observability that integrates with Prometheus.
• Setup Grafana:
  • Download and Install: Download Grafana from the official site and follow the installation instructions.
  • Add Prometheus Data Source: In Grafana, add Prometheus as a data source using the URL of your Prometheus server (e.g., http://localhost:9090).
  • Create Dashboards: Use Grafana to create custom dashboards and visualizations based on the metrics collected by Prometheus.

• Elasticsearch: A distributed, RESTful search and analytics engine. Download and install Elasticsearch from the official site.
• Logstash: A server-side data processing pipeline that ingests data, transforms it, and sends it to Elasticsearch.
  • Configure Logstash to Read Logs: Create a configuration file (e.g., logstash.conf) to read Spring Boot logs and send them to Elasticsearch

  input {
  file {
    path => "/path/to/logs/app.log"
    start_position => "beginning"
    }
  }
  
  output {
    elasticsearch {
      hosts => ["http://localhost:9200"]
      index => "spring-boot-logs-%{+YYYY.MM.dd}"
      }
  }

  Copy code snippet
  
  • Run Logstash: Start Logstash with the configuration file

  logstash -f logstash.conf

• Kibana: A visualization tool that works with Elasticsearch.
• Setup Kibana: Download and install Kibana from the official site.
• Create Dashboards: Use Kibana to create visualizations and dashboards based on the data indexed in Elasticsearch.

• Setting Up SonarQube:
  • Download and Install SonarQube: Download SonarQube from the official website, extract it, and start the server.

  ./bin/{OS}/sonar.sh start

  • Install SonarScanner: Download and install SonarScanner from the official website.
• Configure SonarQube in Your Project:
• Add SonarQube Plugin in pom.xml:

<plugin>
  <groupId>org.sonarsource.scanner.maven</groupId>
  <artifactId>sonar-maven-plugin</artifactId>
  <version>3.9.1.2184</version>
  </plugin>

Copy code snippet

• Configure sonar-project.properties: Create a sonar-project.properties file in the root of your project.

sonar.projectKey=my_project
sonar.host.url=http://localhost:9000
sonar.login=my_sonar_token

Copy code snippet

• Running SonarQube Analysis:
  • Execute SonarQube Scan: Run the following command to analyze your project.

  mvn clean verify sonar:sonar

  • Review Results: Open SonarQube dashboard (http://localhost:9000), login, and navigate to your project to view the analysis results.
  

FROM openjdk:11-jre-slim

EXPOSE 8080

ARG JAR_FILE=target/*.jar

ADD ${JAR_FILE} app.jar

ENTRYPOINT ["java","-jar","/app.jar"]

docker build -t my-spring-boot-app .

docker run -p 8080:8080 my-spring-boot-app

FROM node:14-alpine as build

WORKDIR /app

COPY package.json ./
RUN npm install

COPY . .
RUN npm run build

FROM nginx:alpine

COPY --from=build /app/build /usr/share/nginx/html

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

docker build -t my-react-app .

docker run -p 80:80 my-react-app

version: '3'
services:
  backend:
    image: my-spring-boot-app
    ports:
      - "8080:8080"
  frontend:
    image: my-react-app
    ports:
      - "80:80"
version: '3'
services:
  backend:
    image: my-spring-boot-app
    ports:
      - "8080:8080"
  frontend:
    image: my-react-app
    ports:
      - "80:80"

docker-compose up -d

1. Deploying Spring Boot Application on AWS Elastic Beanstalk:

AWS Elastic Beanstalk is a service for deploying and managing applications in the AWS cloud without worrying about the infrastructure that runs those applications.

Steps:

• Create a WAR/JAR file

  mvn clean package

• Go to the AWS Management Console, navigate to Elastic Beanstalk, and create a new environment.
• During environment creation, upload the generated WAR/JAR file.
• Set up environment variables, instance types, and other configurations as needed.
• Once the environment is set up, Elastic Beanstalk will deploy your application and manage the resources.
2. Deploying React Application on AWS S3 and CloudFront:

   AWS S3 and CloudFront can be used to host and deliver your React application.

   Steps:

   • Build the React Application

     npm run build

   • Go to the AWS Management Console, create an S3 Bucket
   • Upload the contents of the build directory to the S3 bucket.
   • Configure the bucket policy to make the files publicly accessible.
   • Navigate to CloudFront, create a new distribution, and point it to your S3 bucket.
   • Your React application will be accessible via the CloudFront distribution URL.

name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout Repository
      uses: actions/checkout@v2

    - name: Set up JDK 11
      uses: actions/setup-java@v1
      with:
        java-version: 11

    - name: Build Spring Boot App
      run: mvn clean install
      working-directory: ./backend

    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: 14

    - name: Install Dependencies and Build React App
      run: |
        npm install
        npm run build
      working-directory: ./frontend

    - name: Deploy to DockerHub
      run: |
        echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
        docker build -t my-spring-boot-app ./backend
        docker build -t my-react-app ./frontend
        docker push my-spring-boot-app
        docker push my-react-app

1. Create a ‘.git/hooks’ directory in your repository
2. Add a Pre-commit Hook by creating a file named ‘pre-commit’ inside the ‘.git/hooks’ directory and add the following script:

#!/bin/sh
npm run lint
if [ $? -ne 0 ]; then
  echo "Linting failed. Please fix the issues before committing."
  exit 1
fi

Copy code snippet

3. Make the Hook Executable

chmod +x .git/hooks/pre-commit