Java

Backend Syllabus

Java Fundamentals (24 Lessons)

1. Introduction to Java

1. • History, JVM, JDK, and Hello World.

1. Primitive Data Types and Variables

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

1. Operators and Expressions

1. • Arithmetic, relational, logical, and bitwise operators.

1. Control Flow Statements

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

1. Loops and Iteration

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

1. Arrays and Array Manipulation

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

1. String Handling

1. • String, StringBuilder, StringBuffer, and immutability.

1. OOP Basics: Classes, Objects, and Records

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

1. Methods, Constructors, and Initialization

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

1. Inheritance and Polymorphism

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

1. Abstraction classes

1. • abstract classes and sealed classes.

1. Encapsulation and Access Control

1. • Packages, import, access modifiers (public, private, protected).
2. Interface
   • Iterface default/static methods,

1. Exception Handling

1. • try-catch-finally
2. Exception Handling
   • Custom exceptions and try-with-resources.

1. Generics: Basics and Type Parameters

1. • Generic classes, methods, and bounded types.

1. Advanced Generics

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

1. Collections Framework: Lists and Sets

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

1. Collections Framework: Maps and Ordering

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

1. Collections Utilities

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

1. Multithreading Fundamentals

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

1. File I/O: Basics

1. • File, FileReader, FileWriter, and exception handling.

1. File I/O: Streams and Advanced Handling

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

1. Functional Programming with Lambdas

1. • Lambda syntax, @FunctionalInterface, and method references.

1. Streams API: Foundations

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

1. Advanced Streams and Parallel Processing

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

SQL with PostgreSQL (4 Lessons)

1. Introduction to PostgreSQL and Basic SQL

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

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

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

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

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

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

1. • Inversion of Control (IoC), Dependency Injection (DI).
   • Stereotype annotations: @Component, @Service, @Repository, @Autowired.

1. Spring Configuration and Profiles

1. • Java-based configuration (@Configuration, @Bean).
   • Property files (@PropertySource), environment profiles (@Profile).

1. Bean Lifecycle and Scopes

1. • @PostConstruct, @PreDestroy, bean scopes (singleton, prototype).
   • BeanFactory vs. ApplicationContext.

1. Spring AOP Basics

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

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

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

1. • HTTP client fundamentals, GET/POST requests.
   • Error handling, retries, headers, and authentication.

1. Declarative REST Clients with Feign

1. • Feign setup, interface-based API definitions.
   • Customization (logging, error decoders), basic request/response handling.

Spring Data JPA (5 Lessons)

1. JPA Entities & Mapping

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

1. Repositories & Query Methods

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

1. Custom Queries

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

1. Entity Relationships

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

1. Transactions & Optimizations

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

Spring Security (3 Lessons)

1. Authentication & Authorization Basics

1. • Security filters, in-memory/user-details authentication.
   • Role-based access control (hasRole, hasAuthority).

1. JWT Integration

1. • Token generation/validation, JwtFilter, signing keys.

1. Securing REST APIs

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

Testing (2 Lessons)

1. Unit Testing Basics with JUnit 5

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

1. • Mocking complex dependencies (e.g., REST clients, databases).
   • Parameterized tests (@ParameterizedTest).
   • Test coverage with JaCoCo, edge case testing.

Docker (2 Lessons)

1. Docker Fundamentals

1. • Containers vs. images, Docker CLI (build, run, logs).
   • Dockerfile for Spring Boot apps, multi-stage builds.

1. Docker Compose & Networking

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

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

1. Deployment & Final Demo

1. • Dockerizing the app, deploying to the cloud.
   • Demo with Postman/Swagger documentation.