Spring 7 & Spring Boot 4 for Beginners (Includes 8 Projects)

Install Java 25 on Windows 11 from Oracle's official downloads and configure JAVA_HOME and PATH. Verify with java -version and javac to confirm an up-to-date lts with primitive pattern matching.

Download and install the IntelliJ Idea Community Edition on Windows 11 from the official site. Access the Community Edition, free and licensed under Apache 2.0, with JVM and Android features.

Install Spring Tool Suite 4 on Windows, create a Spring Boot project, add Spring Web, and test a simple REST API at localhost:8080/hello-world.

Install Lombok in Spring Tool Suite (STS) and test by creating a Spring project; reduce boilerplate with Lombok annotations like @Data, @Getter, @Setter, and verify with a demo Student class.

Discover how the Spring Framework reduces Java development complexity by automating object creation, lifecycle, and configuration, breaking tight coupling and enabling scalable, testable applications.

Explore Spring framework features like dependency injection, inversion of control, and bean management within the Spring container, plus annotation-based configuration, loose coupling, unit testing, centralized configuration, and modular, declarative support.

Explore the core Spring framework modules, from Spring core with dependency injection to Spring context, AOP, JDBC, ORM, transaction management, MVC, security, and Spring Boot.

Create a spring application in IntelliJ IDEA by configuring a Maven project, adding spring core and spring context dependencies in pom.xml, and enabling dependency injection and bean management.

Understand tightly versus loosely coupled designs using a vehicle interface and implementations like car, bike, and cycle, and see how Spring IoC container enables loose coupling.

Explore how the Spring IoC container creates and manages Spring beans, uses dependency injection to wire dependencies, and compares bean factory with application context and their enterprise features.

Create a Java based configuration in a Spring application by defining an AppConfig class with @Configuration, creating beans with @Bean, and retrieving them from the application context using getBean.

Discover how a Spring container manages beans using Java-based configuration, enabling dependency injection to assemble car, bike, cycle, and traveler objects and retrieve them via getBean.

Learn how the Spring IoC container creates and manages beans, reads configuration files (XML, annotation-based, or Java-based), and performs dependency injection.

Understand how a Spring bean is a Java object created and managed by the Spring container through dependency injection, with component scanning and an application context providing the bean.

Learn how annotation based configuration enables the Spring IoC container to auto-detect components with @Component, configure beans with @ComponentScan, and inject dependencies with @Autowired and @Qualifier.

Explore how @Qualifier and @Primary annotations resolve bean ambiguity in Spring, guiding injection of car, bike, or cycle implementations for a vehicle interface, with examples across environments.

Explore stereotype annotations such as @Component, @Controller, @Service, and @Repository to auto-create spring beans in the spring IoC container and structure controller, service, and repository layers.

Compare Java-based and annotation-based configuration for Spring beans, highlighting manual bean creation versus container-managed objects, with @Bean, @Component, and @Autowired handling dependencies.

Understand dependency injection as a design pattern where the framework injects dependencies, enabling inversion of control and loose object coupling. See how the Spring IoC container creates and wires beans.

Explore dependency injection with a practical example, showing how a message service interface enables loose coupling between MessageSender and services like SMS and Email, and how a framework injects dependencies.

Learn how spring framework automatically injects dependencies using @Component, @Autowired, and AppConfig with component scanning to manage beans in the spring IoC container. Explore constructor, setter, and field dependency injection.

Discover constructor-based dependency injection in spring, where the container injects EmailService into a MessageSender bean via its constructor; @Autowired is optional on a single constructor since spring 4.3, and required for multiple constructors.

Explore setter-based dependency injection in Spring by annotating a setter with @Autowired and using @Qualifier to inject EmailService, while supporting an additional SMSService via another setter.

Compare constructor-based and setter-based dependency injection for mandatory and optional dependencies in Spring. Demonstrate how the Spring IoC container initializes beans and how setter injection can avoid circular dependencies.

Learn why constructor-based dependency injection is recommended in Spring 6 and Spring Boot 3, enabling initialization, immutability, and simplifying unit testing.

Learn field based dependency injection in Spring by annotating fields with @Autowired and using @Qualifier, and compare drawbacks with constructor and setter injections—immutability, testing, and tight coupling.

Explore how the bean annotation creates spring beans in a config class for address and student. Learn constructor injection, bean name customization, and retrieval by type or name.

Use the bean annotation's initMethod and destroyMethod attributes to run initialization and cleanup logic at startup and shutdown, such as inserting and removing records in a database.

Create a data source interface with getEmails, implement it with MySQL and PostgreSQL sources returning hardcoded IDs, inject into an email service, and print IDs.

Explore annotation based configuration in Spring by implementing a data source interface with MySQL and PostgreSQL beans, using @Primary and constructor injection, and running app context to print emails.

Learn to switch from annotation based configuration to Java based configuration by creating a Java config package, defining Spring bean definitions with @Bean, and injecting dependencies.

Learn how Spring Boot automatically configures common Spring beans and dependencies to reduce boilerplate. Discover its embedded Tomcat and starter dependencies for rapid, boilerplate-free Spring applications.

Explore Spring Boot features that simplify building Spring applications: starters with managed dependencies, auto configuration, externalized configuration, actuator for production insight, and embedded servlet containers.

Create your first Spring Boot project using Spring Initializr with Maven and Java, selecting Spring Boot 4, then add web dependencies to generate a runnable REST API.

Create a Spring Boot hello world rest API by building a rest controller, using the rest controller annotation and the get mapping annotation, returning a hello world json at http://localhost:8080/hello-world.

Explore how spring boot starters bundle and auto configure web, data, and security libraries, aligning versions via the bom to simplify dependency management.

Explore how the Spring Boot starter parent provides default configurations, dependency version management, and preconfigured Maven plugins. It centralizes versions via Spring Boot dependencies to simplify builds.

Learn how Spring Boot auto configuration reduces boilerplate by auto-wiring beans based on dependencies, using conditional annotations and enabling auto configuration to set up web components automatically.

Explore how spring boot auto configuration creates beans from classpath dependencies, auto-starts embedded tomcat on port 8080, and configures the dispatcher servlet and JSON converters without manual setup.

Exclude specific auto configuration classes in Spring Boot to take manual control over data source auto configuration and JDBC template auto configuration using the exclude attribute on Spring Boot.

Explore how Spring Boot conditional annotations drive auto configuration by evaluating conditions such as class presence, missing beans, properties, web vs non-web contexts, and Java version, enabling intelligent, lightweight behavior.

Discover how the Spring Boot application annotation combines @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan to enable auto configuration, component scanning, and extra beans or imported configuration.

Spring Boot starts from the main method as the run method orchestrates environment selection, the banner, and application context creation, then refreshes the context and triggers runners.

Learn how an api enables two software systems to talk, and how rest api uses http methods like get, post, put, and delete to exchange json.

Explore the six REST architectural constraints—client-server, statelessness, cacheability, uniform interface, layered system, and optional code on demand—explaining how they shape reliable, scalable APIs.

Explore resources, sub resources, and uris in rest apis, learning how each data piece is identified by a url and accessed, with examples like pizzas, orders, and reviews.

Discover how the four core HTTP methods—get, post, put, and delete—drive rest api interactions. Use get to read data, post to create, put to update, and delete to remove resources.