Backend Syllabus

Java Fundamentals (24 Lessons)

1. Introduction to Java
   • History, JVM, JDK, and Hello World.
2. Primitive Data Types and Variables
   • int, double, boolean, variable declaration, and scope.
3. Operators and Expressions
   • Arithmetic, relational, logical, and bitwise operators.
4. Control Flow Statements
   • if-else, switch-case, and ternary operator.
5. Loops and Iteration
   • for, while, do-while, and loop control (break, continue).
6. Arrays and Array Manipulation
   • 1D/2D arrays, Arrays utility class, and varargs.
7. String Handling
   • String, StringBuilder, StringBuffer, and immutability.
8. OOP Basics: Classes, Objects, and Records
   • Class syntax, object creation, record types (immutable data carriers).
9. Methods, Constructors, and Initialization
   • Method overloading, constructors, static/instance initializer blocks.
10. Inheritance and Polymorphism
    • extends, method overriding, super, and runtime polymorphism.
11. Abstraction classes
    • abstract classes and sealed classes.
12. Encapsulation and Access Control
    • Packages, import, access modifiers (public, private, protected).
13. Interface
    • Iterface default/static methods,
14. Exception Handling
    • try-catch-finally
15. Exception Handling
    • Custom exceptions and try-with-resources.
16. Generics: Basics and Type Parameters
    • Generic classes, methods, and bounded types.
17. Advanced Generics
    • Wildcards (?, ? extends T, ? super T), type erasure, and limitations.
18. Collections Framework: Lists and Sets
    • ArrayList, LinkedList, HashSet, LinkedHashSet, and iteration.
19. Collections Framework: Maps and Ordering
    • HashMap, LinkedHashMap, TreeMap, and Comparator vs. Comparable.
20. Collections Utilities
    • Sorting, searching, Collections class, and iterator patterns.
21. Multithreading Fundamentals
    • Thread class, Runnable, thread lifecycle, and basic synchronization.
22. File I/O: Basics
    • File, FileReader, FileWriter, and exception handling.
23. File I/O: Streams and Advanced Handling
    • Byte streams (InputStream, OutputStream), character streams (Reader, Writer).
24. Functional Programming with Lambdas
    • Lambda syntax, @FunctionalInterface, and method references.
25. Streams API: Foundations
    • Stream creation, map, filter, collect, and terminal operations.
26. Advanced Streams and Parallel Processing
    • reduce, groupingBy, parallel streams, and performance considerations.

SQL with PostgreSQL (4 Lessons)

1. 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).
2. 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.
3. 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.
4. 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)

1. 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).
2. 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)

1. Spring Core: IoC, DI, and Annotations
   • Inversion of Control (IoC), Dependency Injection (DI).
   • Stereotype annotations: @Component, @Service, @Repository, @Autowired.
2. Spring Configuration and Profiles
   • Java-based configuration (@Configuration, @Bean).
   • Property files (@PropertySource), environment profiles (@Profile).
3. Bean Lifecycle and Scopes
   • @PostConstruct, @PreDestroy, bean scopes (singleton, prototype).
   • BeanFactory vs. ApplicationContext.
4. Spring AOP Basics
   • Aspect-Oriented Programming concepts (logging, transactions).
   • @Aspect, @Before, @After, @Around advice.

HTTP & Web Fundamentals (1 Lesson)

(Added as a bridge between Spring Framework and Spring Boot)

• 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)

1. 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.
2. 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.
3. API Consumption with RestTemplate
   • HTTP client fundamentals, GET/POST requests.
   • Error handling, retries, headers, and authentication.
4. Declarative REST Clients with Feign
   • Feign setup, interface-based API definitions.
   • Customization (logging, error decoders), basic request/response handling.

Spring Data JPA (5 Lessons)

1. JPA Entities & Mapping
   • @Entity, @Table, @Id, @GeneratedValue, @Column.
2. Repositories & Query Methods
   • CrudRepository, JpaRepository, derived queries (e.g., findByEmail).
3. Custom Queries
   • JPQL (@Query), native SQL queries, and parameter binding.
4. Entity Relationships
   • @OneToMany, @ManyToOne, @JoinColumn, bidirectional mappings.
5. Transactions & Optimizations
   • @Transactional, isolation levels, read-only transactions.

Spring Security (3 Lessons)

1. Authentication & Authorization Basics
   • Security filters, in-memory/user-details authentication.
   • Role-based access control (hasRole, hasAuthority).
2. JWT Integration
   • Token generation/validation, JwtFilter, signing keys.
3. Securing REST APIs
   • CSRF/CORS configuration, method-level security (@PreAuthorize).

Testing (2 Lessons)

1. 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).
2. 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)

1. Docker Fundamentals
   • Containers vs. images, Docker CLI (build, run, logs).
   • Dockerfile for Spring Boot apps, multi-stage builds.
2. Docker Compose & Networking
   • Defining services in docker-compose.yml.
   • Running Spring Boot + PostgreSQL together.
   • Environment variables and volume mounts.

Cloud Deployment (1 Lesson)

1. 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)

1. Project Setup & Core Implementation

1. • Requirements, architecture design, Git setup.
   • Building REST APIs with Spring Boot, JPA, and security.
2. Deployment & Final Demo
   • Dockerizing the app, deploying to the cloud.
   • Demo with Postman/Swagger documentation.