diff --git a/src/main/java/com/example/myproject/controller/UserController.java b/src/main/java/com/example/myproject/controller/UserController.java
index dc4073b..b6aaab7 100644
--- a/src/main/java/com/example/myproject/controller/UserController.java
+++ b/src/main/java/com/example/myproject/controller/UserController.java
@@ -530,6 +530,7 @@
 import com.example.myproject.service.DynamicService;
 import com.example.myproject.service.UserService;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 
@@ -716,6 +717,17 @@
         return userService.checkUserShareRate(userId);
     }
 
+    // 用户充值接口
+    @PostMapping("/recharge")
+    public ResponseEntity<?> recharge(@RequestParam Long userId, @RequestParam Integer amount) {
+        String result = userService.recharge(userId, amount);
+        if (result.startsWith("充值成功")) {
+            return ResponseEntity.ok(Map.of("status", "success", "message", result));
+        } else {
+            return ResponseEntity.badRequest().body(Map.of("status", "failure", "message", result));
+        }
+    }
+
 
 }
 
diff --git a/src/main/java/com/example/myproject/entity/Users.java b/src/main/java/com/example/myproject/entity/Users.java
index 282ef79..a9398cf 100644
--- a/src/main/java/com/example/myproject/entity/Users.java
+++ b/src/main/java/com/example/myproject/entity/Users.java
@@ -77,7 +77,17 @@
     @Column(name = "lastupdatetime")
     private Date lastupdatetime;
 
+    @Column(name = "money", nullable = false)
+    private Integer money;
+
     // Getters and Setters
+    public Integer getMoney() {
+        return money;
+    }
+    public void setMoney(Integer money) {
+        this.money = money;
+    }
+
     public Long getUserId() {
         return userId;
     }
diff --git a/src/main/java/com/example/myproject/service/UserService.java b/src/main/java/com/example/myproject/service/UserService.java
index 4315c39..7f0b48a 100644
--- a/src/main/java/com/example/myproject/service/UserService.java
+++ b/src/main/java/com/example/myproject/service/UserService.java
@@ -714,6 +714,21 @@
         }
         return false;
     }
+    public String recharge(Long userId, Integer amount) {
+        if (amount == null || amount <= 0) {
+            return "充值金额必须大于0";
+        }
+        Users user = userRepository.findById(userId).orElse(null);
+        if (user == null) {
+            return "用户不存在";
+        }
+        // 累加money
+        Integer currentMoney = user.getMoney() == null ? 0 : user.getMoney();
+        user.setMoney(currentMoney + amount);
+        userRepository.save(user);
+        return "充值成功，当前余额：" + user.getMoney();
+    }
+
 
 
 }
