Otavio Santana’s Post

🚀 Day 26 – Java Backend Journey | Producing UserCreated Event Today I practiced implementing a real-world event-driven use case by producing a UserCreated event whenever a new user is created. 🔹 What I practiced today I integrated Kafka with my User Service and configured it to publish an event after a user is successfully created. 🔹 What is UserCreated Event? A UserCreated event is triggered when: 👉 A new user is added to the system 👉 An event message is sent to Kafka 👉 Other services (like Notification Service) can consume it 🔹 Implementation Approach 1️⃣ Create user using API 2️⃣ Save user in database 3️⃣ Produce event to Kafka topic 🔹 Example Code public User createUser(User user) { User savedUser = userRepository.save(user); // Publish event to Kafka kafkaTemplate.send("user-topic", "User created with ID: " + savedUser.getId()); return savedUser; } 🔹 Event Flow User Service → Kafka Topic → Other Services • User is created • Event is published • Other services can react to it 🔹 What I learned • How to integrate Kafka Producer in Spring Boot • How events are published after DB operations • Basics of event-driven communication • How services can be loosely coupled using events 🔹 Why this is important Producing events like UserCreated is a key concept in: ✔ Microservices architecture ✔ Notification systems ✔ Real-time processing systems 🔹 Key takeaway Event production allows backend systems to communicate asynchronously, making applications more scalable, flexible, and efficient. 📌 Next step: Implement Kafka Consumer to handle UserCreated events. #Java #SpringBoot #Kafka #EventDrivenArchitecture #BackendDevelopment #Microservices #SoftwareEngineering #LearningInPublic #JavaDeveloper #100DaysOfCode

☕️Java 26 is here — and IntelliJ IDEA supports it from Day 1! The Java ecosystem isn’t slowing down — it’s accelerating. 🚀 With #Java26, we’re seeing meaningful steps toward a faster, more modern Java. 🔍 What’s new? • Performance improvements across the JVM • ~10 JEPs shaping the next wave of Java • New APIs for modern, scalable development • Stronger preview features worth experimenting with 💡 What stands out? Zero waiting time. IntelliJ IDEA already supports Java 26 from Day 1, so you can start exploring, testing, and building immediately — no setup friction, no delays. 👉 Whether you’re building microservices, high-scale backend systems, or enterprise platforms, staying current with Java releases is no longer optional — it’s a competitive advantage. 🔗 Dive into the official release notes: https://lnkd.in/dNXeGQaF #Java #Java26 #JavaDeveloper #JVM #SpringBoot #BackendDevelopment #SoftwareEngineering

🔹 ModelMapper vs ObjectMapper in Java – What’s the Difference? Many Java developers get confused between ModelMapper and ObjectMapper because both deal with data transformation. But their purposes are different. ModelMapper ModelMapper is used to map one Java object to another Java object. It is commonly used in Spring Boot applications to convert Entity objects to DTOs and vice versa. This helps keep the application layers clean and maintainable. Example use case: UserEntity → UserDTO UserRequest → UserEntity ObjectMapper ObjectMapper is part of the Jackson library and is used for JSON serialization and deserialization. It converts Java objects to JSON and JSON to Java objects, which is very useful when working with REST APIs. Example use case: JSON → Java Object Java Object → JSON Key Difference ModelMapper → Object to Object mapping ObjectMapper → JSON to Object conversion Understanding when to use each of these tools helps build cleaner and more efficient backend applications. #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #JavaDeveloper

How I Migrated a Production Java 8 Codebase to Java 21 Using AI: A Technical Playbook. Sharing 5 prompts that will do the job for you. Prompt 1: Analyze this Java 8 codebase for Java 21 compatibility. Flag: - Removed/deprecated APIs with line references - Reflection usage impacted by the module system (JPMS) - Third-party libs with known Java 21 incompatibilities - JVM flag changes affecting startup/runtime behavior Output as a prioritized risk matrix. Prompt 2: Refactor this Java 8 service class for Java 21: - Replace POJOs with Records where immutability applies - Use sealed classes for domain modeling - Apply pattern matching in switch expressions - Identify candidates for Virtual Threads (blocking I/O operations) Preserve existing behavior. Flag any logic changes with inline comments. Prompt 3: Review this pom.xml for Java 21 / Spring Boot 3.x migration: - Flag javax.* → jakarta.* namespace breaking changes - Identify Spring Security 6.x config changes (WebSecurityConfigurerAdapter removed) - Check Hibernate 6 query compatibility (HQL/Criteria API changes) - Detect transitive dependency conflicts using dependency:tree analysis Suggest pinned versions with rationale. Prompt 4: Generate JUnit 5 + Mockito test suite for this service class: - Cover happy path, edge cases, and exception flows - Add parameterized tests for boundary values - Mock external dependencies (DB, REST clients, Kafka) - Include a concurrency test if the class uses shared state - Flag any untestable code patterns (static calls, tight coupling). Prompt 5: Review this migrated Java 21 service for production readiness: - Identify blocking calls inside Virtual Threads (thread pinning risks) - Flag synchronized blocks that limit Virtual Thread scalability - Suggest ZGC tuning flags for this heap allocation pattern - Check for memory leak risks in the new Stream/Record usage Honest Takeaway: AI cuts the discovery and boilerplate work by 60% .It won't catch business logic regressions that's still on your engineers .The real ROI is freeing senior devs for architecture decisions, not mechanical refactoring. Always review AI-generated refactors especially around concurrency and state. Currently exploring Java modernization or AI-assisted development at scale? Drop a comment or DM happy to share specifics.

🚀 Java & Spring Ecosystem Updates (2026): What Modern Java Developers Should Focus On The Java ecosystem continues to evolve with strong improvements in performance, cloud-native development, and AI integration. 🔹 Java 26 Highlights Java 26 introduces several performance and concurrency improvements. Key features include Structured Concurrency for safer multithreading, Primitive Pattern Matching for cleaner code, Vector API for high-performance computing and AI workloads, HTTP/3 support for faster network communication, and ongoing G1 Garbage Collector improvements for better memory management. These updates make Java more efficient for microservices, AI, and high-performance backend systems. 🔹 Spring Boot 4 Spring Boot 4, built on Spring Framework 7, is a major step forward for enterprise Java development. It brings improved observability, better microservices support, API versioning, cloud-native optimization, and support for newer Java versions. It is designed for modern distributed systems and containerized deployments. 🔹 Spring AI Spring AI is one of the most important new additions to the Spring ecosystem. It allows developers to integrate AI capabilities directly into Spring Boot applications, including LLM integration, embeddings, vector databases, AI chatbots, semantic search, document processing, and image generation. This makes it much easier to build AI-powered enterprise applications using Java. 🔹 Modern Java Architecture (2026) A modern full-stack Java architecture typically includes: 😍I following this Architecture - Backend: Spring Boot 4 - AI Integration: Spring AI - Frontend: React or Next.js - Database: PostgreSQL - Cache: Redis - Messaging: Kafka - Containerization: Docker - CI/CD: GitHub Actions - Cloud: AWS / Azure - Microservices & Kubernetes 🔹 Key Skills for Java Developers in 2026 To stay competitive, Java developers should focus on: - Microservices Architecture - Docker & Kubernetes - Spring Boot & Spring Security - Spring AI & AI Integration - System Design - Cloud Deployment - Distributed Systems - Performance Optimization #Java #SpringBoot #SpringAI #Java26 #Microservices #Cloud #AI #Docker #Kubernetes #SoftwareEngineering #BackendDevelopment

🚀 Java 21 Migration Guide using GitHub Copilot (Spec-Driven Approach) Migrating to Java 21 isn’t just about upgrading the JDK. It involves: • Refactoring legacy code • Handling deprecated APIs • Ensuring performance & security (CVE fixes) • Avoiding production risks I explored a structured way to solve this using: 👉 Spec-Driven Development + GitHub Copilot Instead of ad-hoc changes, this approach: ✔ Defines clear migration rules ✔ Uses Copilot for consistent refactoring ✔ Makes upgrades repeatable and safer If you're working on: 1. Java modernization 2. Backend systems 3. AI-assisted development This guide will help 👇 🔗 https://lnkd.in/ga2_3gfK 💡 Key topics covered: #Java21 #JavaMigration #GitHubCopilot #SoftwareEngineering #ArtificialIntelligence #BackendDevelopment #Java

🚨 Exception Handling in Java: More Than Just try-catch Many developers treat exception handling as an afterthought. But in reality, it's one of the pillars of building robust and maintainable systems. Good exception handling is not about catching everything — it's about handling the right things, in the right way. 💡 Key principles every Java developer should follow: ✔️ Catch only what you can handle If you don’t know how to recover, don’t swallow the exception. Let it propagate. ✔️ Never ignore exceptions An empty catch block is a hidden bug waiting to explode in production. ✔️ Use specific exceptions Avoid generic Exception or Throwable. Be explicit — it improves readability and debugging. ✔️ Add context to exceptions Wrap exceptions with meaningful messages: throw new OrderProcessingException("Failed to process order " + orderId, e); ✔️ Use finally or try-with-resources Prevent resource leaks: try (BufferedReader br = new BufferedReader(new FileReader(file))) { // use resource } ✔️ Create custom exceptions when needed They make your domain logic clearer and more expressive. ⚠️ Common anti-patterns: ❌ Swallowing exceptions ❌ Logging and rethrowing without context ❌ Using exceptions for flow control ❌ Catching NullPointerException instead of fixing the root cause 🔥 Pro tip: Well-designed exception handling turns unexpected failures into controlled behavior — and that’s what separates fragile systems from resilient ones. How do you usually handle exceptions in your projects? Have you ever debugged a production issue caused by bad exception handling? #Java #SoftwareEngineering #CleanCode #BackendDevelopment #BestPractices

POJO (Plain Old Java Object) Classes:- A POJO class is a simple Java class that is not bound to any specific framework. It is used to represent data in an object-oriented way, typically containing: Private variables (fields) Public getter and setter methods Constructors (optional) toString(), equals(), hashCode() (optional) ✅ Example of a POJO Class public class User { private String name; private int age; // Default constructor public User() {} // Parameterized constructor public User(String name, int age) { this.name = name; this.age = age; } // Getter public String getName() { return name; } // Setter public void setName(String name) { this.name = name; } // Getter public int getAge() { return age; } // Setter public void setAge(int age) { this.age = age; } } 🎯 Usage of POJO Classes:- 1. Data Representation:- POJOs are used to represent structured data (like JSON or XML) in Java. Example: API response → converted into POJO object. 2. Serialization & Deserialization (Very Important in API Testing):- In tools like Rest Assured, POJOs are used to: Convert JSON → Java Object (Deserialization) Convert Java Object → JSON (Serialization) Example (Deserialization): User user = response.as(User.class); System.out.println(user.getName()); Example (Serialization): User user = new User("John", 30); given() .contentType("application/json") .body(user) .post("/users"); 3. Clean Code & Maintainability:- Instead of handling raw JSON, POJOs make code readable and structured. Helps in large frameworks and enterprise-level automation. 4. Reusability:- Same POJO can be reused across multiple test cases or APIs. 5. Validation:- Easy to validate response fields using getters. assertEquals(user.getName(), "John"); #testing #softwaretesting #automationtesting #sdet #qa #fullstackqa #java #restassured #selenium

Java 26 marks another important step in the evolution of the Java platform, focusing less on flashy syntax changes and more on strengthening the foundations of modern, cloud-native application development. One of its most notable contributions is the continued advancement of Structured Concurrency, which aims to simplify how developers manage parallel tasks. Instead of dealing with fragmented asynchronous code using constructs like CompletableFuture, structured concurrency introduces a more organized approach where related tasks are treated as a single unit. This improves readability, error handling, and cancellation, making it especially valuable for microservice orchestration layers where multiple service calls must be coordinated efficiently. Another significant addition is HTTP/3 support in the Java HTTP Client. By leveraging QUIC instead of traditional TCP, HTTP/3 reduces latency and improves performance in unreliable network conditions. This is particularly beneficial for modern distributed systems that rely heavily on external APIs, cross-region communication, and mobile clients. For enterprise applications, especially in domains like finance or e-commerce, this enhancement can lead to faster response times and more resilient integrations. Java 26 also continues progress toward faster startup and better runtime efficiency through initiatives aligned with Project Leyden, such as Ahead-of-Time (AOT) object caching. This feature helps reduce application warm-up time by allowing the JVM to reuse pre-initialized objects, which is highly advantageous in containerized and serverless environments. Alongside this, improvements to the G1 Garbage Collector enhance throughput by reducing synchronization overhead, resulting in more stable performance under high load—an important factor for large-scale Spring Boot applications and data-intensive services. On the language side, Java 26 expands pattern matching capabilities to include primitive types, making conditional logic more expressive and consistent. This leads to cleaner and more maintainable code, particularly in scenarios involving complex decision-making or data validation. Additionally, the platform is moving toward stronger integrity with changes that reinforce the immutability of final fields, reducing reliance on unsafe reflection practices and improving overall security. Finally, Java 26 includes enhancements in cryptography with improved support for PEM-encoded keys and certificates, simplifying secure communication and authentication workflows. While some features remain in preview, the overall direction is clear: Java is evolving to better support modern architectures, emphasizing performance, reliability, and maintainability. For developers and architects, Java 26 offers a glimpse into the future of enterprise Java, where concurrency is structured, networking is faster, and the runtime is increasingly optimized for cloud environments. #Java #Java26 #SpringBoot #Microservices