Java

Backend Syllabus

Java Fundamentals (24 Lessons)

1. Introduction to Java

• History, JVM, JDK, and Hello World.

1. Primitive Data Types and Variables

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

1. Operators and Expressions

• Arithmetic, relational, logical, and bitwise operators.

1. Control Flow Statements

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

1. Loops and Iteration

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

1. Arrays and Array Manipulation

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

1. String Handling

• String, StringBuilder, StringBuffer, and immutability.

1. OOP Basics: Classes, Objects, and Records

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

1. Methods, Constructors, and Initialization

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

1. Inheritance and Polymorphism

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

1. Abstraction classes

• abstract classes and sealed classes.

1. Encapsulation and Access Control

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

1. Interface

• Iterface default/static methods,

1. Exception Handling

• try-catch-finally

1. Exception Handling

• Custom exceptions and try-with-resources.

1. Generics: Basics and Type Parameters

• Generic classes, methods, and bounded types.

1. Advanced Generics

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

1. Collections Framework: Lists and Sets

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

1. Collections Framework: Maps and Ordering

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

1. Collections Utilities

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

1. Multithreading Fundamentals

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

1. File I/O: Basics

• File, FileReader, FileWriter, and exception handling.

1. File I/O: Streams and Advanced Handling

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

1. Functional Programming with Lambdas

• Lambda syntax, @FunctionalInterface, and method references.

1. Streams API: Foundations

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

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

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

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

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

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

1. Spring Configuration and Profiles

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

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

1. Bean Lifecycle and Scopes

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

• BeanFactory vs. ApplicationContext.

1. Spring AOP Basics

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

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

(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.

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

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

1. Repositories & Query Methods

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

1. Custom Queries

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

1. Entity Relationships

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

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

1. JWT Integration

• Token generation/validation, JwtFilter, signing keys.

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

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

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

• Requirements, architecture design, Git setup.

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

1. Deployment & Final Demo

• Dockerizing the app, deploying to the cloud.

• Demo with Postman/Swagger documentation.

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