Mastering Spring Boot: From A to Z

Explore the Spring Boot framework, its core concepts and guiding principles, learn how to configure supporting tools, and build a first Groovy application with the Spring Boot command line interface.

Learn how spring boot reduces developer work through convention over configuration, sensible defaults, and easy customization, while simplifying dependency management and avoiding code generation or xml.

Explore how Spring Boot achieves automatic configuration by interviewing your code base with conditional annotations to infer web, security, and persistence needs, using starters and embedded containers.

Download and install Spring Tool Suite, an Eclipse-based environment for Spring development; extract the 64-bit Windows zip, launch Spring Tool Suite, and set up a workspace.

Install spring boot seelie CLI from the zip distribution, update your path, and run spring boot seelie commands to prototype spring applications with automatic configuration, project starters, and groovy scripts.

Demonstrates building a simple Spring application with Groovy, using a REST controller and root mapping, and running with Spring Boot to auto-configure Tomcat and MVC.

Build your foundation in spring boot basics with hands-on examples. Explore auto configuration, starter palms, and manual configuration, then bootstrap projects quickly with spring initializer.

Learn to manually configure a spring boot project using maven and a pom.xml. Add a spring boot starter parent and starter web dependency to enable a web application.

Manually configure a Spring Boot web project using preconfigured POMs and auto configuration, then create a RestController with a root endpoint and run the app.

Learn how Spring Boot starter pom reduces project complexity by auto-importing testing dependencies via the parent pom, enabling seamless unit testing with the Spring test framework.

Enable auto configuration annotation in Spring Boot to auto configure beans based on classpath and main class base package scanning for embedded Tomcat.

Explore how Spring Boot auto configuration provisions an embedded Tomcat web server, uses conditional annotations, and backs off when you customize server.port and server.context-path.

Override Spring Boot auto configuration with an external application.properties file, explore IntelliSense-assisted configuration, set server port and context path, and use placeholders for dependency injection in your project.

Discover how Spring Boot offers configuration options, including application.yml alongside properties files, to tailor project behavior. Create a yaml file and understand its hierarchical structure for settings like server.port.

Learn to configure application-specific beans in a Spring Boot project using Java configuration, including @Configuration and @Bean, then expose a Hello O'Riley bean via a rest controller.

Learn how start.spring.io, a web interface, quickly generates a spring boot project by selecting maven, boot version, coordinates, and dependencies like web, security, and data, then generate and import.

Learn to create a Spring Boot project quickly with Spring Initializer, selecting packaging, Maven or Gradle, and web dependencies via the web interface or CLI tools, then import into Eclipse.

Explore how Gradle powers Spring Boot with a Groovy-based dsl in the build.gradle file. Use the Gradle wrapper and Spring Boot plugin to build executable jars and war files.

Install the Buildship Gradle integration from the Eclipse marketplace to enable Gradle as the build tool for a Spring Boot project and set up a new Spring starter project.

Create a Spring Boot project with Gradle as build tool using the Spring Starter wizard, configure name and package, add Spring MVC web dependency, and explore Gradle tasks and wrapper.

Use the gradle wrapper to lock a specific gradle version and run a spring boot project from the root, invoking the boot run task to start Tomcat on port 80.

Explore the spring boot initializer build.gradle, including the build script block and the spring boot version property, and how the Gradle plugin uses Maven central for dependencies.

Explore configuring a Gradle build with build.gradle, applying the spring boot and eclipse plugins, and running the boot run task while comparing Gradle DSL to Maven pom.xml.

Explore how the Spring Boot Gradle plugin's boot repackaged task builds an executable jar or a war, and how to switch to a war using the war plugin.

Explore advanced Spring Boot configurations, including random values and environment-specific profiles for flexible applications. Learn to inject properties into beans and use startup interfaces to run code at boot.

Learn to generate random configuration values in Spring Boot using @Value with a random int property source, wire the bean, and expose an endpoint that returns the startup lucky number.

Run the spring boot app to generate random values with the random value property source, producing ints, longs, and alphanumeric strings configured via yaml for test data.

Explore spring boot profiles to conditionally load beans and configurations, using application configuration, @Configuration, @Bean, and @Value, with dev and prod, and override settings via properties or program arguments.

Learn to configure Spring Boot with profile specific properties files and naming conventions to select prod or default configurations via command line or run configurations.

Use the configuration properties annotation in spring boot to bind a prefix from the application properties file to bean fields and inject them.

Explore flexible property injection in Spring Boot, using all caps with underscores or dashed names, via component scanning and example.properties on the classpath.

Learn to execute code at Spring Boot startup using the application runner and command line runner interfaces, including a bean that prints startup arguments.

Implement the application runner interface and register it as a bean to access application arguments during startup. Compare with the command line runner and inject arguments via ApplicationArguments.

Explore how Spring Boot streamlines web development with auto configuration, embedded servlet containers, and templating support, while enabling caching, compression, and easy configuration of servlet filters and listeners.

Explore how Spring Boot auto configuration powers Spring MVC, enabling the dispatcher servlet, automatic static resource mapping, and default index.html routing in a sample web project.

Learn how Spring Boot autoconfiguration registers Spring Web MVC components behind the scenes, enabling Thymeleaf view resolution, content negotiating view resolver, and JSON and XML serialization with an error page.

Master mustache templating in spring boot to render dynamic html while separating ui from business logic. Configure mustache starter, set prefix and suffix, and map a controller to the template.

Learn how Spring Boot and Spring MVC implement cache busting for static client-side resources, using the resources chain with a content-hash versioning strategy via application properties.

Learn how Spring Boot serves static resources with cache busting using a version resource resolver and the fixed strategy, including enabling fixed version, setting a version, and observing URL changes.

Learn how Spring Boot uses embedded servlet containers, switch from Tomcat to Jetty, and customize behavior via server properties in the pom.xml.

Explore configuring embedded servlet containers in Spring Boot by setting host, port, and context path, enabling gzip compression, and tailoring mime types across Tomcat, Jetty, and Undertow.

Register servlet components in a Spring Boot app by creating a filter, implementing doFilter, and using component scan or Web filter annotations with an embedded container.

Explore two ways to configure Spring Boot's embedded servlet container: a programmatic customizer bean that sets the context path, and an embedded servlet container factory bean with Tomcat.

Explore Spring Boot auto configuration for Spring Security, safeguard endpoints with HTTP basic authentication, subscribe to security events with an application listener, and experiment with OETH integration and GitHub authentication.

Discover how Spring Boot auto-configures Spring Security and enables http basic authentication for web resources. Build a starter project, examine the default in-memory user, and customize credentials via application properties.

Publish and subscribe to Spring Security events with a custom application listener in Spring Boot, listening for abstract authentication failure events, logging the failure message via component scanning.

Enable oauth support in Spring Boot by adding the Spring Security OAuth dependency for single sign-on, and configure GitHub access in application.yml with client id, secret, and access token flow.

Use spring boot with spring security to implement OAuth authentication via GitHub, exposing a /user endpoint that returns the principal object of the authenticated user, with all routes protected.

Spring Boot guides you to access and persist data with H2 in-memory and MySQL databases, using JDBC template for CRUD operations, exploring connection pools, jandi data source, and test_schema setup.

Spring Boot auto-configures beans to jump start sql database work. Create an in-memory H2 database, define a stock table, and insert VMware, AT&T, and Facebook records on startup.

Wire a JDBC template through Spring Boot auto configuration and use it to query a stock table, exposing a /stocks endpoint that returns a JSON list of stocks.

Learn how spring boot exposes the h2 console for an in-memory database, configure properties, access the web console, and run the load dot sequal file to initialize the stock table.

Configure a Spring Boot project to connect to a persistent MySQL database, set up a data source, manage dependencies, and validate the connection pool for production readiness.

learn to configure and manage a data source with jandi in spring boot jdbc, run on an external container with war packaging and a provided tomcat runtime.

Configure a spring boot project to run on an external container and establish a jndi data source using a mysql jdbc driver added to the server classpath.

Master Spring Data with Spring Boot to simplify persisting data via JPA, entity manager, and repositories, with auto scanning in the IOC container and connecting to a MySQL database.

Learn to integrate Spring Boot with Spring Data JPA, set up an embedded H2 database, and build a stock entity with ID, company name, and symbol, including getters and setters.

Turn the class into a rest controller with a /stocks endpoint that returns all stocks via an entity manager and a query, leveraging Spring Boot auto configuration.

Discover how Spring Data repositories simplify data access by extending JpaRepository to create a stock repository with a find by symbol method, then autowire it into a controller.

Explore how spring boot configures hibernate ddl-auto to auto generate tables from entities, including adding a new column, with create-drop used for demos only.

Switch from an embedded to a persistent MySQL database by configuring spring boot, removing h2, adding the mysql jdbc driver, and setting the data source, credentials, and hibernate dialect.

Mastering spring boot introduces mongo db integration using spring data, mongo template, and repositories to quickly persist documents in a sandbox database, with hands-on setup instructions for a stock collection.

Create a spring boot app that persists data to a MongoDB store using the spring data mongodb starter and a stock document with id, company, symbol, CEO, and price.

Learn to build a spring boot mongo rest controller, autowire the mongo db factory, and manage a stocks endpoint that inserts and finds a document in the stocks collection.

Explore how Spring Boot auto configures a Mongo template to simplify CRUD operations and map domain objects to MongoDB documents, illustrated by inserting and querying a Tesla stock.

Learn to use Spring Boot's MongoRepository to auto-configure data access, create a stock repository extending MongoRepository, and use a findBySymbol query to retrieve documents.

Explore caching in spring boot, from a generic starter to E.H. Cash, with auto-configured beans and a cache manager. Learn both transparent annotation-based caching and explicit cache access for testing.

Leverage spring boot caching to avoid unnecessary method calls and boost performance by caching stock prices with a cached get price method in a stock tracker bean.

Enable the caching annotation in a Spring Boot application, implement the command line runner, and demonstrate that the stock tracker's get price method uses the cache after the first invocation.

Switch Spring Boot cache to ehcache by adding the dependency, configuring ehcache.xml with a price cache, and enabling debug to verify auto-configuration and cache manager creation.

Learn to use the cache manager bean auto configured by Spring Boot, inject it into the stock tracker, and fetch a symbol's price from the price cache.

Explore Spring Boot's automatic restarts and live reload for faster development, and learn to tune logback and logging, writing to files, with properties and profile-based configurations.

Learn how Spring Boot dev tools enable automatic restarts on classpath changes to speed up development with instant reloading and easy disablement via properties.

Explore how Spring Boot detects changes and uses Live Reload to automatically refresh your browser, with steps to enable the extension and configure automatic reloading.

Discover how spring boot uses logback and slf4j, adjust logging with application properties, set granular levels for packages like spring framework web, and route logs to console or a file.

configure logback in spring boot using a logback-spring.xml and a prod profile to log to a dedicated file, while using a dev profile for console debug output, via run configurations.

Explore Spring Boot actuator to monitor and manage applications via HTTP endpoints, viewing health, info, metrics, logs, heap usage, and thread dumps, while customizing endpoints.

Configure a spring boot project with actuator, expose and explore http endpoints for monitoring and diagnostics, including beans, mappings, traces, and thread dumps.

Learn to customize spring boot actuator endpoints by editing the application properties: change auto config path, enable or disable endpoints, set the management context path, and adjust health endpoint sensitivity.

Explore how spring boot exposes a health endpoint with auto configured indicators for jdbc data sources, mongo, and rattus, and learn to create a custom health indicator.

Expose and customize your Spring Boot info endpoint by configuring app name and details in the application properties file, and reference Maven properties like artifact id to avoid duplication.

Enable sending logs to a file, then access the log file via the logfile endpoint in a browser to quickly view application log entries for debugging.

Enable actuator hypermedia in Spring Boot by adding the spring-boot-starter-hateoas artifact to pom.xml, restart, and view a discovery page with hypermedia links for REST resources.

Create a custom endpoint in Spring Boot Actuator by implementing the endpoint interface and exposing it under the /custom path, with JSON responses via the invoke method.

Access the spring boot actuator metrics endpoint to view diagnostics such as memory, system load, and data source activity, then increment a counter metric within a controller's execute method.