Summary
Highlights
This course offers a comprehensive, easy-to-follow, and practical approach to mastering Spring Boot, taking you from beginner to confident application developer. It's divided into two parts: fundamentals (this video) and advanced web application/API building, packed with hands-on examples and exercises. The instructor, Mosh Hamadani, a software engineer with over 20 years of experience, has taught millions to code.
To get the most out of this course, you should have a solid understanding of Java, including object-oriented programming (classes, methods, interfaces). A refresher Java course is recommended if needed. Familiarity with relational databases and SQL (tables, primary/foreign keys, basic queries) is also essential. An SQL course is suggested for those needing to strengthen their skills in this area.
The course is structured in two parts. Part one covers Spring Boot fundamentals, building a strong foundation, while part two focuses on web applications and APIs. Part one is further divided into three sections: understanding Spring Boot, Dependency Injection, and Database Integration with Spring Data JPA. The course emphasizes sequential learning and encourages completing exercises before viewing solutions for better concept retention.
All source code for the course is available in a GitHub repository at github.com/hamedani/spring-store. Each commit in the repository corresponds to a lesson, allowing you to easily review the exact code. Tags are also provided for the beginning of each section, though following lessons in order is highly recommended for optimal learning.
This section introduces Spring Boot, its popularity, and guides you through setting up a development environment. You will create your first Spring Boot project, understand project structure, manage dependencies, and build/run your application. Essential tools like Spring Boot Dev Tools for faster development and application configuration with properties, along with debugging techniques, will also be covered.
The Spring Framework is a powerful, modular toolbox for Java applications, with modules for dependency injection, web applications (handling requests, processing data), data access (SQL, NoSQL), aspect-oriented programming (logging, security), and testing. Spring Boot builds on this by simplifying development, providing sensible defaults, and ready-to-use features to accelerate application development and reduce boilerplate code. It's part of a larger Spring ecosystem that includes projects like Spring Data, Spring Security, and Spring Cloud.
To prepare your development environment for Spring Boot, download the latest Java Development Kit (JDK), preferably JDK 23 or newer. Verify installation using 'java -version' in your terminal. The course recommends IntelliJ IDEA Ultimate Edition as the code editor due to its advanced features, smart editor, and built-in tools for Spring Boot, and a free 3-month trial is available. Maven is chosen as the build automation tool, which is built into IntelliJ IDEA; otherwise, it needs to be installed separately.
There are two ways to create a Spring Boot project. The first is using start.spring.io, where you select build tool (Maven), language (Java), Spring Boot version (latest stable), project metadata (group, artifact, name, description, package name), package type (jar), and Java version (23). The second, and recommended, method is directly through IntelliJ IDEA Ultimate Edition's 'New Project' option, which offers the same configurations, including easy JDK downloading and Git repository creation.
The project structure includes: '.idea' (IntelliJ configurations), '.mvn' (Maven wrapper for consistent builds), Git-related files, 'help.md' (getting started instructions), 'pom.xml' (Project Object Model: heart of Maven projects, defines dependencies and project configuration via XML). The 'src' folder contains main code and test code. 'main/java' holds Java files, and 'main/resources' contains non-Java files like 'application.properties' for configuration, where key-value pairs define settings such as application name, server port, or custom properties. The entry point is the 'StoreApplication.java' file with a main method calling 'SpringApplication.run'.
Dependencies are third-party libraries used in applications. Spring Boot simplifies this by using 'starter dependencies,' which are curated collections of compatible libraries (e.g., 'spring-boot-starter-web' includes Tomcat, web and MVC libraries). You can find dependencies on Maven Central and add them to your 'pom.xml' file, then reload the Maven project in IntelliJ. A better way is to add dependencies directly in IntelliJ by pressing Command+N (Mac) or Control+N (Windows), searching for the desired starter, and letting Spring Boot manage the versions by omitting the version tag in your 'pom.xml'.
To handle requests and serve an HTML file, we'll create a controller using Spring MVC (Model-View-Controller). MVC separates an application into Model (data/business logic), View (what the user sees, e.g., HTML), and Controller (handles requests, interacts with model, tells view what to display). A 'HomeController' Java class is created, annotated with '@Controller' to mark it as a web controller. A method named 'index' in this controller, annotated with '@RequestMapping("/")' to handle root requests, returns "index.html" as the view name. The corresponding 'index.html' file is placed in the 'src/main/resources/static' folder.
To run the Spring Boot application, IntelliJ users can click the play icon or use the shortcut (Ctrl+R). The console shows Tomcat starting on port 8080. You can then access the homepage by navigating to localhost:8080 in a browser. Alternatively, if not using IntelliJ, you can run the application using Maven from the terminal within the project folder. Use the Maven wrapper ('./mvnw' on Mac/Linux or 'mvnw.cmd' on Windows) with the command 'spring-boot:run'. Verify Maven version with '-V'.
Debugging is crucial for all developers. To debug a Spring Boot application, you can use print statements (System.out.println) to inspect variable values. A more robust method involves using IntelliJ's debugging tools. Set a breakpoint by clicking in the left margin next to a line of code. Start the application in 'Debug' mode (debug button or Ctrl+D). When the breakpoint is hit, execution pauses, allowing you to 'Step Over' (F8) to execute line by line, or 'Step Into' (F7) to enter a method call. The 'Variables' window shows current variable values, and expressions can be added to monitor specific values. 'Resume Program' continues execution.
Spring Boot Dev Tools allows for automatic application restarts upon code changes, improving development speed compared to manual rebuilding. To enable it, add the 'spring-boot-devtools' dependency to your 'pom.xml' with `<optional>true</optional>`. In IntelliJ IDEA, go to Settings -> Compiler and check 'Build project automatically'. Also, in Settings -> Advanced Settings, check 'Allow auto-make to start even if developed application is currently running'. While not as instantaneous as in some other environments, it still provides a beneficial automatic restart feature.
Application settings, such as server port or database credentials, are configured in 'application.properties' (or 'application.yml') using key-value pairs (e.g., 'server.port=8081', 'spring.application.name=store'). Custom properties can also be defined (e.g., 'app.page-size=10'). To use these properties in your Java code, inject them using the '@Value' annotation on a private field, specifying the property key with a special syntax: `${key_name}`. Spring will inject the property's value at runtime. This allows externalizing configurations for flexibility.
Dependency Injection (DI) is a core Spring concept that simplifies code maintenance and testing. It addresses tight coupling between classes, like an 'OrderService' depending on a 'StripePaymentService'. Tight coupling means changing one class (e.g., switching payment providers) requires modifying and retesting others, and prevents isolated testing. DI decouples classes by having them depend on interfaces (e.g., 'PaymentService' interface) instead of concrete implementations. This allows swapping implementations (Stripe, PayPal) without changing the dependent class, adhering to the 'Open/Closed Principle' (open for extension, closed for modification).
To demonstrate DI, create an 'OrderService' class with a 'placeOrder' method, and a 'StripePaymentService' class with a 'processPayment' method. Initially, 'OrderService' directly instantiates 'StripePaymentService', demonstrating tight coupling. To decouple, extract an interface 'PaymentService' from 'StripePaymentService'. Now, 'StripePaymentService' implements 'PaymentService', and 'OrderService' will depend on this interface, allowing for different payment implementations without modifying 'OrderService'.
Constructor injection is the recommended way to inject dependencies. In 'OrderService', a constructor is defined that takes a 'PaymentService' object as an argument. This argument is then stored in a private field. When creating an instance of 'OrderService' in the main application, you can pass either a 'StripePaymentService' or a 'PayPalPaymentService' (which also implements 'PaymentService'). This demonstrates how to switch implementations without modifying 'OrderService', adhering to the Open/Closed Principle. The Open/Closed Principle states that a class should be open for extension but closed for modification, reducing bugs when adding new functionality.
Another way to inject dependencies is through setter methods. In 'OrderService', generate a setter for the 'paymentService' field. This allows setting the dependency after object creation. However, setter injection is primarily for *optional* dependencies. If a dependency is *required*, using setter injection can lead to 'NullPointerException' if the setter is forgotten. Constructor injection is generally preferred for required dependencies as it ensures the object is always created with all its necessary components.
Manually creating and wiring dependencies can be tedious. Spring's Inversion of Control (IoC) container automatically creates objects (called 'beans'), injects their dependencies, and manages their lifecycle. An 'ApplicationContext' object (returned by 'SpringApplication.run') serves as the IoC container. To retrieve a bean, use `context.getBean(ClassName.class)`. If Spring doesn't know how to create an instance of a class, it will throw a 'NoSuchBeanDefinitionException'.
To tell Spring about objects it should manage, use annotations. '@Component' is a general-purpose annotation, while specialized annotations like '@Service' (for business logic), '@Repository' (for database interaction), and '@Controller' (for web requests) are often more semantically appropriate. These specialized annotations are aliases for '@Component'. When a class has a single constructor, Spring automatically autowires dependencies without an explicit '@Autowired' annotation. However, with multiple constructors, '@Autowired' is necessary to indicate which constructor Spring should use for dependency injection; otherwise, 'BeanCreationException' can occur.