// 大小写决定可见性
type User struct {
    ID   int    // 公开
    name string // 私有
}

func (u *User) GetName() string { // 公开方法
    return u.name
}

func (u *User) setName(name string) { // 私有方法
    u.name = name
}

// 每个成员都需要明确修饰符
public class User {
    private Long id;        // 必须指定private
    private String name;    // 必须指定private
    
    // 公开getter，需要显式public
    public String getName() {
        return this.name;
    }
    
    // 私有setter，需要显式private
    private void setName(String name) {
        this.name = name;
    }
}

// 不要试图在Java中完全复制Go的隐式组合
// 接受Java需要更多样板代码的事实，体现了显式优于隐式的设计原则

// Go风格（隐式组合）
type Service struct {
    *Logger     // 嵌入指针，自动获得Logger的方法
    *Metrics    // 自动获得Metrics的方法
    *Database   // 自动获得Database的方法
}

// Java风格（显式但有更多控制）
class Service {
    private final Logger logger;
    private final Metrics metrics;
    private final Database database;
    // 显式构造器
    public Service(Logger logger, Metrics metrics, Database database) {
        this.logger = logger;
        this.metrics = metrics;
        this.database = database;
    }
    
    // 显式委托方法
    public void log(String message) {
        logger.log(message); // 明确的方法调用
    }
}

my-go-project/
├── cmd/                    # 应用程序入口目录
│   ├── app1/              # 每个可执行文件有自己的目录
│   │   ├── main.go        # main函数
│   │   └── config.yaml    # 该应用的配置
│   └── app2/
│       └── main.go
│
├── internal/               # 私有应用程序代码库
│   ├── pkg1/              # 项目内部包，外部项目不能导入
│   │   ├── service.go
│   │   └── service_test.go
│   └── pkg2/
│       ├── repository.go
│       └── repository_test.go
│
├── pkg/                    # 公共库代码
│   ├── lib1/              # 可以被外部项目导入
│   │   ├── lib.go
│   │   └── lib_test.go
│   └── lib2/
│       ├── util.go
│       └── util_test.go
│
├── api/                    # API定义
│   ├── protobuf/          # Protocol Buffer定义
│   │   └── user.proto
│   └── openapi/
│       └── swagger.yaml
│
├── web/                    # Web静态资源
│   ├── static/
│   │   ├── css/
│   │   └── js/
│   └── templates/
│       └── index.html
│
├── configs/                # 配置文件模板或默认配置
│   ├── config.yaml.example
│   └── config.dev.yaml
│
├── scripts/                # 构建、安装、分析等脚本
│   ├── build.sh
│   ├── install.sh
│   └── release.sh
│
├── test/                   # 额外的外部测试和测试数据
│   ├── integration/
│   └── testdata/
│
├── deployments/            # 部署配置
│   ├── docker/
│   │   ├── Dockerfile
│   │   └── docker-compose.yaml
│   └── kubernetes/
│       ├── deployment.yaml
│       └── service.yaml
│
├── docs/                   # 文档
│   ├── design.md
│   ├── api.md
│   └── README.md
│
├── vendor/                 # 依赖的副本（可选）
│
├── go.mod                  # 模块定义
├── go.sum                  # 模块校验和
├── .gitignore
├── LICENSE
└── README.md

my-java-project/
├── src/
│   ├── main/                     # 主源代码
│   │   ├── java/                # Java源代码
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── myapp/
│   │   │               ├── Application.java
│   │   │               ├── config/           # 配置类
│   │   │               ├── controller/       # 控制器层
│   │   │               ├── service/          # 服务层
│   │   │               │   ├── impl/         # 服务实现
│   │   │               │   └── UserService.java
│   │   │               ├── repository/       # 数据访问层
│   │   │               │   ├── entity/       # JPA实体类
│   │   │               │   ├── dao/         # DAO接口
│   │   │               │   └── mapper/      # MyBatis Mapper
│   │   │               ├── model/           # 数据传输对象
│   │   │               │   ├── dto/         # 请求/响应对象
│   │   │               │   └── vo/          # 视图对象
│   │   │               ├── exception/       # 异常类
│   │   │               └── util/            # 工具类
│   │   │
│   │   ├── resources/           # 资源文件
│   │   │   ├── application.yml  # 主配置文件(启动端口、servlet配置之类的)
│   │   │   ├── application-dev.yml
│   │   │   ├── application-prod.yml
│   │   │   ├── logback-spring.xml
│   │   │   ├── mapper/         # MyBatis Mapper XML
│   │   │   ├── static/         # 静态资源
│   │   │   │   ├── css/
│   │   │   │   ├── js/
│   │   │   │   └── images/
│   │   │   └── templates/      # 模板文件
│   │   │       └── thymeleaf/
│   │   │
│   │   └── webapp/             # Web应用资源
│   │       ├── WEB-INF/
│   │       └── index.jsp
│   │
│   └── test/                   # 测试代码
│       ├── java/
│       │   └── com/example/myapp/
│       │       ├── ApplicationTests.java
│       │       ├── controller/
│       │       ├── service/
│       │       └── repository/
│       └── resources/          # 测试资源
│           ├── application-test.yml
│           └── test-data.sql
│
├── target/                    # 构建输出目录
│   ├── classes/
│   ├── test-classes/
│   ├── generated-sources/
│   ├── my-app.jar
│   └── surefire-reports/
│
├── pom.xml                    # Maven配置文件
├── mvnw                       # Maven包装器
├── mvnw.cmd
├── .mvn/                      # Maven配置
│   └── wrapper/
│       └── maven-wrapper.properties
├── .gitignore
├── LICENSE
└── README.md

microservices-go/
├── api-gateway/              # API网关
│   ├── cmd/
│   ├── internal/
│   └── go.mod
├── user-service/             # 用户服务
│   ├── cmd/
│   ├── internal/
│   │   ├── handler/
│   │   ├── service/
│   │   └── repository/
│   ├── pkg/
│   └── go.mod
├── order-service/            # 订单服务
│   ├── cmd/
│   ├── internal/
│   └── go.mod
├── product-service/          # 产品服务
│   ├── cmd/
│   ├── internal/
│   └── go.mod
├── pkg/                      # 共享包
│   ├── models/              # 共享模型
│   ├── utils/               # 共享工具
│   └── errors/              # 共享错误定义
├── deployments/              # 部署配置
│   ├── docker-compose.yaml
│   └── kubernetes/
├── scripts/
├── .gitignore
├── README.md
└── Makefile                  # 统一构建脚本

microservices-java/
├── discovery-server/         # 服务发现
│   ├── src/
│   └── pom.xml
├── api-gateway/              # API网关
│   ├── src/
│   └── pom.xml
├── user-service/
│   ├── src/main/java/com/example/user/
│   │   ├── UserApplication.java
│   │   ├── controller/
│   │   ├── service/
│   │   ├── repository/
│   │   ├── model/
│   │   └── config/
│   ├── src/main/resources/
│   ├── Dockerfile
│   └── pom.xml
├── order-service/
│   ├── src/
│   └── pom.xml
├── product-service/
│   ├── src/
│   └── pom.xml
├── common/                   # 公共模块
│   ├── src/main/java/com/example/common/
│   │   ├── dto/
│   │   ├── exception/
│   │   └── utils/
│   └── pom.xml
├── config-server/            # 配置中心
│   ├── src/
│   └── pom.xml
├── deployments/
│   └── kubernetes/
├── .gitignore
├── README.md
└── pom.xml                   # 父POM，子模块可以继承配置

// 基于域名的导入路径
import (
    "github.com/username/project/pkg/math"
    "github.com/username/project/internal/database"
    "mycompany.com/shared/utils"
)

// 包名与目录名相关，一目录一包命名
// 目录: /home/user/project/pkg/math
// 包声明: package math

// 反向域名 + 项目结构
package com.example.myapp.domain.user;

// 或分层结构
package com.example.myapp.controller;
package com.example.myapp.service;
package com.example.myapp.repository.entity;
package com.example.myapp.model.dto;

// Go: go.mod 文件
module github.com/mycompany/myapp

go 1.19  // 指定Go版本

require (
    github.com/gin-gonic/gin v1.8.1
    github.com/go-sql-driver/mysql v1.6.0
)

// 特点：
// 1. 语言版本在go.mod中指定
// 2. 依赖版本直接写在require中
// 3. 没有类似Maven的"属性变量"概念
// 4. 版本管理更简单直接

go build ./cmd/app      # 编译
go test ./...           # 测试所有包
go mod tidy             # 整理依赖
go mod vendor           # 创建vendor目录

<!-- Maven: pom.xml -->
<project>
    <!-- pom.xml的版本号，表明pom文件个字段含义的，不同于maven和项目的版本号 -->
    <modelVersion>4.0.0</modelVersion>
    
    <!-- 项目的基本信息坐标 -->
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <!-- 继承父pom.xml-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <!-- 不写relativePath时，会默认使用../pom.xml作为父pom.xml -->
        <!-- 如下，为(空值）时，Maven 会跳过本地文件系统查找，直接从配置的远程仓库中下载父 POM -->
        <relativePath/>
    </parent>

    <!-- properties 是 Maven 的"变量声明"区 -->
    <properties>
        <!-- 这里定义的都是"键值对"，可以在整个pom.xml和代码中引用 -->
        <java.version>11</java.version>  <!-- 键: java.version, 值: 11 -->
    </properties>

    <dependencies>
        <!-- Jar包依赖，包含Spring Boot的核心包依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    
    <build>
        <!-- 插件配置， 配置和管理mvn命令行的构建过程-->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>  <!-- 引用上面properties的属性 -->
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# 编译项目
mvn compile
# 运行应用，开发调试
mvn spring-boot:run
# 打包成可执行JAR
mvn package
# 清理构建
mvn clean
# 清理并重新下载依赖
mvn clean install

<!-- 外部属性加载方式 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>properties-maven-plugin</artifactId>
            <version>1.1.0</version>
            <executions>
                <execution>
                    <phase>initialize</phase>
                    <goals>
                        <goal>read-project-properties</goal>
                    </goals>
                    <configuration>
                        <files>
                            <file>versions.properties</file>
                        </files>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

// main.go
package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()  // 显式创建路由
    
    // 中间件：显式添加
    r.Use(Logger())  // 全局中间件
    
    // 路由定义：简单直接
    r.GET("/users", getUsers)
    r.POST("/users", createUser)
    r.GET("/users/:id", getUser)
    
    auth := r.Group("/api", AuthMiddleware())  // 分组中间件
    
    // 启动：一行代码
    r.Run(":8080")
}

// 处理器：普通函数
func getUser(c *gin.Context) {
    id := c.Param("id")  // 手动获取参数,也有Bind()方法,需手动创建Go结构体接收
    // 处理逻辑...
    users := []User{{ID: id, Name: "Alice"}}
    c.JSON(200, gin.H{"data": users})
}

@RestController // 默认返回JSON
@RequestMapping("/api/users") // 路由前缀
public class UserController {
    
    @Autowired  // 自动注入
    private UserService userService;
    
    // 通过注解声明路由
    @GetMapping
    public ResponseEntity<List<User>> getUsers() {
        return ResponseEntity.ok(userService.getAllUsers());
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        return ResponseEntity.status(201)
            .body(userService.createUser(user));
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) { // 自动绑定参数
        return ResponseEntity.ok(userService.getUserById(id));
    }
}

// 主类 （Spring Boot 项目通常有一个名为 *Application 的入口类，
// 入口类里有一个main方法， 这个main方法其实就是一个标准的Java应用的入口方法）
// 最核心的启动类注解，下文细讲
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);  // 自动配置
    }
}

// GORM: 链式调用，类似SQL
type User struct {
    gorm.Model
    Name  string
    Email string `gorm:"uniqueIndex"`
    Age   int
}

// 查询
var user User
db.Where("age > ?", 18).
   Where("name LIKE ?", "%张%").
   Order("created_at desc").
   First(&user)

// 关联查询 - 需要显式Preload
db.Preload("Orders").Preload("Profile").Find(&users)

// 原生SQL支持
db.Raw("SELECT * FROM users WHERE age > ?", 20).Scan(&users)

// 手动事务
tx := db.Begin()
if err := tx.Create(&user).Error; err != nil {
    tx.Rollback()
    return err
}
tx.Commit()

// JPA实体
@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @Column(unique = true)
    private String email;
    
    private Integer age;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;  // 自动关联
    
    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;
}

// Repository接口 - 声明式查询
public interface UserRepository extends JpaRepository<User, Long> {
    
    // 方法名自动生成查询
    List<User> findByAgeGreaterThan(int age);
    
    List<User> findByNameContaining(String name);
    
    // 自定义查询
    @Query("SELECT u FROM User u WHERE u.age > :age ORDER BY u.createdAt DESC")
    List<User> findAdults(@Param("age") int age);
    
    // 分页查询
    Page<User> findAll(Pageable pageable);
}

// 事务管理 - 声明式
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(User user) {
        return userRepository.save(user);  // 自动事务
    }
}

// 1. 手动依赖注入（最常用）
type UserService struct {
    repo UserRepository
    cache Cache
    logger *log.Logger
}

func NewUserService(repo UserRepository, cache Cache, logger *log.Logger) *UserService {
    return &UserService{repo: repo, cache: cache, logger: logger}
}

// 2. 选项模式（Builder模式）
type UserService struct {
    repo UserRepository
    cache Cache
    logger *log.Logger
}

type Option func(*UserService)

func WithCache(cache Cache) Option {
    return func(s *UserService) { s.cache = cache }
}

func NewUserService(repo UserRepository, opts ...Option) *UserService {
    s := &UserService{repo: repo}
    for _, opt := range opts {
        opt(s)
    }
    return s
}

// 使用
service := NewUserService(repo, WithCache(redisCache))

// 1. 构造器注入（Spring推荐）
@Service
public class UserService {
    
    private final UserRepository userRepository;
    private final Cache cache;
    private final Logger logger;
    
    @Autowired
    public UserService(UserRepository userRepository, 
                      Cache cache, 
                      Logger logger) {
        this.userRepository = userRepository;
        this.cache = cache;
        this.logger = logger;
    }
}

// 2. Setter注入
@Service
public class UserService {
    
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

// 使用Viper, Go生态中最流行的配置管理库
import "github.com/spf13/viper"

func LoadConfig() (*Config, error) {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    
    // 默认值
    viper.SetDefault("server.port", 8080)
    viper.SetDefault("server.timeout", 30)
    
    // 环境变量支持
    viper.AutomaticEnv()
    viper.SetEnvPrefix("APP")
    viper.BindEnv("server.port", "APP_SERVER_PORT")
    
    // 配置文件
    if err := viper.ReadInConfig(); err != nil {
        if _, ok := err.(viper.ConfigFileNotFoundError); ok {
            log.Println("使用默认配置")
        } else {
            return nil, err
        }
    }
    
    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        return nil, err
    }
    
    return &config, nil
}

// 结构体映射
type Config struct {
    Server   ServerConfig   `mapstructure:"server"`
    Database DatabaseConfig `mapstructure:"database"`
    Redis    RedisConfig    `mapstructure:"redis"`
}

type ServerConfig struct {
    Port    int    `mapstructure:"port"`
    Timeout int    `mapstructure:"timeout"`
    Env     string `mapstructure:"env"`
}

// 1. application.yml
server:
  port: 8080
  timeout: 30s

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db
    username: root
    password: secret
  redis:
    host: localhost
    port: 6379

app:
  name: myapp
  version: 1.0.0

// 2. @ConfigurationProperties
@Configuration
@ConfigurationProperties(prefix = "app")
@Data
public class AppProperties {
    private String name;
    private String version;
    private List<String> features = new ArrayList<>();
}

// 3. @Value注解
@Component
public class MyComponent {
    
    @Value("${server.port}")
    private int port;
    
    @Value("${app.name:defaultApp}")  // 默认值
    private String appName;
    
    @Value("#{'${app.features}'.split(',')}")
    private List<String> features;
}

// 1. 原生goroutine + ticker
func scheduleTask() {
    ticker := time.NewTicker(1 * time.Hour)
    defer ticker.Stop()
    
    for {
        select {
        case <-ticker.C:
            doTask()
        case <-stopChan:
            return
        }
    }
}

// 2. 使用cron库
import "github.com/robfig/cron/v3"

func main() {
    c := cron.New()
    
    // 添加任务
    c.AddFunc("0 0 * * *", cleanUpTask)       // 每天午夜
    c.AddFunc("*/5 * * * *", heartbeatTask)   // 每5分钟
    c.AddFunc("@hourly", hourlyTask)          // 每小时
    c.AddFunc("@every 1h30m", complexTask)    // 每1.5小时
    
    c.Start()
    defer c.Stop()
    
    // 等待
    select {}
}

// 3. 分布式任务调度 (Machinery)
import "github.com/RichardKnop/machinery/v1"
import "github.com/RichardKnop/machinery/v1/config"

func main() {
    // 配置
    cnf := &config.Config{
        Broker:        "redis://localhost:6379",
        DefaultQueue:  "machinery_tasks",
        ResultBackend: "redis://localhost:6379",
    }
    
    // 创建服务器
    server, err := machinery.NewServer(cnf)
    if err != nil {
        panic(err)
    }
    
    // 注册任务
    server.RegisterTask("add", Add)
    server.RegisterTask("multiply", Multiply)
    
    // 启动worker
    worker := server.NewWorker("worker1", 10)
    go worker.Launch()
    
    // 发送任务
    signature := &tasks.Signature{
        Name: "add",
        Args: []tasks.Arg{
            {Type: "int64", Value: 1},
            {Type: "int64", Value: 2},
        },
    }
    
    asyncResult, err := server.SendTask(signature)
    if err != nil {
        panic(err)
    }
    
    result, err := asyncResult.Get(time.Duration(time.Millisecond * 5))
    if err != nil {
        panic(err)
    }
}

// 1. Spring Scheduled
@Component
public class ScheduledTasks {
    
    // 固定延迟
    @Scheduled(fixedDelay = 5000)
    public void taskWithFixedDelay() {
        // 任务完成5秒后再次执行
    }
    
    // 固定速率
    @Scheduled(fixedRate = 5000)
    public void taskWithFixedRate() {
        // 每5秒执行一次
    }
    
    // Cron表达式
    @Scheduled(cron = "0 0 9-17 * * MON-FRI")
    public void officeHoursTask() {
        // 工作日9点到17点每小时执行
    }
    
    // 初始延迟
    @Scheduled(initialDelay = 1000, fixedRate = 5000)
    public void taskWithInitialDelay() {
        // 启动后延迟1秒，然后每5秒执行
    }
}

// 2. Quartz集成
@Configuration
public class QuartzConfig {
    
    @Bean
    public JobDetail jobDetail() {
        return JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .storeDurably()
                .build();
    }
    
    @Bean
    public Trigger trigger() {
        return TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withIdentity("myTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                .build();
    }
}

@Component
public class MyJob implements Job {
    
    @Override
    public void execute(JobExecutionContext context) {
        // 执行任务
    }
}

// 3. 分布式任务 (XXL-Job/Elastic-Job)
@XxlJob("demoJobHandler")
public ReturnT<String> demoJobHandler(String param) {
    // 分布式任务
    return ReturnT.SUCCESS;
}

我需要实现 [集成类系统的权限管理]，请帮我：
1. 分析这个需求可能涉及哪些技术领域，有没有成熟的库/项目已经做过类似的事？
2. 确定使用Java技术栈，并使用mvn初始化合适的脚手架

生成该项目的一个团队规范，存放于.trae\rules\project_rules.md文件中

// 1. Repository层：操作数据库
public class UserRepository {
    public void save(User user) {
        System.out.println("保存用户到数据库：" + user.getName());
    }
}

// 2. Service层：业务逻辑
public class UserService {
    // 必须手动创建依赖对象 → 「自己new」，初始化省略..
    private UserRepository userRepository = new UserRepository();
    
    public void registerUser(User user) {
        // 密码加密（业务逻辑）
        user.setPassword(encryptPassword(user.getPassword()));
        // 调用Repository保存
        userRepository.save(user);
    }
    
    private String encryptPassword(String password) {
        return "加密后的密码：" + password;
    }
}

// 3. Controller层：接收请求
public class UserController {
    // 必须手动创建依赖对象 → 「自己new」
    private UserService userService = new UserService();
    
    // 可以改进为接收参数
    public void handleRegisterRequest(String name, String password) {
        User user = new User();
        user.setName(name);
        user.setPassword(password);
        userService.registerUser(user);
    }
}

// 4. 启动类：手动创建所有对象
public class App {
    public static void main(String[] args) {
        // 必须手动创建所有层的对象 → 「自己管理依赖」
        UserController controller = new UserController();
        // 调用注册接口
        controller.handleRegisterRequest("张三", "123456");
    }
}

// 1. Repository层：用@Repository标记，告诉容器「UserRepository类是要管理的Bean对象」
@Repository
public class UserRepository {
    public void save(User user) {
        System.out.println("保存用户到数据库：" + user.getName());
    }
}

// 2. Service层：用@Service标记，@Autowired让容器自动注入依赖
@Service
public class UserService {
    // 容器自动注入UserRepository → 「不用自己new」,配置已初始化
    @Autowired
    private UserRepository userRepository;
    
    public void registerUser(User user) {
        // 专注于业务逻辑（密码加密）
        user.setPassword(encryptPassword(user.getPassword()));
        userRepository.save(user);
    }
    
    private String encryptPassword(String password) {
        return "加密后的密码：" + password;
    }
}

// 3. Controller层：用@RestController标记，@Autowired自动注入Service
@RestController
public class UserController {
    // 容器自动注入UserService → 「自动解决依赖」
    @Autowired
    private UserService userService;
    
    @PostMapping("/register")
    public String registerUser(@RequestBody User user) {
        // 专注于处理请求，不用关心Service怎么来的
        userService.registerUser(user);
        return "注册成功";
    }
}

// 4. 启动类：用@SpringBootApplication标记，容器自动创建所有对象
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        // 一行代码启动 → 容器自动处理所有对象创建和依赖
        SpringApplication.run(App.class, args);
    }
}

# application.yml
server:
  port: 9090  # 覆盖默认的 8080 端口

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yudao
    username: root
    password: 123456

/**
 * Spring Boot应用程序的主启动类
 * 
 * @SpringBootApplication 是一个组合注解，包含以下三个核心功能：
 * 1. @SpringBootConfiguration: 标识这是一个Spring Boot应用的主配置类
 * 2. @EnableAutoConfiguration: 启用Spring Boot的自动配置机制
 * 3. @ComponentScan: 自动扫描当前包及其子包下的组件（如@Controller、@Service、@Repository等）
 * 
 * 这个注解告诉Spring Boot框架：这是一个Spring Boot应用程序的入口点
 */
@SpringBootApplication
public class ServerApplication {
    
    /**
     * 应用程序的主入口方法
     * 
     * 当JVM启动时，会首先执行这个main方法
     * 该方法负责启动整个Spring Boot应用程序
     * 
     * @param args 命令行参数，可以在启动时传入配置参数
     *             例如：--server.port=8081 或 --spring.profiles.active=dev
     */
    public static void main(String[] args) {
        /**
         * SpringApplication.run() 方法执行以下关键操作：
         * 1. 创建Spring应用上下文（ApplicationContext）
         * 2. 启用自动配置（根据classpath中的依赖自动配置Bean）
         * 3. 启动内嵌的Web服务器（如Tomcat、Jetty等）
         * 4. 扫描并注册所有使用Spring注解的组件
         * 5. 启动完成后，应用程序进入运行状态，等待HTTP请求
         * 
         * 参数说明：
         * - ServerApplication.class: 主配置类，Spring Boot会从这个类所在的包开始扫描组件
         * - args: 命令行参数，用于覆盖默认配置
         * 
         * 返回值：ConfigurableApplicationContext对象，代表整个Spring应用上下文
         * 可以用于获取Bean、关闭应用等操作
         */
        SpringApplication.run(ServerApplication.class, args);
    }
}

@Data // @Data组合注解，自动为该类生成getter/setter/toString/equals/hashCode等方法，节省了约50行左右的代码量。
// 相当于以下注解组合
// @Getter、@Setter、@ToString、@EqualsAndHashCode等
public class User {
    private Long id;
    private String name;
    private Integer age;
}

// 所有类都继承 Object
public class User {  // 隐式继承 Object
    // 自动拥有 Object 的方法：toString(), equals(), hashCode() 等
}

Map<User, String> map = new HashMap<>();
User user = new User();
map.put(user, "value");  // 需要拥有正确的 hashCode() 和 equals()

Set<User> set = new HashSet<>();
set.add(user);  // 同样需要正确的 hashCode() 和 equals()