[NEW] Spring Boot 3 and Spring Framework 6

Spring and Spring Boot simplify building web apps, REST APIs, and more by providing plug-and-play modules, auto configurations, and reduced boilerplate for rapid application development.

Start with the Java Spring framework and learn to build web applications using Spring Boot, with dependency injection, inversion of control, component scan, Spring bean, and bean auto wiring.

Create a Spring framework project with Maven and Java using start.spring.io, choose the latest stable version, and configure the group, artifact, packaging, and Java version.

Set up a Spring Boot 3 project with Maven, manage dependencies in pom.xml, and understand the standard structure of src/main/java, src/main/resources, and src/test, then run the application.

Explore tight coupling in a Java importer service and see how a CSV importer is used, then learn how to decouple to support a JSON importer.

Learn how to shift from tight to loose coupling with a base importer interface, letting CSV and JSON importers be used interchangeably by the importer service.

Learn how Spring beans are created and managed in a bean factory and application context, using annotations or XML to define beans and retrieve them by name or type.

Leverage Spring to loosely couple a Java app by configuring beans for the importer service and its csv importer and json importer, using annotation config application context and bean injection.

Explore dependency injection in Spring by wiring an employee to its organization via autowired beans, showing how the application context creates and injects dependent objects.

Explore Spring auto wiring with primary and qualifier, resolving bean selection when multiple beans exist by injecting by type, by name, or with a qualifier.

Configure autowiring for importer services by defining two beans for CSV and JSON importers, apply primary and qualifier annotations to resolve ambiguity, and retrieve by type or name.

Learn how to mark a class with @Component to auto register it as a Spring bean in the application context, and use @ComponentScan to restrict scanning to specific packages.

Learn how spring uses dependency injection by field, setter, and constructor, with autowire, qualifiers, and primary beans, illustrated by csv and json importer examples.

Explore advanced Spring Framework concepts, including lazy and eager bean scopes, bean lifecycle, and lifecycle method injection, to plug these techniques into your Spring applications.

Explore lazy and eager initialization of Spring framework beans. See how lazy loading defers dependency injection until use and how to break cyclic dependencies in examples like the importer service.

Explore the five bean scopes in Spring: singleton, prototype, request, session, and global session, with singleton as default, and prototype creating a new bean per request.

Define bean scopes in Spring, including the default singleton and prototype via configurable bean factory, showing csv importer as prototype and json importer as singleton.

Explore how to inject behaviors into the Spring bean lifecycle using PostConstruct and PreDestroy annotations. Understand bean initialization and destruction, and see practical examples with an importer service.

Explore how Spring Boot builds on Java basics and the Spring Framework, detailing creation methods, features, and how it improves over the Spring Framework.

Understand how Spring Boot reduces boilerplate by auto-configuring databases, APIs, and servers, delivering a fat jar with an embedded server so developers focus on their application.

Create a Spring Boot application using the Spring initializer, then explore Spring CLI and IDE options, and configure Maven with Spring Boot starter web to build a runnable jar.

Create a basic hello world spring boot application using spring initializer and maven; explore the project structure, dependencies, and the main class annotated with spring boot application.

Build a hello world rest API in Spring Boot using a hello world controller with a get mapping, a Spring component wired via dependency injection, and run on port 8080.

Explore how Spring Boot embeds servers in a fat jar, defaulting to Tomcat, and how to switch to Undertow, Jetty, or Netty by adjusting dependencies and exclusions.

Learn to implement logging in Spring Boot with info, debug, trace, and error logs. Configure slf4j and loggerFactory, adjust package and root levels in application.properties, then restart to apply.

Explore how to define and read custom properties in Spring Boot using application.properties or YAML, apply config prefixes, and bind values with @Value and configuration properties.

Explore profiles in Spring Boot to load environment-specific configurations for dev, qa, and prod. Learn how to implement profile-based bean selection and different class implementations.

Understand how Spring Boot actuators expose application health, metrics, and other endpoints; learn to enable, configure, and optionally separate actuator endpoints on separate ports to monitor.

Explore Spring Data JDBC and Spring Data JPA to connect a Spring Boot app to a MySQL database, storing and retrieving data, examine JDBC advantages and disadvantages, and JPA improvements.

Install and configure MySQL on your system using MySQL Workbench, set the root user and port 3306, test the local connection, and create the app db schema for Spring Boot.

Create a Spring Boot 3.3.1 project with Maven and Java, add Spring Data JDBC and MySQL driver, and configure a data source and JDBC template to connect to your database.

Create an order_details table and use Spring JDBC to insert data via the JDBC template, including truncating the table before reinserting data.

Learn to use prepared statements in Spring JDBC to insert dynamic data with a prepared statement setter, binding id, item name, customer name, and address in a faster, pre-compiled insert.

Learn how to replace index-based inserts with named parameters using the Spring JDBC template, map parameters by name, and insert data into order details with dynamic values.

Delete data using Spring JDBC by executing a named parameter delete query with the named parameter JDBC template update method to remove the specified order id.

Execute batch inserts in Spring JDBC with batch update, using a SQL statement and an array of parameter maps to insert multiple records efficiently.

Fetch all orders with Spring JDBC by mapping query results to an OrderDetails POJO using a row mapper, then print the mapped order details.

Fetch a single order with Spring JDBC in a Spring Boot 3 app using a named parameter query and SQL parameter source, including no-data handling and row mapping.

Project a single column in Spring JDBC by using jdbc template.query for list to fetch a list of strings, such as item names from the order details table.

Discover how Spring Data JPA reduces boilerplate with ORM, lazy loading, database independence, and caching, and how entity manager and repositories power production-ready data access.

Enable spring data jpa in a spring boot 3 application, configure dependencies, create an order entity for the order details table, and fetch data using an entity manager with hibernate.

Learn how to insert and retrieve data with Spring Data JPA using the EntityManager, including persisting an order entity, fetching it by id, and managing transactions.

Learn how Spring Data JPA repositories simplify data access by defining a repository interface, using save to persist entities, and letting JPA handle select, insert, and merge operations.

Execute batch inserts and batch processing with Spring Data JPA using the repository save all method to persist a list of order entities, then fetch all records with find all.

Demonstrate derived methods in JPA to fetch order entities by item name, including find by item name, like, and order by clauses, with JPA handling queries internally.

Explore JPQL and native queries in Spring Data JPA, using derived queries, the query annotation, and native SQL options to fetch, filter, and sort order data.

learn how to fetch only selected columns with projections in spring data jpa by using a projection interface for customer details and a find all by item name query.

Learn how to paginate large datasets in Spring Boot using Spring Data JPA. Implement paging with Pageable in repository.findAll, inspect page details, and fetch the next set of records efficiently.

Build RESTful APIs with Spring Boot 3 and Spring Framework 6, implement CRUD operations with an SQL database, and learn production-ready API design, exception handling, and microservice considerations.

Design a cricket application that manages players with add, get, and delete operations. Connect the app to a MySQL database using Spring Boot 3 and Spring Framework 6.

Create a Spring Boot project via start.spring.io, using Maven with Java 21 and Spring Boot 3.3.1, then add web, data JPA, MySQL, and Lombok for a jar rest API.

Build a cricket player rest api with a three-layer Spring Boot application, including controller, service, and repository, plus entity, model, and exception handling, with YAML config and MySQL integration.

Build a post API to create a player in Spring Boot, using controller, service, and repository layers, with player request and response objects and HTTP 201 Created.

Learn how to log in a Spring Boot application using Lombok Log4j2, adding loggers in the controller and service layers to trace post requests and data flow.

Create a get mapping in the controller to fetch all players from the database and return them in a response entity with http status ok.

Implement a get-by-id endpoint in Spring Boot by using a path variable, repository find by id, optional handling, and converting the player entity to a response for precise client data.

Implement a custom runtime exception and a controller advice to return a structured error response with an error code in Spring Boot 3.

Create a delete endpoint for players using a delete mapping with an id path variable, returning an ok status and a deletion confirmation message.

Implement a search API in Spring Boot using optional query parameters, starting with a role filter. Derive a findAllByRole repository method and map entities to player responses.

Enable spring boot validation with hibernate validator to enforce not null and not empty on name and role, and apply @Valid in the controller to return 400 on invalid input.

Document your Spring Boot APIs with the OpenAPI specification and swagger UI. Add the swagger starter dependency in pom.xml, generate the OpenAPI JSON, and explore docs for endpoints like /player.

Learn to add and configure Spring Boot actuator to monitor production health, view application beans, environment variables, and metrics, expose or restrict endpoints via application.properties, and enable custom endpoints.

Explore MongoDB with Spring Boot, compare relational and NoSQL databases, and build a complete Spring Boot app that stores and retrieves data from MongoDB, including installing MongoDB.

Explore how MongoDB, a NoSQL database that stores JSON documents in collections, contrasts with relational databases and enables scalable, flexible data models; install MongoDB and build a Spring Boot app.

Install MongoDB via Docker by installing Docker, pulling the latest MongoDB image, and running a container with host port mapping. Connect with MongoDB Compass to localhost:27017 and verify basic databases.

Create a Spring Boot app that connects to a locally installed MongoDB via Spring Initializr with Spring Web and Spring Data MongoDB, then run as a jar with embedded Tomcat.

Create a Spring Boot app structure with controller, service, repository, and collection packages; implement a rest api with post mapping and MongoDB integration.

Build a Spring Boot app with MongoDB by creating a person document, a Mongo repository, service, and controller, and configuring host, port, and database in application.properties.

Build a post API in a Spring Boot 3 app to save a person to MongoDB, using a controller, service, and repository, and verify via Postman.

Create a spring boot 3 app to search mongo db data by first name. Leverage a derived repository query by first name starts with to fetch results.

Implement a find all endpoint in a Spring Boot 3 app to fetch every person from MongoDB, wiring controller, service, and repository, and verify with Postman.

Build a Spring Boot app with MongoDB by adding a derived method find by age between min and max and expose a get endpoint /person/age with min and max parameters.

Leverage the MongoDB query annotation in a Spring Boot 3 app to fetch by age between min and max, replacing derived repository methods.

Learn how to upgrade a Spring Boot app to use MongoDB alongside MySQL, keeping the API unchanged, with separate services and repositories and Spring profiles to switch databases by environment.

Configure a Spring Boot app to run with MySQL and MongoDB by creating a MongoDB entity, repository, and service, enabling two profiles for database selection, and validating startup behavior.

Configure an application to run with both MongoDB and MySQL using profiles and bean injection in Spring Boot 3 and Spring Framework 6.

Switch between SQL and MongoDB profiles in a Spring Boot app by configuring the active profile in application.yaml, connecting to MongoDB, and disabling unused MySQL connections.

Configure Spring Boot to avoid JPA auto-configuration when MongoDB profile is active by excluding the data source and Hibernate JPA auto-configuration, ensuring MongoDB handles storage.

Explore what Apache Kafka is, why we need to use Kafka, and its architecture, then learn how to use Kafka in your application and install it.

Understand apache kafka as an open-source communication system using a publish-subscribe model, where a sender publishes data to kafka topics and multiple receivers subscribe to receive updates.

Explore how Apache Kafka enables high-throughput pub/sub messaging with topics for real-time driver location updates in cab-booking apps, reducing database load and enabling scalable distributed systems.

Discover how Kafka delivers high throughput across distributed clusters and topics. Leverage fault tolerance with leader and follower replicas to ensure scalable, reliable data during peak loads.

Explore the architecture of Apache Kafka, including the Zookeeper component, the Kafka cluster, brokers, topics, partitions, and offsets, along with sender and receiver data flows.

Install Apache Kafka by following the quickstart, download the release, unzip, install Java eight plus, start ZooKeeper and Kafka, and learn to create topics and publish messages on port 9092.

Create and describe quickstart events topics with Kafka topics commands and a localhost bootstrap server, then publish and consume messages with the console producer and consumer, exploring offsets.

Build a two-app cab booking system with Spring Boot and Apache Kafka, where the driver publishes location updates to a cab location topic and the user subscribes to the location.

Configure a Spring Boot application that consumes Kafka messages from the cab location topic using a defined consumer group, with a Kafka listener printing locations and managing offsets.