SpringBootDemo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/xiaxl/demo/
│   │   │       ├── DemoApplication.java
│   │   │       └── controller/
│   │   └── resources/
│   │       └── application.properties
│   └── test/
├── build.gradle
└── settings.gradle

# 項目名稱，影響構(gòu)建產(chǎn)物的命名
rootProject.name = 'SpringBootDemo'

plugins {
    # 應(yīng)用Java插件，提供編譯、測試、打包等任務(wù)
    id 'java'  
    # SpringBoot插件，提供bootJar、bootRun等任務(wù)
    id 'org.springframework.boot' version '3.3.3'  
    # 依賴管理插件，簡化Spring依賴版本管理
    id 'io.spring.dependency-management' version '1.1.6'  
}  
group = 'com.xiaxl'        # 組織標(biāo)識，通常使用公司域名
version = '0.0.1-SNAPSHOT' # 項目版本，SNAPSHOT表示開發(fā)中版本
java {  
    toolchain {  
       languageVersion = JavaLanguageVersion.of(23)  # 指定JDK版本為23
    }  
}  
repositories {  
    // 配置國內(nèi)鏡像加速依賴下載（按需使用）
    maven { url 'https://maven.aliyun.com/nexus/content/groups/public/' }  
    maven { url 'https://mirrors.cloud.tencent.com/nexus/repository/maven-public/' }  
    maven { url 'https://developer.huawei.com/repo/' }  
    // maven倉庫
    mavenCentral()  
}  
dependencies {
    // 核心依賴：SpringBoot Web Starter，包含：
    // - Spring MVC (Web框架)
    // - Tomcat (嵌入式Web服務(wù)器)
    // - Jackson (JSON處理)
    // - 驗證、數(shù)據(jù)綁定等
    // Spring Boot Web Starter  
    implementation 'org.springframework.boot:spring-boot-starter-web'  
    // 數(shù)據(jù)校驗  
    implementation 'org.springframework.boot:spring-boot-starter-validation'  
    // Lombok簡化代碼
    compileOnly 'org.projectlombok:lombok'  
    annotationProcessor 'org.projectlombok:lombok'  
    //
    testImplementation 'org.springframework.boot:spring-boot-starter-test'  
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'  
}  
tasks.named('test') {  
    useJUnitPlatform()  
}
// 可選：配置JAR包輸出名稱
bootJar {
    archiveFileName = 'springboot-demo.jar'
}

spring.application.name=SpringBootDemo              # 應(yīng)用名稱
spring.servlet.multipart.max-file-size=-1           # 單個文件大小限制，-1表示不限制
spring.servlet.multipart.max-request-size=-1        # 請求總大小限制，-1表示不限制
server.port=8081           # 服務(wù)端口

package com.xiaxl.demo;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
// 使用@SpringBootApplication注解標(biāo)記該類為Spring Boot應(yīng)用的主配置類  
@SpringBootApplication  
public class DemoApplication {  
    // main方法是Java應(yīng)用程序的入口點  
    // 當(dāng)JVM啟動時，首先執(zhí)行這個方法  
    // args參數(shù)用于接收命令行參數(shù)  
    public static void main(String[] args) {  
       // SpringApplication.run()是啟動Spring Boot應(yīng)用的核心方法  
       // 第一個參數(shù)：主配置類（通常是帶有@SpringBootApplication注解的類）  
       // 第二個參數(shù)：命令行參數(shù)，會傳遞給Spring應(yīng)用上下文  
       // 這個方法執(zhí)行以下操作：  
       // 1. 創(chuàng)建Spring應(yīng)用上下文（ApplicationContext）  
       // 2. 啟用自動配置  
       // 3. 啟動嵌入式Web服務(wù)器（如Tomcat）  
       // 4. 掃描并注冊所有Spring組件  
       // 5. 返回應(yīng)用上下文對象（此處未接收返回值）  
       SpringApplication.run(DemoApplication.class, args);  
    }  
}

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.List;  
// 訪問地址：GET http://localhost:8081/api/hello  
// @RestController：標(biāo)記這個類為一個 REST 控制器，意味著類中的方法會處理 HTTP 請求并返回數(shù)據(jù)。 
@RestController  
public class HelloController {
    @GetMapping("/api/hello")
    public HelloResponse getHelloMessages() {  
        HelloResponse response = new HelloResponse();  
        response.setStartupMessage("歡迎來到精彩世界！");  
        response.setNewMessages(Arrays.asList("望長城內(nèi)外惟余莽莽，大河上下頓失滔滔。"));  
        response.setStatusCode(200);  
        return response;  
    }  
    public static class HelloResponse {  
        private String startupMessage;  
        private List<String> newMessages;  
        private int statusCode;  
        public String getStartupMessage() {  
            return startupMessage;  
        }  
        public void setStartupMessage(String startupMessage) {  
            this.startupMessage = startupMessage;  
        }  
        public List<String> getNewMessages() {  
            return newMessages;  
        }  
        public void setNewMessages(List<String> newMessages) {  
            this.newMessages = newMessages;  
        }  
        public int getStatusCode() {  
            return statusCode;  
        }  
        public void setStatusCode(int statusCode) {  
            this.statusCode = statusCode;  
        }  
        public void addNewMessage(String message) {  
            if (this.newMessages == null) {  
                this.newMessages = new ArrayList<>();  
            }  
            this.newMessages.add(message);  
        }  
    }  
}

import com.fasterxml.jackson.annotation.JsonInclude;  
import lombok.AllArgsConstructor;  
import lombok.Data;  
import lombok.NoArgsConstructor;  
import java.time.LocalDateTime;  
// 使用Lombok注解自動生成getter、setter、toString、equals和hashCode方法  
@Data  
// 生成無參構(gòu)造函數(shù)  
@NoArgsConstructor  
// 生成全參構(gòu)造函數(shù)  
@AllArgsConstructor  
// Jackson序列化注解：當(dāng)字段值為null時，不包含在JSON輸出中。這樣可以減少響應(yīng)體大小，避免前端處理null值。  
@JsonInclude(JsonInclude.Include.NON_NULL)  
public class ApiResponse<T> {  
    private boolean success;  
    private String message;  
    private T data;  
    private LocalDateTime timestamp;  
    private Integer code;  
    // 成功響應(yīng)快捷方法  
    public static <T> ApiResponse<T> success(T data) {  
        return new ApiResponse<>(true, "操作成功", data, LocalDateTime.now(), 200);  
    }  
    public static <T> ApiResponse<T> success(String message, T data) {  
        return new ApiResponse<>(true, message, data, LocalDateTime.now(), 200);  
    }  
    // 失敗響應(yīng)快捷方法  
    public static <T> ApiResponse<T> error(String message) {  
        return new ApiResponse<>(false, message, null, LocalDateTime.now(), 500);  
    }  
    public static <T> ApiResponse<T> error(String message, Integer code) {  
        return new ApiResponse<>(false, message, null, LocalDateTime.now(), code);  
    }  
}

import lombok.AllArgsConstructor;  
import lombok.Data;  
import lombok.NoArgsConstructor;  
import lombok.experimental.Accessors;  
import java.time.LocalDateTime;  
import java.util.List;  
// 使用Lombok注解自動生成getter、setter、toString、equals和hashCode方法  
@Data  
// 生成無參構(gòu)造函數(shù)  
@NoArgsConstructor  
// 生成全參構(gòu)造函數(shù)  
@AllArgsConstructor  
// 使用Lombok的@Accessors注解，開啟鏈?zhǔn)秸{(diào)用（chain = true）。  
// 使得setter方法返回當(dāng)前對象，可以連續(xù)調(diào)用。如：user.setId(1L).setName("張三")  
@Accessors(chain = true) // 支持鏈?zhǔn)秸{(diào)用  
public class UserDTO {  
    private Long id;  
    private String name;  
    private String email;  
    private Integer age;  
    private String phone;  
    private String address;  
    private Boolean active;  
    private LocalDateTime createTime;  
    private LocalDateTime updateTime;  
    private List<String> roles;  
    // 靜態(tài)工廠方法  
    public static UserDTO createDefault() {  
        return new UserDTO()  
                .setId(1L)  
                .setName("張三")  
                .setEmail("zhangsan@example.com")  
                .setAge(25)  
                .setPhone("13800138000")  
                .setAddress("北京市海淀區(qū)")  
                .setActive(true)  
                .setCreateTime(LocalDateTime.now())  
                .setUpdateTime(LocalDateTime.now())  
                .setRoles(List.of("USER", "EDITOR"));  
    }  
}

import com.xiaxl.demo.model.response.ApiResponse;  
import com.xiaxl.demo.model.response.UserDTO;  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.http.ResponseEntity;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
import java.time.LocalDateTime;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
@Slf4j  
@RestController  
public class UserController {  
    // 內(nèi)存存儲模擬數(shù)據(jù)（替代數(shù)據(jù)庫）  
    private final Map<Long, UserDTO> mUserMap = new HashMap<>();  
    private Long idCounter = 1L;  
    // 初始化一些測試數(shù)據(jù)  
    public UserController() {  
        initMockData();  
    }  
    private void initMockData() {  
        for (int i = 1; i <= 3; i++) {  
            UserDTO user = new UserDTO()  
                    .setId((long) i)  
                    .setName("用戶" + i)  
                    .setEmail("user" + i + "@example.com")  
                    .setAge(20 + i)  
                    .setPhone("1380013800" + i)  
                    .setAddress("地址" + i)  
                    .setActive(true)  
                    .setCreateTime(LocalDateTime.now())  
                    .setUpdateTime(LocalDateTime.now())  
                    .setRoles(List.of("USER"));  
            mUserMap.put(user.getId(), user);  
            idCounter++;  
        }  
    }  
}

/**  
 * 簡單的GET請求 - 獲取所有用戶列表  
 * 訪問地址：GET http://localhost:8081/api/users  
 */
@GetMapping("/api/users")  
public ResponseEntity<ApiResponse<List<UserDTO>>> getAllUsers() {  
    log.info("獲取所有用戶列表");  
    List<UserDTO> userList = new ArrayList<>(mUserMap.values());  
    return ResponseEntity.ok(ApiResponse.success("獲取用戶列表成功", userList));  
}  

/**  
 * GET請求 - 根據(jù)ID獲取單個用戶  
 * 訪問地址：GET http://localhost:8081/api/users/{id}  
 * 例如：GET http://localhost:8081/api/users/1  
 */
@GetMapping("/api/users/{id}")  
public ResponseEntity<ApiResponse<UserDTO>> getUserById(@PathVariable Long id) {  
    log.info("根據(jù)ID查詢用戶，ID: {}", id);  
    UserDTO user = mUserMap.get(id);  
    if (user == null) {  
        return ResponseEntity  
                .status(HttpStatus.NOT_FOUND)  
                .body(ApiResponse.error("用戶不存在", 404));  
    }  
    return ResponseEntity.ok(ApiResponse.success("獲取用戶成功", user));  
}

/**  
 * GET請求 - 帶查詢參數(shù)的用戶搜索  
 * 訪問地址：GET http://localhost:8081/api/users/search?name=用戶1&active=true  
 */@GetMapping("/api/users//search")  
public ResponseEntity<ApiResponse<List<UserDTO>>> searchUsers(  
        @RequestParam(required = false) String name,  
        @RequestParam(required = false) Boolean active,  
        @RequestParam(defaultValue = "1") Integer page,  
        @RequestParam(defaultValue = "10") Integer size) {  
    log.info("搜索用戶 - name: {}, active: {}, page: {}, size: {}",  
            name, active, page, size);  
    List<UserDTO> result = mUserMap.values().stream()  
            .filter(user -> name == null || user.getName().contains(name))  
            .filter(user -> active == null || user.getActive().equals(active))  
            .skip((page - 1) * (long) size)  
            .limit(size)  
            .toList();  
    return ResponseEntity.ok(ApiResponse.success("搜索成功", result));  
}

import jakarta.validation.constraints.*;  
import lombok.Data;  
@Data  
// 用戶創(chuàng)建請求DTO（Data Transfer Object）類  
// 用于接收前端傳遞的用戶創(chuàng)建請求數(shù)據(jù)  
// 包含各種驗證注解，確保數(shù)據(jù)合法性  
public class UserRequest {  
    @NotBlank(message = "用戶名不能為空")  
    @Size(min = 2, max = 20, message = "用戶名長度必須在2-20個字符之間")  
    private String name;  
    @NotBlank(message = "郵箱不能為空")  
    @Email(message = "郵箱格式不正確")  
    private String email;  
    @NotNull(message = "年齡不能為空")  
    @Min(value = 1, message = "年齡必須大于0")  
    @Max(value = 150, message = "年齡不能超過150")  
    private Integer age;  
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手機(jī)號格式不正確")  
    private String phone;  
    @NotBlank(message = "地址不能為空")  
    private String address;  
    private String remark;  
    @AssertTrue(message = "必須同意用戶協(xié)議")  
    private Boolean agreeTerms;  
}

/**  
 * POST請求 - 創(chuàng)建用戶（JSON格式請求體）  
 * 訪問地址：POST http://localhost:8081/api/post/users  
 * 請求頭：Content-Type: application/json  
 * 請求體示例：  
 * {  
 * "name": "李四",  
 * "email": "lisi@example.com", 
 * "age": 30, * "phone": "13900139000", 
 * "address": "上海市浦東新區(qū)",  
 * "agreeTerms": true 
 * } 
 * @param request       接收并驗證請求體中的JSON數(shù)據(jù)，自動反序列化為UserRequest對象,  
 *                      Valid注解觸發(fā)對UserRequest對象中字段的驗證規(guī)則  
 * @param bindingResult 接收參數(shù)驗證結(jié)果，包含所有驗證錯誤信息  
 * @return ApiResponse<UserDTO>  
 */  
@PostMapping("/api/post/users")  
public ResponseEntity<ApiResponse<UserDTO>> createUser(  
        @Valid @RequestBody UserRequest request,  
        BindingResult bindingResult) {  
    log.info("創(chuàng)建用戶 - 請求數(shù)據(jù): {}", request);  
    // 參數(shù)校驗  
    if (bindingResult.hasErrors()) {  
        Map<String, String> errors = new HashMap<>();  
        for (FieldError error : bindingResult.getFieldErrors()) {  
            errors.put(error.getField(), error.getDefaultMessage());  
        }  
        return ResponseEntity  
                .badRequest()  
                .body(ApiResponse.error(errors.toString(), 400));  
    }  
    // 檢查用戶名是否已存在  
    boolean exists = mUserMap.values().stream()  
            .anyMatch(user -> user.getName().equals(request.getName()));  
    if (exists) {  
        return ResponseEntity  
                .badRequest()  
                .body(ApiResponse.error("用戶名已存在", 400));  
    }  
    // 創(chuàng)建用戶  
    UserDTO newUser = new UserDTO()  
            .setId(idCounter++)  
            .setName(request.getName())  
            .setEmail(request.getEmail())  
            .setAge(request.getAge())  
            .setPhone(request.getPhone())  
            .setAddress(request.getAddress())  
            .setActive(true)  
            .setCreateTime(LocalDateTime.now())  
            .setUpdateTime(LocalDateTime.now())  
            .setRoles(List.of("USER"));  
    mUserMap.put(newUser.getId(), newUser);  
    log.info("用戶創(chuàng)建成功，ID: {}", newUser.getId());  
    return ResponseEntity  
            .status(HttpStatus.CREATED)  
            .body(ApiResponse.success("用戶創(chuàng)建成功", newUser));  
}

POST http://localhost:8081/api/post/users
Headers：Content-Type: application/json  
Body：
{
"name":"李四",
"email":"lisi@example.com",
"age":30,
"phone":"13900139000",
"address":"上海市浦東新區(qū)",
"agreeTerms":true
}

/**  
 * POST表單請求 - 用戶登錄（application/x-www-form-urlencoded）  
 * 訪問地址：POST http://localhost:8081/api/users/login  
 * 請求頭：Content-Type: application/x-www-form-urlencoded  
 * 請求體：name=張三&password=123456  
 */
 @PostMapping(value = "/api/users/login", consumes = "application/x-www-form-urlencoded")  
public ResponseEntity<ApiResponse<Map<String, Object>>> login(  
        @RequestParam String name,  
        @RequestParam String password) {  
    log.info("用戶登錄 - name: {}", name);  
    // 模擬用戶驗證  
    Optional<UserDTO> userOptional = mUserMap.values().stream()  
            .filter(user -> user.getName().equals(name))  
            .findFirst();  
    if (userOptional.isEmpty()) {  
        return ResponseEntity  
                .badRequest()  
                .body(ApiResponse.error("用戶名或密碼錯誤", 401));  
    }  
    // 模擬密碼驗證（實際項目中使用加密驗證）  
    UserDTO user = userOptional.get();  
    if (!"123456".equals(password)) { // 模擬固定密碼  
        return ResponseEntity  
                .badRequest()  
                .body(ApiResponse.error("用戶名或密碼錯誤", 401));  
    }  
    // 生成模擬token  
    String token = "Bearer " + UUID.randomUUID();  
    Map<String, Object> loginResult = new HashMap<>();  
    loginResult.put("user", user);  
    loginResult.put("token", token);  
    loginResult.put("expiresIn", 3600);  
    log.info("用戶登錄成功，生成token: {}", token);  
    return ResponseEntity.ok(ApiResponse.success("登錄成功", loginResult));  
}

POST http://localhost:8081/api/users/login  
Headers：Content-Type: application/x-www-form-urlencoded  
Body：name=張三&password=123456  

/**  
 * 處理多個文件POST上傳  
 * POST http://localhost:8081/api/uploadFiles  
 * Content-Type: multipart/form-data; boundary=4235013262151947840 * <p>  
 * ----4235013262151947840  
 * Content-Disposition: form-data; name="files"; filename="111.png" * Content-Type: image/png * <p>  
 * 111.png字節(jié)流數(shù)據(jù)  
 * ----4235013262151947840  
 * Content-Disposition: form-data; name="files"; filename="222.png" * Content-Type: image/png * <p>  
 * 222.png字節(jié)流數(shù)據(jù)  
 * ----4235013262151947840  
 * * @param files 文件列表  
 * @return  
 */  
@PostMapping("/api/uploadFiles")  
public ResponseEntity<ApiResponse<List<String>>> uploadFiles(@RequestParam("files") MultipartFile[] files) {  
    // 創(chuàng)建一個列表  
    List<String> fileUris = new ArrayList<>();  
    // 循環(huán)輸入的文件  
    for (MultipartFile file : files) {  
        try {  
            // 獲取并清理文件名  
            String fileName = StringUtils.cleanPath(file.getOriginalFilename());  
            // 構(gòu)建文件上傳路徑  
            Path uploadPath = Paths.get(UPLOAD_DIR + fileName);  
            // 創(chuàng)建上傳目錄  
            File uploadDir = new File(UPLOAD_DIR);  
            if (!uploadDir.exists()) {  
                uploadDir.mkdirs();  
            }  
            // 創(chuàng)建輸出流，寫入文件  
            try (FileOutputStream fos = new FileOutputStream(uploadPath.toFile())) {  
                fos.write(file.getBytes());  
            }  
            // 上傳后的文件路徑  
            String fileUri = UPLOAD_DIR + fileName;  
            // 緩存到文件列表中  
            fileUris.add(fileUri);  
        } catch (IOException e) {  
            e.printStackTrace();  
            return ResponseEntity  
                    .badRequest()  
                    .body(ApiResponse.error(e.getMessage(), 500));  
        }  
    }  
    return ResponseEntity.ok(ApiResponse.success("上傳成功", fileUris));  
}

POST http://localhost:8081/api/uploadFiles
Content-Type: multipart/form-data; boundary=4235013262151947840
----4235013262151947840
Content-Disposition: form-data; name="files"; filename="111.png"
Content-Type: image/png
111.png字節(jié)流數(shù)據(jù)
----4235013262151947840
Content-Disposition: form-data; name="files"; filename="222.png"
Content-Type: image/png
222.png字節(jié)流數(shù)據(jù)
----4235013262151947840

dependencies {   
    // SQLite數(shù)據(jù)庫（關(guān)鍵依賴）  
    implementation 'org.xerial:sqlite-jdbc:3.45.1.0'  
    // 添加以下依賴以支持SQLite方言  
    implementation 'org.hibernate.orm:hibernate-community-dialects:6.3.1.Final'  
    // Spring Data JPA  
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'  
    // JSON序列化  
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'  
}

spring.datasource.url=jdbc:sqlite:demo.db  
spring.datasource.driver-class-name=org.sqlite.JDBC  
spring.datasource.username=admin  
spring.datasource.password=123456  
spring.jpa.database-platform=org.hibernate.community.dialect.SQLiteDialect  
spring.jpa.hibernate.ddl-auto=update  
spring.jpa.show-sql=true  
spring.jpa.properties.hibernate.dialect=org.hibernate.community.dialect.SQLiteDialect  
spring.sql.init.mode=never

import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;  
@SpringBootApplication  
@EnableJpaRepositories  
public class DemoApplication {  
    public static void main(String[] args) {  
       SpringApplication.run(DemoApplication.class, args);  
    }  
}

import jakarta.persistence.*;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import java.time.LocalDateTime;
import java.util.List;
@Entity
@Table(name = "users")
@Data
// 生成無參構(gòu)造函數(shù)
@NoArgsConstructor
// 生成全參構(gòu)造函數(shù)
@AllArgsConstructor
public class UserEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(nullable = false, unique = true)
    private String name;
    @Column(nullable = false)
    private String email;
    private String password;
    @Column(name = "nick_name")
    private String nickname;
    private Integer age;
    private String phone;
    private String address;
    private Boolean active;
    private List<String> roles;
    @Column(name = "create_time")
    private LocalDateTime createTime;
    @Column(name = "update_time")
    private LocalDateTime updateTime;
    // 自動設(shè)置時間
    @PrePersist
    protected void onCreate() {
        createTime = LocalDateTime.now();
        updateTime = LocalDateTime.now();
    }
    @PreUpdate
    protected void onUpdate() {
        updateTime = LocalDateTime.now();
    }
}

import com.xiaxl.demo.model.response.ApiResponse;
import com.xiaxl.demo.model.response.UserDTO;
import com.xiaxl.demo.model.request.UserRequest;
import com.xiaxl.demo.service.UserService;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@Slf4j
@RestController
// Lombok注解，自動生成一個包含所有final字段的構(gòu)造函數(shù)
// 這通常用于依賴注入，Spring會自動調(diào)用此構(gòu)造函數(shù)注入所需的依賴
public class UserDbController {
    // 聲明一個UserService類型的final常量，使用依賴注入方式初始化
    // UserService是Spring Data JPA接口，用于操作用戶數(shù)據(jù)表
    // final關(guān)鍵字確保該引用在構(gòu)造函數(shù)初始化后不能被修改
    private final UserService mUserService;
    // 使用構(gòu)造器注入（推薦）
    @Autowired
    public UserDbController(UserService userService) {
        this.mUserService = userService;
    }
}

import com.xiaxl.demo.model.db.UserEntity;
import com.xiaxl.demo.model.response.ApiResponse;
import com.xiaxl.demo.model.response.UserDTO;
import com.xiaxl.demo.model.request.UserRequest;
import com.xiaxl.demo.repository.UserRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;
@Slf4j
@Service
public class UserService {
    // 聲明一個UserRepository類型的final常量，使用依賴注入方式初始化
    // UserRepository是Spring Data JPA接口，用于操作用戶數(shù)據(jù)表
    // final關(guān)鍵字確保該引用在構(gòu)造函數(shù)初始化后不能被修改
    private final UserRepository mUserRepository;
    // 使用構(gòu)造器注入（推薦）
    @Autowired
    public UserService(UserRepository userRepository) {
        this.mUserRepository = userRepository;
    }
    /**
     * 實體轉(zhuǎn)DTO
     *
     * @param userEntity
     * @return
     */
    public UserDTO convertToDTO(UserEntity userEntity) {
        UserDTO dto = new UserDTO();
        BeanUtils.copyProperties(userEntity, dto);
        return dto;
    }
    /**
     * @param userDTO
     * @return
     */
    public UserEntity convertToEntity(UserDTO userDTO) {
        UserEntity userEntity = new UserEntity();
        BeanUtils.copyProperties(userDTO, userEntity);
        return userEntity;
    }
}

import com.xiaxl.demo.model.db.UserEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository  // 添加 @Repository 注解
public interface UserRepository extends JpaRepository<UserEntity, Long> {
    // 根據(jù)用戶名查找用戶
    Optional<UserEntity> findByName(String name);
    // 根據(jù)郵箱查找用戶
    Optional<UserEntity> findByEmail(String email);
    // 查找所有用戶按創(chuàng)建時間倒序
    @Query("SELECT u FROM UserEntity u ORDER BY u.createTime DESC")
    List<UserEntity> findAllOrderByCreatedAtDesc();
}

/**  
 * POST請求 - 創(chuàng)建用戶（JSON格式請求體）  
 * 訪問地址：POST http://localhost:8081/api/post/users  
 * 請求頭：Content-Type: application/json  
 * 請求體示例：  
 * {  
 * "name": "李四",  
 * "email": "lisi@example.com", * "age": 30, * "phone": "13900139000", * "address": "上海市浦東新區(qū)",  
 * "agreeTerms": true * } * * @param request       接收并驗證請求體中的JSON數(shù)據(jù)，自動反序列化為UserCreateRequest對象,  
 *                      Valid注解觸發(fā)對UserCreateRequest對象中字段的驗證規(guī)則  
 * @param bindingResult 接收參數(shù)驗證結(jié)果，包含所有驗證錯誤信息  
 * @return ApiResponse<UserDTO>  
 */  
@PostMapping("/api/post/create/user")  
public ResponseEntity<ApiResponse<UserDTO>> createUser(  
        @Valid @RequestBody UserRequest request,  
        BindingResult bindingResult) {  
    log.info("創(chuàng)建用戶 - 請求數(shù)據(jù): {}", request);  
    // 參數(shù)校驗  
    if (bindingResult.hasErrors()) {  
        Map<String, String> errors = new HashMap<>();  
        for (FieldError error : bindingResult.getFieldErrors()) {  
            errors.put(error.getField(), error.getDefaultMessage());  
        }  
        return ResponseEntity  
                .badRequest()  
                .body(ApiResponse.error(errors.toString(), 400));  
    }  
    return mUserService.createUser(request);  
}

/**  
 * 創(chuàng)建用戶  
 *  
 * @param request  
 * @return  
 */  
public ResponseEntity<ApiResponse<UserDTO>> createUser(UserRequest request) {  
    // 檢查用戶名是否已存在  
    if (mUserRepository.findByName(request.getName()).isPresent()) {  
        return ResponseEntity.badRequest()  
                .body(ApiResponse.error("用戶名已存在"));  
    }  
    // 檢查郵箱是否已存在  
    if (mUserRepository.findByEmail(request.getEmail()).isPresent()) {  
        return ResponseEntity.badRequest()  
                .body(ApiResponse.error("郵箱已存在"));  
    }  
    // 調(diào)用內(nèi)部事務(wù)方法  
    UserEntity savedUserEntity = saveUserEntity(request);  
    return ResponseEntity.status(HttpStatus.CREATED)  
            .body(ApiResponse.success("用戶創(chuàng)建成功", convertToDTO(savedUserEntity)));  
}
@Transactional  
public UserEntity saveUserEntity(UserRequest request) {  
    log.info("saveUserEntity: ", request);  
    try {  
        // 實際的創(chuàng)建邏輯，帶有事務(wù)  
        UserEntity newUserEntity = new UserEntity();  
        newUserEntity.setName(request.getName());  
        newUserEntity.setEmail(request.getEmail());  
        newUserEntity.setAge(request.getAge());  
        newUserEntity.setPhone(request.getPhone());  
        newUserEntity.setAddress(request.getAddress());  
        newUserEntity.setActive(true);  
        newUserEntity.setCreateTime(LocalDateTime.now());  
        newUserEntity.setUpdateTime(LocalDateTime.now());  
        newUserEntity.setRoles(List.of("USER"));  
        log.info("saveUserEntity: ", request);  
        return mUserRepository.save(newUserEntity);  
    }catch (Exception e){  
        e.printStackTrace();  
        log.info("Exception: ", e.getMessage());  
    }  
    return null;  
}

/**  
 * 獲取所有用戶  
 * GET http://localhost:8081/api/get/users  
 */@GetMapping("/api/get/users")  
public ResponseEntity<ApiResponse<List<UserDTO>>> getAllUsers() {  
    log.info("getAllUsers");  
    return mUserService.getAllUsers();  
}

/**  
 * 返回全部用戶  
 *  
 * @return  
 */  
public ResponseEntity<ApiResponse<List<UserDTO>>> getAllUsers() {  
    List<UserDTO> users = mUserRepository.findAllOrderByCreatedAtDesc().stream()  
            .map(this::convertToDTO)  
            .collect(Collectors.toList());  
  
    return ResponseEntity.ok(ApiResponse.success("獲取成功", users));  
}