Spring Boot For Software Engineers

Bootstrap your Spring Boot project from scratch with start.spring.io, choosing Maven and Java and adding web and Jersey for a quick setup with Tomcat.

Explore the Spring Boot project structure, including source with main and test, Java and Resources, pom.xml, application.properties, static and templates, and configure the JDK in IntelliJ.

Discover how to create a simple restful api with spring boot by building a pojo, a rest controller, and a get-mapped endpoint that returns hello world in json.

Define a user model for a Spring Boot course by creating a user class with id, first name, last name, age, email, and gender enum. Include constructor, getters, and toString.

Define a dao interface for user data operations, including get all users, get user by uid, insert, update, and delete, to support database access in an n-tier architecture.

Implement a fake data access object by using a map as a mock database, completing get all users, get user, update, remove, and insert methods with a static mock dataset.

Implement dao interface methods using a fake map-based database: get all users, get by uid, update, remove, and insert; note the dao returns data while service handles business logic.

Implement the service layer to manage business logic, validating user existence before deletion and returning appropriate responses, while refactoring the DAO interface with SQL-like method names for clarity.

Connect the service layer to the Dow layer using Spring dependency injection, replacing new with autowired and annotating classes with @Component, @Service, @Repository, and @Controller.

Implement the service layer business logic for user operations, using dependency injection, optional handling, and the user dao to get, insert, update, or delete users.

Write unit tests for the fake data dao in spring boot, using spring boot starter test, junit, assertJ, mockito, jsonpath, and hamcrest to verify a single Joe Jones user.

Implement unit tests that insert a user into the fake data dao, then select the user by user uid and assert the retrieved fields match.

Finish up dao tests by updating a user, selecting by uid, and asserting all fields, while validating insertions and deletions; resolve static field issues by initializing in the constructor.

Learn to test a user service by mocking the user dao with Mockito using dependency injection. Configure the mock with given and will return, then verify get all users.

Master Mockito BDD by testing get user and update user flows with given, when, and an argument captor, while verifying user dao interactions.

Develop and validate unit tests for remove and insert operations in a Spring Boot app by mocking the DAO, verifying interactions, and capturing arguments with Mockito.

Explore the restful API layer in spring boot, using the controller or resource layer to handle http requests with tomcat by default, and switch to Jetty or Undertow if desired.

Use Postman to issue HTTP GET requests against a Spring Boot RESTful API, retrieving data from a service layer and DAO layer backed by a fake database.

Configure rest end point paths with spring boot using request mapping to create versioned api urls like api/v1/users, test via IntelliJ and chrome, and handle path mapping with get endpoints.

Learn how to fetch a single user by uid with a path variable in spring boot, using a get mapping wired to the user service and testing for missing users.

Explore building robust api responses with response entity by returning 200 with the user payload when found, or 404 with a json error message when not found, using functional style.

Learn to implement a post endpoint in Spring Boot to insert a user into the database, using Postman as the client and handling response entities with ok or bad request.

Install and open Postman, use its user interface to enter the server URL, issue get, post, put, and delete requests, view history, and save calls to a collection.

Learn how to perform HTTP post requests to a Spring Boot server using Postman to send json payloads, map request bodies with @RequestBody, and enforce consumes application/json to persist users.

Discover how to perform http put requests to update a user in Spring Boot by sending a json request body and returning a response entity.

Learn how to implement a delete endpoint in Spring Boot to remove a user by uid, map a delete request, and verify results with Postman.

Explore how to use query params to filter users via a Spring MVC endpoint, capturing gender and age less than values with request parameters and testing with Postman.

Use query params to filter users by gender in spring boot, returning all users when absent; implement optional gender, streaming filter, and case handling for inputs.

Improve test code coverage by adding targeted tests for get all users by gender, handling invalid input, and running tests with coverage to reveal green and red lines, reaching 91%.

Configure server–client data formats in Spring Boot by using @Consumes and @Produces to define accepted and produced file types, including JSON, CSV, MP4, PNG, and XML.

Configure the Spring Boot server to consume and produce json by setting the media type to application/json on user resource methods like fetch users, update user, and delete user.

Explore how the Jackson library converts a list of user pojos returned by a get request into Json, and learn practical Jackson concepts for use in Spring Boot applications.

Learn to preserve immutable objects in Spring Boot by using Jackson's @JsonProperty to map first name, last name, gender, age, and email, enabling Jackson to construct user without default constructor.

Learn how Jackson serializes objects via getters and rename json properties in Spring Boot by either changing the getter to id or using @JsonProperty(name = "ID").

Expose computed json properties by adding getters that derive full name and date of birth from user data, using Jackson serialization to return derived fields.

Explore how to use the @JsonIgnore annotation in Jackson to hide fields sent to clients and tailor data for mobile or web clients.

Explore Spring MVC alternatives for building restful web services, including JAX-RS specifications and implementations such as Jersey, Apache CXF, and Rest easy.

Learn to use the PayPal rest easy spring boot starter to create restful APIs with rest easy in Spring Boot, by adding the dependency and configuring a bean.

Switch from spring mvc to rest easy by configuring an application path, creating a rest easy user resource, and wiring the user service for a working get endpoint.

Migrate the user resource from Spring MVC to JAX-RS annotations, converting post, put, delete operations, media types, path and query parameters, and building responses with the response entity.

Switch the user resource to JAX-RS annotations, implementing get, post, put, and delete with produces json and path parameters, and use optional handling to return not found or ok.

Demonstrates testing a RestEasy jax-rs endpoint with a rest controller and request mappings, then uses Postman for get, post, put, delete, and gender-based user queries.

Spring Boot includes Jersey out of the box; create a config class that extends resource config, register your endpoint, and use Jersey or rest easy annotations with no extra install.

Understand what integration tests are and why they save time by validating components work together. Use the Rest Easy client by JBoss with a proxy interface to simplify integration tests.

Explore the rest easy client with a proxy interface that mirrors API and routes http calls from client to api; install via maven and reference section 45.2 for interface details.

Create a proxy interface that mirrors the user resource API version 1 in IntelliJ, removing method bodies and imports to enable the rest client API integration.

Configure a spring bean that exposes a rest easy proxy to user resource version one by building a RestEasy client targeting localhost:8080/api/v1/users, and return the proxy for autowiring.

Learn to configure a RestEasy client to create a proxy for a user resource API, wiring it as a Spring bean from application.properties, and reuse proxies in integration tests.

Learn how Spring Boot integration tests initialize the app context, spin up an embedded server, and verify component integration using Spring Boot test with web environment options.

Learn how the web environment in Spring Boot tests runs with a mock port, and how to define or use a random port for integration tests.

Write your first integration test for a spring boot application, using a rest easy client proxy, autowire user resource version one, and fetch users to validate.

Write an integration test to insert a user and verify the new user exists in the database by fetching with a random uid.

Design an integration test to delete a user, insert a user, verify deletion with a 404 not found exception, and assert the expected exception to ensure delete functionality works.

Create and run an integration test to update a user in Spring Boot, verifying field-by-field updates and test behavior when update logic changes.

Develop and run a Spring Boot integration test to fetch users by gender, validating female and male filters and asserting included or excluded user data.

Run all integration tests in Spring Boot to verify endpoints, resources, and database interactions, and learn how missing get annotations can cause failures.