Java Programming Career Options for Students in Noida

// OrderService.java — a real Spring Boot service
// This is what a Java backend interview actually tests.

package com.example.orders;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;

@Service
public class OrderService {

    private final OrderRepository orders;
    private final PaymentClient payments;

    public OrderService(OrderRepository orders, PaymentClient payments) {
        this.orders = orders;
        this.payments = payments;
    }

    @Transactional
    public Order placeOrder(Long userId, List<OrderItem> items) {
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("Order must contain at least one item");
        }

        // Validate items have positive quantity and price
        for (OrderItem item : items) {
            if (item.quantity() <= 0) {
                throw new IllegalArgumentException("Quantity must be positive");
            }
            if (item.price().compareTo(BigDecimal.ZERO) < 0) {
                throw new IllegalArgumentException("Price must be non-negative");
            }
        }

        // Compute total using BigDecimal (never double for money)
        BigDecimal total = items.stream()
            .map(OrderItem::lineTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);

        Order order = new Order();
        order.setUserId(userId);
        order.setItems(items);
        order.setTotal(total);
        order.setStatus(OrderStatus.PENDING);
        order.setCreatedAt(LocalDateTime.now());

        Order saved = orders.save(order);

        // Charge the payment provider (external call)
        payments.charge(userId, total)
                .orElseThrow(() -> new PaymentFailedException(saved.getId()));

        saved.setStatus(OrderStatus.CONFIRMED);
        return orders.save(saved);
    }

    public List<Order> historyFor(Long userId) {
        return orders.findByUserIdOrderByCreatedAtDesc(userId);
    }
}

// What an interviewer looks for:
// - Constructor injection (not field injection)
// - @Transactional correctly placed on the write method
// - BigDecimal for money, never double
// - Streams used idiomatically
// - Validation and exceptions at the right boundaries
// - Separation of concerns (service, repository, client)
//
// What students from Noida often miss:
// - They memorise "Spring Boot is an annotation framework" without
//   understanding dependency injection, transactions, or layering.
// - They can build a CRUD app but cannot explain why a transaction
//   boundary matters.
// - They do not test their code — every real interview asks about tests.

// OrderServiceTest.java — JUnit tests, the thing most students skip
// Interviewers spend more time on tests than on code quality claims.

package com.example.orders;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orders;

    @Mock
    private PaymentClient payments;

    @InjectMocks
    private OrderService service;

    @Test
    void placeOrder_rejectsEmptyItems() {
        var ex = assertThrows(IllegalArgumentException.class,
            () -> service.placeOrder(1L, List.of()));
        assertEquals("Order must contain at least one item", ex.getMessage());
        verifyNoInteractions(orders, payments);
    }

    @Test
    void placeOrder_rejectsNegativePrice() {
        var badItem = new OrderItem(1L, 2, new BigDecimal("-100"));
        assertThrows(IllegalArgumentException.class,
            () -> service.placeOrder(1L, List.of(badItem)));
    }

    @Test
    void placeOrder_computesTotalCorrectly() {
        var items = List.of(
            new OrderItem(1L, 2, new BigDecimal("500")),   // 1000
            new OrderItem(2L, 1, new BigDecimal("300"))    // 300
        );

        when(orders.save(any(Order.class)))
            .thenAnswer(inv -> inv.getArgument(0));
        when(payments.charge(eq(1L), eq(new BigDecimal("1300"))))
            .thenReturn(Optional.of("TXN-123"));

        Order result = service.placeOrder(1L, items);

        assertEquals(new BigDecimal("1300"), result.getTotal());
        assertEquals(OrderStatus.CONFIRMED, result.getStatus());
    }

    @Test
    void placeOrder_throwsWhenPaymentFails() {
        var items = List.of(new OrderItem(1L, 1, new BigDecimal("500")));
        when(orders.save(any(Order.class)))
            .thenAnswer(inv -> inv.getArgument(0));
        when(payments.charge(anyLong(), any())).thenReturn(Optional.empty());

        assertThrows(PaymentFailedException.class,
            () -> service.placeOrder(1L, items));
    }
}

// What this shows an interviewer:
// - You test error paths, not just happy paths
// - You verify external interactions (payments, repository)
// - You use mocks appropriately (Mockito)
// - You write readable test names
// - You understand that tests are part of the deliverable
//
// Students who skip tests almost always lose the interview
// at the "code review" stage — even if their code works.

# Dockerfile — deploying a Java service, a skill every Noida role expects
# Multi-stage build: compile once, run small.

# Stage 1: Build
FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline

COPY src ./src
RUN mvn clean package -DskipTests

# Stage 2: Runtime — small JRE image
FROM eclipse-temurin:21-jre
WORKDIR /app

# Create non-root user (security best practice)
RUN useradd -r -u 1001 appuser
USER appuser

COPY --from=build /app/target/*.jar app.jar

# Expose the default Spring Boot port
EXPOSE 8080

# Health check — interviewers love this
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

# JVM tuning flags (memory limits for containers)
ENTRYPOINT ["java", \
  "-XX:MaxRAMPercentage=75.0", \
  "-XX:+UseG1GC", \
  "-jar", "app.jar"]

# Why this matters:
# - Multi-stage builds keep the final image small (better security)
# - Non-root user is a real interview question
# - Health checks are how Kubernetes knows your app is alive
# - MaxRAMPercentage is how you avoid the "app killed by OOM" problem
#
# What a Noida interviewer asks:
# - "How do you deploy this to production?"
# - "How do you handle config and secrets?"
# - "How do you scale this horizontally?"
# If you have done it once in a portfolio project, you can answer
# all three. If you have only run `mvn spring-boot:run`, you cannot.