1.1 Theory: What is Java Full Stack?

• Frontend: UI built with React.
• Backend: APIs built with Spring Boot.
• Database: MySQL/PostgreSQL for persistent data.
• Deployment: CI/CD + cloud runtime.

1.2 Setup Syntax and Practical Example

# Verify tools
java -version
mvn -version
node -v
npm -v

# Create backend project
mvn archetype:generate ...

# Create frontend project
npm create vite@latest ui -- --template react

Practical: initialize backend/frontend repos, commit baseline setup, and define API contract draft in README.

2.3 Collections, Generics, Streams, and Optional

• Use generics to enforce type safety at compile time.
• Prefer stream pipelines for readable transformations.
• Use Optional for explicit null-handling in return types.

record UserSummary(Long id, String name, String email) {}

List<UserSummary> summaries = users.stream()
  .filter(User::isActive)
  .sorted(Comparator.comparing(User::getName))
  .map(u -> new UserSummary(u.getId(), u.getName(), u.getEmail()))
  .toList();

Optional<User> user = userRepo.findByEmail(email);

2.4 Exception Handling, Resource Safety, and Custom Exceptions

• Checked vs unchecked exception strategy in layered apps.
• Try-with-resources for safe cleanup.
• Custom domain exceptions mapped to API error responses.

class UserNotFoundException extends RuntimeException {
  UserNotFoundException(String email) {
    super("User not found for email: " + email);
  }
}

try (BufferedReader br = Files.newBufferedReader(path)) {
  return br.readLine();
}

2.5 JVM Memory and Concurrency Basics

• Stack vs heap understanding to avoid memory leaks.
• Thread safety and immutable data design.
• ExecutorService and CompletableFuture for async operations.

CompletableFuture<User> u1 = CompletableFuture.supplyAsync(() -> userService.get(id));
CompletableFuture<List<Order>> u2 = CompletableFuture.supplyAsync(() -> orderService.byUser(id));

CompletableFuture.allOf(u1, u2).join();

3.3 Required Design Patterns in Java Full Stack

• Factory: central object creation for configurable dependencies.
• Strategy: swap algorithms (payment, discount, notification) without `if-else` chains.
• Builder: create immutable request objects with optional fields.

interface DiscountStrategy { double apply(double amount); }

class FestivalDiscount implements DiscountStrategy {
  public double apply(double amount) { return amount * 0.9; }
}

double finalAmount = strategy.apply(cartTotal);

4.1 Subtopics

• Schema design, keys, constraints, indexing.
• Entity mapping (`@Entity`, `@OneToMany`, `@ManyToOne`).
• Custom queries and pagination.

@Entity
class Order {
  @Id @GeneratedValue
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  private User user;
}

5.1 Theory + Syntax

@SpringBootApplication
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }
}

• Auto-configuration and component scanning.
• Profiles for dev/test/prod environments.
• Configuration via `application.yml`.

5.2 Deep Theory: IoC, Bean Lifecycle, and Scopes

• Inversion of Control (IoC): Spring creates and wires objects.
• Bean lifecycle phases: instantiate -> inject -> post-process -> ready.
• Scopes: singleton, prototype, request, session (web apps).

@Component
@Scope("prototype")
class TokenGenerator {
  String generate() { return UUID.randomUUID().toString(); }
}

6.1 Syntax and Practical API

@PostMapping("/users")
public ResponseEntity<ApiResponse<UserDto>> create(
    @Valid @RequestBody CreateUserRequest request) {
  UserDto created = userService.create(request);
  return ResponseEntity.status(HttpStatus.CREATED)
      .body(ApiResponse.success(created));
}

• Resource naming and status code semantics.
• Validation using Jakarta Bean Validation.
• Global exception handler for consistent responses.

6.2 Advanced API Theory and Syntax

• Idempotency for PUT/DELETE and retry-safe operations.
• Versioning (`/v1`, `/v2`) and backward compatibility strategy.
• Standardized envelope for success and error payloads.

@GetMapping("/v1/users")
public ApiPage<UserDto> list(
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "20") int size) {
  return userService.list(page, size);
}

7.3 Token Lifecycle and Security Hardening

• Access token + refresh token model for better session security.
• Password hashing (BCrypt) and credential rotation policy.
• Rate limiting and lockout policies for login endpoints.

@Bean
PasswordEncoder passwordEncoder() {
  return new BCryptPasswordEncoder();
}

String hashed = passwordEncoder().encode(rawPassword);

8.3 Practical Case Study: Student List UI

• Build list, filter, and detail view using reusable cards.
• Implement loading, empty, and error states.
• Memoize expensive filtering using `useMemo`.

9.3 Practical Case Study: Batch Management Screen

• List page with pagination, server-side filtering, and sorting.
• Detail page with parallel API fetch (`batch`, `students`, `trainers`).
• Graceful fallback UI for partial API failure.

11.1 CI/CD Pipeline Deep Dive

# Pipeline stages
1. lint + static checks
2. backend + frontend tests
3. build backend jar and frontend bundle
4. docker build + scan + push
5. deploy staging
6. smoke + synthetic checks
7. production rollout + post-deploy validation

• Secrets management using secure vault or CI secret store.
• Artifact versioning and immutable releases.
• Blue-green/rolling strategies with rollback triggers.
• Post-deploy monitoring with logs, metrics, and alerts.

11.2 Deployment Example (Spring Boot + React)

# backend Dockerfile
FROM eclipse-temurin:17-jre
COPY target/app.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

# frontend build artifact
npm ci && npm run build

12.1 Project Scope and Subtopics

• Project: Training Management Platform.
• Modules: auth, batch management, content tracking, reporting.
• Advanced features: audit logs, pagination, search, export, dashboard metrics.

12.2 Deliverables

• Source code (frontend + backend).
• API docs / Postman collection.
• Test report and deployment link.
• Architecture diagram and README.

12.3 Evaluation Rubric (100 Marks)

• Architecture and modularity: 20
• Backend API quality and validation: 20
• Frontend UX and state management: 15
• Testing coverage and quality: 15
• Security and access control: 10
• Deployment reliability and docs: 10
• Demo clarity and Q&A defense: 10

12.4 End-to-End Walkthrough Checklist

• Create user -> assign role -> login -> access protected page.
• Create batch -> add students -> update progress -> generate report.
• Trigger validation error and show structured API response.
• Show logs/metrics and explain one optimization decision.