Full Stack Engineering

420 ore de studiu

49 ședințe live

7 luni

Maven

Project Management with Maven

- Manual dependency management - `pom.xml` file. Dependencies, versions and scopes - Maven lifecycle: `clean`, `compile`, `test`, `package` - CLI vs IDE-based management. Plugins

Inversion of Control. Dependency Injection

Inversion of Control and Dependency Injection

- The Inversion of Control (IoC) principle - What Dependency Injection (DI) is - Types of injection: constructor, setter, field injection - Java annotations as configuration metadata

Spring Framework

Spring Application Context

- Spring stereotypes: `@Component`, `@Service`, `@Repository`, `@Controller` - Injection with `@Autowired` - Explicit bean definitions. `@Bean`, `@Configuration` - The Spring `ApplicationContext`. `@ComponentScan`

Bean Configuration

Spring Bean Configuration

- Bean scopes: `singleton`, `prototype`, `request`, `session`, `application`. Use cases - Lifecycle callbacks: `@PostConstruct`, `@PreDestroy` - Configuration with `application.yml` / `application.properties`. Profile-specific files

Spring Boot

Spring Boot 3 and Auto-configuration

- How Spring Boot works. `@SpringBootApplication`. Starters. Standard project structure - Spring Initializr. Project structure. Spring Boot DevTools - `@ConfigurationProperties`. `application.yml` structure
HTTP Protocol

Network Fundamentals. HTTP

- HTTP Definition. client/server model. request/response protocol - TCP/IP. DNS - HTTP methods (`GET`, `POST`, `PUT`, `DELETE`). Status codes. Headers

REST API

REST Architecture

- REST principles - JSON as the data transfer format - Testing REST endpoints with Postman

Implementing a REST API with Spring MVC

- `@RestController`, `@RequestMapping` - `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping` - Binding request data: `@PathVariable`, `@RequestParam`, `@RequestBody` - Returning responses with `@ResponseBody`. The DTO pattern - Logging request body

Validating Incoming Requests

- Bean Validation. `@Valid` adnotation - Common constraints: `@NotNull`, `@Size`, `@Pattern` - Custom validators

Structured error responses

- `@ExceptionHandler`. `@ControllerAdvice` - Problem Details (RFC 7807): Spring Boot 3 native support. `ProblemDetail` and `ErrorResponse` - Consistent error payloads across endpoints

Task Execution and Scheduling

Background Processing

- Asynchronous processing with `@Async`. `@EnableAsync` - Scheduled jobs with `@Scheduled`. `@EnableScheduling` - Thread pool configuration - UseCase: mailing system notifications

Calling External APIs

Calling External APIs

- HttpClient. GET/POST to external APIs -Spring `RestClient`: fluent builder. Error handling with `onStatus`

File Upload and Download

File Upload and Download

- Receiving files via REST. Validating file size and type - Serving files with `Resource`

API Documentation

API Documentation with Swagger / OpenAPI 3

- `springdoc-openapi` (Spring Boot 3 compatible) - Swagger UI. Basic configuration via `application.yml` - Documentation annotations: `@Operation`, `@Parameter`, `@ApiResponse` - Exporting the OpenAPI 3 contract
Persistence with Spring Data JPA

Hibernate ORM. Entity Mapping

- ORM vs. raw SQL. JPA and Hibernate - Entity mapping: `@Entity`, `@Table`, `@Column`, `@Id`, `@GeneratedValue` - ID generation strategies - `DataSource` configuration - Lombok: `@Data`, `@Builder`, `@NoArgsConstructor`, `@AllArgsConstructor`

JpaRepository and Basic CRUD

- `JpaRepository`interface: built-in CRUD operations - The `@Repository` annotation - Service layer using the repository - Full request flow: `Controller` → `Service` → `Repository` → `Database`

Database Migrations with Flyway

- Hibernate `ddl-auto` modes. trade-offs and risks - Flyway migrations. Best practices for safe schema evolution

Entity Associations

- Entity relationships: `@OneToMany`, `@ManyToOne`, `@ManyToMany`, `@OneToOne` - `FetchType.LAZY` vs. `FetchType.EAGER`. Cascade types - Solving N+1: `JOIN FETCH` in JPQL, `@EntityGraph`, `@BatchSize`

Controlling Transaction Boundaries with `@Transactional`

- `@Transactional` fundamentals: ACID guarantees, automatic rollback on `RuntimeException`. Class-level vs. method-level annotation - Propagation and isolation: `REQUIRED` vs. `REQUIRES_NEW`

Advanced Spring Data JPA

Auditing and Custom Queries

- JPA auditing:`@CreatedDate`, `@LastModifiedDate`, `@CreatedBy` - Query methods. `@Query` with JPQL and native SQL

Pagination and DTO Mapping

- Pagination with `Pageable` and `Page`. - Interface-based projections - MapStruct: automatic entity-to-DTO mapping
Authentication and Authorization

Authentication with Spring Security

- Form login vs. HTTP Basic authentication - Session management strategies - Password hashing with `BCryptPasswordEncoder` - The `UserDetailsService` interface

Authorization

- Roles and authorities. Role-based access control - Method-level security: `@PreAuthorize`, `@Secured`. `@EnableMethodSecurity`

JWT Authentication

- JWT (JSON Web Token): structure and validation - Integrating JWT with Spring Security - The `Bearer` token and the `Authorization` header - Refresh tokens

Endpoints Security

Securing Endpoints and Best Practices

- Modern Spring Security configuration: the `SecurityFilterChain` bean - CSRF protection. Stateless REST APIs vs. session-based applications
Integration Testing

Testing REST APIs

- Integration testing - Property based testing - In-memory databases vs. Testcontainers
JavaScript and TypeScript

Introduction to JavaScript

- Primitives. Object types and references. Methods - The JavaScript Runtime. The Event Loop - Asynchronous JavaScript: Callbacks. Promises. `async` / `await`

TypeScript Introduction

Introduction to TypeScript

- Why TypeScript - Basic types - interfaces vs. type aliases
React Fundamentals

Introduction to React

- The DOM. The declarative UI model with React - JSX with TypeScript - React project structure with Vite + TypeScript

Components and Props

- Functional components - Typed props - Composition pattern. Component organization and reusability

React Hooks

- `useState`, `useEffect`, `useRef`, `useContext` - Custom hooks. Rules and best practices - `useMemo` and `useCallback`: optimising re-renders

Styling Components

- CSS Modules - Styled Components. Props. Dynamic mapping - Introduction to Tailwind CSS

Client Architecture

React Router and Navigation

- `react-router`: `BrowserRouter`, `Route`, `Link` - Programmatic navigation: `useNavigate`. Route parameters: `useParams` - Protected routes (`PrivateRoute`) - Integration with JWT-based auth context

Forms and Validation

- `react-hook-form`: `useForm`, `register`, `handleSubmit`, `formState`. Uncontrolled inputs for performance. Error display - Schema validation with Zod

Backend Integration

Communicating with a REST API from React

- The `fetch` API for HTTP requests - Environment variables

CORS and Frontend Integration

- CORS definition and role. The Same-Origin Policy - Preflight requests. Simple requests vs. preflight (`OPTIONS`) requests - CORS configuration in Spring Boot - Per-environment configuration

Authentication Flow in React

- Storing JWT: `HttpOnly` cookie vs. `localStorage` - Security trade-offs and recommendations - Global auth context. `React.createContext`. `useContext` - Logout and full state cleanup. Protecting routes based on auth state

Global State Management

Redux and Global State Management

- Redux Toolkit (the modern Redux). `createSlice`. `configureStore` - `useSelector`. `useDispatch`. Global state

Frontend Testing

Component testing

- Unit Testing. Jest - Jest usage with TanStack Query
Communication Patterns over the Network

Pull-Based Communication

- Short polling. Long Polling - Async Communication

Push-Based Communication

- Server-Sent events - WebSockets
Introduction to DevOps and CI/CD

Docker and Application Containerization

- Images and containers - `Dockerfile` for Spring Boot - Essential Docker commands

Docker Compose: Local Orchestration

- Docker Compose - Environment variables - Persistent volumes - Dependency order

Spring Boot Actuator

- Monitoring endpoints - Docker healthcheck integration - Liveness probes vs. readiness probes

CI/CD with GitHub Actions

- GitHub Actions concepts - Anatomy of a YAML workflow. Common actions - Docker workflow

Environments and Production Configuration

- Spring profiles and environment separation: `dev`, `staging`, `prod`. `application-prod.yml` - Handling sensitive configuration - What never goes into Git
Tools and Techniques for Application profiling

Performance tests for REST APIs

- K6 - Gatling - Tool selection: trade-offs and criteria

Profiling React Applications

- Profiling using browser developer tools