DEV Community: bseayin

Practical Implementation of the Observer Pattern: Elegant Update Mechanism in Spring Boot

bseayin — Sun, 21 Jul 2024 14:37:24 +0000

Practical Implementation of the Observer Pattern: Elegant Update Mechanism in Spring Boot

Introduction

In numerous application systems, we often encounter the challenge of synchronizing updates across multiple related tables. For instance, in an educational management system, when the age field in the student's personal information table changes, we might also need to update corresponding records in the student's profile and academic achievement tables. This article will present a concrete case study on how to utilize the Observer Pattern in a Spring Boot project to address this requirement gracefully.

Overview of the Observer Pattern

The Observer Pattern is a software design pattern that establishes a one-to-many relationship among objects, ensuring that all dependents are notified and automatically updated when the state of an object changes. Within the Spring framework, the Observer Pattern is typically implemented through event-driven mechanisms.

Case Scenario

Let us consider a Spring Boot project for an educational management system, encompassing three primary data tables:

Students Table: Stores personal details of students, including age.
Student Records Table: Maintains records of student profiles.
Student Scores Table: Keeps track of student academic scores.

Our objective is to automatically trigger updates in the student records and scores tables when the age field in the students table is modified.

Technology Stack

Java 11
Spring Boot 2.x
Spring Data JPA

Implementation Steps

Step 1: Define the Event

Initially, we need to create an event class that signifies the update of a student's age.

import org.springframework.context.ApplicationEvent;

public class StudentAgeUpdateEvent extends ApplicationEvent {

    private static final long serialVersionUID = 1L;

    private final Long studentId;
    private final int newAge;

    public StudentAgeUpdateEvent(Object source, Long studentId, int newAge) {
        super(source);
        this.studentId = studentId;
        this.newAge = newAge;
    }

    public Long getStudentId() {
        return studentId;
    }

    public int getNewAge() {
        return newAge;
    }
}

Step 2: Create Listeners

Subsequently, we must establish two listener classes to monitor the StudentAgeUpdateEvent and update the student records and scores tables upon the event's occurrence.

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class StudentRecordUpdater implements ApplicationListener<StudentAgeUpdateEvent> {

    private final StudentRecordRepository studentRecordRepository;

    public StudentRecordUpdater(StudentRecordRepository studentRecordRepository) {
        this.studentRecordRepository = studentRecordRepository;
    }

    @Override
    public void onApplicationEvent(StudentAgeUpdateEvent event) {
        Long studentId = event.getStudentId();
        int newAge = event.getNewAge();

        // Update the student records table
        studentRecordRepository.updateAge(studentId, newAge);
    }
}

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class StudentScoreUpdater implements ApplicationListener<StudentAgeUpdateEvent> {

    private final StudentScoreRepository studentScoreRepository;

    public StudentScoreUpdater(StudentScoreRepository studentScoreRepository) {
        this.studentScoreRepository = studentScoreRepository;
    }

    @Override
    public void onApplicationEvent(StudentAgeUpdateEvent event) {
        Long studentId = event.getStudentId();
        int newAge = event.getNewAge();

        // Update the student scores table
        studentScoreRepository.updateAge(studentId, newAge);
    }
}

Step 3: Publish the Event

Within the student service layer, we need to publish the StudentAgeUpdateEvent after an age field update.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class StudentService {

    private final ApplicationEventPublisher eventPublisher;

    @Autowired
    public StudentService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void updateStudentAge(Long studentId, int newAge) {
        // Update the student's age in the database
        // ...

        // Publish the event
        eventPublisher.publishEvent(new StudentAgeUpdateEvent(this, studentId, newAge));
    }
}

Step 4: Transaction Management

To ensure data consistency and integrity, we should include the @Transactional annotation in the StudentService to guarantee that all update operations occur within a single transaction.

import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class StudentService {
    // ... previous code ...

    public void updateStudentAge(Long studentId, int newAge) {
        // ... previous code ...
    }
}

By employing the Observer Pattern in this manner, we can create a robust and scalable solution for managing data synchronization across related tables in a Spring Boot application. This technique not only simplifies the codebase but also enhances the reliability and efficiency of the system by leveraging Spring's built-in event handling capabilities.

Advanced Techniques in Spring Boot: Mastering Modern Application Development

bseayin — Sun, 21 Jul 2024 14:04:08 +0000

Advanced Techniques in Spring Boot: Mastering Modern Application Development

Introduction

Spring Boot has revolutionized the way we develop enterprise applications by providing a powerful framework that simplifies the setup and configuration of complex systems. Beyond the basics of auto-configuration and dependency management, there are several advanced features that can elevate your development experience and enhance the performance, scalability, and maintainability of your applications. In this blog post, we will explore some of these advanced techniques that can take your Spring Boot applications to the next level.

1. Customizing Actuator Endpoints

Spring Boot Actuator provides production-ready features to monitor and manage your application. By default, it exposes several endpoints such as /health, /info, and /metrics. You can customize these endpoints and even create your own to expose specific metrics or perform custom operations.

Example:

@Configuration
public class CustomEndpointConfiguration implements EndpointDiscoverer {

    @Override
    public Set<Endpoint<?>> getEndpoints() {
        return Collections.singleton(new MyCustomEndpoint());
    }

    private static class MyCustomEndpoint implements Endpoint<Object> {
        @Override
        public Object invoke() {
            // Your logic here
            return "Custom response";
        }

        @Override
        public String getId() {
            return "mycustom";
        }
    }
}

2. Using Profiles for Environment-Specific Configurations

Profiles allow you to define different configurations based on the environment (development, testing, production). You can activate profiles through the -Dspring.profiles.active=profileName command-line option or via the application.properties file.

Example:

# application-dev.properties
server.port=8081

# application-prod.properties
server.port=8080

3. Leveraging Aspect-Oriented Programming (AOP)

AOP allows you to modularize cross-cutting concerns such as logging, security, and transaction management. Spring Boot supports AOP through Spring AOP and AspectJ.

Example:

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayerExecution() {}

    @Before("serviceLayerExecution()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Executing: " + joinPoint.getSignature());
    }
}

4. Implementing Reactive Programming

Spring Boot supports reactive programming through the WebFlux module, allowing you to write non-blocking, event-driven applications.

Example:

@RestController
@RequestMapping("/flux")
public class FluxController {

    @GetMapping(value="/numbers", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<Long> numbersFlux() {
        return Flux.range(1, 10);
    }
}

5. Enhancing Security with Spring Security

Spring Security provides comprehensive security services for securing web and mobile applications. You can configure authentication, authorization, and other security features easily.

Example:

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
            .and()
            .formLogin();
    }
}

6. Building Microservices with Spring Cloud

Spring Cloud provides tools for building microservices architectures, including service discovery, load balancing, circuit breakers, and more.

Example:

Add Spring Cloud dependencies to your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

7. Streamlining Deployment with Docker

Docker containers can simplify deployment and ensure consistency across environments. Spring Boot applications can be easily packaged into Docker images.

Example Dockerfile:

FROM openjdk:8-jdk-alpine
COPY target/myapp.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Conclusion

Mastering these advanced techniques can significantly improve the quality and efficiency of your Spring Boot applications. Whether you're enhancing monitoring capabilities, securing your application, or optimizing deployment strategies, Spring Boot offers a rich set of features to meet your needs. As you continue to develop with Spring Boot, remember to stay updated with the latest best practices and community guidelines to leverage the full potential of the framework. Happy coding!

Implementing Excel Reading into List> in Java

bseayin — Sun, 21 Jul 2024 08:41:08 +0000

Reading an Excel File into a List of Maps Using Java

Introduction

In the world of data manipulation and analysis, Excel files remain a staple format for storing tabular data. Whether you're dealing with financial reports, customer information, or any other kind of structured data, being able to efficiently read and process Excel files is crucial. In this blog post, we will explore how to read an Excel file (.xlsx) using Java and convert its contents into a List<Map<String, String>>, which is a flexible structure that can be easily integrated into various parts of your application.

Prerequisites

Before we dive in, ensure you have the Apache POI library added to your project. If you're using Maven, add the following dependency to your pom.xml:

<!--        excel reader-start-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>5.2.2</version> <!-- 使用你所需的版本号 -->
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>5.2.2</version> <!-- 同上 -->
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.17.1</version> <!-- 使用你所需要的版本 -->
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.17.1</version> <!-- 同上 -->
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version> <!-- 使用你需要的版本 -->
        </dependency>
    <!--        excel reader-end -->

Step-by-Step Guide

Let's break down the process into manageable steps:

Import Necessary Packages

Start by importing the necessary packages from Apache POI.

   import org.apache.poi.ss.usermodel.*;
   import org.apache.poi.xssf.usermodel.XSSFWorkbook;
   import java.io.File;
   import java.io.FileInputStream;
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;

Define the Read Method

Create a method to read the Excel file and return the data as a list of maps.

   public static List<Map<String, String>> readExcelFile(String filePath) throws Exception {
       List<Map<String, String>> dataList = new ArrayList<>();
       try (FileInputStream fis = new FileInputStream(new File(filePath));
            Workbook workbook = new XSSFWorkbook(fis)) {

           Sheet sheet = workbook.getSheetAt(0); // Assuming the first sheet contains the data
           Row headerRow = sheet.getRow(0); // First row as headers

           for (int rowIndex = 1; rowIndex <= sheet.getLastRowNum(); rowIndex++) {
               Row row = sheet.getRow(rowIndex);
               if (row == null) continue; // Skip empty rows

               Map<String, String> rowMap = new HashMap<>();
               for (Cell headerCell : headerRow) {
                   int colIndex = headerCell.getColumnIndex();
                   Cell dataCell = row.getCell(colIndex);
                   String header = headerCell.getStringCellValue();
                   String value = "";

                   if (dataCell != null) {
                       switch (dataCell.getCellType()) {
                           case STRING:
                               value = dataCell.getStringCellValue();
                               break;
                           case NUMERIC:
                               if (DateUtil.isCellDateFormatted(dataCell)) {
                                   value = dataCell.getDateCellValue().toString();
                               } else {
                                   value = String.valueOf(dataCell.getNumericCellValue());
                               }
                               break;
                           case BOOLEAN:
                               value = String.valueOf(dataCell.getBooleanCellValue());
                               break;
                           default:
                               // Handle other cell types if needed
                               break;
                       }
                   }
                   rowMap.put(header, value);
               }
               dataList.add(rowMap);
           }
       }
       return dataList;
   }

Testing the Functionality

Test the functionality by calling the read method and printing the result.

   public static void main(String[] args) {
       try {
           List<Map<String, String>> data = readExcelFile("path/to/your/excel/file.xlsx");
           System.out.println(data);
       } catch (Exception e) {
           e.printStackTrace();
       }
   }

Conclusion

By following these steps, you can effectively read Excel files in Java and convert them into a List<Map<String, String>> format. This approach provides a solid foundation for further data processing, such as filtering, sorting, or integrating the data into databases or other systems. Remember to always handle exceptions gracefully and validate your input to ensure robustness in your applications.
source code: https://github.com/bseayin/ProgrammingArsenal2/blob/main/src/main/java/com/xsz/programmingarsenal/utils/ExcelReader.java

Happy coding!