Learn Spring Boot 3 in 100 Steps - No 1 Java Framework

Understand why Spring Boot powers web apps and rest APIs, compare it with Spring MVC, and master core concepts like Spring Initializer, starter projects, auto-configuration, and Actuator.

Gain a high-level view of the world before Spring Boot, where dependencies and configuration were manual. See how projects required POM.xml, web.xml, and logging, error handling, and monitoring.

Increase learning efficiency with speed watching at 1.25x–2x to save time, while balancing comprehension by starting at 1x and gradually increasing, using the Udemy interface.

Launch a Spring Boot project via Spring Initializr start.spring.io, choosing Maven and Java, then import into Eclipse and run Tomcat on port 8080 to build a REST API.

Build a simple rest API with spring boot by creating a coursecontroller that exposes /courses and returns a list of course objects with id, name, and author, via @restcontroller.

Discover how Spring Boot helps you build production-ready applications quickly by leveraging Spring Initializr, Spring Boot Starter Projects, Auto Configuration, and DevTools, plus environment-specific config, logging, and Actuator.

Explore how Spring Boot starters group dependencies into convenient descriptors, enabling rapid web apps and rest APIs with embedded Tomcat, json conversion, and testing support.

Explore how Spring Boot auto configuration simplifies web app setup by auto configuring DispatcherServlet, Tomcat, error pages, and JSON conversion with Jackson via spring-boot-autoconfigure, guided by classpath.

Boost development productivity with Spring Boot DevTools, which automatically restarts the app on code or property changes. Add spring-boot-devtools to pom.xml; changes to pom.xml require a manual restart.

Configure production readiness in Spring Boot by using profiles to manage environment-specific settings with files like application-dev.properties and application-prod.properties, and activate profiles via spring.profiles.active to merge default and profile properties.

Meet Ranga Karanam, founder of in28minutes and this course's instructor. He brings two decades of programming in Java, Python, JavaScript, with cloud certifications across AWS, Azure, and Google Cloud.

Configure complex application settings with configuration properties and profiles in Spring Boot, centralizing currency-service values from application.properties through a dedicated configuration class.

Discover how embedded servers simplify production deployments by packaging Tomcat, Jetty, or Undertow inside your Spring Boot 3 jar, avoiding the war setup and making multi-environment deployments easier.

Learn to monitor and manage a Spring Boot application in production with Actuator, exposing health, beans, metrics, env, and configprops endpoints, and selectively enabling endpoints to balance performance.

Compare Spring Boot, Spring MVC, and Spring framework, highlighting dependency injection and auto-configuration. See how starter projects, annotations, and web-focused modules simplify building web apps and rest apis.

Gain a 10,000-foot overview of Spring Boot, understand key terminology such as startup projects, auto configuration, actuator, and DevTools, and recognize the production-ready advantages.

Take notes while learning to activate active learning and memory. Review those notes every few days to reinforce long-term retention.

Create a spring boot maven project with start.spring.io, configure pom.xml, add spring boot starter webmvc, and run as a java application on tomcat.

Understand semantic versioning, the major.minor.patch-modifier format, and how major, minor, and patch numbers signal upgrade effort, with snapshots and milestones guiding stable learning and production releases.

Build your first web app with Spring Boot, mastering Spring MVC concepts and DispatcherServlet. Explore view resolver, validations, and a todo management project with Spring Security, JSP, JPA, Bootstrap.

Learn to create a Spring Boot 3 web app via Spring Initializr, choose Maven and Java, add Spring Web and DevTools, then import the Maven project into Eclipse.

Review the project: MyfirstwebappApplication.java, application.properties, and pom.xml, launch the Spring Boot 3 app on port 8080, and note dependencies like spring boot starter web and devtools.

Build your first Spring MVC controller that returns a hello message with @Controller, @RequestMapping, and @ResponseBody. Map /say-hello and run on localhost:8080 to see the message.

Learn to enhance a spring mvc controller by returning html directly, and recognize why hard-coded html is hard to maintain, prompting a shift to views for scalable web pages.

Explore a step-by-step debugging guide for spring boot web apps, using the 99-step-by-step-changes markdown in the GitHub repo, with copyable code snippets and taglib tips for debugging.

Learn how to render JSP views in Spring Boot by creating sayHello.jsp under META-INF/resources/WEB-INF/jsp, mapping the controller to say-hello-jsp, and configuring the view resolver prefix and suffix.

Create a LoginController in com.in28minutes.springboot.myfirstwebapp.login to map /login to login.jsp, then implement login.jsp and enable Spring to serve the login view with @Controller.

Explore how a Spring Boot web app handles http requests and returns html responses, using get methods, and status codes like 200 and 404, with browser inspection tools.

Learn how to capture query parameters with @RequestParam in Spring Boot, pass them via a model map, and display them in a JSP using expression language.

Configure logging levels in application.properties and use slf4j logger for your code. Learn about debug and info levels and per-package logging in Spring Boot.

Explore how the dispatcher servlet powers Spring MVC by routing requests through a front controller, separating model, view, and controller, and resolving views via a view resolver.

Discover how deep work, a state of concentrated focus and flow, maximizes efficiency and learning by creating interruption-free environments and dedicating two to three hours weekly.

Learn how to build a simple login form with user id and password, switch from get to post to secure data, and inspect the form payload.

Learn to redirect login from a JSP to a welcome page, handle GET and POST, capture credentials with RequestParam, and display them via Model in the welcome view.

Implement a hard coded authentication check in step 13 of Learn Spring Boot 3 in 100 steps, using an authentication service, constructor injection, and model-driven error messaging for invalid credentials.

Build a to-do management feature with Spring Boot 3 by creating a Todo bean and a static list Todo service tracking id, username, description, target date, and done.

Create the first version of the list todos page by building a TodoController, wiring a list-todos route to listTodos.jsp, and populating it with todos from TodoService using ModelMap.

Explore how request, model, and session scopes differ in lifetime and accessibility, and use @SessionAttributes to persist values across login, welcome, and list-todos pages.

Enhance a Spring Boot 3 app by adding JSTL dependencies and using JSTL core for each in a JSP to render a dynamic to-do list in an HTML table.

Learn to integrate Bootstrap via WebJars in a Spring Boot 3 project, add Bootstrap and jQuery dependencies, and load Bootstrap CSS and JS in JSP pages.

Apply bootstrap styling to jsp pages with a container div and bootstrap table classes for todos, and extend to login and welcome pages.

Add a new to-do view via a button linking to an add to-do page, with a JSP form for description and post handling, redirecting to the to-do list.

Stay relevant by making the best use of work time, asking why decisions are made, learning from curious colleagues, attending conferences, and following industry trends like ThoughtWorks Radar for insights.

Learn to implement a TodoService.addTodo method that creates and adds a todo with username, description, target date, and completion status, using a static in-memory list and preparing for database persistence.

Learn to implement server-side validations with Spring Boot Starter Validation, using a Command Bean and a Form Backing Object for two-way binding, and display validation errors in the Todo view.

Map the to-do form to a command bean to enable two-way binding, validate input with Jakarta validation, and display errors beside the field using binding result and form errors.

Implement a per-row delete todo feature with a delete button beside each item, linking to delete-todo with the id to remove the item via controller and service.

Learn how to add an update button, show the update to-do page by loading a to-do by its id, and prepare for submitting updates back to the list.

Implement the update-todo flow to save changes on submit using post, handle binding errors, call todoService.updateTodo with updated details, and redirect to list-todos while preserving username and target date.

Add a target date field to update and add todo pages, group description fields with a fieldset and label, and enforce a date format with spring.mvc.format.date and bootstrap datepicker.

Add a top navigation bar with Bootstrap to listTodos.jsp and todo.jsp, then reduce duplication by creating JSP fragments header, navigation, and footer and including them via the include directive.

Prepare for spring security by cleaning up login logic, routing root to a welcome page, and renaming the login controller to a welcome controller.

Add the spring-boot-starter-security dependency, run the app, and see protected urls with a generated development password, then learn to configure your own users.

Configure Spring Security with a custom in-memory user and a BCrypt password encoder, building user details with a builder, enabling login, logout, and role-based access to to-dos.

Refactor to remove hard-coded user id by retrieving the authenticated username from Spring Security. Update welcome and to-do controllers to use this dynamic username and filter to-dos accordingly.

Add and test new users in a spring boot 3 todo app by refactoring security configuration, creating a reusable user details method, and validating multi-user access.

add spring boot starter data jpa and h2 dependencies, configure the in-memory h2 database, and verify the setup with the h2 console.

Identify your learning style and optimize study habits: read a book first, watch expert videos, and optionally try hands-on for programming while prioritizing understanding to stay relevant in tech.

Configure spring security to enable the H2 console by disabling csrf and allowing frames, and by updating the security filter chain to require authentication with form login.

Explore the evolution from JDBC to Spring JDBC, then to JPA (Hibernate) and Spring Data JPA, detailing entity mapping and how Spring Data JPA simplifies repository operations.

Map the todo bean to a database table using @Entity, @Id, and @GeneratedValue, then Spring Boot auto-creates H2 tables and initializes data with data.sql.

Create a TodoRepository interface in Spring Data JPA to manage Todo entities and connect the list todos page to the H2 database using findByUsername, save, and delete.

Connect delete, update, and add todo to the database using TodoControllerJpa and todoRepository. See how JPA and Spring Data JPA save and retrieve Todo entities via repositories.

Explore the magic of Spring Boot starter data jpa and H2, including auto configuration, repository methods, and sql generation with spring.jpa.show-sql.

Explore connecting a todo app to a MySQL database with JPA and Spring Data JPA, using a Docker MySQL instance, and compare with easy H2 connections.

Complete the optional hands-on Docker installation across Windows, Mac, and Linux with Docker Desktop, follow platform-specific setup steps, and use troubleshooting guidelines for a smooth startup.

Connect your Spring Boot todo app to a Docker MySQL database by launching a MySQL container, adding the MySQL Connector/J, and configuring JDBC URL, dialect, and DDL auto.

Discover how consistency improves long-term learning, and create a concrete two-week plan with daily lecture goals, a visible reminder, and share your plan in the Q&A.

Learn why unit testing matters and how JUnit enables testing specific methods or classes, contrasting unit tests with system and integration tests, with practical examples.

Create a Java project in Eclipse, implement MyMath.calculatesum for integer arrays, and write a JUnit 5 (Jupiter) test in a separate test folder using assertEquals to verify 6.

Improve your unit testing by creating multiple tests, refactoring with a common MyMath, and inlining calculations, then validate through continuous integration with GitHub, Jenkins, or Azure DevOps.

Explore various JUnit assertions, including assertEquals, assertTrue, assertFalse, assertNull, and assertNotNull, as well as array assertions like assertArraysEquals, to write clear failure messages and robust tests.

Explore the core JUnit annotations with step-by-step examples, including @BeforeAll, @BeforeEach, @AfterAll, and @AfterEach, and learn their static usage and how test order may vary.

Develop the habit of daily learning to stay ahead of evolving technology by committing to 28 minutes of study each day for 28 days.

Explore Mockito, the popular Java mocking framework, and learn to test classes with multiple dependencies using stubs and mocks to improve unit tests.

Set up a Spring Boot 3 project with Mockito using Spring Initializer and Maven, create a simple business and data layer, and write unit tests with Mockito.

Learn to write a unit test for SomeBusinessImpl using a data service stub via constructor injection, avoiding NullPointerException and highlighting mocks as an alternative.

Learn how to write unit tests with mocks using Mockito, creating data service mocks, defining return values with when, and validating tests with JUnit.

Master mocking with Mockito annotations like @Mock and @InjectMocks to inject DataService into SomeBusinessImpl, then enable automatic mock initialization with @ExtendWith(MockitoExtension.class) for streamlined JUnit tests, including edge cases like EmptyArray.

Explore mocking with Mockito by creating a List mock, configuring size and get methods with when-thenReturn, testing with JUnit assertions, and using any parameter matchers for flexible mocks.

Discover how in28minutes promotes viewing change as an opportunity, fuels inquisitiveness, and sustains a daily habit of learning something new for 28 minutes.

Gradle blends Maven's structure with Ant's flexibility, using a Groovy or Kotlin DSL to enable incremental builds and caching, while preserving the project layout of source/main/java, resources, and test resources.

Compare Maven and Gradle, detailing Maven’s XML configuration versus Gradle’s Groovy or Kotlin DSL and incremental builds. Choose the tool that best fits project needs.

Prioritize your wellbeing while pursuing your learning goals by getting adequate sleep, following a balanced diet, and incorporating regular physical activity to support brain function.

Learn how REST structures web APIs around resources with URIs, and perform actions like retrieving, adding, updating, and deleting users and to-dos using Spring Boot.

Create a Spring Boot 3 rest api project with Maven via Spring Initializr and import it into Eclipse. Set group id com.in28minutes.springboot and artifact id first-rest-api.

Create a Hello World rest resource in Spring Boot by defining HelloWorldResource, mapping the hello-world URL, and returning 'Hello World' with @ResponseBody on port 8080.

Create a rest controller that returns a hello world bean in Spring Boot. Use @RestController to automatically include the response body, and convert the bean to JSON with Jackson.

Explore path variables and path parameters in a Spring Boot REST API, learn how to map URL segments using @PathVariable, and handle multiple path parameters in resource URIs.

Define survey and question models and build a REST API for surveys, enabling get request to localhost 8080 surveys, with a Spring service that stores and initializes surveys and questions.

Create a Spring Boot REST API to retrieve all surveys with a get /surveys endpoint, using SurveyResource and SurveyService, returning a list of surveys in JSON via Jackson.

Build a spring boot rest api to retrieve a specific survey by id using a path variable, streams, and equals, returning 404 when not found.

Explore rest api best practices by using the right http methods (get, post, put, patch, delete) and returning correct statuses for outcomes, including 200, 201, 400, 401, 404, and 500.

Learn to build rest endpoints for survey questions in spring boot, retrieving all questions by survey id and a specific question by id, with proper not found handling.

Balance hard work with regular time off by trekking the world, from Annapurna Base Camp near Pokhara in Nepal to the Via Alpina Green Trek in Switzerland, fueling renewed focus.

Implement a spring boot 3 rest api to add a new survey question with post, mapping it to a survey id via request body, and test with Talend API tester.

Enhance the post method for adding a survey question by generating a cryptographically random id with secure random and BigInteger, then assign it to the question. Return a 201 Created with a location header built from the current request path, pointing to surveys/{surveyId}/questions/{questionId} and exposing the generated id.

Implement a Spring Boot 3 REST delete method to remove a survey question by id, returning 204 no content on success.

Learn how to update a survey question with a Spring Boot 3 REST PUT, including path parameters, request body, and updating logic, preparing for automation in the next step.

Set up spring boot data jpa with h2 database, configure a mem:testdb, and build a user details entity with a jpa repository for CRUD in a rest api.

Explore Spring Boot 3 data JPA by seeding startup data with CommandLineRunner, using UserDetailsRepository to save and query users, including findByRole, and view results in the H2 console.

Expose a REST API automatically with Spring Data REST by extending PagingAndSortingRepository and configuring RepositoryRestResource, then explore paging, sorting, and creating users via post.

Learn to write your first Spring Boot integration test by launching the Spring context and using TestRestTemplate on a random port to validate the survey resource and its questions endpoint.

Learn how to write JSON asserts in Spring Boot tests using JSON assert, including strict and non-strict comparisons, ignoring spaces, and pinpointing exact mismatches in response bodies.

Improve Spring Boot integration tests by refactoring test setup, extracting the url as a constant, and strengthening JUnit asserts to verify status 200, content type application/json, and json content.

write a spring boot 3 integration test for the get surveys/Survey1/questions endpoint, validating a json list and concise id-based assertions.

Write spring boot integration tests for posting a survey question, using exchange with http entity and headers, and validate status 201 and the location header.

Learn how to enforce zero side effects in tests by combining post and delete flows, and deleting created data via a delete request to locationHeader, for integration and unit tests.

Develop a Spring Boot MockMvc unit test for the web layer by mocking the SurveyService with @MockBean and testing SurveyResource.retrieveSpecificSurveyQuestion via a GET request.

Rate this course to help Udemy's recommendation system reach more learners through your reviews today. Leave a rating and a review to support the course's visibility and progress.

Improve Spring Boot mock mvc unit tests by stubbing survey service responses with Mockito, asserting 404 and 200 results, and validating json content with JsonAssert and Jackson.

learn to write a mock mvc unit test for the post add survey question method, posting json, verifying 201 created and location header, with service mocking.

Add security to your REST APIs by integrating Spring Boot Starter Security, updating pom.xml, and testing with a user id and password.

Configure Spring Security for a Spring Boot REST API by creating in-memory users with bcrypt, switching to HTTP Basic authentication, disabling CSRF, and adjusting H2 frame options for secure access.

Learn how to fix Spring Boot unit and integration tests by disabling security for unit tests, enabling security for integration tests, and using basic auth with encoded credentials.

Minimize distractions and identify your productive zone to boost focus. Apply the Pomodoro Technique, work 25 minutes, then a five-minute break, to structure study sessions and sustain progress.

Build a loosely coupled hello world game using the Spring Framework. Understand tight and loose coupling, IoC container, application context, dependency injection, and Spring beans through hands-on iterations.

Set up a new Spring project via Spring Initializr with Maven and Java, choosing the latest released version, then import as an existing Maven project into Eclipse.

Create a tightly coupled GameRunner and MarioGame in a Spring Boot project, wiring a MarioGame constructor and a run method to print up, down, left, and right actions.

Explain tight coupling in the game runner as it switches from Mario to Super Contra, and show how to reduce coupling for looser integration.

Discover how to reduce tight coupling by introducing a GamingConsole interface and implementing it in SuperContracGame and MarioGame, enabling a flexible GameRunner to run either game.

Explore loose coupling with interfaces by swapping in a PacmanGame using the GameRunner, demonstrating how interfaces enable running Pacman without changing GameRunner.

Explore loose coupling by wiring the Mario game through the Spring Framework, turning concrete dependencies into beans managed by an application context with @Component and @Autowired.

Teaching others deepens understanding and improves communication by simplifying complex ideas. It builds confidence, expands knowledge, and fosters empathy by staying updated and adapting to learners' perspectives.

Explore how Spring identifies candidate components, wires them via constructor autowiring, and manages singleton beans, using GameRunner and MarioGame, while enabling debug logs to trace dependencies and errors.

Clarify key Spring terminology—component, @Component, dependency, ComponentScan, Spring Boot application, ApplicationContext, IoC container, bean, autowiring, and inversion of control—through concrete examples like GameRunner and MarioGame.

Spring Framework adds value by autowiring components across web, business, and data layers, letting developers focus on business logic.

Use @Primary to resolve multiple matching beans during autowiring in Spring Framework. The step shows designating a single primary bean and the error when more than one primary exists.

Learn how Maven downloads the Spring framework and its transitive dependencies via pom.xml, including groupId and artifactId, and understand the difference between Maven dependencies and Spring dependencies.

Explores the three Spring dependency injection types—constructor-based, setter-based, and field injection—and demonstrates how constructor injection keeps all dependencies ready, with setter and field approaches shown.

Explore Spring modules from the core IoC container to Spring context, and discover mock objects, Spring MVC Test, JDBC, JPA, WebFlux, and JMS for modular app design.

Explore Spring projects like Spring Boot, Spring Cloud, Spring Data, and Spring Security, and learn how evolving architectures drive cloud-native, rest apis, and microservice development.

Review the Spring Framework basics, covering dependency injection, autowiring, Spring beans, component scan, the IoC container, and the application context, with a hands-on approach to prepare for building Spring projects.

Learn to reframe failures as learning opportunities, analyze what went wrong, seek mentor input, and keep a journal of failures and lessons learned to turn setbacks into Spring Boot progress.

Get started with JPA and Hibernate using Spring Boot, JDBC, and Spring Data JPA; build an in-memory H2 project, explore differences between JPA and Hibernate, and learn the step-by-step approach.

Set up a Spring Boot project for JPA and Hibernate with Maven, add Spring Web, Spring Data JPA, Spring Data JDBC, and H2, run to see Tomcat 8080 and Hibernate.

Configure the h2 in-memory database in a spring boot 3 project, create the course table with schema.sql, and access it via the h2 console using a static jdbc url.

Master spring jakarta

Learn to insert hardcoded data with Spring JDBC by wiring a JDBC template, creating a repository, and running a startup insert via a command line runner.

Learn to insert and delete course data with Spring JDBC using parameterized queries and an H2 database. Build a course class and a JDBC repository to perform these operations.

Learn how to query data with Spring JDBC, map a ResultSet to a Course bean using BeanPropertyRowMapper, and implement findById with queryForObject.

Set long-term goals to guide your learning path and shape short-term goals, like deploying a full stack app to AWS, Azure, and Google Cloud, and mastering DevOps tools.

Map a Java bean to a database table with JPA entities and an entity manager, then insert, find, and delete with a transactional persistence context.

Explore the magic of Jpa and Spring data jpa, map course entity to course table, manage inserts, finds, and deletes with entityManager, and see sql run in the background.

Discover how Spring Data JPA simplifies JPA by handling the entity manager in the background and exposing ready-to-use repository methods for the Course entity with a long id.

Explore advanced Spring Data JPA features in Spring Boot 3 by querying repositories with findAll and count, and by defining custom methods such as findByAuthor and findByName to retrieve courses.

Understand the difference between JPA and Hibernate, with JPA as the API for defining entities and mapping, and Hibernate as its popular implementation.

View technology change as an opportunity to boost employability and creativity. Learn how embracing new tools and emerging technologies enhances problem solving and positions you for long-term success.