Mohamed Gdoura’s Post

🚀 Spring Boot 4: Real Null-Safety at Last! For years in Java we’ve played the guessing game around null. When you see a method like: User findUserByEmail(String email) Can it return null? Maybe. Maybe not. You hope it won’t… and sometimes — 💥 boom — a NullPointerException in production. With Spring Boot 4, that uncertainty is finally over. Thanks to the @NullMarked support (via JSpecify & NullAway) the nullability of your APIs becomes explicit. Here’s what it means in practice: Add @NullMarked at the package level → by default, types are non-null unless annotated otherwise. The IDE (IntelliJ, Eclipse, VS Code) immediately shows where nulls are risky. The compiler and build tools (via NullAway) help you fix issues before runtime. Every parameter, return type and field clearly tells you whether it can be null or cannot. Your code becomes more predictable, more readable, and above all — safer. 💡 Daily benefits: ✅ Fewer bugs and production surprises ✅ Clearer method and API contracts ✅ Self-documenting code for teammates and reviewers ✅ Easier code reviews and maintainability ✅ Better interoperability (especially with Kotlin, which understands nullability) But null-safety isn’t the only upgrade in Spring Boot 4.0. Among other improvements: Baseline requirement of Java 17+ — unlocking records, sealed classes, pattern-matching, better performance. Enhanced native image and ahead-of-time (AOT) compilation support, making microservices start faster and use fewer resources. Improved API versioning support, so evolving REST-APIs become easier to maintain side-by-side. In short: Spring Boot 4 doesn’t just add features — it upgrades the developer experience and makes your entire codebase more trustworthy. 💪 If you’re tired of endless Optionals, manual null checks, and unpredictable NPEs — it’s time to take the leap. #SpringBoot #Java #CleanCode #NullSafety #DeveloperExperience #JSpecify #NullAway

🚀 Spring Boot 4 is Changing the Game for Null Safety! As a Java developer, we've all been there - the dreaded NullPointerException 💥  that crashes production at 2 AM. Spring Boot 4 (releasing November 2025) brings a game-changing feature:  JSpecify Null Safety Annotations ✨ 🔍 Here's how it prevents NPEs at COMPILE TIME: // ❌ Old Way (Runtime Explosion) @Service public class UserService {   public String getUserName(User user) {     return user.getName(); // 💣 NPE waiting to happen!   } } // ✅ New Way with JSpecify (Spring Boot 4) import org.jspecify.annotations.Nullable; import org.jspecify.annotations.NonNull; @Service public class UserService {   public @NonNull String getUserName(@Nullable User user) {     if (user == null) {       return "Guest"; // Compiler forces you to handle null!     }     return user.getName();   } } 🎯 What makes this powerful? 1️⃣ Compile-time checks - Catch bugs before deployment 2️⃣ IDE support - IntelliJ/Eclipse shows warnings immediately 3️⃣ Kotlin interop - Seamless null safety with Kotlin projects 4️⃣ Clear contracts - Method signatures tell the truth about nullability 💡 Real Impact: - Reduced production bugs by catching NPEs during development - Better code documentation (nullability is explicit) - Safer API contracts between microservices Spring Boot 4 + JSpecify = Fewer debugging sessions! 😴 Are you ready to upgrade when Spring Boot 4 GA releases this November? #SpringBoot #Java #NullSafety #SoftwareEngineering #BackendDevelopment

Hi Java fellows 👋 and Spring enthusiasts 🌿, The releases of Spring Framework 7 (November 13th) and Spring Boot 4 (November 20th) are just around the corner, and here's what you should know: Spring Framework 7: ✅ Resilience features: RetryTemplate, @Retryable, @ConcurrencyLimit ✅ API Versioning ✅ Null Safety with JSpecify ✅ Programmatic Bean Registration ✅ HTTP Interface Client configuration .... Release note:🔗 https://lnkd.in/g7SfnbBk Spring Boot 4: ✅ HTTP Service Clients ✅ OpenTelemetry starter ✅ Improved Observability ✅ Native Image Improvements ... Release note: 🔗https://lnkd.in/gDcGR3KJ (Draft version) For a deeper dive into what's coming, check out the official "Road to GA Introduction" blog post here: https://lnkd.in/g3gXyEn6 Happy learning! 👨💻🎉 #SpringFramework #SpringBoot #Java #SpringFramework7 #SpringBoot4

💡 Before Spring Boot, Java projects were painful to configure. You had to: Manually define beans in XML Manage countless dependency versions Write boilerplate setup for every service Then came Spring Boot — and it changed everything. Here’s how it solved configuration hell 👇 🔹 Auto-Configuration Spring Boot automatically scans your classpath and configures beans for you. If you add spring-boot-starter-web, it creates a web context with Tomcat and registers all required beans — no XML, no manual setup. 🔹 Convention over Configuration Default ports, default JSON mappers, default error handling — everything just works out of the box. You can override anything later, but the defaults help you start fast. 🔹 Opinionated Starters Instead of juggling 10 dependencies, you add a single starter — spring-boot-starter-data-jpa → and you get Hibernate, DataSource, TransactionManager ready instantly. 🔹 Actuator & Observability Health checks, metrics, and monitoring — all with a single dependency. Production readiness built-in. That’s why I love Spring Boot. It’s not just a framework — it’s an engineering philosophy: “Make the common things easy, and the complex things possible.” What’s one Spring Boot feature you think most developers don’t appreciate enough? 👇 #SpringBoot #Java #SoftwareEngineering #BackendDevelopment #TechLearning #ProgrammingTips #EngineeringMindset

🧠 Real-world lesson as a junior Java developer After a month of running perfectly, my Spring Boot app suddenly stopped working. The logs showed: java.sql.SQLNonTransientConnectionException: Socket fail to connect to host: localhost:3307 After hours of debugging, I realized the real issue wasn’t the database — it was Docker networking. Inside a container, localhost doesn’t point to the VM — it points to the container itself. 😅 💡 What I learned and fixed: Connected Spring Boot container to the correct Docker network Changed DB URL from localhost to db: jdbc:mariadb://db:3306/insurance_app Split configs into: application-properties application-local-properties application-prod-properties Used spring.profiles.active=prod for the right environment 🚀 Result: The app is up again — and I learned how critical Spring profiles, Docker networks, and environment separation are. A small crash turned into a big lesson. 💪 #Java #SpringBoot #Docker #Backend #LearningByDoing #DeveloperJourney

Spring Annotations — The Secret Sauce Behind Cleaner Java Code When I first started working with the Spring Framework, I remember being amazed by how a few words with an @ symbol could replace pages of configuration. That’s the beauty of annotations — they make Spring feel intuitive, elegant, and powerful. Here are some I keep coming back to: @Component / @Service / @Repository / @Controller Tell Spring, “Hey, manage this class for me!” — and just like that, it becomes a Spring bean. @Autowired Dependency injection made simple — no need for manual wiring; Spring handles it all behind the scenes. @Configuration & @Bean Say goodbye to XML configs. Define your beans right in code, clean and readable. @RestController & @RequestMapping Building REST APIs? These two make it a breeze to handle endpoints and responses. @Transactional Handles transactions automatically so you don’t have to worry about rollbacks or commits — magic for database operations. @SpringBootApplication The grand entry point — combines multiple annotations into one neat package and spins up your app in seconds. Every time I use these, I’m reminded how much Spring has evolved — from heavy XML setups to annotation-driven simplicity. What’s the one Spring annotation you can’t live without? #SpringBoot #JavaDevelopers #BackendDevelopment #SpringFramework #CodingLife #TechCommunity

☕ Java 17 → Java 25: The Evolution We’ve All Been Waiting For 🚀 Most production systems I see still run on Java 17 — and for good reason. It’s stable, fast, and familiar. But after exploring Java 25, it’s clear how much the language — and the JVM — have leveled up. Here’s what stood out 👇 ⚡ Startup & performance: Huge gains thanks to AOT improvements and better warm-up times (perfect for containers). 🧵 Virtual Threads: Concurrency that actually feels simple. No more thread-pool gymnastics. 🧩 Pattern Matching & Record Patterns: Cleaner, safer, and more expressive code. 🧠 Smaller memory footprint: Each container instance now runs leaner and cheaper. 🔍 Improved observability: Enhanced JFR & profiling tools built right into the JVM. If you’re still on Java 17, the jump to 25 isn’t just “keeping up with releases” — it’s unlocking performance, readability, and long-term stability for modern, cloud-native systems. 👉 Curious — what’s keeping your team on 17, or what finally made you move? #Java #SpringBoot #Java25 #Microservices #CloudNative #DevOps #Performance #SoftwareEngineering

🚀 Java 21 — The Most Powerful Java Release Yet! ☕ Recently migrated one of my Spring Boot projects to Java 21, and the performance & developer experience have leveled up big time. Here’s why this version deserves the hype 👇 💡 Key Features that Stand Out: 1️⃣ Virtual Threads (Project Loom) — Concurrency made lightweight! Say goodbye to thread-pool tuning nightmares. 2️⃣ Record Patterns — Pattern matching for records simplifies destructuring complex data. 3️⃣ Switch Pattern Matching — Cleaner, safer, and more expressive switch statements. 4️⃣ Sequenced Collections — Finally, ordered access methods (getFirst(), getLast()) for List, Set, and Map. 5️⃣ String Templates (Preview) — Embed expressions directly inside strings without concatenation hell. 6️⃣ Scoped Values (Preview) — A better, safer alternative to ThreadLocal. 7️⃣ Improved Garbage Collection — G1 and ZGC enhancements for lower latency and better memory usage. 🔥 Bonus: Performance boosts across the board, improved startup time, and better integration with modern frameworks like Spring Boot 3.3+. 🧠 If you're still on Java 17 or older, this upgrade is worth every bit of effort — especially if you're chasing scalability and cleaner code. Would you upgrade your project to Java 21 or wait for the next LTS? Drop your thoughts 👇

Spring Boot Annotations — Turning Configuration into Elegance In modern Spring Boot applications, annotations aren’t just syntactic sugar — they’re the backbone of declarative programming. With a single annotation, we can unlock complex behaviors that once required pages of configuration. From @SpringBootApplication that kickstarts the entire context, to @EnableCaching, @KafkaListener, @EnableWebSecurity, or @ControllerAdvice — each one encapsulates powerful patterns for caching, messaging, security, and global exception handling. These annotations bring clarity, reduce coupling, and let us focus on what the application should do, not how to wire it together. It’s one of the main reasons Spring Boot remains a cornerstone in enterprise Java development. 💡 I’ve put together a concise PDF reference covering the most used Spring Boot annotations — ideal for developers who want to deepen their understanding or prepare for technical interviews. #Java #SpringBoot #BackendDevelopment #Microservices #Coding #SoftwareEngineering #TechLearning

Just finished reading the latest Java Annotated Monthly, where Josh Long highlights some of the exciting new features coming with Spring Boot 4 and Spring Framework 7. Here’s a brief overview of the new features that caught my attention: 1️⃣ Modularized autoconfiguration ➡️ Faster startup, lower memory usage, smaller native images, and clearer configuration boundaries. 2️⃣ Jakarta EE 11 baseline + Java 17/25 support ➡️ Modern APIs, stronger security, improved performance, and access to new JVM capabilities (including Loom and updated concurrency features). 3️⃣ GraalVM 25 for native images ➡️ Smaller, faster, more optimized native executables with improved build and runtime efficiency. 4️⃣ JSpecify nullability across the ecosystem ➡️ Better null-safety, fewer NPE issues, stronger static analysis, and more predictable APIs. 5️⃣ Jackson 3 adoption ➡️ Faster JSON processing, richer type handling, better Kotlin support, and more consistent API behavior. To learn more: https://lnkd.in/e6rG7_7k #Java #SpringBoot #Spring #SoftwareEngineering #BackendDevelopment