Explore what a web service is and why html output or sharing a jar isn’t a web service, including challenges with dependencies, updates, and platform independence.

A web service enables machine-to-machine interaction over a network, is platform independent, and supports interoperable communication across languages and platforms.

Discover how to build platform independent web services by ensuring interoperable requests and responses using XML or JSON as platform independent formats.

Explore key web services terminology, including requests and responses, message exchange formats like XML and JSON, and the roles of service provider and consumer.

Compare soap and rest web services, highlighting soap xml with envelope, header, and body, and rest built on http using get, post, and delete for common operations.

Explore fundamentals of Rest API and build a Rest API with Spring Boot to lay the groundwork for microservices, emphasizing web services as the essential building block.

Explore building a REST API with Spring Boot, including resource identification, JSON request and response structures, status handling, security, validation, internationalization, and advanced features with JPA and Hibernate.

Set up a REST API project with Spring Initializr, choosing Maven, Java, and the latest Spring Boot; add web, Spring Data JPA, H2, and DevTools.

Create a hello world REST API with Spring Boot by building HelloWorldController. Map GET /hello-world to return Hello World and later adopt @GetMapping for cleaner routing.

Discover the origin of in28minutes and its core mindset, invest in yourself, view change as an opportunity, stay inquisitive, and commit to learning something new every day.

Convert the REST API to return a JSON hello world bean with a message field by creating the HelloWorldBean class and its constructor and getters.

Explore how Spring Boot auto configuration and startup projects wire dispatcher servlet, Tomcat, and Jackson to deliver rest json responses from hello world beans.

Explore how Spring Boot 4 modularizes dependencies, replacing starter web with web mvc and introducing web mvc test and data jpa test to reduce startup time.

Explore path parameters in rest APIs and implement a hello world rest endpoint using a path variable in Spring, capturing values from urls like /hello-world/path-variable/{name} and returning a personalized message.

Design and implement a rest api for a social media app, focusing on users and posts, with urls such as /users and /users/{id}/posts, using get, post, put, patch, and delete.

Define a user bean with id, name, and birthDate, generate accessors, and build a Spring component UserDaoService using a static in-memory list to support rest api operations for all users.

Builds a Spring Boot REST API to retrieve all users and a specific user by id, using a user resource, REST controller, and GET mappings.

Implement a REST POST /users endpoint to create a new user from a request body (name, birthDate) with a server-generated ID, using @PostMapping and @RequestBody, tested via Talend API Tester.

Return 201 created for post requests and include a location header with the new user's URL built from the current request URL using ResponseEntity.created and ServletUriComponentsBuilder.

Meet ranga karanam, founder of in28minutes, and your primary instructor for this course. He brings two decades of programming and cloud certifications on AWS, Azure, and Google Cloud.

Learn to return 404 on missing resources by using orElse, creating a UserNotFoundException with ResponseStatus Not Found, and delivering a structured json error.

Learn how to implement a custom global error response with an ErrorDetails structure, use ResponseEntityExceptionHandler and ControllerAdvice to return a 404 for not found errors, including timestamp, message, and details.

Implement a delete by id rest endpoint to remove a user using DeleteMapping, updating the user service to delete by ID and return a 200 status.

Explore adding validations to a spring boot rest api using spring-boot-starter-validation, applying @Valid and jakarta.validation.constraints.Size and jakarta.validation.constraints.Past, and returning meaningful error messages via a custom ResponseEntityExceptionHandler.

Explore advanced REST API features, including OpenAPI and Swagger documentation, content negotiation for JSON and XML, i18n for language-based responses, API versioning, HATEOAS, static and dynamic filtering, and monitoring.

Document your REST APIs using the OpenAPI specification and Swagger UI to define resources, actions, and request–response structures, while generating up-to-date, consistent documentation from code.

Configure Swagger documentation for your Spring Boot REST API using springdoc-openapi, update pom.xml, and view the OpenAPI spec at /v3/api-docs and the Swagger UI at /swagger-ui.html.

Explore content negotiation in a rest api by leveraging accept headers to serve xml or json representations of the same resource, and use accept-language to vary language.

Implement internationalization (i18n) in a Spring REST API using the Accept-Language header, messages.properties, and a MessageSource to return locale-specific greetings.

Version your REST API to avoid breaking consumers by adopting URI versioning with v1 and v2 endpoints like /v1/person and /v2/person, and consider parameter, header, and media type options.

Explore multiple rest api versioning strategies—uri, request parameter, header, and media type content negotiation—demonstrating spring mvc implementations and their trade-offs for a consistent enterprise approach.

Discover how spring boot 4 provides built-in semantic versioning and supports path, query parameter, header, and media-type versioning (v1, v2, 1.0.0) configured in application.properties.

Master HATEOAS for rest APIs by adding hypermedia links with entity model and Spring HATEOAS, using HAL to guide clients to subsequent actions, such as retrieving all users.

Learn how to customize rest api responses by selecting field names with JsonProperty, and implement static filtering using JsonIgnore to hide sensitive fields in Jackson.

Implement dynamic filtering in a Spring REST API using JsonView with two views to return field sets per URL, contrasting with static filtering and JsonIgnore.

Learn how Spring Boot Actuator provides production-ready monitoring and management features with endpoints like health, beans, metrics, and mappings, plus how to enable and explore them.

Explore your rest api with hal explorer and the json hypertext application language, linking resources via _links; see spring boot auto-configuration and endpoints like /actuator, /beans, /metrics, and /users/1.

Upgrade the user resource to use a JPA and Hibernate backed repository, connect the REST API to the H2 in-memory database, and prepare to switch to MySQL.

Create a JPA-managed user entity with @Entity, @Id, and @GeneratedValue, rename to user_details to avoid h2 keywords, and preload data via data.sql with deferred datasource initialization.

Enhance your REST API by wiring a JPA repository to an H2 database using Hibernate, switch endpoints to /jpa/users, and implement findAll, findById, deleteById, and save for robust CRUD.

Create a post entity, map a one-to-many relationship with user using many-to-one, configure lazy fetch, ignore in JSON, and seed data via data.sql for H2.

Implement a GET API at /jpa/users/{id}/posts to retrieve all posts for a user, locating the user with findById, and returning the user's posts.

Implement post api to create a post for a user by wiring a post repository, validating the request body with @Valid and @Size(min=10), and saving the post to return 201.

Explore how a rest api uses JPA and Hibernate to fetch users and their posts. Observe show-sql output, findAll, findById, and sequence-driven insertions for new posts.

Learn how to connect a Spring Boot REST API to a MySQL database using JPA and Hibernate, by launching MySQL in Docker and switching from H2 with simple changes.

Install Docker Desktop on Windows, macOS, or Linux using the official installer and platform-specific instructions. Ensure admin rights, restart if needed, and verify with docker --version.

Launch a MySQL Docker container and connect the REST API to MySQL by configuring datasource properties, replacing H2, adding the MySQL connector, and verifying persistent data.

Add Spring Security to the project and enable basic authentication for all rest endpoints. Configure username and password in application.properties, restart the app, and verify access with authenticated requests.

Configure a custom security filter chain to require authentication, enable HTTP basic authentication with defaults, and disable CSRF so REST post requests succeed with proper credentials.

Learn to be consistent by committing to a two-week, few-hours-a-day study plan with specific lecture targets, keep the plan visible, and share progress in the Q&A to boost retention.

Explore how Maven simplifies creating and packaging Java class files into a single JAR file. Learn how Spring MVC jars can be downloaded and reused, with Maven handling their integration.

Maven automates Java builds and dependency management with a standard project structure and build lifecycle, downloading transitive dependencies so you can focus on coding.

Create a Spring Boot Maven project via start.spring.io, selecting Maven, Java, and a boot version, with groupId com.in28minutes and artifactId learn-maven; import and add spring-boot-starter-webmvc for web APIs with Tomcat.

Explore the pom.xml, the heart of Maven, and define the project's identity with groupid, artifactid, and version to enable reuse of dependencies like spring-boot-starter and spring-boot-starter-webmvc.

Learn how Maven manages dependencies automatically, including transitive ones, by declaring groupId and artifactId in pom.xml. See how dependency hierarchy shows what Maven downloads for your Spring Boot project.

Learn how Maven downloads dependencies from the central repository into your local .m2/repository, checking the local cache first and then fetching artifacts like spring-boot-starter-webmvc via pom.xml dependencies.

Master Maven's convention over configuration by embracing the standard folder structure (src/main/java, src/main/resources, src/test/java, src/test/resources) and pom.xml.

Learn how Maven enforces a build lifecycle that validates, compiles, tests, and packages code, then optionally verifies, installs, and deploys, with practical examples of mvn package and mvn install.

Explore how starter dependencies and the parent POM simplify Spring Boot projects, with version management from spring-boot-dependencies and the Spring Boot Maven Plugin for running and building containers.

Discover semantic versioning with major, minor, and patch numbers, and learn when to increment each, including snapshots, milestones, and released production versions, while avoiding snapshots for learning.

Explore Apache Maven's role in building Java projects, sharing code via JARs and POM.xml dependencies, and managing transitive dependencies with convention over configuration and Spring Boot starters.

Begin the microservices section by transforming a solid rest api into a microservice, adding key microservice features, and previewing docker and kubernetes in upcoming steps.

Define a monolith as a large application with a single database and millions of lines of code, and outline its deployment, coupling, scalability, and technology lock in challenges.

Explore the varied definitions of microservices and learn three core focus areas: REST API standards and best practices, small, well-chosen independently deployable units, and dynamic scaling.

Compare monolith and microservices by examining a movie booking app, showing how independently deployable services—movie service, booking service, pricing service, customer service, and review service—define boundaries and evolve over time.

Explore how microservices enable easy adoption of new technologies for individual services, with dynamic scaling and faster releases that meet market demands.

Explore key microservice solutions, including Spring Boot for rapid REST API development and Spring Cloud for centralized configuration, load balancing, service discovery, and tracing, plus Docker and Kubernetes deployment.

Explore Spring Cloud's core solutions—Config Server, Spring Cloud Load Balancing, Eureka service discovery, Zipkin tracing, Spring Cloud Gateway, and Resilience4j fault tolerance—and learn to implement them for microservices.

Explore centralized configuration for microservices using Spring Boot and Spring Cloud, and learn how to manage runtime settings across distributed apps.

Set up the limits microservice with Spring Cloud Config Client and prepare it to fetch configuration from a Spring Cloud Config Server, which will pull settings from a Git repository.

Create a hard coded limits service with a simple rest api using Spring Boot, exposing /limits via LimitsController and a Limits bean with minimum and maximum.

Configure the limits service to read minimum and maximum values from application.properties using a configuration class with @ConfigurationProperties, then autowire it into the controller.

Set up a spring cloud config server with Spring Initializr, configure dev tools and config server, run on port 8888, and prepare to connect to a git repository.

Install git on your local machine, initialize a local repository, create and track configuration files like limits-service.properties, and commit changes with git add and git commit.

Connect the Spring Cloud config server to a local git repository by configuring spring.cloud.config.server.git.uri to a file URL. Restart the server and verify localhost:8888/limit-service-default shows default properties.

Connect the limits service to the spring cloud config server by configuring the config client and setting the application name to limits-service, fetching properties from localhost:8888/limits-service/default.

Troubleshoot challenges on your own to build resilience. Use Google and ChatGPT for solutions, then ask in Q&A when needed, share knowledge, and take breaks when stuck.

Store environment-specific limits-service configurations in a GitHub repo and fetch them via Spring Cloud Config Server; use dev, qa, stage, and production profiles to override default values.

Follow the constantly updated debugging guide to diagnose and fix issues in a complex microservices system with naming server, API gateway, and distributed tracing, now with Docker and Docker Compose.

Introduce currency exchange and currency conversion microservices, with endpoints for USD to INR rates and amount conversion. Learn how these services collaborate to compute totals and support gateways and tracing.

Set up currency exchange microservice with Spring Initializr, Maven, Java, and config client; name it currency exchange and set port 8000, launching toward currency conversion, naming server, and api gateway.

Develop a simple currency exchange rest api with a hard-coded value, exposing /currency-exchange/from/{from}/to/{to} through a currency exchange controller and model.

Learn to enhance the currency exchange microservice by returning the environment port in the response, enabling instance tracking for load balancers and multi-port deployments like 8000 and 8001.

spring boot 4 modularizes the h2 dependency into two components: com.h2databaseh2 and spring-boot-h2console, which enables running the h2 console to view data in your in-memory database.

Configure an in-memory H2 database with JPA and Spring Data JPA, add relevant dependencies, enable the H2 console, and seed data via data.sql for currency_exchange.

Create and wire a CurrencyExchange repository for Spring Data JPA to manage CurrencyExchange entities, enabling findByFromAndTo queries from the controller with null checks.

Prioritize wellbeing during the course by getting adequate sleep, eating a balanced diet, and exercising regularly; take breaks to stretch or walk to reduce stress and boost brain function.

Set up the currency-conversion-service with Spring Initializr, Maven, Java, groupId com.in28minutes.microservices, artifactId currency-conversion-service, then configure properties and launch on port 8100 to connect with the currency-exchange-service in the next step.

Create a currency conversion rest api in the currency conversion service using a rest controller and get mapping with from, to, and quantity path variables, using hard-coded values for now.

Invoke the currency exchange microservice from the currency conversion service using RestTemplate with URI variables, map the response, and calculate the total amount.

Apply Spring Cloud Feign to replace verbose RestTemplate calls with a Feign proxy, simplifying inter-service calls between currency conversion and currency exchange, and enabling easier load balancing.

Register services with a naming server or service registry to dynamically discover active instances and balance load, eliminating the need to hard-code urls.

Set up a Eureka naming server to enable dynamic service discovery and load balancing among currency exchange instances, replacing hard-coded addresses with a central service registry.

Register the currency exchange and currency conversion microservices with the naming server by adding the Eureka client dependency and configuring the server URL in application.properties.

Balance hard work with regular breaks by taking one to two-week treks around the world, highlighting Annapurna Base Camp near Pokhara and the Via Alpina green trek in Switzerland.

Balance requests across multiple currency exchange instances with Eureka, Feign, and spring cloud load balancer, enabling client-side load balancing between 8000 and 8001 and updating in 15–30 seconds.

Implement cross-cutting concerns like authentication, authorization, logging, and rate limiting across microservices with Spring Cloud Gateway, using route predicates, filters, discovery, and path rewriting for proxied services.

Set up a Spring Cloud api gateway project using Spring Initializer and Maven, add Eureka discovery client and reactive gateway, run on port 8765 with security, monitoring, metrics, and resiliency.

Enable discovery locator with Eureka in the Spring Cloud gateway, enable discovery client and locator, and route lower-case currency-exchange and currency-conversion through the API gateway.

Configure custom routes in Spring Cloud Gateway with a route locator and builder, using predicates, filters, and rewrite paths for Eureka-backed services like currency exchange.

Implement a global logging filter in Spring Cloud Gateway to log incoming requests, using GlobalFilter, a logger, and chain continuation, then register it as a component and observe logs.

Learn how resilience4j enables a circuit breaker in Spring Boot microservices to return fallbacks when a downstream service slows or fails, with a sample currency exchange on port 8000.

Explore Resilience4j retry and fallback in a Spring Boot microservice. Configure max retry attempts, wait duration, and exponential backoff with a fallback method.

Explore Resilience4j circuit breaker features in Spring Boot, with default configuration and fallback method hardcodedResponse, and learn open, closed, and half-open states through practical demos.

Explore rate limiting and bulkhead features in resilience4j by configuring a rate limiter and a bulkhead for a sample API. Set 10-second windows with two requests per window.

Enhance software development focus by minimizing distractions, identifying your productive zone, and applying the Pomodoro Technique to structure work and study sessions.

Explore how Docker containers enable language-agnostic microservice deployment, creating Docker images that bundle runtime and code so Java, Go, Python, and JavaScript services run consistently across any infrastructure.

Install Docker Desktop on Linux, Mac, or Windows using the latest Docker version. Use admin rights, follow platform-specific Mac Intel or Apple chip guidance, and verify with Docker --version.

Discover how Docker streamlines deployment by creating and running container images. Experience a single command deployment, pulling the in28minutes/hello-world-python image and serving hello world python on localhost:5000.

Explore how docker images bundle the operating system, runtime, and dependencies, enabling the same container run across local, data center, and cloud environments with a docker runtime.

Explore how docker images become containers via docker registry and docker hub, using repositories and tags, port mapping (-p), and detached mode (-d) to run isolated containers.

Explore Docker terminology, including Docker image as a versioned package, Docker repository and tags like latest, Docker registry and hub, and Docker container as a runtime instance.

Create a docker image for a Spring Boot project via a dockerfile that builds with Maven, uses OpenJDK as base, copies the app jar, and exposes port 5000.

Implement a two-stage Docker build that compiles a Spring Boot jar inside the image and runs it from a slim runtime stage, ensuring builds are self-contained and consistent across machines.

Optimize Docker builds by exploiting layer caching: copy pom.xml and the Spring Boot application class first, run mvn clean package, then add rest of code to speed up rebuilds.

Build docker images with the Spring Boot Maven plugin using mvn spring-boot-build-image to create an OCI image. The plugin uses build packs for smaller, faster images and smoother rebuilds.

Explore distributed tracing for microservices by launching a Zipkin server in Docker, aggregating request data in memory database, and tracing calls across microservices to identify issues.

Launch the distributed tracing server Zipkin with Docker by running the openzipkin/zipkin image on port 9411, download the image from Docker Hub, and verify Zipkin is up.

Explore how observability extends monitoring by turning metrics, logs, and traces into actionable intelligence. Learn OpenTelemetry, a single standard to instrument and export telemetry data across cloud platforms.

Enable distributed tracing across currency exchange microservice and the API gateway using Zipkin, Micrometer, and OpenTelemetry; configure dependencies, sampling, and trace IDs to observe spans and timing.

From the API gateway to currency conversion and currency exchange using Zipkin, Micrometer, and Spring Boot 3 with Feign and RestTemplate tracing.

Set up and verify microservices locally before creating container images by importing the GitHub project, running the api gateway, currency exchange, and currency conversion as Java apps, and testing endpoints.

Create a docker image for currency-exchange-service with the spring-boot-maven-plugin, naming it mmv2-currency-exchange-service and tagging it 0.0.1-SNAPSHOT, then run the container on port 8000.

Launch multiple microservices with Docker Compose by defining a docker-compose.yml to start the currency exchange service, Zipkin, and RabbitMQ, with a dedicated network for containers.

Learn to run the Eureka naming server with Docker Compose, and configure the currency exchange service to register with it using an environment variable that points to http://naming-server:8761/Eureka.

Configure and run the currency conversion microservice with Docker Compose, build the image with Maven, and verify service discovery via Eureka and Feign, using currency-exchange instead of localhost.

Launch and test the Spring Cloud api gateway with Docker Compose, build its image, register with the naming server and Eureka, and verify routing to currency exchange and conversion.

Configure and run Zipkin with Docker Compose, set spring.zipkin.baseUrl to zipkin-server:9411 across currency-exchange, currency-conversion, and api-gateway, then view traces in Zipkin's UI.

Reframe failures as learning opportunities, analyze what went wrong, seek mentors' input and peer perspectives, keep a failure journal, and pursue hands-on practice to turn setbacks into progress.

Explore how container orchestration enables production-ready microservices with Docker, scaling, service discovery, load balancing, self-healing, and zero-downtime deployments using Kubernetes on Google Cloud with GKE.

Create a Google Cloud account and start a trial with 300 free credit by entering personal and card details, verifying your mobile number, and selecting account type and tax status.

Create a Google Cloud Kubernetes cluster with a default node pool in standard mode after enabling the Kubernetes Engine API, and compare autopilot versus standard.

Learn to deploy a hello world rest API on a Google Cloud Kubernetes cluster by creating a deployment and a load balancer service, exposing port 8080, using kubectl and gcloud.

Explore the gke in gcp console to inspect a kubernetes cluster, node pools, and deployments, and learn how services, ingresses, and yaml expose scalable microservices via load balancers.

Showcases scaling a Kubernetes deployment with kubectl by adjusting replicas, demonstrates load balancing across pods via the service, and covers manual cluster resizing of node pools with gcloud.

Scale microservices automatically with kubectl autoscale, set CPU targets to 70% with a max of four pods, and manage config maps and secrets for deployments in Kubernetes.

Learn to deploy Kubernetes workloads with YAML declarative configuration and compare it to imperative commands, adjusting replicas and services via deployment.yaml and kubectl apply -f.

Deploy a gpu-enabled microservice by creating a new node pool with gcloud, attach it to the cluster, and use a node selector in deployment.yaml targeting cloud.google.com/gke-node-pool.

Discover how Kubernetes clusters operate, including master (control plane) components—API server, scheduler, control manager, etcd—and worker nodes with Kubelet, pods, and deployments, using Google Kubernetes Engine (GKE).

Explore pods as the smallest deployable units in Kubernetes, hosting one or more containers, with ephemeral IPs and shared volumes across containers within a pod.

Explore how deployments handle zero-downtime microservice upgrades, while replica sets maintain a fixed pod count per version. Learn image updates, rolling deployments, and kubectl verification.

Expose deployments with Kubernetes services to give stable IPs, keeping external users unaffected as pods and releases change, and learn about Cluster IP, load balancer, node port, and ingress routing.

Install and configure gcloud and kubectl from your terminal to deploy microservices; follow platform-specific steps for mac, linux, and windows, then authenticate and set your project.

Install kubectl on your local machine across Mac, Windows, and Linux, connect to a Google Cloud cluster, compare server versions, and manage YAML configuration files locally with version control.

Set up currency exchange and conversion microservices on Kubernetes, update to 0.0.11-SNAPSHOT, disable spring cloud components, enable service discovery via config maps and probes, and configure Feign proxy using CURRENCY_EXCHANGE_SERVICE_HOST.

Deploy currency conversion and exchange services to Kubernetes by building docker containers, pushing them to Docker Hub, and updating responder XML with docker id, then log in and push images.

Deploy currency exchange and currency conversion microservices to Kubernetes, expose them via load balancer, and verify with curl; learn Kubernetes environment variables for service discovery and pod host names.

Explore declarative Kubernetes YAML to deploy microservices, manage deployments and services, and enable service discovery and load balancing with kubectl in a currency exchange example.

Step 18 guides cleaning up Kubernetes YAML for microservices by creating a backup in the repository, simplifying deployment and service configurations, and focusing on replicas, labels, and rolling updates.

Enable and configure Google Cloud Logging and tracing APIs to monitor microservices, including the Cloud Logging API and Stackdriver Monitoring, Trace, Error Reporting, and Profiler APIs, before deployment.

Deploy microservices with Kubernetes using deployment.yaml, manage deployments with kubectl apply and delete, and verify pods and services by curling to the external ip.

Deploy and update currency exchange and currency conversion microservices using declarative Kubernetes YAML and apply deployment changes with kubectl. Monitor external IP provisioning and verify service discovery and load balancing.

Create a custom currency exchange URI environment variable in the currency conversion service to enable reliable microservice communication via the currency-exchange URL in deployment.yaml.

Create a Kubernetes configmap to centralize configuration for the currency conversion service, using kubectl create configmap with from-literal currency_exchange_URI, and reference it in deployment.yaml to replace hard-coded values.

Explore Kubernetes centralized logging with GKE, view logs and the GKE dashboard, filter by pod and trace id, and monitor cluster and node metrics for debugging.

Explore Kubernetes deployment workflows, using kubectl rollout history, diff, and apply to safely upgrade microservices, with rollbacks like undoing currency-exchange to avoid downtime.

Configure Kubernetes liveness and readiness probes to prevent downtime during deployments for microservices, using Spring Boot Actuator health endpoints. Route traffic only to ready pods.

Configure a horizontal pod autoscaler for the currency-exchange deployment to scale pods based on cpu utilization, with min 1 and max 3, and observe autoscaling in action.

Delete the created Kubernetes cluster and reflect on a complete microservices journey using Docker and Kubernetes, with Spring Boot and Spring Cloud in this final walkthrough.

Leverage student reviews to drive Udemy’s course recommendations. Make sure you leave a review and a rating to help this course reach more learners.

Celebrate completing this course on mastering microservices with Spring Boot and Spring Cloud, and stay engaged with the in28minutes team for your ongoing learning journey.

Explore the Spring Framework hands-on by building a loosely coupled HelloWorld gaming application, and introduce dependency injection, IoC container concepts, component scan, autowiring, and interfaces across three iterations.

Set up a new Spring Initializer project, selecting Maven and Java, and use the latest released Spring Boot and Java versions. Set the group id and artifact id.

Create a tightly coupled GameRunner and MarioGame in a Spring Boot project, implementing up, down, left, right, and run methods to observe the coupling.

Explore tight coupling in the GameRunner by swapping MarioGame for SuperContraGame, recognize the need to alter code directly, and preview approaches to loosen coupling in the next step.

Introduce the GamingConsole interface to decouple game logic from the runner, allowing MarioGame and SuperContraGame (and Pacman) to implement up, down, left, and right actions.

Explore loose coupling by using interfaces with PacmanGame in the GameRunner, switching from MarioGame to PacmanGame via GamingConsole, and advance to iteration three with Spring Framework.

Explore how Spring Framework enables loose coupling by turning MarioGame and GameRunner into managed beans with @Component and @Autowired, and retrieve them from the application context to run different games.

Discover how the Spring framework identifies candidate components, wires beans by constructor, and uses singleton beans like GameRunner and MarioGame. Enable debug logging to trace autowiring and resolve bean errors.

Explore how Spring identifies components with @Component and @ComponentScan and wires dependencies. See how the application context manages Spring beans via dependency injection, autowiring, and inversion of control.

Spring framework adds value by managing object lifecycles and wiring across web, business, and data layers using annotations and autowiring, simplifying complex enterprise apps.

Resolve Spring autowiring conflicts by designating a primary bean among multiple components. Mark the Super Contra game as primary to ensure the correct bean is autowired.

Learn how Maven downloads Spring jars and manages dependencies, including transitive dependencies, via pom.xml with groupId and artifactId, and distinguish Maven dependencies from Spring dependencies.

Explore the Spring Framework dependency injection types—constructor-based, setter-based, and field injection—discover why constructor injection is recommended and see practical wiring in sample classes.

Explore the modular Spring framework, from the core IOC container to modules for testing, databases, web, reactive, and messaging. Choose the right modules for your project.

Explore how spring projects evolve with architectures, from spring boot for rest APIs and microservices to spring cloud for cloud-native apps, with spring data for NoSQL and SQL databases.

Master the spring framework essentials by exploring key terminology—dependency, dependency injection, autowiring, spring beans, components, ioc container, and application context—through hands-on practice, preparing you to build projects with spring modules.