java -version
mvn -version

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version> <!-- 版本可能不同 -->
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>user-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>user-api</name>
    <description>Demo project for Spring Boot REST API</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
      
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package com.example.userapi.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * User Model Class
 * This class represents a user in our system.
 *
 * @Data is a Lombok annotation to create all the getters, setters,
 *       equals, hash, and toString methods, based on the fields.
 * @NoArgsConstructor generates a constructor with no parameters.
 * @AllArgsConstructor generates a constructor with one parameter for each field in your class.
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String username;
    private String email;
    private String fullName;
}

package com.example.userapi.service;

import com.example.userapi.model.User;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Service layer for managing users.
 * This class simulates a database using an in-memory map.
 * The @Service annotation marks this class as a Spring service component.
 */
@Service
public class UserService {

    // Using ConcurrentHashMap for thread safety in a multi-threaded environment.
    private final Map<Long, User> userDatabase = new ConcurrentHashMap<>();
  
    // Using AtomicLong for thread-safe generation of unique IDs.
    private final AtomicLong idCounter = new AtomicLong();

    // Initialize with some dummy data.
    public UserService() {
        save(new User(null, "john.doe", "john.doe@example.com", "John Doe"));
        save(new User(null, "jane.smith", "jane.smith@example.com", "Jane Smith"));
        save(new User(null, "alice.jones", "alice.jones@example.com", "Alice Jones"));
    }

    /**
     * Retrieves all users from the database.
     * @return a list of all users.
     */
    public List<User> findAll() {
        return new ArrayList<>(userDatabase.values());
    }

    /**
     * Finds a user by their ID.
     * @param id The ID of the user to find.
     * @return an Optional containing the user if found, or an empty Optional otherwise.
     */
    public Optional<User> findById(Long id) {
        return Optional.ofNullable(userDatabase.get(id));
    }

    /**
     * Saves a new user or updates an existing one.
     * If the user's ID is null, a new ID is generated and the user is created.
     * If the user's ID exists, the existing user is updated.
     * @param user The user object to save.
     * @return The saved user object with its ID.
     */
    public User save(User user) {
        if (user.getId() == null) {
            // This is a new user, generate an ID.
            long newId = idCounter.incrementAndGet();
            user.setId(newId);
        }
        userDatabase.put(user.getId(), user);
        return user;
    }

    /**
     * Deletes a user by their ID.
     * @param id The ID of the user to delete.
     * @return true if the user was found and deleted, false otherwise.
     */
    public boolean deleteById(Long id) {
        return userDatabase.remove(id) != null;
    }
}

package com.example.userapi.controller;

import com.example.userapi.model.User;
import com.example.userapi.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * REST Controller for managing users.
 * This controller exposes a series of REST endpoints for User resources.
 *
 * @RestController is a convenience annotation that combines @Controller and @ResponseBody.
 * @RequestMapping("/api/users") specifies that all endpoints in this controller
 * will be prefixed with "/api/users".
 */
@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    /**
     * Constructor-based dependency injection.
     * Spring will automatically inject an instance of UserService here.
     * This is the recommended way to inject dependencies.
     * @param userService The user service to be injected.
     */
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    /**
     * GET /api/users
     * Retrieves a list of all users.
     * @return A ResponseEntity containing a list of all users and an HTTP 200 OK status.
     */
    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userService.findAll();
        return ResponseEntity.ok(users);
    }

    /**
     * GET /api/users/{id}
     * Retrieves a single user by their ID.
     * @param id The ID of the user, extracted from the URL path.
     * @return A ResponseEntity containing the found user and HTTP 200 OK,
     *         or HTTP 404 Not Found if the user does not exist.
     */
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        return userService.findById(id)
                .map(ResponseEntity::ok) // If user exists, wrap in ResponseEntity.ok()
                .orElse(ResponseEntity.notFound().build()); // If not, build a 404 response
    }

    /**
     * POST /api/users
     * Creates a new user.
     * The user data is passed in the request body as JSON.
     * @param user The user object to create, deserialized from the request body.
     * @return A ResponseEntity containing the newly created user and an HTTP 201 Created status.
     */
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        // In a real application, you would validate the user object here.
        user.setId(null); // Ensure we are creating a new user, not updating.
        User savedUser = userService.save(user);
        return new ResponseEntity<>(savedUser, HttpStatus.CREATED);
    }

    /**
     * PUT /api/users/{id}
     * Updates an existing user.
     * @param id The ID of the user to update.
     * @param userDetails The new user data from the request body.
     * @return A ResponseEntity containing the updated user and HTTP 200 OK,
     *         or HTTP 404 Not Found if the user to update does not exist.
     */
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        return userService.findById(id)
                .map(existingUser -> {
                    // Update the fields of the existing user
                    existingUser.setUsername(userDetails.getUsername());
                    existingUser.setEmail(userDetails.getEmail());
                    existingUser.setFullName(userDetails.getFullName());
                    User updatedUser = userService.save(existingUser);
                    return ResponseEntity.ok(updatedUser);
                })
                .orElse(ResponseEntity.notFound().build());
    }

    /**
     * DELETE /api/users/{id}
     * Deletes a user by their ID.
     * @param id The ID of the user to delete.
     * @return A ResponseEntity with HTTP 204 No Content if successful,
     *         or HTTP 404 Not Found if the user does not exist.
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        if (userService.deleteById(id)) {
            return ResponseEntity.noContent().build(); // HTTP 204
        } else {
            return ResponseEntity.notFound().build(); // HTTP 404
        }
    }
}

[
    {
        "id": 1,
        "username": "john.doe",
        "email": "john.doe@example.com",
        "fullName": "John Doe"
    },
    {
        "id": 2,
        "username": "jane.smith",
        "email": "jane.smith@example.com",
        "fullName": "Jane Smith"
    },
    {
        "id": 3,
        "username": "alice.jones",
        "email": "alice.jones@example.com",
        "fullName": "Alice Jones"
    }
]

// In a new package: com.example.userapi.exception
package com.example.userapi.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

// In UserService.java
public User findByIdOrThrow(Long id) {
    return findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("User not found with id: " + id));
}

// In a new package: com.example.userapi.exception
package com.example.userapi.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;

import java.time.LocalDateTime;
import java.util.LinkedHashMap;
import java.util.Map;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<Object> handleResourceNotFoundException(
            ResourceNotFoundException ex, WebRequest request) {

        Map<String, Object> body = new LinkedHashMap<>();
        body.put("timestamp", LocalDateTime.now());
        body.put("status", HttpStatus.NOT_FOUND.value());
        body.put("error", "Not Found");
        body.put("message", ex.getMessage());
        body.put("path", request.getDescription(false).replace("uri=", ""));

        return new ResponseEntity<>(body, HttpStatus.NOT_FOUND);
    }
}