Spring Boot Training: Architecture & Best Practices with Mohammed Ezzaim

One Thing Spring Boot Projects Taught Me (That Tutorials Didn’t) While working on my Spring Boot project this week, I realized something that I never truly understood from tutorials alone. 🔹 Entity relationships force you to think about data ownership, not just tables When I connected User ↔ Task, the real challenge wasn’t writing @OneToMany or @ManyToOne. The challenge was answering questions like: Who owns the relationship? What should happen when a user is deleted? Should tasks exist without a user? Where should cascade actually be used? Until I built this myself, relationships felt like annotations. Now they feel like design decisions. 🔹 Authentication changes how you think about every endpoint After adding basic authentication, I had to rethink: Which endpoints should be public? Which data should be user-specific? How accidental exposure can happen if you’re not careful Security stopped being a configuration step and started feeling like a responsibility. This week taught me that backend development is less about writing code fast and more about thinking clearly before writing it. Still learning. Still building. One small step at a time. #SpringBoot #BackendDevelopment #LearningByBuilding #Java #BuildingInPublic

Day 3 of my Spring Boot learning journey 🚀 Today’s focus was on writing cleaner and more maintainable code in a Spring Boot application. What I learned: Using Java Streams (stream()) for cleaner data processing Understanding and applying Lambda expressions Using DTOs in a layered architecture to separate concerns Creating Entities and mapping them to the database Writing Repository interfaces for data access Learning how DTOs and Streams improve code readability and structure was especially insightful today. Small concepts, but they make a big difference in real-world applications. 👉 From a professional perspective, what’s one common mistake beginners make when working with DTOs or Streams in Spring Boot? #SpringBoot #Java #Streams #DTO #BackendDevelopment #LearningInPublic #DeveloperJourney #CleanCode

✨ Today's Learning – Spring Framework ✨ Today I learned about Loose Coupling, Setter Injection, and @Autowired in Spring. Earlier, I used to create objects manually using new keyword. But with Spring, objects are managed by the framework itself, which helps in achieving loose coupling. 🔹 Loose Coupling It helps us change implementations easily without affecting other parts of the application. 🔹 Setter Injection Dependencies are injected using setter methods, which makes the code more flexible and easier to test. 🔹 @Autowired Spring automatically injects the required dependency, reducing boilerplate code and improving readability. Understanding these concepts made me realize how Spring simplifies object management and improves code maintainability. Learning step by step and enjoying the process 🚀 #SpringFramework #Java #Learning #BackendDevelopment #SoftwareEngineering

Day 28 — Going Deeper into Java Constructors 🧩 Today I revisited constructors and focused less on what they are and more on how and when to use them properly. Things that became clearer: Types of constructors Default constructor Parameterized constructor Constructor overloading for different object states Accessibility of constructors Constructors can be public, protected, default, or private Access level controls who can create objects of a class Rules of constructors Same name as the class No return type Called automatically during object creation Can be overloaded but not overridden Where to use them To initialize required fields To enforce valid object creation To set default values cleanly Where not to use them For heavy business logic For long-running operations For work that doesn’t belong to object initialization Understanding these rules made me realize how constructors influence object design and code reliability. Learning isn’t just about writing code — it’s about knowing why we write it a certain way. 🚀 #Day28 #LearningInPublic #JavaLearning #JavaDeveloper #ConstructorsInJava #OOPSConcepts #100DaysOfCode #DeveloperJourney #TechLearning

Tools and Syntax doesn't matter in the long run; Fundamentals do; Fundamentals are important for any project, not the syntax and tools. Most people chase frameworks, libraries, and shiny tools. I rarely meet someone who chases fundamentals more than those tools. I saw a lot of people just adding zod, bcrypt, cors and more npm packages at their backend service without knowing the true purpose of that package. Did someone actually learn why or tried to go one level deeper in those packages. Maybe someday, you may need to switch to other tools like Golang, Spring boot. If you have learned fundamentals the right way, you will have no problem by the next week. But if you just coded following tutorials for projects. It will be tough road ahead. Tools make you productive. Fundamentals make you adaptable. Fundamentals >>>>>> Tools #ComputerScience #SystemDesign #SoftwareEngineering #LearningInPublic #Fundamentals

🔄 𝗥𝗲𝗳𝗮𝗰𝘁𝗼𝗿𝗶𝗻𝗴 𝗺𝘆 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝘁𝗮𝘂𝗴𝗵𝘁 𝗺𝗲 𝗺𝗼𝗿𝗲 𝘁𝗵𝗮𝗻 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗶𝘁 Recently, I revisited one of my old Spring Boot projects and realized something important — the code worked, but it wasn’t clean or scalable. So I decided to refactor it by following proper backend best practices. 🔴 𝗕𝗲𝗳𝗼𝗿𝗲 𝗿𝗲𝗳𝗮𝗰𝘁𝗼𝗿𝗶𝗻𝗴:   • Controllers handling too much logic   • Entities exposed directly in APIs   • Generic exception handling   • Minimal logging 🟢 𝗔𝗳𝘁𝗲𝗿 𝗿𝗲𝗳𝗮𝗰𝘁𝗼𝗿𝗶𝗻𝗴:   • Thin controllers with a clear service layer   • DTOs for request and response   • Centralized global exception handling using @ControllerAdvice   • Structured logging with SLF4J This experience helped me understand that writing maintainable code is just as important as writing working code. If you’re learning Spring Boot, I highly recommend refactoring your old projects — it’s a real growth booster 🚀 👉 𝗪𝗵𝗮𝘁’𝘀 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝘁𝗵𝗶𝗻𝗴 𝘆𝗼𝘂 𝘂𝘀𝘂𝗮𝗹𝗹𝘆 𝗿𝗲𝗳𝗮𝗰𝘁𝗼𝗿 𝗶𝗻 𝗮 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗽𝗿𝗼𝗷𝗲𝗰𝘁? #Java #SpringBoot #CleanCode #BackendDevelopment #SoftwareEngineering #LearningByDoing

🚀 Learning Something New in Spring: Understanding CGLIB Today I explored a concept that often works silently behind the scenes in Spring but plays a very critical role — CGLIB (Code Generation Library). As a backend developer, we frequently use annotations like @Configuration, @Transactional, and @Async, but rarely pause to understand how Spring enforces their behavior internally. This learning helped me connect those dots. 🔍 What is CGLIB? CGLIB is a bytecode generation library used by Spring to create runtime subclasses of classes. These subclasses act as proxies, allowing Spring to intercept method calls and apply additional behavior. In simple terms: CGLIB allows Spring to add extra logic around your methods without modifying your code. ⚙️ Why does Spring use CGLIB? Spring uses CGLIB when: A class does not implement an interface, or Method-level interception is required (for example, configuration and AOP-related features) Common places where CGLIB is used: @Configuration @Transactional @Async @Cacheable 🧠 CGLIB and @Configuration This was the most interesting part for me. When a class is annotated with @Configuration, Spring creates a CGLIB proxy subclass of that class This ensures that: Each @Bean method returns the same singleton instance Even if the method is called multiple times internally Without CGLIB, every direct call to a @Bean method could create a new object, breaking the singleton contract. 🆚 @Configuration vs @Component Although both are singleton beans by default there is a key difference: @Configuration → Uses CGLIB proxying to enforce singleton behavior for @Bean methods @Component → Does not use CGLIB for @Bean methods This distinction is subtle but extremely important in real-world Spring applications. 🎯 Key Takeaway @Configuration is not just a stereotype annotation — it is a contract that Spring enforces using CGLIB to maintain correct bean behavior. Learning such internals has helped me better understand why Spring behaves the way it does, not just how to use it. 📌 Always learning. Always improving. #SpringBoot #Java #CGLIB #BackendDevelopment #LearningJourney #SoftwareEngineering

Day 6 of my Spring Boot learning journey 🚀 Today was a hands-on day — I built a Quiz Application REST API using Spring Boot. What I implemented: API to add questions API to fetch questions API to create a quiz API to get quiz questions While developing this, I learned and applied: Writing custom queries using @Query in repositories Creating custom repository methods following Spring Data conventions Using appropriate HTTP status codes for different API responses Building a small but complete feature helped connect multiple concepts — controller flow, service logic, repository queries, and proper API responses. This kind of practice really shows how individual Spring concepts come together in a real application. 👉 From an API design perspective, what’s one thing you always look for first when reviewing a beginner’s REST API — status codes, query design, or naming conventions? #SpringBoot #Java #RESTAPI #SpringDataJPA #BackendDevelopment #LearningInPublic #DeveloperJourney #APIDesign

#Great #Lecture Koushik Kothagal Learnt a lot of new things in your lectures... Learnt to build resilient apps with Spring Framework 7 and Spring Boot 4. This Java Brains course explores retry logic and concurrency limiting, explaining the concepts behind these resilience patterns. Using hands-on examples, the instructor demonstrates how to implement these features and configure them effectively. What I Learn: Understanding #resilience in #distributed #systems Implementing the @Retryable annotation for #transient #failure #handling Configuring #exponential #backoff and #jitter to #prevent #thundering #herd problems Using @ConcurrencyLimit to protect resources from overload Working with #RetryTemplate for programmatic retry control #Virtual #threads and their impact on #concurrency #limiting Best practices for combining #retry and #concurrency #patterns https://lnkd.in/g6YCUZNh