Forem: Code Reacher

From Spring Boot to Python Backend with Docker + React: My First Fullstack Project Experience

Code Reacher — Tue, 22 Apr 2025 12:51:34 +0000

As a Java Spring Boot developer, I recently challenged myself to build a fullstack app using Python (FastAPI) for the backend and ReactJS for the frontend—containerized using Docker.

What I Built
A simple user dashboard with:

React frontend (UI)
FastAPI backend (Python)
MongoDB database
All services containerized with Docker Compose

Challenges Faced & How I Solved Them
1. Docker Build Failures
Problem:
React build was failing due to missing environment variables and node_modules not being copied correctly in Dockerfile.

Solution:
Updated the Dockerfile with proper steps:

# Dockerfile for React
FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
CMD ["npm", "start"]

2. CORS Issues
Problem:
React app couldn’t connect to FastAPI backend due to CORS errors.

Solution:
Enabled CORS in FastAPI:

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # Replace with actual domain in production
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

3. Docker Networking
Problem:
React tried to access backend using localhost:8000, which failed inside Docker.

Solution:
Used Docker service name (e.g., backend:8000) instead of localhost. Updated API calls in React to hit the backend through the Docker network.
My Final Docker Compose Setup

version: '3.8'

services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    depends_on:
      - backend

  backend:
    build: ./backend
    ports:
      - "8000:8000"
    environment:
      - MONGO_URI=mongodb://mongo:27017/mydb
    depends_on:
      - mongo

  mongo:
    image: mongo
    ports:
      - "27017:27017"

What I Learned

Dockerizing apps requires understanding networking, volumes, build context.
CORS is a common issue with frontend-backend interactions.
Python + React is a lightweight alternative to Java Spring Boot apps.

References

Conclusion
While Spring Boot is amazing for large-scale enterprise apps, exploring Python + Docker gave me a new perspective on speed and flexibility. Let me know if you're trying the same!

Diving into Spring Web Services (Spring-WS): Contract-First SOAP Service Development

Code Reacher — Wed, 16 Apr 2025 03:14:44 +0000

Spring Web Services (Spring-WS) is a robust framework focused on creating document-driven web services using a contract-first approach. By adhering to the principles of SOAP and XML payloads, Spring-WS enables flexible service development while leveraging core Spring features like dependency injection.

In this post, we’ll take an in-depth look at Spring-WS, explore common issues encountered during development, and provide practical solutions and code examples to build and secure contract-first SOAP services.

What is Spring Web Services (Spring-WS)?
Spring-WS is designed for:

**Contract-first SOAP service development: **Begin with a WSDL/XML schema and generate your service artifacts accordingly.
Document-driven services: Emphasizes creating flexible web services centered around XML payloads.
Spring integration: All Spring concepts, such as dependency injection and AOP, are integrated to streamline development.

Why Choose a Contract-First Approach?
With contract-first development, you define your service contract (WSDL and XML schema) upfront. This approach ensures:

Clarity in communication between service providers and consumers.
Interoperability across different systems and platforms.
Stronger contracts that reduce misinterpretation of service functionalities.

Common Issues in Spring-WS Projects and Their Solutions
1. Issue: Complex XML Manipulation
Problem:
Handling and validating complex XML payloads can be challenging, especially when services require frequent schema updates.

Solution:

Use JAXB for XML binding. It can automatically map XML elements to Java objects.
Schema Validation: Configure your endpoints to validate XML payloads against your XSD.

Example:

@Endpoint
public class ProductEndpoint {

    private static final String NAMESPACE_URI = "http://www.example.com/schemas/products";

    @PayloadRoot(namespace = NAMESPACE_URI, localPart = "getProductRequest")
    @ResponsePayload
    public GetProductResponse getProduct(@RequestPayload GetProductRequest request) {
        GetProductResponse response = new GetProductResponse();
        // Map your response data here
        return response;
    }
}

In your Spring configuration, ensure to define the Jaxb2Marshaller:

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
    <property name="contextPath" value="com.example.schemas.products" />
</bean>

2. Issue: Version and Contract Drift
Problem:
When the service contract changes (e.g., updated XSD), keeping the implementation in sync can become error-prone.

Solution:

Automate WSDL Generation: Use Maven plugins or Spring Boot starters to generate WSDLs from your XSDs dynamically.
Versioning: Adopt a versioning strategy in your URLs or namespaces (e.g., /v1/products) to allow changes without breaking existing clients.
Contract Testing: Implement contract tests (e.g., using SoapUI or Spring Cloud Contract) to ensure your service stays compliant with the defined contract.

3. Issue: Handling SOAP Faults and Errors
Problem:
Unclear or unstructured SOAP fault messages can confuse client applications and hinder troubleshooting.

Solution:

Custom Exception Handling: Leverage Spring-WS’s capability to map exceptions to SOAP faults.
Define a Fault Resolver:

@Component
public class CustomSoapFaultMappingExceptionResolver extends SoapFaultMappingExceptionResolver {
    @Override
    protected SoapFaultDefinition getFaultDefinition(Object endpoint, Exception ex) {
        SoapFaultDefinition definition = new SoapFaultDefinition();
        definition.setFaultCode(SoapFaultDefinition.SERVER);
        definition.setFaultStringOrReason("An unexpected error occurred: " + ex.getMessage());
        return definition;
    }
}

Ensure your resolver is registered in the Spring configuration so that all exceptions are translated into meaningful SOAP fault responses.

4. Issue: Configuring Endpoint Security
Problem:
Exposing your SOAP endpoints without proper security can lead to unauthorized access and data leaks.

Solution:

Secure your endpoints using Spring Security: **Configure security filters to restrict access to sensitive SOAP operations.
**Example Configuration:

<http security="none" pattern="/ws/**"/>

Then apply custom security to those endpoints using interceptors or filters based on your organization’s needs.

WS-Security: Consider implementing WS-Security standards (e.g., username tokens, digital signatures) for additional SOAP message-level security.

Best Practices for Building Robust Spring-WS Applications

Keep contracts stable: Document your WSDLs and schemas rigorously and leverage automated tools to keep them updated.
Validate rigorously: Always validate incoming XML against the schema to catch errors early.
Implement comprehensive exception handling: Translate Java exceptions into informative SOAP faults.
Secure your endpoints: Use Spring Security and WS-Security to protect your services from unauthorized access.
Monitor and log effectively: Integrate with logging and monitoring tools to track and resolve issues rapidly.

References

Final Thoughts
Spring Web Services (Spring-WS) empowers developers to build flexible, contract-first SOAP services. By addressing common issues—such as complex XML manipulation, version drift, SOAP fault handling, and endpoint security—you can build robust, scalable web services that stand the test of time.

What challenges have you faced with Spring-WS? Share your experience in the comments!

🧩 Spring Boot + Microservices: Build Smarter, Scale Faster

Code Reacher — Mon, 14 Apr 2025 08:42:22 +0000

In today’s tech world, Microservices are no longer a trend—they’re the standard. Instead of building one massive, tightly-coupled application (monolith), we're breaking it into smaller, self-contained services. Each service does one thing well and communicates with others through APIs.

And what’s the go-to tool for building these services in Java?
👉 Spring Boot + Spring Cloud

🚀 Why Microservices?
Scalability: Scale only the parts that need it (like payment service during a sale).

Resilience: If one service fails, the whole system doesn’t crash.

Faster Deployments: Smaller services = easier and safer deployments.

Tech Diversity: Each service can use different tech, DBs, or languages (polyglot).

🧰 Why Use Spring Boot for Microservices?
Spring Boot is built to simplify Java development, and it shines when paired with microservices architecture. Here’s why:

✅ Embedded Tomcat/Jetty – Just run the JAR file
✅ Minimal Configuration – Fast setup with application.yml/properties
✅ Built-in Actuators – Health checks, metrics, and monitoring
✅ RESTful APIs – Easy creation with @RestController
✅ Spring Data JPA – Seamless DB integration

🔗 Why Add Spring Cloud?
Spring Cloud brings in the glue for microservices:

🔹 Service Discovery – Use Eureka for dynamic service registration
🔹 API Gateway – Use Spring Cloud Gateway to route and filter requests
🔹 Circuit Breakers – With Resilience4j or Hystrix to handle failures gracefully
🔹 Config Server – Centralized configuration management
🔹 Tracing – Distributed tracing with Zipkin or Sleuth

💻 Sample Code – Creating a Microservice in Spring Boot
Let’s build a simple User Service that exposes a REST endpoint.

pom.xml Dependencies

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

2. Main Class

@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

3. User Controller

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public ResponseEntity<String> getUser(@PathVariable String id) {
        return ResponseEntity.ok("User fetched with ID: " + id);
    }
}

4. application.yml

server:
  port: 8081

spring:
  application:
    name: user-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

🔗 Eureka Server Setup
Create a simple Eureka Server to register your services.

1. Add to pom.xml:

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

2. Main Class

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

3. application.yml

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

🔐 Securing Your Microservices with JWT (Optional)
You can secure endpoints with Spring Security + JWT to ensure only authorized services/clients can communicate.

📦 Example Architecture
User-Service → Authenticates users

Order-Service → Manages orders

Inventory-Service → Tracks product stock

API-Gateway → Exposes unified entry

Eureka Server → Enables discovery

Config Server → Loads centralized configs

💡 Best Practices
✅ Keep services stateless
✅ Use DTOs for API communication
✅ Enable logging and tracing
✅ Write contract tests to ensure stability
✅ Secure services with OAuth2 or JWT

📘 References

📣 Final Thoughts
Spring Boot + Spring Cloud is a powerful combination to build robust, scalable, and maintainable microservices. Whether you're just starting or moving away from monoliths, this duo will save time, reduce boilerplate, and give your services the resilience they need in production.

🔍 Mastering Logging in Spring Boot: Striking the Right Balance

Code Reacher — Fri, 11 Apr 2025 04:24:23 +0000

Logging is crucial for monitoring, debugging, and analyzing application behavior. However, inadequate logging makes issue diagnosis difficult, while excessive logging can degrade performance and clutter logs.

🚨 Common Logging Issues in Spring Boot

🔴 1. Insufficient Logging

Missing logs for critical events like authentication failures, API requests, and database errors.
Hard to trace issues in production due to lack of error stack traces.

🔴 2. Excessive Logging

Logging every minor detail (e.g., debug logs in production).
Duplicate logs across multiple components, increasing storage costs.
Performance impact due to synchronous logging slowing down requests.

🔴 3. Unstructured or Inconsistent Logging

Logs without timestamps, levels (INFO, WARN, ERROR), or context.
JSON logs missing proper formatting for tools like ELK Stack.

✅ Best Practices for Effective Logging in Spring Boot
1️⃣ Use Log Levels Wisely
Spring Boot supports logging frameworks like Logback, Log4j2, and SLF4J. Use appropriate log levels:

private static final Logger logger = LoggerFactory.getLogger(MyService.class);

public void processOrder(Order order) {
    logger.info("Processing order: {}", order.getId()); // INFO: Normal flow
    try {
        // Business logic
    } catch (Exception e) {
        logger.error("Error processing order: {}", order.getId(), e); // ERROR: Critical issues
    }
}

🔹 Log levels to follow:

DEBUG: For local debugging, disabled in production

INFO: General application flow (e.g., "User logged in")

WARN: Potential issues (e.g., "High memory usage detected")

ERROR: Failures that need immediate attention

2️⃣ Configure Logging in application.properties
Customize logging levels for different packages:

logging.level.org.springframework=INFO
logging.level.com.myapp.service=DEBUG
logging.level.com.myapp.database=ERROR

🔹 This ensures only essential logs appear in production.

3️⃣ Implement Structured Logging
Instead of plain text logs, use JSON logging for better integration with monitoring tools (e.g., ELK, Grafana, Loki).

# Enable JSON format
logging.pattern.console={"timestamp":"%d{yyyy-MM-dd HH:mm:ss}","level":"%p","message":"%m"}

🔹 Why? Structured logs improve searchability and filtering in log management tools.

4️⃣ Avoid Performance Issues with Asynchronous Logging
Synchronous logging slows down your app. Instead, enable async logging in logback.xml:

<configuration>
    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="FILE"/>
    </appender>
</configuration>

🔹 This ensures log writes don't block application performance.

5️⃣ Centralized Logging for Production
For microservices, use ELK Stack (Elasticsearch, Logstash, Kibana) or Loki & Grafana for real-time log monitoring.

🚀 Conclusion
Logging is a powerful debugging tool—but only when used correctly.
✅ Use structured logs for readability
✅ Set log levels wisely (avoid debug logs in production)
✅ Enable asynchronous logging for better performance
✅ Integrate with log management tools for monitoring

🔗 References:

📌 Spring Boot Logging Docs
📌 Logback Configuration Guide
📌 ELK Stack for Logging

📢 Have you faced logging challenges in your projects? Let’s discuss in the comments! ⬇️

🔍 Securing Spring Boot Actuator Endpoints: A Must for Production

Code Reacher — Thu, 10 Apr 2025 03:04:20 +0000

Spring Boot Actuator is a powerful tool that provides insights, monitoring, and management for applications. However, exposing these endpoints without proper security can leak sensitive data or even compromise your application.

🚨 Common Security Risks with Actuator

🔴 Problem: Unauthorized Access to Actuator Endpoints
Actuator exposes endpoints like /health, /metrics, /env, and /beans. If not secured, attackers can:

View system health status (potentially exposing vulnerabilities)

Access application configurations (e.g., environment variables)

Discover sensitive internal details (like database URLs)

🔍 Example:
If Actuator is enabled without security, anyone can access:

curl http://yourdomain.com/actuator/health

This could expose private system information!
🔐 How to Secure Spring Boot Actuator Endpoints
1️⃣ Restrict Access Using management.endpoints.web.exposure.include
By default, Actuator exposes only a few endpoints. You can explicitly specify which endpoints to expose in application.properties or application.yml:

✅ Recommended Secure Configuration:

# Expose only necessary endpoints
management.endpoints.web.exposure.include=health,info

This prevents exposing sensitive endpoints like /env, /beans, and /mappings.

2️⃣ Secure Actuator Endpoints with Spring Security
Spring Security can restrict access to Actuator endpoints. Add the following configuration in your security setup:

✅ Secure Endpoints in application.properties:

# Require authentication for Actuator endpoints
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=when_authorized
management.endpoints.web.base-path=/admin

🔹 This makes Actuator endpoints accessible only to authenticated users under /admin/actuator.

3️⃣ Protect with Role-Based Access Control (RBAC)
To ensure only admin users can access Actuator, update your Spring Security configuration:

✅ Secure Actuator with Spring Security (Java Config)

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/actuator/**").hasRole("ADMIN") // Restrict Actuator to ADMIN only
            .antMatchers("/public/**").permitAll()
            .and()
            .httpBasic();
    }
}

🔹 This restricts Actuator access to users with the ADMIN role.

4️⃣ Hide Sensitive Information in Actuator Responses
Even with restricted access, some Actuator endpoints expose sensitive data. Limit details using:

management.endpoint.health.show-details=never
management.endpoint.env.show-values=never

🔹 This prevents sensitive configurations from being displayed.

🚀 Conclusion
Spring Boot Actuator is a powerful tool, but securing it is crucial to avoid exposing sensitive system details. Always:
✅ Restrict exposed endpoints
✅ Use Spring Security to enforce authentication
✅ Apply role-based access control
✅ Hide sensitive configuration values

📢 Have you faced security issues with Actuator? Let’s discuss in the comments! ⬇️

📌 Helpful Links:
🔗 Spring Boot Actuator Docs
🔗 Spring Security Basics

#SpringBoot #Java #SpringSecurity #Microservices #BackendDevelopment #DevOps #CyberSecurity #WebDevelopment

🚀 Solving Common Deployment Issues in Spring Boot

Code Reacher — Wed, 09 Apr 2025 05:27:08 +0000

Deploying a Spring Boot application can be challenging due to configuration mismatches, dependency conflicts, database connectivity issues, and port conflicts. Let’s break down these issues and explore effective solutions! 🛠️

🔴 Common Deployment Issues & Their Solutions

1️⃣ Environment Configuration Differences
📌 Problem: Configuration varies across environments (dev, test, prod), leading to unexpected failures.
✅ Solution:

Use Spring Profiles (application-dev.yml, application-prod.yml).

Store sensitive data in environment variables or Spring Cloud Config.

🔹 Example (application.yml):

spring:
  config:
    activate:
      on-profile: prod
  datasource:
    url: jdbc:mysql://prod-db:3306/mydb
    username: prod_user
    password: ${DB_PASSWORD}

Run with:java -jar myapp.jar --spring.profiles.active=prod
2️⃣ Dependency Conflicts in Deployment
📌 Problem: Conflicting dependency versions cause runtime failures.
✅ Solution:

Use Maven/Gradle dependency management to enforce consistent versions.

Run mvn dependency:tree or gradle dependencies to identify conflicts.

🔹 Example (Maven Enforced Versions):

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.7.2</version>
        </dependency>
    </dependencies>
</dependencyManagement>

3️⃣ Database Connectivity Issues (MySQL & MongoDB)
📌 Problem: *Incorrect database configurations or network restrictions prevent connections.
*✅ Solution:

Ensure the database is running and accessible.

Use the correct JDBC URL format.

Allow firewall access to database ports.

🔹 Example (MySQL in application.yml):

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    driver-class-name: com.mysql.cj.jdbc.Driver

🔹 Example (MongoDB in application.yml):

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/mydatabase

4️⃣ Port Conflicts
📌 Problem: The application’s default port (8080) is already in use.
✅ Solution:

Change the port in application.properties:server.port=9090
Find conflicting processes and stop them:

netstat -tulnp | grep 8080  # Linux/macOS
netstat -ano | findstr :8080  # Windows
kill -9 <PID>  # Stop the process

5️⃣ Incorrect Build Artifact
📌 Problem: The wrong build file (.jar or .war) is deployed.
✅ Solution:

Ensure you are building the correct format:
mvn clean package -DskipTests java -jar target/myapp.jar
Use Spring Boot plugins for proper packaging:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

🔥 Final Thoughts
Proper configuration management, dependency resolution, database setup, and artifact handling can significantly reduce deployment failures.

Have you ever faced deployment issues? Share your experience in the comments! 🚀

📌 Helpful Links:
🔗 Spring Boot Profiles
🔗 Maven Dependency Management
🔗 Spring Boot Database Configuration

SpringBoot #Java #Maven #Deployment #DevOps #BackendDevelopment #Database #MySQL #MongoDB

🚀 Dependency Management Issues in Spring Boot & How to Fix Them!

Code Reacher — Tue, 08 Apr 2025 01:52:20 +0000

Managing dependencies in Spring Boot can be tricky. Issues like conflicts, missing dependencies, bloated applications, and incorrect scopes can cause runtime errors and unexpected behavior. Let’s break it down and fix these problems!

🔴 Common Dependency Issues & Their Solutions
1️⃣ Dependency Conflicts
✅ Use dependency management to enforce specific versions.
✅ Run mvn dependency:tree (Maven) or gradle dependencies (Gradle) to detect conflicts.

📌 Example (Maven):
<dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.7.2</version> </dependency> </dependencies> </dependencyManagement>

2️⃣ Unnecessary Dependencies
✅ Remove unused dependencies to improve performance and security.
✅ Run mvn dependency:analyze (Maven) or gradle dependencies --scan (Gradle) to check for unnecessary dependencies.

3️⃣ Missing Dependencies
✅ Ensure all required dependencies are included in pom.xml or build.gradle.
✅ If a dependency isn’t available, check if the correct repository is used:
<repositories> <repository> <id>central</id> <url>https://repo.maven.apache.org/maven2</url> </repository> </repositories>
4️⃣ Incorrect Dependency Scope
✅ Use the right scope (compile, test, runtime) to prevent errors in different build phases.

📌 Example (Test Dependency in Maven):
<dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.7.0</version> <scope>test</scope> </dependency>
🔥 Final Thoughts
Effective dependency management ensures a stable, secure, and optimized Spring Boot application. Have you faced dependency issues in your project? Share your experience in the comments! 🚀

📌 Helpful Links:
🔗 Maven Dependency Management
🔗 Gradle Dependency Management

🔗 If you found this guide helpful, check out my previous article: Common Problems in Spring Boot Exception Handling (and How to Fix Them)

🚀 Follow me for more backend development tips!

SpringBoot #Java #Maven #Gradle #BackendDevelopment #WebDevelopment #SoftwareEngineering #JavaDevelopers

⚠️ Common Problems in Spring Boot Exception Handling (and How to Fix Them) 🚀

Code Reacher — Mon, 07 Apr 2025 02:00:28 +0000

Exception handling is an essential part of building robust applications in Spring Boot. However, developers often face issues like uncaught exceptions, improper error messages, and inconsistent responses. In this guide, I’ll walk you through the most common exception handling problems and how to solve them effectively.

🔹 Problem 1: Returning Generic Error Messages
By default, Spring Boot throws generic error messages, which don’t provide meaningful information to the client.

❌ Bad Practice:
If an exception occurs, the response might look like this:
{ "timestamp": "2025-04-06T14:22:00.123+00:00", "status": 500, "error": "Internal Server Error", "message": "No message available" }
This is not helpful for debugging.

✅ Solution: Use @ControllerAdvice for Global Exception Handling
Instead of returning generic errors, create a custom global exception handler:
import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.time.LocalDateTime; import java.util.HashMap; import java.util.Map; @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) public ResponseEntity<Object> handleGlobalException(Exception ex) { Map<String, Object> errorDetails = new HashMap<>(); errorDetails.put("timestamp", LocalDateTime.now()); errorDetails.put("message", ex.getMessage()); errorDetails.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value()); return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR); } }
Now, the error response is more meaningful and structured.

🔹 Problem 2: Handling Specific Exceptions Like EntityNotFoundException
Sometimes, fetching a resource that doesn’t exist causes 500 Internal Server Error instead of a 404 Not Found.

❌ Bad Practice:
If an entity is not found, it throws:
javax.persistence.EntityNotFoundException: No entity found for query
✅ Solution: Handle Specific Exceptions
Modify the global exception handler to return 404 Not Found when an entity is missing:
@ExceptionHandler(EntityNotFoundException.class) public ResponseEntity<Object> handleEntityNotFoundException(EntityNotFoundException ex) { Map<String, Object> errorDetails = new HashMap<>(); errorDetails.put("timestamp", LocalDateTime.now()); errorDetails.put("message", ex.getMessage()); errorDetails.put("status", HttpStatus.NOT_FOUND.value()); return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND); }
Now, the API will return:
{ "timestamp": "2025-04-06T14:30:00.123+00:00", "message": "User not found", "status": 404 }
🔹 Problem 3: Handling Validation Errors in @RequestBody
If the user submits invalid data in a POST request, Spring Boot might throw MethodArgumentNotValidException with an unclear error message.

✅ Solution: Customize Validation Error Handling
Modify your GlobalExceptionHandler to catch validation errors:
import org.springframework.validation.FieldError; import org.springframework.web.bind.MethodArgumentNotValidException; @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<Object> handleValidationException(MethodArgumentNotValidException ex) { Map<String, Object> errors = new HashMap<>(); for (FieldError fieldError : ex.getBindingResult().getFieldErrors()) { errors.put(fieldError.getField(), fieldError.getDefaultMessage()); } return new ResponseEntity<>(errors, HttpStatus.BAD_REQUEST); }
Now, if a user submits invalid data, the response will be more readable:
{ "name": "Name is required", "email": "Invalid email format" }
🔹 Problem 4: Handling Custom Business Logic Exceptions
Let’s say we have a banking application, and a user tries to withdraw more money than available. Instead of throwing a generic RuntimeException, we can create a custom exception.

✅ Solution: Create a Custom Exception Class
public class InsufficientBalanceException extends RuntimeException { public InsufficientBalanceException(String message) { super(message); } }
Now, handle it in GlobalExceptionHandler:
@ExceptionHandler(InsufficientBalanceException.class) public ResponseEntity<Object> handleInsufficientBalance(InsufficientBalanceException ex) { Map<String, Object> errorDetails = new HashMap<>(); errorDetails.put("timestamp", LocalDateTime.now()); errorDetails.put("message", ex.getMessage()); errorDetails.put("status", HttpStatus.BAD_REQUEST.value()); return new ResponseEntity<>(errorDetails, HttpStatus.BAD_REQUEST); }
If a user tries to withdraw more than their balance, they will see this error:
{ "timestamp": "2025-04-06T14:45:00.123+00:00", "message": "Insufficient balance for withdrawal", "status": 400 }
🎯 Conclusion
🔹 Key Takeaways:
✅ Use @ControllerAdvice for centralized exception handling.
✅ Handle specific exceptions like EntityNotFoundException properly.
✅ Improve validation error messages for better user experience.
✅ Create custom exceptions for business logic errors.

By implementing these best practices, you’ll ensure your Spring Boot application is robust, user-friendly, and easy to debug. 🚀

💬 What’s Next?
What are some common Spring Boot exception handling issues you've faced? Drop a comment below!

🔗 If you found this guide helpful, check out my previous article: Getting Started with Spring Boot and PostgreSQL

🚀 Follow me for more backend development tips!

SpringBoot #Java #ExceptionHandling #BackendDevelopment #APIs #TechWriting

🚀 Getting Started with Spring Boot and PostgreSQL: A Beginner-Friendly Guide

Code Reacher — Sun, 06 Apr 2025 13:46:33 +0000

Spring Boot is one of the most popular frameworks for building backend applications, and PostgreSQL is a powerful relational database that pairs well with it. In this guide, we'll walk through setting up a Spring Boot application with PostgreSQL, so you can get started with database-backed web applications.

🔹 Why Choose Spring Boot and PostgreSQL?
Spring Boot simplifies the setup of Java applications by handling configurations and dependencies, while PostgreSQL provides scalability, security, and advanced SQL features. Together, they form a solid backend foundation for modern applications.

🛠️ Prerequisites
Before we begin, ensure you have the following installed:
✅ Java 17 (or Java 11)
✅ Spring Boot (Spring Initializr)
✅ PostgreSQL Database
✅ Postman (for API testing)

📌 Step 1: Create a Spring Boot Project
We’ll use Spring Initializr to generate a Spring Boot project.

1️⃣ Go to start.spring.io and select:

Project: Maven
Language: Java
Spring Boot Version: 3.x (or the latest)
Dependencies: Spring Web, Spring Data JPA, PostgreSQL Driver

2️⃣ Click "Generate", extract the ZIP file, and open it in IntelliJ IDEA or VS Code.

📌 Step 2: Configure PostgreSQL in application.properties
Update your src/main/resources/application.properties file with the PostgreSQL database details:
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb spring.datasource.username=postgres spring.datasource.password=yourpassword spring.jpa.hibernate.ddl-auto=update spring.jpa.show-sql=true
📌 Make sure PostgreSQL is running, and you’ve created a database named mydb.

📌 Step 3: Create an Entity and Repository
Define a simple User entity in User.java:
import jakarta.persistence.*; @Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; // Getters and Setters }
Now, create a JPA repository in UserRepository.java:
import org.springframework.data.jpa.repository.JpaRepository; public interface UserRepository extends JpaRepository<User, Long> { }

📌 Step 4: Build a Simple REST API
Create a controller in UserController.java to handle HTTP requests:
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/users") public class UserController { @Autowired private UserRepository userRepository; @PostMapping public User createUser(@RequestBody User user) { return userRepository.save(user); } @GetMapping public List<User> getUsers() { return userRepository.findAll(); } }

📌 Step 5: Run the Application and Test API
Start your Spring Boot application by running:
mvn spring-boot:run

Now, test the endpoints using Postman or curl:

Create a user

curl -X POST http://localhost:8080/users -H "Content-Type: application/json" -d '{"name":"Alice","email":"alice@example.com"}'

Get all users

curl -X GET http://localhost:8080/users

🎯 Conclusion
You’ve successfully built a Spring Boot application with PostgreSQL! 🚀 Now you can expand this project by adding pagination, validation, authentication, and more.

If you found this guide helpful, 💬 drop a comment and let me know what you'd like to learn next!

🔗 Further Reading:
📌 Spring Boot Official Docs
📌 PostgreSQL Docs