Java

• Backend Syllabus

Java Fundamentals (24 Lessons)
Introduction to Java

History, JVM, JDK, and Hello World.

Primitive Data Types and Variables

• int, double, boolean, variable declaration, and scope.

Operators and Expressions

• Arithmetic, relational, logical, and bitwise operators.

Control Flow Statements

• if-else, switch-case, and ternary operator.

Loops and Iteration

• for, while, do-while, and loop control (break, continue).

Arrays and Array Manipulation

• 1D/2D arrays, Arrays utility class, and varargs.

String Handling

• String, StringBuilder, StringBuffer, and immutability.

OOP Basics: Classes, Objects, and Records

• Class syntax, object creation, record types (immutable data carriers).

Methods, Constructors, and Initialization

• Method overloading, constructors, static/instance initializer blocks.

Inheritance and Polymorphism

• extends, method overriding, super, and runtime polymorphism.

Abstraction classes

• abstract classes and sealed classes.

Encapsulation and Access Control

• Packages, import, access modifiers (public, private, protected).

1. Interface

• Iterface default/static methods,

Exception Handling

• try-catch-finally

1. Exception Handling

• Custom exceptions and try-with-resources.

Generics: Basics and Type Parameters

• Generic classes, methods, and bounded types.

Advanced Generics

• Wildcards (?, ? extends T, ? super T), type erasure, and limitations.

Collections Framework: Lists and Sets

• ArrayList, LinkedList, HashSet, LinkedHashSet, and iteration.

Collections Framework: Maps and Ordering

• HashMap, LinkedHashMap, TreeMap, and Comparator vs. Comparable.

Collections Utilities

• Sorting, searching, Collections class, and iterator patterns.

Multithreading Fundamentals

• Thread class, Runnable, thread lifecycle, and basic synchronization.

File I/O: Basics

• File, FileReader, FileWriter, and exception handling.

File I/O: Streams and Advanced Handling

• Byte streams (InputStream, OutputStream), character streams (Reader, Writer).

Functional Programming with Lambdas

• Lambda syntax, @FunctionalInterface, and method references.

Streams API: Foundations

• Stream creation, map, filter, collect, and terminal operations.

Advanced Streams and Parallel Processing

• reduce, groupingBy, parallel streams, and performance considerations.

SQL with PostgreSQL (4 Lessons)
Introduction to PostgreSQL and Basic SQL

• PostgreSQL installation, psql CLI, and GUI tools (pgAdmin).

• CRUD Operations: SELECT, INSERT, UPDATE, DELETE.

• Data types (VARCHAR, INT, DATE), and table creation (CREATE TABLE).

Advanced Querying: Joins and Aggregation

• Joins: INNER JOIN, LEFT/RIGHT JOIN, FULL OUTER JOIN.

• Aggregation: GROUP BY, HAVING, and functions (SUM, AVG, COUNT).

• Subqueries: Nested queries, EXISTS, and IN clauses.

Database Design and Optimization

• Normalization: 1NF, 2NF, 3NF, and denormalization trade-offs.

• Indexes: CREATE INDEX, B-tree vs. Hash indexes, query optimization.

• Transactions: BEGIN, COMMIT, ROLLBACK, and ACID properties.

JDBC: Connecting Java to PostgreSQL

• JDBC architecture, DriverManager, and connection strings.

• Executing queries (Statement, PreparedStatement), handling ResultSet.

• Connection pooling basics (HikariCP) and best practices.

Git & Version Control (2 Lessons)
Git Fundamentals and Local Workflow

• Core Concepts: Repositories, commits, staging (git add), and .gitignore.

• Branching: git branch, git checkout, and branch lifecycle.

• Remote Repositories: git remote, git push/pull, GitHub/GitLab setup.

• Tools: VS Code Git integration, CLI basics, and GUIs (Sourcetree).

Team Collaboration with Git

• Merge Conflicts: Identification, resolution, and git mergetool.

• Pull Requests: Creating, reviewing, and merging PRs on GitHub.

• Workflows: Centralized vs. Feature Branch vs. GitHub Flow.

• Best Practices: Atomic commits, meaningful messages, and rebasing vs. merging.

Spring Framework (4 Lessons)
Spring Core: IoC, DI, and Annotations

• Inversion of Control (IoC), Dependency Injection (DI).

• Stereotype annotations: @Component, @Service, @Repository, @Autowired.

Spring Configuration and Profiles

• Java-based configuration (@Configuration, @Bean).

• Property files (@PropertySource), environment profiles (@Profile).

Bean Lifecycle and Scopes

• @PostConstruct, @PreDestroy, bean scopes (singleton, prototype).

• BeanFactory vs. ApplicationContext.

• Spring AOP Basics

• Aspect-Oriented Programming concepts (logging, transactions).

• @Aspect, @Before, @After, @Around advice.

• How the Web Works

• HTTP protocol, request-response cycle, IP, and ports.

• HTTP methods (GET, POST, PUT, DELETE), status codes (200, 404, 500).

• Headers, cookies, and statelessness.\

Spring Boot (4 Lessons)

• Spring Boot Fundamentals

• Starters, auto-configuration, @SpringBootApplication, embedded servers.

• Configuration with application.properties/YAML, profiles (dev, prod).

• Actuator basics: Health checks, metrics, and custom endpoints.

• RESTful APIs with Validation & Database Integration

• @RestController, @GetMapping/@PostMapping, JSON serialization.

• Input validation (@Valid, @Size), exception handling (@ControllerAdvice).

• PostgreSQL setup with Spring Data JPA, HikariCP connection pooling.

1. API Consumption with RestTemplate

• HTTP client fundamentals, GET/POST requests.

• Error handling, retries, headers, and authentication.

• Declarative REST Clients with Feign

• Feign setup, interface-based API definitions.

• Customization (logging, error decoders), basic request/response handling.

Spring Data JPA (5 Lessons)

• JPA Entities & Mapping

• @Entity, @Table, @Id, @GeneratedValue, @Column.

• Repositories & Query Methods

• CrudRepository, JpaRepository, derived queries (e.g., findByEmail).

• Custom Queries

• JPQL (@Query), native SQL queries, and parameter binding.

• Entity Relationships

• @OneToMany, @ManyToOne, @JoinColumn, bidirectional mappings.

• Transactions & Optimizations

• @Transactional, isolation levels, read-only transactions.

Spring Security (3 Lessons)

• Authentication & Authorization Basics

• Security filters, in-memory/user-details authentication.

• Role-based access control (hasRole, hasAuthority).

• JWT Integration

• Token generation/validation, JwtFilter, signing keys.

• Securing REST APIs

• CSRF/CORS configuration, method-level security (@PreAuthorize).

Testing (2 Lessons)

• Unit Testing Basics with JUnit 5

• Writing tests for services, repositories, and controllers.

• Assertions (assertEquals, assertThrows), test lifecycle (@BeforeEach, @AfterEach).

• Basic mocking with Mockito (@Mock, @InjectMocks).

• Advanced Unit Testing & Coverage

• Mocking complex dependencies (e.g., REST clients, databases).

• Parameterized tests (@ParameterizedTest).

• Test coverage with JaCoCo, edge case testing.

Docker (2 Lessons)

• Docker Fundamentals

• Containers vs. images, Docker CLI (build, run, logs).

• Dockerfile for Spring Boot apps, multi-stage builds.

• Docker Compose & Networking

• Defining services in docker-compose.yml.

• Running Spring Boot + PostgreSQL together.

• Environment variables and volume mounts.

Cloud Deployment (1 Lesson)

• Deploying to AWS/Heroku

• Deploying Dockerized apps to AWS EC2/Heroku.

• Configuring production databases (RDS/Heroku Postgres).

• Monitoring with Actuator and logging.

Final Project (2 Lessons)

• Requirements, architecture design, Git setup.

• Building REST APIs with Spring Boot, JPA, and security.

• Deployment & Final Demo

• Dockerizing the app, deploying to the cloud.

• Demo with Postman/Swagger documentation.

HTTP & Web Fundamentals (1 Lesson)
.Project Setup & Core Implementation