Jānis Ošs’ Post

🚀 What actually happens when a request hits a Spring Boot application? Many developers use Spring Boot daily, but understanding the internal flow of a request helps you write cleaner and better backend code. Here is the simplified flow: 1️⃣ Client Request Browser or Postman sends an HTTP request Example: "POST /api/users" 2️⃣ DispatcherServlet Spring’s front controller receives the request and routes it to the correct controller. 3️⃣ Controller Layer "@RestController" receives the request, validates input, and delegates the work to the service layer. 4️⃣ Service Layer "@Service" contains the business logic such as validation, processing, and transformations. 5️⃣ Repository Layer "JpaRepository" interacts with the database and executes SQL queries. 6️⃣ Response to Client Spring converts the Java object to JSON (via Jackson) and sends it back with HTTP 200 OK. --- 🔑 Golden Rules ✅ Controller → HTTP only ✅ Service → Business logic ✅ Repository → Database operations ✅ Each layer has one responsibility (SRP) This layered architecture makes Spring Boot applications clean, testable, and scalable. #Java #SpringBoot #SpringFramework #Backend #SoftwareEngineering #Programming #Developer #Tech #CleanCode #JavaDeveloper

🚨 @Transactional will NOT work as expected with @Async in Spring Boot Many developers assume that adding "@Transactional" to an asynchronous method will automatically manage database transactions. But in reality, transactions often don’t behave as expected when used with async execution. 🔍 Why does this happen? Spring manages transactions using proxy-based AOP. When we use "@Async", the method executes in a separate thread managed by Spring’s TaskExecutor. Because of this: - The transactional context from the main thread is NOT propagated to the async thread. - If "@Transactional" is used incorrectly, no transaction may be created at all. - Lazy loading issues and partial commits can occur. ❌ Common mistake @Async @Transactional public void processData() { // database operations } Many assume this ensures transactional consistency, but the async proxy invocation can prevent proper transaction creation depending on how the method is called. ✅ Correct approaches ✔ Call async method from a different Spring bean (so proxy works) ✔ Keep transaction boundary inside the async method ✔ Avoid calling "@Async" method from the same class (self-invocation problem) ✔ Use "Propagation.REQUIRES_NEW" if separate transaction is required @Async @Transactional(propagation = Propagation.REQUIRES_NEW) public void processDataAsync() { // executes in independent transaction } 💡 Key takeaway "@Async" = different thread "@Transactional" = thread-bound If they are not structured properly, your transaction may silently fail. Understanding this behavior is very important when working with Spring Boot microservices, batch jobs, and background processing. #SpringBoot #Java #Microservices #Async #Transactional #BackendDevelopment #SoftwareEngineering #SpringFramework #JavaDeveloper #TechTips #Learning #Programming

I worked on building a backend system using Java + Spring Framework 👨💻 The goal was to design something that can handle real-world load and smooth service communication ⚡ Tech Stack: • Spring Boot, Java • Kafka (Message Queue) • REST APIs • SQL Database • Maven / Gradle Here’s what I worked on: 🔹 REST APIs with Spring 🔹 Event-driven architecture using Kafka 🔹 SQL database integration 🔹 Clean project setup with build tools What I did: Introduced Kafka as a message queue — making the system more scalable and flexible 📦➡️📦 This changed how I think about backend development 💡 Still improving it — but learned a lot along the way 🚀 Challenge: Handling reliable communication between services 🤯 Solution: Used Kafka to decouple services and improve scalability 📈 This project really helped me understand how real backend systems are built 🏗️ Would love your thoughts or suggestions! 💬

@Service in Spring Boot @Service is used to define the business logic layer in a Spring Boot application. It tells Spring: “This class contains the core logic of the application.” Key idea: • Processes data • Applies business rules • Connects Controller and Repository Works closely with: • @Repository → Fetches data • @RestController → Handles requests In simple terms: @Service → Handles Logic Understanding @Service helps you keep your application clean, organized, and maintainable. #SpringBoot #Java #BackendDevelopment #LearningInPublic

Spring Boot Annotations Cheat Sheet for Developers While working with Spring Boot, annotations play a crucial role in simplifying configuration, dependency injection, REST APIs, and database interactions. Here is the quick cheat sheet of commonly used Spring Boot annotations that every backend developer should know. This can be useful for interview preparation, quick revision, or day-to-day development. Covers key annotations across: 🔹Core Spring Boot configuration 🔹REST API development 🔹Dependency Injection 🔹JPA & Database operations 🔹Request handling Having these annotations at your fingertips can significantly speed up development and improve code readability. Sharing this as a quick reference for fellow developers. Hope it helps! 💡 If you find it useful, feel free to save or share it with your network. #SpringBoot #Java #BackendDevelopment #FullStackDevelopment #JavaDeveloper #SpringFramework #SoftwareEngineering #CodingTips #DeveloperResources #TechLearning #InterviewPreparation

🚀 Built a Secure Task Manager REST API with Spring Boot I recently worked on a backend project to strengthen my understanding of API design, authentication, and clean backend architecture. The goal was to build a production-style REST API that demonstrates how modern backend systems handle authentication, data persistence, and structured service layers. 🔧 Tech Stack • Java 21 • Spring Boot • Spring Security • JWT Authentication • Spring Data JPA & Hibernate • H2 Database • Swagger / OpenAPI ✨ Key Features ✔ Secure JWT-based authentication (Register & Login) ✔ Complete CRUD APIs for task management ✔ Pagination and filtering for efficient data retrieval ✔ Global exception handling for consistent API responses ✔ Clean layered architecture (Controller → Service → Repository) ✔ Interactive API documentation using Swagger This project helped me deepen my understanding of building secure, scalable backend services and applying best practices commonly used in real-world applications. 🔗 GitHub Repository: [https://lnkd.in/dA7FdDQQ] Always learning and improving — excited to continue exploring backend engineering and system design. #Java #SpringBoot #BackendDevelopment #RESTAPI #SoftwareEngineering #APIDevelopment

Lately, I’ve been trying to focus more on building small backend projects while learning Spring Boot instead of just going through concepts. So I worked on a small project — an Employee Management REST API. The API supports basic operations like creating, retrieving, updating, and deleting employee records. While building this, I also implemented a few things to make it closer to a real backend system: • PostgreSQL integration for persistent storage • Pagination to handle larger datasets • Input validation for cleaner API requests • Layered architecture (Controller → Service → Repository) Working on this helped me understand how Spring Boot applications are structured and how REST APIs interact with a database. GitHub: https://lnkd.in/gahW3RMC #Java #SpringBoot #PostgreSQL #BackendDevelopment #LearningInPublic

While building a Spring Boot project recently, I ran into a bug that looked simple at first but turned out to be a classic backend trap. I had created an API to return account details. The database was fine, the relationships were mapped correctly, and the service logic was clean. But when I hit the endpoint, the API kept failing with a serialization error. After spending some time debugging, I realized the issue wasn’t in my business logic at all. It was happening when Spring Boot was converting my entities into JSON. Here’s what was going wrong: My entities had a bidirectional relationship. An Account had a reference to a Customer. The Customer had a list of Accounts. When the API tried to return an Account, Jackson started converting it to JSON. It saw the Customer inside the Account, so it tried to convert the Customer. Then it saw the list of Accounts inside the Customer, so it tried to convert those Accounts again. And this kept repeating. Account → Customer → Accounts → Customer → Accounts… This created an infinite loop, and eventually the application crashed. The tricky part was that nothing looked wrong in the code. The mappings were correct. The data was correct. But the serialization process didn’t know when to stop. Once I understood the root cause, the fix was straightforward. I used @JsonIgnore on the parent reference inside the child entities: i. Ignored Customer inside Account ii. Ignored Account inside Transaction and Loan By doing this, I told Jackson to stop traversing back up the relationship. After applying this change, the API returned a clean and finite JSON response, and everything worked as expected. This experience taught me an important lesson: In backend development, defining relationships is only half the job. You also need to control how those relationships are exposed in your API responses. #SpringBoot #Java #BackendDevelopment #SoftwareDevelopment #JPA #Hibernate #RESTAPI #Microservices #BackendEngineer #Debugging #TechLearning #Developers #CleanCode

Spring Framework is a powerful and widely used Java framework that simplifies building enterprise-grade applications by providing a clean and modular architecture. At its core, Spring promotes concepts like dependency injection and inversion of control, which help reduce tight coupling between components and make applications easier to maintain and test. I’ve found Spring especially useful for organizing backend systems, where it handles everything from configuration and transaction management to integrating with databases and external services. With modules like Spring MVC, Spring Data, and Spring Security, it provides a comprehensive ecosystem for building robust applications. Another key strength of the Spring Framework is its seamless support for modern application development, particularly with Spring Boot and microservices architectures. Spring Boot simplifies setup by providing auto-configuration and embedded servers, allowing developers to focus on business logic instead of boilerplate code. Combined with features for building REST APIs, securing applications, and integrating with cloud platforms, Spring makes it easier to develop scalable and production-ready systems. Its flexibility, strong community support, and continuous evolution make it a reliable foundation for building modern Java applications. #SpringFramework #SpringBoot #Java #BackendDevelopment #Microservices #APIDevelopment #CloudNative #SoftwareEngineering

🚀 Spring Boot Annotations Cheat Sheet for Developers While working with Spring Boot, annotations play a crucial role in simplifying configuration, dependency injection, REST APIs, and database interactions. Here is the quick cheat sheet of commonly used Spring Boot annotations that every backend developer should know. This can be useful for interview preparation, quick revision, or day-to-day development. Covers key annotations across: 🔹Core Spring Boot configuration 🔹REST API development 🔹Dependency Injection 🔹JPA & Database operations 🔹Request handling Having these annotations at your fingertips can significantly speed up development and improve code readability. Sharing this as a quick reference for fellow developers. Hope it helps! 💡 If you find it useful, feel free to save or share it with your network. #SpringBoot #Java #BackendDevelopment #FullStackDevelopment #JavaDeveloper #SpringFramework #SoftwareEngineering #CodingTips #DeveloperResources #TechLearning #InterviewPreparation