brew install --cask temurin@21

java --version
# openjdk 21.0.x ...

public class Hello {   // class name must match the file name
  // main is the entry point Java looks for:
  //   public = callable from outside
  //   static = no object needed to call it
  //   void   = returns nothing
  //   String[] args = CLI arguments, like process.argv
  public static void main(String[] args) {
    String name = "world";
    System.out.println("Hello, " + name);
  }
}

java Hello.java
# Hello, world

// Imports work differently than in JS: no npm install here.
// Everything below ships with the JDK (the standard library).
// Only java.lang basics like String and System come auto-imported;
// the rest must be imported. The .* form is a wildcard,
// like `import * as` — "everything in this package".

import java.io.IOException;      // thrown by file operations
import java.nio.file.Files;      // file read/write — Node's fs
import java.nio.file.Path;       // an object for a file path
import java.util.*;              // List, Map, Set, Optional...
import java.util.concurrent.*;   // threads, CompletableFuture
import java.util.function.*;     // the types lambdas satisfy
import java.util.stream.*;       // Java's map/filter/reduce

public class Playground {
  // "throws Exception": if anything in main throws a checked
  // exception, just crash — saves try/catch while experimenting
  public static void main(String[] args) throws Exception {
    System.out.println("ready");   // console.log
  }
}

java Playground.java
# ready

mkdir -p hello-java/src/main/java/com/example
cd hello-java

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>    <!-- POM format, always 4.0.0 -->
  <groupId>com.example</groupId>        <!-- like an npm scope -->
  <artifactId>hello-java</artifactId>   <!-- "name" in package.json -->
  <version>1.0.0</version>              <!-- "version" in package.json -->

  <properties>
    <!-- Java version to compile with/for, like tsconfig "target" -->
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <!-- a <dependencies> block would go here — none needed yet -->
</project>

package com.example;   // must mirror the folder path: src/main/java/com/example/

public class App {
  public static void main(String[] args) {
    System.out.println("Hello from Maven");
  }
}

mvn clean compile
java -cp target/classes com.example.App
# Hello from Maven

plugins {
  id 'java'
}

group = 'com.example'
version = '1.0.0'

java {
  sourceCompatibility = JavaVersion.VERSION_21
}

repositories {
  mavenCentral()
}

let value = "hello";
value = 42;
value = { name: "Alice" };

String value = "hello";
System.out.println(value);
// value = 42; // uncomment this line and rerun

Playground.java:13: error: incompatible types: int cannot be converted to String

int count = 42;
double price = 19.99;
boolean active = true;
char grade = 'A';
String name = "Alice";
System.out.println(name + " scored " + grade + " with " + count + " points");
// Alice scored A with 42 points

// JavaScript
const json = `{
  "name": "Alice",
  "active": true
}`;

String json = """
  {
    "name": "Alice",
    "active": true
  }
  """;
System.out.println(json);

String name = "Alice";

// %s = "string goes here", %d = "whole number goes here"
// .formatted(...) fills them in order: %s ← name, %d ← 3
String greeting = "Hello, %s! You have %d messages.".formatted(name, 3);
System.out.println(greeting);
// Hello, Alice! You have 3 messages.

String a = "hello";
String b = new String("hello");   // force a second, separate object

System.out.println(a == b);        // false — different objects!
System.out.println(a.equals(b));   // true  — same contents

var name = "Alice"; // String, forever
var count = 42;     // int, forever
// name = 10;       // still a compile error — try it
System.out.println(name + " / " + count);

interface User { name: string; email: string; }
const user = { name: "Alice", email: "alice@example.com" };

record User(String name, String email) {}

User user = new User("Alice", "alice@example.com");
System.out.println(user.name());
// Alice
System.out.println(user);
// User[name=Alice, email=alice@example.com]

static String describe(Object value) {
  return switch (value) {
    case Integer i -> "integer: " + i;
    case String s -> "string: " + s;
    case null -> "null";
    default -> "unknown";
  };
}

System.out.println(describe(42));      // integer: 42
System.out.println(describe("hi"));    // string: hi
System.out.println(describe(null));    // null
System.out.println(describe(3.14));   // unknown

List<String> fruits = new ArrayList<>();   // mutable, like []
fruits.add("apple");                       // push
fruits.add("banana");
// fruits.add(42);                         // compile error — try it

System.out.println(fruits.get(0));         // fruits[0] → apple
System.out.println(fruits.size());         // .length  → 2

Map<String, Integer> ages = new HashMap<>();      // {} / new Map()
ages.put("Alice", 30);                            // ages["Alice"] = 30
System.out.println(ages.get("Alice"));            // 30
System.out.println(ages.getOrDefault("Bob", 0));  // no undefined —
                                                  // you pick the fallback

List<String> frozen = List.of("a", "b");
frozen.add("c");   // UnsupportedOperationException — run it and see

List<String> thawed = new ArrayList<>(List.of("a", "b"));
thawed.add("c");   // fine
System.out.println(thawed);   // [a, b, c]

List<String> fruits = List.of("apple", "banana", "cherry");

for (String fruit : fruits) {   // for (const fruit of fruits)
  System.out.println(fruit);
}

fruits.forEach(f -> System.out.println(f));   // .forEach works too

class Person {
  private String name;
  private String email;

  Person(String name, String email) {
    this.name = name;
    this.email = email;
  }

  String getName() {
    return name;
  }

  void setName(String name) {
    this.name = name;
  }

  String getEmail() {
    return email;
  }
}

Person p = new Person("Alice", "alice@example.com");
p.setName("Alicia");
System.out.println(p.getName() + " <" + p.getEmail() + ">");
// Alicia <alice@example.com>

class Animal {
  private String name;

  Animal(String name) {
    this.name = name;
  }

  String getName() {
    return name;
  }

  String speak() {
    return getName() + " makes a sound";
  }
}

class Dog extends Animal {
  Dog(String name) {
    super(name);
  }

  @Override
  String speak() {
    return getName() + " barks";
  }
}

Animal generic = new Animal("Rex");
Animal dog = new Dog("Fido");
System.out.println(generic.speak()); // Rex makes a sound
System.out.println(dog.speak());     // Fido barks

interface Greeter {
  String greet(String name);
}

class FriendlyGreeter implements Greeter {
  public String greet(String name) {
    return "Hey there, " + name + "!";
  }
}

class FormalGreeter implements Greeter {
  public String greet(String name) {
    return "Good day, " + name + ".";
  }
}

List<Greeter> greeters = List.of(new FriendlyGreeter(), new FormalGreeter());
for (Greeter g : greeters) {
  System.out.println(g.greet("Alice"));
}
// Hey there, Alice!
// Good day, Alice.

abstract class Shape {
  abstract double area();

  void printArea() {
    System.out.println("Area: " + area());
  }
}

class Circle extends Shape {
  private final double radius;

  Circle(double radius) {
    this.radius = radius;
  }

  double area() {
    return Math.PI * radius * radius;
  }
}

new Circle(2).printArea();
// Area: 12.566370614359172

// JavaScript
const upper = names.map(n => n.toUpperCase());

List<String> names = List.of("Alice", "Bob", "Charlie");

List<String> upper = names.stream()
  .map(String::toUpperCase)
  .toList();

System.out.println(upper);
// [ALICE, BOB, CHARLIE]

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);

List<Integer> evens = numbers.stream()
  .filter(n -> n % 2 == 0)
  .toList();
System.out.println(evens);
// [2, 4, 6]

int sum = numbers.stream()
  .reduce(0, Integer::sum);
System.out.println(sum);
// 21

double average = numbers.stream()
  .mapToInt(Integer::intValue)   // unbox Integer objects → raw ints,
  .average()                     // unlocking math ops like average()
  .orElse(0.0);
System.out.println(average);
// 3.5

List<String> names = List.of("Alice", "Bob", "Charlie");

Set<String> unique = names.stream().collect(Collectors.toSet());

Map<String, Integer> nameLengths = names.stream()
  .collect(Collectors.toMap(Function.identity(), String::length));

System.out.println(nameLengths);
// {Bob=3, Alice=5, Charlie=7}

static Optional<String> findUser(long id) {
  return id == 1 ? Optional.of("Alice") : Optional.empty();
}

String found = findUser(1).map(String::toUpperCase).orElse("UNKNOWN");
String missing = findUser(99).map(String::toUpperCase).orElse("UNKNOWN");
System.out.println(found);   // ALICE
System.out.println(missing); // UNKNOWN

String s = null;
System.out.println(s.length()); // NullPointerException at runtime

String maybeNull = Math.random() > 0.5 ? "hello" : null;

String result = Optional.ofNullable(maybeNull)
  .map(String::toUpperCase)
  .orElse("nothing there");

System.out.println(result);
// HELLO (or: nothing there)

try {
  String content = Files.readString(Path.of("data.json"));
  System.out.println(content);
} catch (IOException e) {
  System.out.println("Could not read file: " + e.getMessage());
}
// Could not read file: data.json

echo '{"ok": true}' > data.json
java Playground.java
# {"ok": true}

try (var reader = Files.newBufferedReader(Path.of("data.json"))) {
  System.out.println(reader.readLine());
} catch (IOException e) {
  throw new RuntimeException(e);
}

class UserNotFoundException extends RuntimeException {
  UserNotFoundException(long id) {
    super("User not found: " + id);
  }
}

try {
  throw new UserNotFoundException(42);
} catch (UserNotFoundException e) {
  System.out.println(e.getMessage());
}
// User not found: 42

var thread = new Thread(() -> {
  System.out.println("Running in: " + Thread.currentThread());
});
thread.start();
System.out.println("Main keeps going in: " + Thread.currentThread());
thread.join(); // wait for it, like await

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
  for (int i = 1; i <= 5; i++) {
    int id = i;   // lambdas capture effectively-final locals; `i` changes
                  // every pass, so copy it to a stable local the lambda sees
    executor.submit(() -> {
      Thread.sleep(1000); // pretend this is a database call
      System.out.println("fetched user " + id);
      return id;
    });
  }
} // the try block waits for all tasks
System.out.println("all done");

// JavaScript
fetchUser(1).then(u => u.name).then(console.log);

CompletableFuture.supplyAsync(() -> "Alice")   // pretend this fetches
  .thenApply(String::toUpperCase)              // .then(...)
  .thenAccept(System.out::println)             // .then(...)
  .join();                            // block until done, or main exits
// ALICE

curl https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d javaVersion=21 \
  -d groupId=com.example -d artifactId=blog -d name=blog \
  -d dependencies=web,data-jpa,h2,validation,devtools \
  -o blog.zip
unzip blog.zip -d blog && cd blog

blog/
  mvnw                  ← Maven wrapper: ./mvnw runs Maven without installing it
  pom.xml               ← dependencies, like package.json
  src/
    main/
      java/com/example/blog/
        BlogApplication.java
      resources/
        application.properties
    test/
      java/com/example/blog/

// one annotation = auto-configuration + scan this package for components
@SpringBootApplication
public class BlogApplication {
  public static void main(String[] args) {
    // boots the server — app.listen(), roughly
    SpringApplication.run(BlogApplication.class, args);
  }
}

./mvnw spring-boot:run

curl http://localhost:8080/anything
# {"timestamp":"...","status":404,"error":"Not Found","path":"/anything"}

package com.example.blog.controller;

import java.util.Map;   // standard library, like in Part 1

// org.springframework imports come from the dependencies in pom.xml —
// this is the equivalent of importing from "express" in node_modules
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// @RestController: "this class handles HTTP and returns JSON" —
// Spring finds it automatically by scanning the package
@RestController
public class HelloController {

  @GetMapping("/hello")   // app.get("/hello", ...)
  public Map<String, String> hello() {
    return Map.of("message", "Hello from Spring Boot");
    // returned objects auto-serialize to JSON
  }
}

curl http://localhost:8080/hello
# {"message":"Hello from Spring Boot"}

package com.example.blog.model;

import jakarta.persistence.*;      // JPA: maps classes to tables
import jakarta.validation.constraints.NotBlank;   // validation rules
import java.time.LocalDateTime;    // built-in date-time, no Moment.js
// Hibernate is the library that implements JPA under the hood
import org.hibernate.annotations.CreationTimestamp;

@Entity                    // "this class is a database table"
@Table(name = "posts")     // ...named "posts" (defaults to the class name otherwise)
public class Post {

  @Id                      // primary key...
  @GeneratedValue(strategy = GenerationType.IDENTITY)   // ...auto-increment
  private Long id;         // Long (object), not long (primitive):
                           // it must be null before the DB assigns one

  @NotBlank                    // validation: reject blank (via @Valid later)
  @Column(nullable = false)    // schema constraint: NOT NULL in the database
  private String title;

  private String content;      // no annotations = plain nullable column

  @NotBlank
  @Column(nullable = false)
  private String author;

  @CreationTimestamp              // Hibernate fills this with "now" on INSERT
  private LocalDateTime createdAt;

  public Long getId() { return id; }
  public String getTitle() { return title; }
  public void setTitle(String title) { this.title = title; }
  public String getContent() { return content; }
  public void setContent(String content) { this.content = content; }
  public String getAuthor() { return author; }
  public void setAuthor(String author) { this.author = author; }
  public LocalDateTime getCreatedAt() { return createdAt; }
}

package com.example.blog.repository;

import com.example.blog.model.Post;   // our own class, by package
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;

// JpaRepository<Post, Long> = "a repository of Posts, id type Long".
// Extending it inherits save(), findById(), findAll(), deleteById(),
// count()... all for free.
public interface PostRepository extends JpaRepository<Post, Long> {
  List<Post> findAllByOrderByCreatedAtDesc();   // ORDER BY created_at DESC
  List<Post> findByAuthorIgnoreCase(String a);  // WHERE LOWER(author) = ?
}

package com.example.blog.config;

import com.example.blog.model.Post;
import com.example.blog.repository.PostRepository;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration   // "this class defines beans" — objects Spring manages
public class DataSeeder {

  // @Bean: the return value becomes a managed object. Spring runs
  // every CommandLineRunner it finds once, at startup. Asking for
  // PostRepository as a parameter makes Spring inject it. And since
  // CommandLineRunner is a one-method interface, a lambda satisfies
  // it — Part 1's interfaces + lambdas working together.
  @Bean
  CommandLineRunner seed(PostRepository posts) {
    return args -> {
      if (posts.count() == 0) {
        Post first = new Post();
        first.setTitle("Hello Java");
        first.setContent("First post, seeded at startup");
        first.setAuthor("BJ");
        posts.save(first);

        Post second = new Post();
        second.setTitle("Hello Spring Boot");
        second.setContent("Second post, seeded at startup");
        second.setAuthor("BJ");
        posts.save(second);
      }
    };
  }
}

package com.example.blog.service;

import com.example.blog.model.Post;
import com.example.blog.repository.PostRepository;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;

@Service   // a business-logic component — Spring creates and manages it
public class PostService {

  // final = set once in the constructor, never reassigned
  private final PostRepository postRepository;

  // Constructor injection: you never call `new PostService(...)`.
  // Spring sees the constructor needs a PostRepository → passes one in.
  public PostService(PostRepository postRepository) {
    this.postRepository = postRepository;
  }

  public List<Post> findAll() {
    return postRepository.findAllByOrderByCreatedAtDesc();
  }

  public Optional<Post> findById(Long id) {
    return postRepository.findById(id);
  }

  public Post save(Post post) {
    return postRepository.save(post);
  }

  // load the existing post, update its fields, save the same row back.
  // Optional chain: present → a Post, empty → null for the caller to 404.
  public Optional<Post> update(Long id, Post updates) {
    return postRepository.findById(id)
      .map(existing -> {
        existing.setTitle(updates.getTitle());
        existing.setContent(updates.getContent());
        existing.setAuthor(updates.getAuthor());
        return postRepository.save(existing);   // same id, mutated fields
      });
  }

  public void deleteById(Long id) {
    postRepository.deleteById(id);
  }
}

package com.example.blog.controller;

import com.example.blog.model.Post;
import com.example.blog.service.PostService;
import jakarta.validation.Valid;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;   // all web annotations

@RestController
@RequestMapping("/api/posts")   // base path for every route below
public class PostController {

  private final PostService postService;

  public PostController(PostService postService) {   // injection again
    this.postService = postService;
  }

  @GetMapping   // no path = the base path itself: GET /api/posts
  public List<Post> getAllPosts() {
    return postService.findAll();   // serializes to a JSON array
  }

  // {id} is a route param, like Express /:id
  // @PathVariable = req.params.id, already parsed into a Long
  @GetMapping("/{id}")
  public ResponseEntity<Post> getPostById(@PathVariable Long id) {
    return postService.findById(id)
      .map(ResponseEntity::ok)                      // has value → 200
      .orElse(ResponseEntity.notFound().build());   // empty → 404
  }

  // @RequestBody = req.body parsed from JSON into a Post
  // @Valid = run the @NotBlank rules; failures → 400 automatically
  @PostMapping
  public ResponseEntity<Post> createPost(@RequestBody @Valid Post post) {
    Post saved = postService.save(post);
    return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    // ↑ res.status(201).json(saved)
  }

  // PUT replaces the resource at this id: @PathVariable grabs the id,
  // @RequestBody the new values. Both optional chains map to HTTP —
  // present → 200 with the updated post, empty → 404.
  @PutMapping("/{id}")
  public ResponseEntity<Post> updatePost(
    @PathVariable Long id, @RequestBody @Valid Post post
  ) {
    return postService.update(id, post)
      .map(ResponseEntity::ok)
      .orElse(ResponseEntity.notFound().build());
  }

  @DeleteMapping("/{id}")
  public ResponseEntity<Void> deletePost(@PathVariable Long id) {
    postService.deleteById(id);           // Void = no response body
    return ResponseEntity.noContent().build();   // 204
  }
}

curl http://localhost:8080/api/posts
# [{"id":2,"title":"Hello Spring Boot",...},{"id":1,"title":"Hello Java",...}]

curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"Written from curl","content":"It lives","author":"BJ"}'
# {"id":3,"title":"Written from curl",...}   ← note the 201 and generated id

curl http://localhost:8080/api/posts/3
# {"id":3,"title":"Written from curl",...}

curl -X PUT http://localhost:8080/api/posts/3 \
  -H "Content-Type: application/json" \
  -d '{"title":"Edited","content":"Same id, new body","author":"BJ"}'
# {"id":3,"title":"Edited",...}   ← same id, updated fields

curl -i -X DELETE http://localhost:8080/api/posts/3
# HTTP/1.1 204

curl -i http://localhost:8080/api/posts/3
# HTTP/1.1 404

curl -i -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"","author":""}'
# HTTP/1.1 400

package com.example.blog.exception;

public class PostNotFoundException extends RuntimeException {
  public PostNotFoundException(Long id) {
    super("Post not found: " + id);
  }
}

package com.example.blog.exception;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

// "advice" applies to ALL controllers — a global error boundary
@RestControllerAdvice
public class GlobalExceptionHandler {

  // catches this exception no matter which controller threw it
  @ExceptionHandler(PostNotFoundException.class)
  public ProblemDetail handleNotFound(PostNotFoundException e) {
    // ProblemDetail = Spring's built-in RFC 9457 error body:
    // {type, title, status, detail}
    return ProblemDetail
      .forStatusAndDetail(HttpStatus.NOT_FOUND, e.getMessage());
  }

  // deleteById throws this when the id doesn't exist (Spring Data behavior),
  // so delete on a missing post must 404 too — not crash with a 500
  @ExceptionHandler(EmptyResultDataAccessException.class)
  public ProblemDetail handleMissingDelete(EmptyResultDataAccessException e) {
    return ProblemDetail
      .forStatusAndDetail(HttpStatus.NOT_FOUND, "Post not found");
  }
}

@GetMapping("/{id}")
public Post getPostById(@PathVariable Long id) {
  return postService.findById(id)
    .orElseThrow(() -> new PostNotFoundException(id));
}

curl http://localhost:8080/api/posts/999
# {"type":"about:blank","title":"Not Found","status":404,"detail":"Post not found: 999",...}

curl -i -X DELETE http://localhost:8080/api/posts/999
# HTTP/1.1 404  ← not a 500 crash

spring.jpa.show-sql=true

# application.yml — base config
server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/blog
    username: blog
    password: blog
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false

# application-dev.yml — active only with the dev profile
spring:
  datasource:
    url: jdbc:h2:mem:blogdb
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true

@Value("${feature.new-dashboard:false}")
private boolean newDashboard;

feature:
  new-dashboard: true

package com.example.blog;

// "import static" pulls in methods (not classes) so you can write get(...) and
// status() bare instead of MockMvcRequestBuilders.get(...) — it's what makes
// the test read almost like an English sentence.
import static org.hamcrest.Matchers.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

@SpringBootTest          // boot the whole application context
@AutoConfigureMockMvc    // ...plus a fake HTTP client wired into it
class PostControllerTest {

  // @Autowired field injection: "Spring, fill this in". Constructors
  // are preferred in app code, but @Autowired fields are normal in tests.
  @Autowired
  private MockMvc mockMvc;

  @Test
  void shouldReturnSeededPosts() throws Exception {
    // the DataSeeder from Step 4 runs for tests too
    mockMvc.perform(get("/api/posts"))
      .andExpect(status().isOk())
      // jsonPath queries the response JSON: $ is the root,
      // $.title a field, $[0].title the first element's field
      .andExpect(jsonPath("$", hasSize(greaterThanOrEqualTo(2))));
  }

  @Test
  void shouldCreatePost() throws Exception {
    String json = """
      {
        "title": "Hello from a test",
        "content": "Text blocks make JSON fixtures pleasant",
        "author": "BJ"
      }
      """;

    mockMvc.perform(post("/api/posts")
        .contentType(MediaType.APPLICATION_JSON)
        .content(json))
      .andExpect(status().isCreated())
      .andExpect(jsonPath("$.title").value("Hello from a test"));
  }

  @Test
  void shouldRejectBlankTitle() throws Exception {
    mockMvc.perform(post("/api/posts")
        .contentType(MediaType.APPLICATION_JSON)
        .content("{\"title\":\"\",\"author\":\"BJ\"}"))
      .andExpect(status().isBadRequest());
  }
}

./mvnw test
# ...
# Tests run: 3, Failures: 0

package com.example.blog;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;

import com.example.blog.model.Post;
import com.example.blog.repository.PostRepository;
import com.example.blog.service.PostService;
import java.util.List;
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;

// Mockito only, no Spring context = milliseconds fast
@ExtendWith(MockitoExtension.class)
class PostServiceTest {

  @Mock   // a fake PostRepository — jest.mock() territory
  private PostRepository postRepository;

  @InjectMocks   // a real PostService, built with the mock above
  private PostService postService;

  @Test
  void shouldFindAllPosts() {
    when(postRepository.findAllByOrderByCreatedAtDesc())
      .thenReturn(List.of(new Post()));

    List<Post> result = postService.findAll();

    assertThat(result).hasSize(1);
  }
}

./mvnw clean package
java -jar target/blog-0.0.1-SNAPSHOT.jar

./mvnw spring-boot:build-image

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY target/blog-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

@Configuration
@EnableWebSecurity
public class SecurityConfig {

  @Bean
  public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
      .csrf(csrf -> csrf.disable())            // see the caveat below
      .authorizeHttpRequests(auth -> auth      // rules: most specific first
        .requestMatchers("/api/public/**").permitAll()   // ** = any depth
        .requestMatchers("/api/admin/**").hasRole("ADMIN")
        .anyRequest().authenticated()          // everything else: log in
      )
      .httpBasic(Customizer.withDefaults());   // log in via HTTP Basic

    return http.build();
  }
}

@Entity
@Table(name = "short_links")
public class ShortLink {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false, unique = true, length = 7)
  private String shortCode;

  @Column(nullable = false, length = 2048)
  private String targetUrl;

  private long clickCount = 0;

  @CreationTimestamp
  private LocalDateTime createdAt;

  // getters and setters for all fields — generate them with your IDE
  // (IntelliJ: Code → Generate → Getter and Setter)
}

public interface ShortLinkRepository extends JpaRepository<ShortLink, Long> {
  Optional<ShortLink> findByShortCode(String shortCode);

  // One atomic UPDATE in the database — no read-modify-write
  // window for concurrent requests to race in.
  @Modifying   // this query changes data (default assumption is SELECT)
  @Query("""
    update ShortLink s
    set s.clickCount = s.clickCount + 1
    where s.shortCode = :shortCode
    """)
  int incrementClickCount(String shortCode);
}

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;

public record ShortenRequest(
  @NotBlank @Size(max = 2048) String targetUrl
) {}

// SecureRandom: strong randomness — Math.random() is guessable
import java.security.SecureRandom;

// thrown when a database constraint (like UNIQUE) is violated
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ShortLinkService {

  // static final = one shared constant, like a module-level const
  private static final String ALPHANUM =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  private static final int CODE_LENGTH = 7;
  private static final int MAX_ATTEMPTS = 5;

  private final ShortLinkRepository shortLinkRepository;
  private final SecureRandom random = new SecureRandom();

  public ShortLinkService(ShortLinkRepository shortLinkRepository) {
    this.shortLinkRepository = shortLinkRepository;
  }

  public ShortLink shortenUrl(String targetUrl) {
    for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
      ShortLink link = new ShortLink();
      link.setShortCode(generateShortCode());
      link.setTargetUrl(targetUrl);
      try {
        return shortLinkRepository.save(link);
      } catch (DataIntegrityViolationException e) {
        // another request claimed the same code between generation and save;
        // the unique constraint is the source of truth, so retry with a new code
      }
    }
    throw new IllegalStateException("Could not generate a unique short code");
  }

  public Optional<ShortLink> findByShortCode(String shortCode) {
    return shortLinkRepository.findByShortCode(shortCode);
  }

  @Transactional   // wrap both statements in one database transaction:
                   // they succeed together or roll back together
  public Optional<ShortLink> recordClickAndReturn(String shortCode) {
    shortLinkRepository.incrementClickCount(shortCode);
    return shortLinkRepository.findByShortCode(shortCode);
  }

  private String generateShortCode() {
    // Strings are immutable, so += in a loop copies the whole string
    // every pass. StringBuilder is the mutable buffer for building one.
    StringBuilder code = new StringBuilder(CODE_LENGTH);
    for (int i = 0; i < CODE_LENGTH; i++) {
      int index = random.nextInt(ALPHANUM.length());
      code.append(ALPHANUM.charAt(index));
    }
    return code.toString();
  }
}

import java.net.URI;

@RestController
public class ShortLinkController {

  private final ShortLinkService shortLinkService;

  public ShortLinkController(ShortLinkService shortLinkService) {
    this.shortLinkService = shortLinkService;
  }

  @PostMapping("/api/links")
  public ResponseEntity<ShortLink> createShortLink(
    @RequestBody @Valid ShortenRequest request
  ) {
    ShortLink saved = shortLinkService.shortenUrl(request.targetUrl());
    return ResponseEntity.status(HttpStatus.CREATED).body(saved);
  }

  // root level, not under /api — this IS the short URL
  @GetMapping("/{shortCode}")
  public ResponseEntity<Void> redirect(@PathVariable String shortCode) {
    return shortLinkService.recordClickAndReturn(shortCode)
      .map(link -> ResponseEntity.status(HttpStatus.FOUND)   // 302
        .location(URI.create(link.getTargetUrl()))   // Location: header
        .build())
      .orElse(ResponseEntity.notFound().build());
  }

  @GetMapping("/api/links/{shortCode}/stats")
  public ResponseEntity<ShortLink> stats(@PathVariable String shortCode) {
    return shortLinkService.findByShortCode(shortCode)
      .map(ResponseEntity::ok)
      .orElse(ResponseEntity.notFound().build());
  }
}

curl -X POST http://localhost:8080/api/links \
  -H "Content-Type: application/json" \
  -d '{"targetUrl":"https://billieheidelberg.com"}'
# {"id":1,"shortCode":"aB3xK9p","targetUrl":"https://billieheidelberg.com","clickCount":0,...}

curl -iL http://localhost:8080/aB3xK9p
# HTTP/1.1 302 → follows to the target

curl http://localhost:8080/api/links/aB3xK9p/stats
# {"shortCode":"aB3xK9p","clickCount":1,...}

for i in $(seq 1 50); do curl -s -o /dev/null http://localhost:8080/aB3xK9p & done; wait
curl http://localhost:8080/api/links/aB3xK9p/stats
# clickCount is exactly 51