3 Docker Image Creation Methods for Java Apps

🔥 ClassLoader Hierarchy and Why It Matters More Than You Think In Java, a Class Is Not Just Its Name a class is uniquely identified by (ClassLoader + Fully Qualified Class Name). That means aame .class file loaded by 2 ClassLoaders = 2 different types 1️⃣ The ClassLoader Hierarchy (Under the Hood) Bootstrap ClassLoader (native, part of JVM)     ↓ Platform ClassLoader (JDK modules)     ↓ Application ClassLoader (your classpath)     ↓ Custom ClassLoaders (frameworks, plugins) Who loads what? Bootstrap → java.lang, java.util (core classes) Platform → JDK internal modules Application → Your app classes Custom loaders: Spring Boot App servers (Tomcat) Plugin systems 2️⃣ Parent Delegation Model (Critical Concept) When JVM needs a class: 1️⃣ Ask parent ClassLoader 2️⃣ Parent tries to load 3️⃣ If not found → child loads This ensures: No duplicate core classes Consistent class definitions Security boundaries 3️⃣ Why You Can’t Override java.lang.String Even if you write: package java.lang; public class String {} It won’t work because for security guarantee -> Bootstrap ClassLoader already loaded the real String -> Your version is ignored. 4️⃣ What Happens Internally During Class Loading When a class is loaded: Step 1 -> Loading Bytecode read into memory Step 2 -> Linking Verification (bytecode safety) Preparation (allocate static fields) Resolution (symbolic → direct references) Step 3 -> Initialization Static variables assigned Static blocks executed Only after this → class is usable. 5️⃣ Real Production Bug: “A Cannot Be Cast to A” ClassCastException: com.User cannot be cast to com.User This happens when same class loaded by different ClassLoaders Example: App server loads User Plugin loads User 👉 Same name 👉 Same code 👉 Different ClassLoaders JVM treats them as different types 6️⃣ Why Frameworks Use Custom ClassLoaders 🔹 Isolation -> Different apps/modules don’t interfere 🔹 Hot Reloading -> Reload classes without restarting JVM 🔹 Plugin Systems -> Load/unload modules dynamically Used in: Spring Boot DevTools Tomcat OSGi 7️⃣ Memory Leaks (Advanced but Important) ClassLoaders can cause leaks If: -> A ClassLoader is referenced -> Its classes cannot be garbage collected 👉 Entire module stays in memory Common in: -> App servers -> ThreadLocal misuse -> Static references 💡In Java, two classes are equal only if their ClassLoader is equal. #Java #JVM #ClassLoader #JavaInternals #BackendEngineering #SoftwareEngineering #SystemDesign #Performance #LearnInPublic

Day 28 — #100DaysOfJava ☕ Today a user typed something in a browser. My Java code received it, processed it, and sent a response back. That is client-server communication. And I built it from scratch. --- What I built today. A simple login form in HTML. User types username and password. Clicks submit. A Java Servlet receives that data on the server, reads it, and sends a response back to the browser. No framework. No Spring. No magic. Just raw Java talking directly to an HTTP request. --- How it actually works — and why every Spring Boot developer should understand this. The browser submits a form with method="post" to action="./firstServlet". The server sees that URL and maps it to my Servlet — because of this one annotation: @WebServlet("/firstServlet") That annotation replaced an entire XML configuration file. One line. Done. The Servlet extends HttpServlet and overrides two methods: doGet() — handles GET requests. When someone just visits the URL. doPost() — handles POST requests. When someone submits a form. Inside doPost(): String username = request.getParameter("username"); String password = request.getParameter("password"); PrintWriter writer = response.getWriter(); writer.print("Hello " + username); request.getParameter() reads the form field by its name attribute. PrintWriter writes the response back to the browser. That is the complete cycle. Request in. Process. Response out. --- What this taught me that no tutorial explains clearly. Every HTTP request has a method — GET or POST. GET is for fetching data. POST is for sending data. This is not just a Servlet concept. This is how the entire web works. Every form submission, every API call, every button click in a web app — underneath it is either a GET or a POST going to a server somewhere. Understanding this at the Servlet level means REST APIs, Spring Boot controllers, and API design all make immediate sense. @WebServlet maps a URL to a Java class. In Spring Boot, @RequestMapping and @GetMapping do the exact same thing — just with more features. Same concept. Different syntax. --- What Spring Boot does that raw Servlets do not. With raw Servlets — I write doGet() and doPost() manually. I configure the server. I handle everything. With Spring Boot — @RestController and @GetMapping handle all of this automatically. The Servlet container is embedded. Configuration is automatic. But here is the thing — Spring Boot is doing Servlet work underneath. It IS a Servlet application. Understanding the foundation means I will never be confused by what Spring Boot is doing for me. --- One thing I noticed in my own code today. I printed the password directly in the response: writer.print("I know your password " + password) Day 1 ... .......Day 28 To any developer reading this — what was the moment HTTP requests finally clicked for you? Drop it below. 👇 #Java #Servlets #HttpServlet #BackendDevelopment #WebDevelopment #100DaysOfJava #JavaDeveloper #LearningInPublic

🚀 Unlocking Docker BuildKit Features in Java: A Deep Dive into API Integration  ⚠️ The Challenge  When working with Docker builds in Java applications, a common issue arises: the popular 𝐝𝐨𝐜𝐤𝐞𝐫-𝐣𝐚𝐯𝐚 library doesn't support BuildKit's advanced features like cache mounts (--mount=type=cache). These features require the version=2 query parameter in Docker's API, but docker-java only uses API versions as path components.  🔍 The Investigation  𝐖𝐡𝐚𝐭 𝐖𝐚𝐬 𝐃𝐢𝐬𝐜𝐨𝐯𝐞𝐫𝐞𝐝:  - Docker API endpoint: /v1.47/build?version=2 enables BuildKit backend  - version=1 = Legacy builder (fails with BuildKit features)  - version=2 = BuildKit backend (supports advanced features)  - docker-java library missing this crucial parameter  💡 The Solution  𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡:  1. 𝐌𝐨𝐝𝐢𝐟𝐲 BuildImageCmd interface to add withBuildKitVersion() method  2. 𝐔𝐩𝐝𝐚𝐭𝐞 BuildImageCmdExec to include version query parameter  3. 𝐄𝐧𝐡𝐚𝐧𝐜𝐞 DefaultDockerClientConfig with BuildKit version support  4. 𝐁𝐮𝐢𝐥𝐝 𝐜𝐮𝐬𝐭𝐨𝐦 𝐉𝐀𝐑 and integrate with bmuschko Gradle plugin  🔬 Key Technical Insights  𝐁𝐮𝐢𝐥𝐝𝐊𝐢𝐭 𝐯𝐬 𝐋𝐞𝐠𝐚𝐜𝐲 𝐂𝐨𝐦𝐩𝐚𝐫𝐢𝐬𝐨𝐧:  # Legacy (version=1) - FAILS with cache mounts  curl "http://localhost/v1.47/build?version=1&..."  # Error: "the --mount option requires BuildKit"  # BuildKit (version=2) - SUCCESS    curl "http://localhost/v1.47/build?version=2&..."  # Rich BuildKit trace output, cache mounts work!  𝐆𝐫𝐚𝐝𝐥𝐞 𝐈𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐢𝐨𝐧:   buildscript {     repositories {       mavenLocal() // Custom docker-java version     }     dependencies {       classpath 'com.github.docker-java:docker-java-core:3.4.0-buildkit'     }   }   task buildWithBuildKit(type: DockerBuildImage) {     dockerCommand.withBuildKitVersion("2") // Enable BuildKit!   }  📈 The Impact  𝐑𝐞𝐬𝐮𝐥𝐭𝐬:  - ✅ 𝐁𝐚𝐜𝐤𝐰𝐚𝐫𝐝𝐬 𝐂𝐨𝐦𝐩𝐚𝐭𝐢𝐛𝐥𝐞: Existing builds continue working  - ⚡ 𝐎𝐩𝐭-𝐢𝐧 𝐁𝐮𝐢𝐥𝐝𝐊𝐢𝐭: Enable advanced features when needed  - 🏃♂️ 𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐁𝐨𝐨𝐬𝐭: BuildKit's parallel processing & caching  - 🔮 𝐅𝐮𝐭𝐮𝐫𝐞-𝐑𝐞𝐚𝐝𝐲: Supports latest Docker build innovations  🎓 Lessons Learned  𝐊𝐞𝐲 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲𝐬:  - 📚 Always check API documentation for missing query parameters  - 🍎 GNU tar vs BSD tar matters for Docker builds on macOS (xattr issues!)  - 🕵️ Direct API exploration reveals gaps in wrapper libraries  - 🔧 Local modifications can bridge functionality gaps in open source libraries  Have you encountered similar gaps between wrapper libraries and underlying APIs? What approaches worked best for your use case? 💭 #Docker #ContainerDevelopment #BuildKit

Optional Misuse Patterns in Java: The Problem: A user lookup crashes in production with NoSuchElementException. The developer is confused — they used Optional, so it should be safe. But they called .get() directly without checking if the value is present. The Optional wrapper added zero safety. Root Cause: Optional was introduced in Java 8 to make absent values explicit and force callers to handle the empty case. But calling .get() on an empty Optional throws NoSuchElementException — just as calling a method on null throws NullPointe java User u = userRepo.findById(id).get(); That one line is no safer than a null dereference. Optional.get() on an empty Optional throws NoSuchElementException. Calling a method on null throws NullPointerException. Different exception, identical outcome. The Optional wrapper added zero protection. Optional was introduced to make absence explicit and force the caller to handle it. But calling .get() skips the entire contract. You have paid the ceremony tax with zero safety benefit. The other anti-pattern is isPresent() + get() — it works, but it is just a verbose null check. The same bug is still possible if someone removes the isPresent() guard later. Three correct patterns: java // 1 — fail with a meaningful exception (service layer default) .orElseThrow(() -> new UserNotFoundException(id)) // 2 — provide a safe default .orElse(User.anonymous()) // 3 — return Optional to caller, let them decide return userRepo.findById(id); Prevention Checklist: ->Never call Optional.get() without an explicit guard ->Prefer orElseThrow() at service layer — fail fast with meaningful exception ->Use orElseGet() instead of orElse() when the default is expensive to create ->Return Optional<T> from repo/service when absence is expected and valid ->Never use Optional as a method parameter or entity field — only as return type ->Enable IntelliJ inspection: "Optional.get() without isPresent()" Lesson: Optional.get() without a guard is just a different way to write a NPE. Optional forces you to think about the empty case — use its API to handle it. orElseThrow() for service layers. orElse() for defaults. Return Optional when absence is valid. Never call .get() directly. It is not a safe operation. #Java #DataStructures #DSA #SystemDesign #SpringBoot #BackendDevelopment #SoftwareEngineering #JavaDeveloper #Programming

Spring & Spring Boot Annotations Every Java Developer Should Know If you're preparing for interviews or working on real-time projects, mastering these annotations is a must! 💡 @Primary-When multiple beans of the same type exist, this one gets autowired by default. @Order - Controls the order in which components are applied or loaded (e.g., filters or interceptors). @Scope-Defines bean scope: singleton (default), prototype, request, session, etc. @Qualifier-Helps resolve conflict when multiple beans of the same type are available by specifying which one to inject. Dependency Injection Annotations @Autowired-Automatically injects a dependency by type. Can be applied to constructors, fields, or setters. @Resource - JSR-250 standard. Injects by name (first), then by type. @Inject-JSR-330 standard. Functions like @Autowired, but without Spring-specific options like required=false. @Required-Ensures that a property must be set in Spring config. Throws error if not Initialized (now deprecated in favor of constructor injection). Spring Boot Annotations @SpringBootApplication-Combines @Configuration, @EnableAutoConfiguration, and @Component Scan in a single annotation to bootstrap a Spring Boot app easily. @EnableAutoConfiguration - Tells Spring Boot to auto-configure your application based on the dependencies present on the classpath. @Configuration Properties - Binds external configuration (like from application.properties) to a POJO and validates them using JSR-303/JSR-380. @Conditional0nClass-Loads a bean or configuration only if a specified class is available in the classpath. @Conditional0nMissingClass - Opposite of @ConditionalOnClass; activates if the class is not present. @Conditional0nBean - Loads configuration or beans only if a certain bean exists. @Conditional0nMissingBean-Loads the bean only if the specified bean is not present in the context. @Conditional0nProperty-Activates beans/config based on a property's presence and value. @EnableConfiguration Properties - Enables support for @Configuration Properties-annotated beans. @ConstructorBinding-Indicates that configuration properties should be bound using the constructor instead of setters. #Java #SpringBoot #Microservices #BackendDeveloper #InterviewPreparation #JavaDeveloper #Coding #TechCareers

🚀 JPA vs Hibernate vs HikariCP Most Java devs use these 3 together but never really explain what each one does. Let me fix that with one simple analogy 👇 Think of your app as a busy restaurant 🍽️ 🧾 JPA = The Menu & Rule Book JPA (Java Persistence API) is just a set of rules and guidelines. It says “here’s HOW data should be saved and fetched” — but it cannot do it alone. It’s like a restaurant menu with zero chefs in the kitchen 😅 JPA is just the STANDARD. Someone else has to do the actual work! 👨🍳 Hibernate = The Head Chef Hibernate reads JPA’s rules and actually DOES the cooking! ✅ Converts your Java objects → SQL queries ✅ Saves data to the database ✅ Fetches, updates and deletes records automatically You write Java. Hibernate handles the messy SQL behind the scenes 🔧 🚪 HikariCP = The Restaurant Door Manager Now imagine 1000 customers arriving at once 😱 Every customer needs a door to enter the kitchen (database connection). Opening a new door every single time = SLOW and EXPENSIVE ⛔ HikariCP is the smart door manager who keeps a pool of doors already open and ready! ✅ Reuses existing database connections ✅ Super fast — lightning quick ⚡ ✅ Manages how many connections are open at once ✅ Default connection pool in Spring Boot 🔑 The Golden Rule: 💬 “JPA tells WHAT to do. Hibernate does HOW to do it. HikariCP makes sure the DATABASE DOOR is always open fast!” 🧠 How they work TOGETHER: Your Java code talks to JPA 👇 JPA gives instructions to Hibernate 👇 Hibernate needs a database connection 👇 HikariCP hands over a ready-made connection instantly ⚡ Data gets saved or fetched 🎉 🎯 One line each — remember forever: 📌 JPA → The rulebook (specification only) 📌 Hibernate → The worker who follows the rules (implementation) 📌 HikariCP → The fast connection manager (connection pool) 🔌 Real world analogy recap: JPA = USB Standard (just the rules) Hibernate = The USB device that follows those rules HikariCP = The USB HUB that keeps multiple ports ready so you never wait! 💡 Fun Fact: Spring Boot automatically uses HikariCP as the default connection pool since Spring Boot 2.0 because it is the FASTEST connection pool available in Java! 🏆 Whether you’re a fresher 👶 or a senior dev 🧓 — understanding all three together will make you shine in system design interviews! 💬 Did this help you? Drop a comment below! ♻️ Repost to help your Java network learn this today! #Java #SpringBoot #JPA #Hibernate #HikariCP #Backend #LearnToCode #JavaDeveloper #TechSimplified #CodingForBeginners #SoftwareEngineering #DatabaseConnection

🚀 100 Java Stream API Problems Every Spring Boot Developer Should Practice If you're working with Java + Spring Boot, mastering Stream API is a must. It helps you write cleaner, functional, and efficient code for filtering, mapping, grouping, and transforming data. Here are the first 50 Stream API problems from basic → intermediate 👇 ✅ Basic Stream API Problems (1–20) 1. Filter even numbers from a list 2. Convert a list of strings to uppercase 3. Count strings starting with a specific letter 4. Find the first element in a list 5. Sort a list of strings 6. Remove duplicates from a list 7. Count the number of elements in a list 8. Find the maximum number in a list 9. Find the minimum number in a list 10. Sum all numbers in a list 11. Join strings with a comma separator 12. Square each number in a list 13. Filter strings longer than 3 characters 14. Convert list of strings to their lengths 15. Collect filtered elements into a set 16. Find average of list of integers 17. Check if all elements are positive 18. Check if any element is null 19. Limit to first 5 elements 20. Skip first 5 elements 🔁 Intermediate Problems (21–50) 21. Group employees by department 22. Partition a list of numbers into even and odd 23. Sort a list of employees by salary 24. Get top 3 highest paid employees 25. Find employee names who joined after 2020 26. Count employees in each department 27. Find duplicate elements in a list 28. Get second highest number in a list 29. Convert a map to a list of keys 30. Convert a map to a list of values 31. Find the frequency of each character in a string 32. Reverse a list using streams 33. Merge two lists into one 34. Flatten a list of lists 35. Capitalize first letter of each word 36. Get longest string in a list 37. Get shortest string in a list 38. Create a comma-separated string from a list 39. Convert list of strings to map of word and length 40. Count vowels in a list of strings 41. Remove null values from a list 42. Get distinct characters from a list of strings 43. Sum of squares of all numbers 44. Sort map by values using streams 45. Convert list of objects to map 46. Sort list of strings by length 47. Filter palindromes from list 48. Count distinct elements in a list 49. Create a list of prime numbers from another list 50. Group list of students by grade #Java #SpringBoot #StreamAPI #BackendDevelopment #CodingPractice

#Day81 🚀 || AI Powered Java Full Stack Course 💻 Advanced Java | 🌐 Introduction to JSP, Scripting Elements & Scopes with Frontlines EduTech (FLM) Hello connections 👋😊 As part of my AI Powered Java Full Stack Course, today’s session introduced Java Server Pages (JSP) — a powerful server-side technology used to build dynamic and interactive web applications 💡🚀 Today marks 📅 Day 81 of my learning journey, where I explored how JSP simplifies web development by seamlessly combining HTML and Java code in a single file 🌐 🔹 🌐 Introduction to JSP JSP (Java Server Pages) enables developers to create dynamic web pages by embedding Java code directly into HTML 🧩 ✨ Key points: • Java code is executed on the server side • The processed result is sent to the browser as HTML • Helps in building dynamic and user-interactive applications 🔹 🎯 Purpose of JSP ✨ • Generates dynamic content efficiently • Simplifies UI development compared to Servlets • Reduces boilerplate code by integrating Java with HTML 🔹 🛠️ Creating a JSP File ✨ Steps: • Navigate to the webapp directory • Create a file with .jsp extension (e.g., index.jsp) 👉 Acts as the entry point for rendering web pages 🔹 🧩 JSP Scripting Elements JSP provides special elements to embed Java code within HTML 🔗 ✨ Types of scripting elements: • Scriptlet Tag → <% Java code %> 👉 Used for implementing business logic (loops, conditions) • Expression Tag → <%= expression %> 👉 Outputs data directly to the browser • Declaration Tag → <%! declaration %> 👉 Used to declare variables and methods at class level 🔹 🔄 JSP Scopes Scopes are used to store and share data across different components of a web application 📊 ✨ Types of scopes: • Request Scope 📥 👉 Stores data for a single request-response cycle 👉 Commonly used between Servlet and JSP (forwarding) • Session Scope 🔐 👉 Stores data across multiple requests for a single user session 👉 Data persists until session expires or browser is closed • Application Scope 🌍 👉 Stores data shared across the entire application 👉 Accessible by all users and components 🔹 ⚠️ Important Note ✨ • getAttribute() returns data as Object type • Requires typecasting while retrieving values 💡 Today’s Takeaway: JSP simplifies the development of dynamic web pages by bridging the gap between frontend (HTML) and backend (Java). Understanding scripting elements and scopes is crucial for managing data flow effectively in real-world web applications 💯🚀 🙏 Special thanks to Krishna Mantravadi, Upendra Gulipilli, and my trainer Fayaz S for their continuous guidance 💡 #Java #JSP #AdvancedJava #WebDevelopment #Servlets #JavaFullStack #BackendDevelopment #LearningJourney #AIPoweredJavaFullStack #FrontlinesEdutech #FLM 🚀

💡 Java Basics Made Clear: `.equals()` vs `.hashCode()` (Plus a Spring Shortcut 🚀) This is one concept that looks simple—but can cause real bugs if misunderstood. 👉 What does `.equals()` do? It checks if two objects have the **same data (same content)**. 👉 What does `.hashCode()` do? It gives a **number (hash value)** that helps Java quickly find objects in collections like HashSet or HashMap. --- ⚠️ The Common Mistake: If you override `.equals()` but NOT `.hashCode()`, Java behaves unexpectedly. 👇 Example: ```java import java.util.*; class Person { String name; Person(String name) { this.name = name; } @Override public boolean equals(Object o) { return ((Person) o).name.equals(this.name); } } public class Test { public static void main(String[] args) { Set<Person> set = new HashSet<>(); set.add(new Person("Kartik")); set.add(new Person("Kartik")); System.out.println(set.size()); // ❌ Output: 2 (Should be 1) } } ``` 🤔 Why? * `.equals()` says both objects are SAME ✅ * But `.hashCode()` is different ❌ * So Java treats them as different objects --- ✅ The Fix: ```java @Override public int hashCode() { return name.hashCode(); } ``` ✔ Now output → `1` (Correct) --- 🚀 Spring / Lombok Shortcut (Best Practice) Instead of manually writing both methods, you can use Lombok: ```java import lombok.*; @Data class Person { private String name; } ``` 👉 `@Data` automatically generates: * `.equals()` * `.hashCode()` * getters, setters, and more You can also use: ```java @EqualsAndHashCode ``` 📌 This avoids human error and keeps code clean. --- 📌 Simple Rule: If two objects are equal using `.equals()` ➡️ They MUST have the same `.hashCode()` --- 🚀 Final Takeaway: * `.equals()` → checks equality * `.hashCode()` → helps in fast lookup * Always override BOTH or use Lombok annotations --- #Java #SpringBoot #Lombok #BackendDevelopment #CodingBestPractices #Developers

☕ Core JAVA Notes — Complete Study Guide 📖 About the Document A thorough, beginner-to-intermediate Core Java study guide spanning 130 pages, packed with clear explanations, syntax breakdowns, real code examples, and comparison tables. Scanned and formatted for students and aspiring Java developers. 🚀 🏗️ What's Inside? 🔷 Chapter 1 — Java Introduction ➤ What is Java? — A high-level, object-oriented, platform-independent language by Sun Microsystems (now Oracle), born in 1995 ➤ The legendary "Write Once, Run Anywhere" (WORA) principle powered by the JVM ➤ Key features: Platform Independence, OOP, Robustness, Multithreading, Rich Standard Library ➤ Where Java is used: Web Development, Mobile Apps (Android), Enterprise Systems ➤ First program: Hello, World! 👋 🔶 Chapter 2 — OOP Concepts (Object-Oriented Programming) ➤ Classes & Objects — Blueprints and instances of real-world entities ➤ POJO (Plain Old Java Object) — private fields, constructors, getters/setters, toString/hashCode ➤ Constructors — Default, Parameterized, this() and super() keywords ➤ Inheritance — extends keyword, parent-child relationships, super calls ➤ Polymorphism — Method Overloading & Overriding ➤ Abstraction — Abstract classes & Interfaces ➤ Encapsulation — Access modifiers: public, private, protected 🟡 Chapter 3 — Core Language Features ➤ Data Types, Variables, Operators, Control Statements (if, switch, loops) ➤ Arrays — single/multi-dimensional, iteration patterns ➤ Exception Handling — try, catch, finally, throws, custom exceptions 🟢 Chapter 4 — String Handling ➤ String class — immutable, pool concept ➤ Key methods: length(), charAt(), substring(), equals(), compareTo(), replace() ➤ StringBuilder — mutable, faster, single-threaded environments ➤ StringBuffer — mutable, thread-safe for concurrent modifications 🔵 Chapter 5 — Collections Framework ➤ ArrayList vs Array — dynamic sizing, java.util.ArrayList ➤ List, Set, Map interfaces — HashMap, HashSet, LinkedList ➤ Iterating with for, for-each, and Iterator ➤ Java Collections = store & manipulate groups of objects efficiently 📦 #CoreJava #Java #JavaProgramming #OOPConcepts #LearnJava #JavaForBeginners #ObjectOrientedProgramming #JVM #WORA #JavaCollections #StringHandling #StringBuilder #Inheritance #Polymorphism #Encapsulation #Abstraction #LambdaExpressions #AnonymousClass #Multithreading #JavaInterviewPrep #PlacementPreparation #ComputerScience #CodingNotes #ProgrammingLanguage #SoftwareDevelopment #JavaDeveloper #BackendDevelopment #TechNotes #StudyMaterial #CodeWithJava