update 'Spring Boot' course

content/courses/spring-boot/_index.md

@@ -34,3 +34,384 @@ weight: 3
 While the spring framework is powerfull, using it often involves a lot of configuration. For example, if you want to build a web app you might need to setup a web server, configure routing and manage dependencies manually. That's when **Spring Boot** comes in.
 
 You can think of spring boot as a layer on top of the spring framework, that takes care of all of the setup.
+
+*Sring Boot* siplifies Spring development by providing sensible defaults and ready-to-use features.
+
+By the way, the spring framework is just one part of a larger family of projects in the spring ecosystem.
+
+![Spring ecosystem](assets/spring-ecosystem.svg) 
+*Img. 2 -- Spring ecosystem*
+
+| **Module Name** | **Purpose** | 
+| ------------- | -------------- |
+| *Spring Data* | Simplifying database access |
+| *Spring Security* | Adding authentication and authorization |
+| *Spring Batch* | Batch processing |
+| *Spring Cloud* | Building microservices and distributed systems |
+| *Spring Integration* | Symplifying messaging and integration between systems |
+
+--- 
+
+# Initialize Spring Boot Project 
+
+To initialize a new spring boot project you can go to [start.spring.io](https://start.spring.io/) and select options that suits you.
+
+![Spring Options](assets/spring-project-init.png)
+*Img. 3 -- Spring Boot options*
+
+After unpacking the `zip` arvhive we have this template project.
+
+```bash
+.
+├── HELP.md
+├── mvnw
+├── mvnw.cmd
+├── pom.xml
+├── src
+│   ├── main
+│   │   ├── java
+│   │   │   └── us
+│   │   │       └── fymio
+│   │   │           └── store
+│   │   │               └── StoreApplication.java
+│   │   └── resources
+│   │       └── application.properties
+│   └── test
+│       └── java
+│           └── us
+│               └── fymio
+│                   └── store
+│                       └── StoreApplicationTests.java
+└── target
+    ├── classes
+    │   ├── application.properties
+    │   └── us
+    │       └── fymio
+    │           └── store
+    │               └── StoreApplication.class
+    ├── generated-sources
+    │   └── annotations
+    ├── generated-test-sources
+    │   └── test-annotations
+    ├── maven-status
+    │   └── maven-compiler-plugin
+    │       ├── compile
+    │       │   └── default-compile
+    │       │       ├── createdFiles.lst
+    │       │       └── inputFiles.lst
+    │       └── testCompile
+    │           └── default-testCompile
+    │               ├── createdFiles.lst
+    │               └── inputFiles.lst
+    ├── surefire-reports
+    │   ├── TEST-us.fymio.store.StoreApplicationTests.xml
+    │   └── us.fymio.store.StoreApplicationTests.txt
+    └── test-classes
+        └── us
+            └── fymio
+                └── store
+                    └── StoreApplicationTests.class
+```
+
+The "heart" of our project is the file named `pom.xml`: 
+
+```xml
+<?xml version="1.0" encoding="UTF-8" ?>
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"
+>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.springframework.boot</groupId>
+		<artifactId>spring-boot-starter-parent</artifactId>
+		<version>4.0.2</version>
+		<relativePath /> <!-- lookup parent from repository -->
+	</parent>
+	<groupId>us.fymio</groupId>
+	<artifactId>store</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	<name>store</name>
+	<description>Store</description>
+	<url />
+	<licenses>
+		<license />
+	</licenses>
+	<developers>
+		<developer />
+	</developers>
+	<scm>
+		<connection />
+		<developerConnection />
+		<tag />
+		<url />
+	</scm>
+	<properties>
+		<java.version>21</java.version>
+	</properties>
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
+```
+
+Maven uses this file to download dependencies and build our project.
+
+In the `source` folder we have the actual code for our project.
+
+```bash
+src
+├── main
+│   ├── java
+│   │   └── us
+│   │       └── fymio
+│   │           └── store
+│   │               └── StoreApplication.java
+│   └── resources
+│       └── application.properties
+└── test
+    └── java
+        └── us
+            └── fymio
+                └── store
+                    └── StoreApplicationTests.java
+```
+
+The `StoreApplication.java` file is the entry point to our application.
+
+```java
+package us.fymio.store;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class StoreApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(StoreApplication.class, args);
+	}
+
+}
+```
+
+In the `main` method we have a call to `SpringApplication.run` method.
+
+If we run `mvn clean install` from the root of our project we will get this result (the output is partially reduced):
+
+```bash
+...
+[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.542 s -- in us.fymio.store.StoreApplicationTests
+[INFO]
+[INFO] Results:
+[INFO]
+[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
+[INFO]
+[INFO]
+[INFO] --- jar:3.4.2:jar (default-jar) @ store ---
+[INFO] Building jar: /home/fymio/store/target/store-0.0.1-SNAPSHOT.jar
+[INFO]
+[INFO] --- spring-boot:4.0.2:repackage (repackage) @ store ---
+...
+...
+[INFO] Installing /home/fymio/store/pom.xml to /home/fymio/.m2/repository/us/fymio/store/0.0.1-SNAPSHOT/store-0.0.1-SNAPSHOT.pom
+[INFO] Installing /home/fymio/store/target/store-0.0.1-SNAPSHOT.jar to /home/fymio/.m2/repository/us/fymio/store/0.0.1-SNAPSHOT/store-0.0.1-SNAPSHOT.jar
+[INFO] ------------------------------------------------------------------------
+[INFO] BUILD SUCCESS
+[INFO] ------------------------------------------------------------------------
+[INFO] Total time:  14.787 s
+[INFO] Finished at: 2026-02-19T13:16:47+03:00
+[INFO] ------------------------------------------------------------------------
+```
+
+So we can tell that our application was built without errors.
+
+# Dependency Management
+
+Dependencies are third-party libraries or frameworks we use in our application. For example to build a web application we need an embedded web server like *Tomcat*, we need libraries for handling web requests building APIs, processing JSON data, logging and so on. 
+
+In spring boot applications instead of adding multiple individual libraries we can use a **starter dependency**. 
+
+![Spring Boot Starter Web](assets/spring-boot-starter-web.svg) 
+*Img. 5 -- Spring Boot Starter Web*
+
+To use this dependency we just need to copy the code below to our `pom.xml` file.
+
+```xml
+<dependency>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-web</artifactId>
+    <version>4.1.0-M1</version>
+</dependency>
+```
+
+So the `dependencies` section would look like this
+
+```xml
+<dependencies>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <!-- <version>4.1.0-M1</version> -->
+        </dependency>
+	</dependencies>
+```
+
+Notice, that I commented out the version of our dependency. That's because it's a better practice to let Spring Boot decide what version of the dependency to use.
+
+# Controllers
+
+**Spring MVC** stands for *Model View Controller*. 
+
+*Model* is where our application's data lives. It represents the business logic and is usually connected to a database or other data sources. In spring boot the model can be a simple java class.
+
+*View* is what the user sees. It's the HTML, CSS or JavaScript that's rendered in the browser. In Spring MVC views can be static files or dynamically generated. 
+
+*Controller* is like a traffic controller. It handles incoming requests from the user, interacts with the model to get data and then tells the view what to display.
+
+Let's add a new java class called `HomeController`. It will be located at `src/main/java/us/fymio/store/HomeController.java`.
+
+```java
+package us.fymio.store;
+
+public class HomeController {}
+```
+
+To make this a controller we have to decorate it with the controller annotation. And import the `Controller` from `org.springframework.stereotype` package.
+
+```java
+package us.fymio.store;
+
+import org.springframework.stereotype.Controller;
+
+@Controller
+public class HomeController {}
+```
+
+Let's now add an `index` method. When we send a request to the root of our website we want this method to be called. Also we need to add another special annotation to this method.
+
+```java
+package us.fymio.store;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Controller
+public class HomeController {
+
+    @RequestMapping("/") // this represents the root of our website
+    public String index() {
+        return "index.html"; // this returns the view
+    }
+}
+```
+
+Now we need to create this view. We add the `index.html` at `src/main/resources/static/index.html`. For now let's just print "Hello world!".
+
+```html
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>View</title>
+    </head>
+    <body>
+        <h1>Hello world!</h1>
+    </body>
+</html>
+```
+
+Now let's build our application using `mvn spring-boot:run`.
+
+As we can see from the logs:
+
+```bash
+2026-02-19T14:55:23.948+03:00  INFO 36752 --- [store] [           main] o.s.boot.tomcat.TomcatWebServer          : Tomcat initialized with port 8080 (http)
+```
+
+It means that our app is up and running at [localhost:8080](http://localhost:8080/). 
+
+![Hello world!](assets/hello-world.png) 
+*Img. 7 -- Our app is up and running!*
+
+# Configuring Application Properties
+
+Let's take a look at our `application.properties` file located at `src/main/resources/application.properties`.
+
+```properties
+spring.application.name=store
+```
+
+To use this property in our code we can use the `@Value` annotation.
+
+Let's change our `HomeController` class so it prints the name of our application.
+
+```java
+package us.fymio.store;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Controller
+public class HomeController {
+
+    @Value("${spring.application.name}")
+    private String appName;
+
+    @RequestMapping("/") // this represents the root of our website
+    public String index() {
+        System.out.println("application name = " + appName);
+        return "index.html"; // this returns the view
+    }
+}
+```
+
+And as we can see after running our application there is a `store` printed out in the terminal.
+
+```bash
+...
+2026-02-19T15:32:37.507+03:00  INFO 41536 --- [store] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
+2026-02-19T15:32:37.509+03:00  INFO 41536 --- [store] [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 2 ms
+application name = store
+...
+```
+
+# Dependency injection
+
+Imagine we are building an E-Commerce application that handles placing orders. When the order is placed, the customer's payment needs to be processed so order service depends on a payment service like stripe payment service. In this case we can say that order service is *dependent* or *coupled to* stripe payment service.
+
+![Depends on/Coupled to relation](assets/depends-on-coupled-to.svg) 
+*Img. 8 -- Depends On/Coupled To relation.*