[NEW] Master Spring 7, Spring Boot 4, REST, JPA, Security

Explain the NoUniqueBeanDefinitionException when multiple beans share a type; fix by retrieving by name and type, as demonstrated with vehicle1, vehicle2, vehicle3.

Assign custom bean names with @Bean using name or value parameters. Use bean aliasing to provide multiple names and @Description for context.

Learn modular Spring configuration by using @Import to load multiple config classes, such as ProjectConfig and AnotherProjectConfig, exposing beans like helloWorld and LuckyNumber across the context.

Learn to create spring beans with @Component, annotating the Vehicle class and enabling @ComponentScan in ProjectConfig. Contrast this with @Bean and see how the framework creates the bean via context.getBean.

Declare bean lifecycle hooks with @PostConstruct and @PreDestroy to initialize and clean up a Spring bean. Compare alternatives like InitializingBean, DisposableBean, and initMethod/destroyMethod for bean setup and teardown.

Compare @Bean and @Component to see how @Bean creates multiple beans with custom initialization, while @Component defines a single application bean.

Identify how @Component, @Service, @Repository, and @Controller create beans and map to controller, service, and repository layers, enabling rest APIs and reusable business logic with @RestController for JSON responses.

Learn bean wiring in the spring IOC container by manually connecting dependent beans using method calls and method parameters, using @Bean to create vehicle and person beans.

Demonstrate method-based bean wiring with @Bean by defining Vehicle and Person, wiring them in ProjectConfig, and showing outputs before and after wiring to illustrate manual dependency injection.

Autowiring lets Spring automatically inject dependencies, replacing manual wiring with field, setter, or constructor injection. Constructor injection is recommended for production due to fewer drawbacks.

Explore constructor injection in Spring, see how car and engine beans are created in order and how to avoid circular dependencies while gaining testability and immutability.

Explore advanced autowiring scenarios with Spring beans, resolving ambiguity between Cappuccino and Espresso using @Primary or @Qualifier, and constructor injection in a coffee shop example.

Learn how @Qualifier and @Primary resolve multiple beans during autowiring, avoid NoUniqueBeanDefinitionException, name beans with @Component, and use @DependsOn to manage startup order, illustrated with coffee and engine examples.

Register beans programmatically in Spring 7 and Spring Boot 4 using a BeanRegistrar, environment-based conditions, and the registerBean approach with suppliers and application context, illustrated with Engine, Vehicle, and Bike.

Explore bean scopes in the Spring framework, focusing on singleton as the default and prototype for new instances, with demos showing multiple bean definitions and unique instances per context.

Learn how spring eagerly creates singleton beans by default and how @Lazy defers creation until first use. Compare eager and lazy initialization and their startup time and memory impact.

Explain prototype scope in Spring, where each bean request creates a new instance with a unique sessionId, contrasting singleton scope and guiding when to use prototype for user-specific data.

Explore official documentation on spring.io to learn core concepts like IOC container and AOP, and balance Gen AI tool use with solid Spring and Spring Boot knowledge.

Learn to build a Spring Boot back-end for a job portal with REST APIs, database interactions, caching, transactions, and validations. Test APIs with Postman and integrate with a React UI.

Learn how Spring Boot acts as the hero of the Spring ecosystem by reducing boilerplate and automatic configurations, enabling rapid web app skeletons for microservices, cloud, and backend services.

Launch your first spring boot rest endpoint with a demo controller using @RestController and @GetMapping('/home'), returning Hello World on port 8080.

Explore how Spring Boot starters bundle the libraries, configurations, and auto settings needed for a production-grade web application, simplifying dependency management and version consistency.

Explore how @RestController combines @Controller and @ResponseBody to deliver JSON in REST APIs, contrast with MVC HTML rendering, and embrace client-side rendering and loose coupling in Spring Boot apps.

Discover how the @SpringBootApplication annotation auto-configures beans, enables component scanning, and simplifies starting a Spring Boot app, with practical notes on base packages and outside packages.

Discover convention over configuration with embedded tomcat on port 8080 and overridable defaults in application.properties. See how spring boot auto-configures beans for web, json, logging, and database support.

Master REST API best practices in Spring Boot, including proper HTTP methods, noun-based paths, correct status codes, and using @RestController to return JSON.

Explore the anatomy of HTTP requests and responses in REST APIs, covering method, path, path variables, query params, headers, body, status codes, and JSON or XML payloads.

Master path variable handling in Spring by matching input parameter names to placeholders, and capture multiple variables with a single map parameter via pathVariablesMap.

Set up Postman and test REST APIs by creating collections, folders, and requests; learn base_url variable, prerequest scripts, and best practices for robust testing.

Master how to use @RequestMapping in spring boot to define a common prefix for REST APIs, handle multiple http methods, and configure paths, headers, consumes, and produces.

Learn to accept query params with @RequestParam in REST APIs alongside path variables. Configure required and optional params, set default values, and map inputs, including using maps for multiple params.

Read and utilize request headers in Spring Boot rest APIs with @RequestHeader for single headers like user-agent. Read multiple headers with Map and HttpHeaders, support optional headers with defaults.

Master spring request handling by using RequestEntity to read headers, body, query params, and path variables in one object; compare with annotations and explore ResponseEntity for responses.

Learn to structure REST responses with ResponseEntity in Spring Boot, using 200 and 201 statuses, headers, and body to convey results and errors.

Explore why api versioning matters for rest apis and how it prevents breaking changes in client applications. Learn four popular versioning approaches through a FoodRush scenario.

Explore four API versioning strategies—path versioning, request parameter versioning, header versioning, and media type versioning—using MIME types like application/vnd.myapp.v1+json to keep REST APIs stable.

Explore legacy api versioning techniques, including path, request param, header, and media type versioning, plus three-digit versioning and fallbacks, with a preview of spring 7 and spring boot 4.

Learn to implement api versioning in Spring 7 with the api versioning configurator, centralizing version control via path segment or query param, including default version and 2.0+ support.

Explain api versioning via request headers and media type with ApiVersionConfigurer in spring 7, using X-API-VERSION and a custom media type to support 1.0, 2.0, and 3.0 with a default.

Explore organizing Spring Boot projects with layer vs. feature domain package structures, compare advantages and drawbacks, and establish naming conventions for enterprise rest backend applications.

Implement a company-domain rest api for a job portal via a /api/companies controller, with a global /api prefix and media-type versioning (default 1.0; 2.0 and 3.0).

Learn to customize spring boot console logs by editing application.properties with logging.pattern.console, enabling colorized, structured patterns showing time, level, thread, logger, and message, using environment variable syntax.

Discover how Spring Boot DevTools speeds local development with fast restarts, live reload, and hot deployment, including runtime and optional scope considerations for Maven dependencies.

Learn how to integrate a spring boot application with an in-memory h2 database, enable the h2 console, and connect via Spring Data JPA for development and testing.

Pre-load an H2 database at startup by placing schema.sql and data.sql under resources, enabling Spring Boot to create tables and insert data automatically.

Configure H2 to store data on disk with a file-based url and auto_server. Switch spring.sql.init.mode to always for file-based H2, and use MySQL, Postgres, or Oracle in production.

Explore how the Spring Data umbrella provides a cohesive, database-agnostic model for data access, with Spring Data JPA built on JPA and Hibernate.

Discover how Hibernate implements the JPA specification to map Java objects to relational tables, and learn how Spring Data JPA abstracts ORM complexities with repositories and simple CRUD.

Create a company entity with @Entity, @Table, and @Column, define @Id with @GeneratedValue(IDENTITY), and map fields including @Lob and audit data using Spring Data JPA and H2.

Learn how Spring Data and Spring Data JPA provide built-in CRUD operations via the repository pattern, with interfaces like CrudRepository and ListCrudRepository that generate findAll, findById, save, delete, and more.

Explore Spring Data interfaces like CrudRepository and PagingAndSortingRepository, use findAll with Pageable for pagination and sorting, and leverage JpaRepository for combined CRUD, paging, and database specific methods.

Demonstrates building a Spring Data JPA repository, injecting CompanyRepository into a service, and using findAll() to fetch all records from the companies table via a REST controller.

Discover how Lombok reduces boilerplate by using annotations to generate getters, setters, and constructors at compile time, and configure Maven pom.xml with Lombok dependencies and annotation processing.

Master the DTO pattern for secure, efficient data transfer by converting entities to simple DTO objects, mapping fields, and decoupling presentation from data access layers to avoid exposing sensitive data.

Apply the dto pattern with a record class to create CompanyDto objects. Map entities to DTOs, omit audit fields for UI, and return DTOs from service to REST controller.

Set up a React UI for the job portal to visualize REST API data and test frontend-backend integration, including Node.js setup and addressing CORS policy.

Understand CORS in Spring Boot, including cross-origin resource sharing and browser preflight. Learn how to configure origins, credentials, and headers with @CrossOrigin, CorsFilter, and WebMvcConfigurer.

Configure cors globally in spring boot by overriding addMapping in web config, setting allowed origins, methods, headers, credentials, and max age for all urls, instead of per-controller annotations.

Install docker desktop and sign in to enable containerized development with MySQL. Replace H2 for production-ready backends and learn basic docker concepts for your Spring Boot projects.

Learn how Docker packages an application with its dependencies and configurations into a portable image, then runs it as lightweight containers with isolation, port mapping, and persistent volumes.

Spin up a MySQL database in minutes with a docker run command, using the official image from Docker Hub, set root password, map ports, and create a jobportal database.

Migrate spring boot backend from H2 to MySQL by adding the MySQL driver, configuring data source properties and env vars, and running sql scripts for the jobportal schema.

Persist MySQL data in Docker by using volumes to mount a local folder to /var/lib/mysql, ensuring data survives container restarts and deletions in cloud deployments.

Spring Boot now bootstraps dependent containers via docker compose, automating startup and shutdown of databases, RabbitMQ, Kafka, and Redis through a compose.yml.

Override the default Docker Compose file with spring.docker.compose.file and learn lifecycle options like start, stop, none, or start-only, including Docker Compose up versus start and Docker Compose down versus stop.

Build a backend REST API for a job portal contact us page using Spring Boot; define controllers, services, and repositories, and map post and get endpoints to store user inquiries.

Explore how hibernate manages the database schema with spring.jpa.hibernate.ddl-auto, illustrating modes like create, update, validate, and none and their production versus development use.

Demonstrates using spring.jpa.hibernate.ddl-auto to validate or update the database schema, showing how Hibernate creates a new contact table and enables a rest api with MySQL.

Generate JPA entity classes and repositories from database tables using JPA Buddy in IntelliJ, with optional DTOs and Lombok, via JPA designer; free version alternatives via GitHub.

Create a new contacts rest api by implementing the controller and service layers, mapping ContactRequestDto to Contact, validating persistence with the repository, and returning appropriate 201 or 500 responses.

Test the contact API with Postman and the UI, sending a json payload to create a new contact and confirm a record with status new is saved in the database.

Learn to implement global exception handling in spring boot with @RestControllerAdvice and ErrorResponseDto, delivering uniform json error responses (apiPath, errorCode, message) for all REST APIs.

Explore how Spring Boot global exception handling uses @RestControllerAdvice and @ExceptionHandler to return structured json errors with apiPath, errorCode, errorMessage, and errorTime.

Enforce backend data validations on rest apis to prevent junk or incomplete data, and avoid relying on client-side validation by returning meaningful 400 errors.

Enforce backend validations in spring boot by annotating fields with @NotBlank, @Email, @Size, and @Pattern, and apply @Valid in the controller.

Demonstrates handling backend validations with MethodArgumentNotValidException by returning a 400 with a map of field errors, and applying similar validation to query params and path variables.

Implement spring data jpa auditing by creating a base entity with created and updated fields, enabling jpa auditing, and supplying an AuditAware to capture created by and updated by.

Learn to document hundreds of REST APIs using Springdoc OpenAPI starter in a Spring Boot project, generate OpenAPI specifications, and render interactive Swagger UI for API exploration and testing.

Explore the four web-specific bean scopes: request, session, application, and web socket, and learn when each creates and destroys beans for HTTP requests, user sessions, global data, and live connections.

Demonstrates creating request-scoped and session-scoped beans in a Spring app, showing per-request bean creation and session-persistent data via REST endpoints that set and read a username John Doe.

Explore application scope in spring with ApplicationScopedBean, showing how data like a global visitor count is shared across the app via the servlet context, and compare to singleton scope.

Explore the foundation of entity relationships in Spring Data JPA, including one-to-one, one-to-many, many-to-one, and many-to-many mappings, with real-world examples and upcoming code demos.

Create the jobs table with a foreign key to companies, enable on delete cascade, and bulk load thousand test job records using SQL scripts for a Spring Data JPA workflow.

Generate a job entity from the jobs table using JPA Buddy, establishing a many-to-one relation to Company and an inverse one-to-many from Company, with cascade, orphan removal, and list-based mapping.

Explore mapping a one-to-many relationship between company and job with JPA. Learn cascade all, orphan removal, bidirectional ownership, mappedBy, join columns, and fetch type choices.

Explore fetch configurations in Spring Data JPA, including eager vs lazy loading and default fetch behavior. Learn how cascade types propagate changes from parent to child and reduce boilerplate.

Explore how @OnDelete configurations in entities control child deletions at the database level, compare on delete cascade with cascade types and orphanRemoval, and understand practical delete scenarios.

Create JobDto and CompanyDto to reflect one to many and many to one mappings, expose via rest, and transform entities to dto, with notes on active job filtering.

Learn how Spring Security secures a Spring Boot backend by enabling authentication and authorization for REST APIs, with default login, basic auth, CSRF and CORS considerations, and database-stored credentials.

Explains how spring security enables default form login and http basic for all requests using a SecurityFilterChain bean, withDefaults and customizable security configuration.

Learn how anyRequest().permitAll() and anyRequest().denyAll() control access in Spring Security, disable CSRF for testing, and apply environment-specific beans to balance security and accessibility.

Learn to craft custom security configurations with Spring security by marking rest APIs as public or secured using requestMatchers, permitAll, and authenticated, including regex-based public paths ending with public.

Expose swagger UI and OpenAPI docs while securing REST APIs with Spring Security. Externalize path rules using PathsConfig with publicPaths and securedPaths, permitting all or requiring authentication.

Understand the Spring Security internal flow from public paths through authentication filters to authentication manager and providers, including user details service and password encoding.

Explore how spring security's internal flow processes credentials through filters and the authentication manager, creating a UsernamePasswordAuthenticationToken for the DaoAuthenticationProvider.

Trace the Spring Security authentication flow: load user details via UserDetailsService (InMemoryUserDetailsManager), validate with PasswordEncoder, and create a successful authentication in the security context.