Lecture 151: Overview of the final project and its goals

We've been on a long and fun ride learning the Spring Framework and related technologies. At first we covered the basics of Spring: the IoC container, dependency injection (DI), and different ways to work with Spring Beans. Then we dug into Spring Boot, where we got familiar with application configuration, autoconfiguration, YAML setup, and the built-in tools that make development smoother. We sharpened our database skills using Spring Data JPA, learned transaction management, explored security details with Spring Security, and built REST APIs.

Later we focused on practical aspects of developing with Spring Boot: from building full-featured applications to creating and testing microservices. We also integrated Apache Kafka, studied event-driven architecture, microservice patterns, and important tools like API Gateway, Service Discovery, and others.

Now it's time to put all that knowledge into practice! Today we'll start developing our final project, which will be the culmination of your Spring journey.

1. Project description

To build a bridge you first need to know what it connects. So let's step back for a moment and look at what we're going to build.

So, our project is a full-fledged Spring application with a rich feature set: REST API, security, database work, logging, monitoring, and CI/CD setup for deployment.

The goal of the project is to simulate a real-life scenario where you build a product from initial design to deployment.

Our app will include the following parts:

• REST API: users will interact with your app via convenient HTTP requests.
• Security: we'll use Spring Security and JWT to protect the app's data.
• Database work: user data and business logic will be stored in a database managed through Spring Data JPA.
• Logging and monitoring: we'll set up logging using centralized systems like ELK and monitoring via Spring Boot Actuator.
• CI/CD: simple deployment using Docker and CI/CD tools.

Application domain

Our app will simulate task management (Task Manager). This web app will let users create accounts, add tasks, update their status, delete them, and sort by various criteria.

Sample usage scenario:

1. User registers and authenticates in the system.
2. Creates a task list with descriptions, status, and deadlines.
3. Performs actions on tasks: update, delete, and view.
4. Checks task statistics (for example, how many were completed in a week).

2. Project requirements

Let's move on to what we expect from the final project. As in real life, requirements are split into functional and non-functional.

Functional requirements

1. The user must be able to register and log in to the system.
2. The system should support CRUD operations (create, read, update, delete) for tasks.
3. There should be the ability to filter tasks by status or due dates.
4. The REST API must be protected with authentication and authorization.
5. The app should expose metrics about system health.

Non-functional requirements

1. The app should be scalable and fault-tolerant.
2. Every request should be logged for later analysis.
3. The database should be optimized to store a large number of tasks.
4. The CI/CD pipeline should provide automated build and deployment of the app.

Your future work is basically the quintessence of a real corporate project. You won't just learn to design architecture and write clean code, but also to handle security, performance, and deployment.

3. Implementation plan

As one wise dev said: "If you don't plan, you're planning to fail." Let's break our task into smaller pieces.

Project phases

1. Architecture design
   • We'll define architectural styles, component interactions, and the key modules of the app.
2. Database and API creation
   • Design the database schema, create JPA entities, and implement CRUD operations via repositories.
   • Develop the REST API so clients can create, update, and delete tasks.
3. Security implementation
   • Add authentication and authorization with Spring Security and JWT.
4. Monitoring and logging
   • Integrate Spring Boot Actuator for monitoring and the ELK stack for logging.
5. Automation with CI/CD
   • Set up a pipeline for building, testing, and deploying the app in Docker containers.

Milestones

To keep the project on track, we'll introduce key milestones:

• Architecture and database readiness.
• Implementation of the API and basic CRUD operations.
• Security setup.
• Logging and monitoring.
• Successful run via Docker and a CI/CD pipeline.

Implementing the final project will not only show you how to build a product from scratch, but also teach you how to organize your work. This will give you experience that's valued in real interviews and helps on the job.

You'll understand how all parts of the app connect, from the database to a secure REST API, and how important it is to consider cross-cutting concerns like monitoring and automation. Plus, your project will make a great portfolio piece if you want to show a real example of your work to an employer.

Now that we know what we're going to do, why, and how, it's time to start implementing. Onward — to the next lecture where we'll dive into the architecture of our future app!