Another month, another book.

To refresh my Spring Framework / Spring Boot knowledge (that I'm using on day-to-day basis), I've started reading an excellent Spring in Action, 6th edition published by Manning.

I'm not sure about you, but taking notes (writing/drawing) really helps me get the most out of the book, so I'm sharing everything I have with you (for further reference).

I also really like taking notes in Markdown format. The nice thing about Markdown is, that I can publish it on dev.to and get a nice HTML automatically generated/published for further reference!!

1. Getting started with Spring

This chapter covers

• Spring and Spring Boot essentials
• Initializing a Spring project
• An overview of the Spring landscape

1.1 What is Spring?

Application Context

• at its core, Spring offers a container, often referred to as the Spring application context, that creates and manages application components

• these components, or beans, are wired together inside the Spring application context to make a complete application, much like bricks, mortar, timber...are bounded to make a house

• application components are managed and injected into each other by spring application context

Dependency Injection

• the act of wiring beans together
• dependency injected application relies on a separate entity (container) to create and maintain all components and inject those into the beans that need them.
• typically done through constructor args or property accessor methods

<bean id="inventoryService"
      class="com.example.InventoryService"
/>

<bean id="productService"
      class="com.example.ProductService">
      <constructor-arg ref="inventoryService"/>
</bean>

@Configuration
public class ServiceConfiguration {
  @Bean
  public InventoryService inventoryService() {
    return new InventoryService();
  }

  @Bean
  public ProductService productService() {
    return new ProductService(inventoryService());
  }
}

@Configuration

• indicates that class provides beans to the Spring application context

@bean

• indicates that returned object should be added as a bean in the application context

Component Scanning

• Spring automatically discover components from an application's classpath and create them as bean in the Spring application context

Autowiring

• Spring automatically injects the components with the other beans that they depend on

Spring Boot

• most well-known enhancement is auto-configuration
  • make reasonable guesses of what components need to be configured and wired together based on entries in the classpath, env vars,...

1.2 Initializing a Spring application

Initializing a Spring project with Spring Tool Suite

• Taco Cloud

  • an online app for ordering food
  • dependencies:
  • spring web
  • spring dev tools
  • thymeleaf

Exploring the build specification

• parent pom provides dependency management for several libraries commonly used in Spring projects:

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.3</version>
    <relativePath />
  </parent>

• library version is inherited from the parent version

• spring boot starter dependencies typically don't have any library code themselves, but instead transitively pull in other libraries

  • you're able to think of your dependencies in terms of what capabilities they provide, rather than their library names
  • you don't have to worry about the library version

Spring Boot Plugin

• it provides a Maven goal to run the application
• ensures that all deps. are included within the executable JAR file and available on the runtime classpath
• produces a manifest file (contains metadata) in the JAR file that denotes the bootstrap class as the main class for the executable JAR

Bootstrapping the application

@SpringBootApplication

• composite annotation that combines 3 other annotations:
  • @SpringBootConfiguration (specialized form of the @Configuration)
  • @EnableAutoConfiguration (automatically configure any component you might need)
  • @ComponentScan (spring automatically discovers/registers components, services, controllers..)

Testing the application

$ ./mvnw package
...
$ java -jar target/taco-cloud-0.0.1-SNAPSHOT.jar

$ ./mvnw package
...
$ java -jar target/taco-cloud-0.0.1-SNAPSHOT.jar

A baseline application test

• can be used to assert that the application starts

package tacos;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TacoCloudApplicationTests {

  @Test
  public void contextLoads() {
  }

}

@SpringBootTest

• tells JUnit to bootstrap the test with Spring Boot capabilities
• ocmposite annotation:
  • @ExtendWith(SpringExtension.class)

1.3 Writing a Spring application

Create Taco Cloud application homepage:

• create controlle
• create view template
• write tests

Handling web requests

Spring MVC

• controller - a class that handles req/resp
• @Controller annotation
  • identify class as a component for component scanning
• home() method
• @GetMapping
• return "home"
  • "home" is a logical name of a view
  • template name is derivered from the logical view name /templates/home.html

Defining the view

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" 
      xmlns:th="http://www.thymeleaf.org">
  <head>
    <title>Taco Cloud</title>
  </head>

  <body>
    <h1>Welcome to...</h1>
    <img th:src="@{/images/TacoCloud.png}"/>
  </body>
</html>

Static content, e.g. images are kept in the /src/main/resources/static/

Testing the controller

• perform the HTTP GET request for the root path '/'
  • expect successful result (viewName = home, content = "Welcome to...")

package tacos;

import static org.hamcrest.Matchers.containsString;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;

@WebMvcTest(HomeController.class)
public class HomeControllerTest {

  @Autowired
  private MockMvc mockMvc;

  @Test
  public void testHomePage() throws Exception {
    mockMvc.perform(get("/"))
      .andExpect(status().isOk())
      .andExpect(view().name("home"))
      .andExpect(content().string(
          containsString("Welcome to...")));
  }

}

@WebMvcTest

• special annotation provided by spring boot
• arranges the test to run in the context of a Spring MVC application
  • arranges HomeController to be registered in Spring MVC so that you can send request to it
• it doesn't start the server (mockin is good enough in this case)
• the test class is injected with a MockMvc object for the test to drive the mockup

Building and running the application

./mvnw springBoot:run

Spring Boot application tend to bring everything they need with them and don't need to be deployed to some application server. Tomcat is a part of your application.

Getting to know Spring Boot DevTools

Spring DevTools provides developers with some handy development-time tools:

• automatic application restart when code (or application properties) changes
• automatic browser refresh
• automatic disable of template caches
• built in h2 console/DB

How it works?

• there are 2 class loaders
  • first one contains you Java code, property files that change frequently
  • second one contains dependency libraries which aren't changed often
• when change is detected, first class loader is automatically restarted

Let's review

• initialized project
• wrote controller
• defined template
• wrote simple test

The main benefit is that you can focus on the code that meets the requirements of an application, rather than on satisfying the demands of a framework <- "framework-less framework"

• declare dependencies in pom.xml
  • web
  • thymeleaf

these two dependencies transitively bring in other dependencies:

• spring mvc framework
• embedded tomcat
• thymeleaf and thymeleaf layout dialect
• spring auto-configuration library

1.4 Surveying the Spring landscape

• Spring Framework (Core)
  • provides core container and dependency injection
  • provides Spring MVC, a Spring's web framework, JDBC support, WebFlux (reactive)
• Spring Boot
  • provides starter dependencies and auto-configuration
  • actuator (runtime insight into the inner workings of the application)
  • flexible specification of env. properties
  • additional testing support
  • Spring Boot CLI (alternative programming model based on Groovy scripts)
• Spring Date
  • define data repositories as Java interfaces (sql, nosql, graph,..)
• Spring Security
  • authentication, authorization, API security
• Spring Integration
  • real time integration where data is processed as it's made available
• Spring Batch
  • batched integration
• Spring Cloud
  • check out Cloud Native Spring
• Spring Native
  • Spring Boot + GraalVM => native images

1.5 Sumary

• spring aims to make developer challenges easy
  • creating web apps, working with databases, securing applications, and microservices
• spring boot builds on top of spring to make spring even easier
• spring applications can be initialized using the spring initializer
• beans (components) can be declared explicitly with Java or XML, discovered by component scanning, or automatically configured with spring boot auto-configuration