diff --git a/src/main/java/com/example/tampopotest/controller/ActivityController.java b/src/main/java/com/example/tampopotest/controller/ActivityController.java
new file mode 100644
index 0000000..ae07029
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ActivityController.java
@@ -0,0 +1,108 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.Activity;
+import com.example.tampopotest.service.ActivityService;
+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.time.LocalDateTime;
+import java.util.List;
+
+@RestController
+public class ActivityController {
+    
+    @Autowired
+    private ActivityService activityService;
+    
+    @GetMapping("/users/{user-id}/activities")
+    public ResponseEntity<List<Activity>> getActivities(@PathVariable("user-id") String userId) {
+        try {
+            List<Activity> activities = activityService.getActivitiesByUserId(userId);
+            return ResponseEntity.ok(activities);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/users/{user-id}/activities")
+    public ResponseEntity<Activity> createActivity(@PathVariable("user-id") String userId,
+                                                    @RequestParam("text") String text) {
+        try {
+            Activity activity = activityService.createActivity(userId, text);
+            return ResponseEntity.ok(activity);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @GetMapping("/users/{user-id}/activities/{activity-id}")
+    public ResponseEntity<Activity> getActivity(@PathVariable("user-id") String userId,
+                                                 @PathVariable("activity-id") Long activityId) {
+        try {
+            Activity activity = activityService.getActivityById(activityId);
+            return ResponseEntity.ok(activity);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @DeleteMapping("/users/{user-id}/activities/{activity-id}")
+    public ResponseEntity<Void> deleteActivity(@PathVariable("user-id") String userId,
+                                               @PathVariable("activity-id") Long activityId) {
+        try {
+            activityService.deleteActivity(activityId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @GetMapping("/users/{user-id}/activities/{activity-id}/text")
+    public ResponseEntity<String> getActivityText(@PathVariable("user-id") String userId,
+                                                   @PathVariable("activity-id") Long activityId) {
+        try {
+            String text = activityService.getActivityText(activityId);
+            return ResponseEntity.ok(text);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @PutMapping("/users/{user-id}/activities/{activity-id}/text")
+    public ResponseEntity<String> updateActivityText(@PathVariable("user-id") String userId,
+                                                      @PathVariable("activity-id") Long activityId,
+                                                      @RequestParam("new-text") String newText) {
+        try {
+            String text = activityService.updateActivityText(activityId, newText);
+            return ResponseEntity.ok(text);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @GetMapping("/users/{user-id}/activities/{activity-id}/updated-time")
+    public ResponseEntity<LocalDateTime> getActivityUpdatedTime(@PathVariable("user-id") String userId,
+                                                                 @PathVariable("activity-id") Long activityId) {
+        try {
+            LocalDateTime time = activityService.getActivityUpdatedTime(activityId);
+            return ResponseEntity.ok(time);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @GetMapping("/users/{user-id}/activities/last-updated-time")
+    public ResponseEntity<LocalDateTime> getLastUpdatedTime(@PathVariable("user-id") String userId) {
+        try {
+            LocalDateTime time = activityService.getLastUpdatedTime(userId);
+            if (time == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+            }
+            return ResponseEntity.ok(time);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/ChatController.java b/src/main/java/com/example/tampopotest/controller/ChatController.java
new file mode 100644
index 0000000..07818a8
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ChatController.java
@@ -0,0 +1,109 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.ChatRequest;
+import com.example.tampopotest.entity.ChatRoom;
+import com.example.tampopotest.entity.Message;
+import com.example.tampopotest.service.ChatService;
+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;
+
+@RestController
+public class ChatController {
+    
+    @Autowired
+    private ChatService chatService;
+    
+    // Chat Requests
+    @GetMapping("/chat-requests")
+    public ResponseEntity<List<ChatRequest>> getAllChatRequests() {
+        try {
+            List<ChatRequest> requests = chatService.getAllChatRequests();
+            return ResponseEntity.ok(requests);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/chat-requests")
+    public ResponseEntity<ChatRequest> createChatRequest(@RequestParam("from-user-id") String fromUserId,
+                                                          @RequestParam("to-user-id") String toUserId) {
+        try {
+            ChatRequest request = chatService.createChatRequest(fromUserId, toUserId);
+            return ResponseEntity.ok(request);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @DeleteMapping("/chat-requests/{chat-request-id}")
+    public ResponseEntity<Void> deleteChatRequest(@PathVariable("chat-request-id") Long chatRequestId) {
+        try {
+            chatService.deleteChatRequest(chatRequestId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    // Chat Rooms
+    @GetMapping("/chat-rooms")
+    public ResponseEntity<List<ChatRoom>> getAllChatRooms() {
+        try {
+            List<ChatRoom> rooms = chatService.getAllChatRooms();
+            return ResponseEntity.ok(rooms);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/chat-rooms")
+    public ResponseEntity<ChatRoom> createChatRoom(@RequestParam("user-id1") String userId1,
+                                                    @RequestParam("user-id2") String userId2) {
+        try {
+            ChatRoom room = chatService.createChatRoom(userId1, userId2);
+            return ResponseEntity.ok(room);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @GetMapping("/chat-rooms/{chatroom-id}/{user-id}")
+    public ResponseEntity<List<Message>> getMessages(@PathVariable("chatroom-id") Long chatroomId,
+                                                      @PathVariable("user-id") String userId) {
+        try {
+            List<Message> messages = chatService.getMessagesByChatroomId(chatroomId);
+            return ResponseEntity.ok(messages);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @PostMapping("/chat-rooms/{chatroom-id}/{user-id}")
+    public ResponseEntity<Message> createMessage(@PathVariable("chatroom-id") Long chatroomId,
+                                                  @PathVariable("user-id") String userId,
+                                                  @RequestParam("text") String text) {
+        try {
+            Message message = chatService.createMessage(chatroomId, userId, text);
+            return ResponseEntity.ok(message);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @PutMapping("/chat-rooms/{chatroom-id}/{user-id}/message")
+    public ResponseEntity<Message> updateMessage(@PathVariable("chatroom-id") Long chatroomId,
+                                                  @PathVariable("user-id") String userId,
+                                                  @RequestParam("message-id") Long messageId,
+                                                  @RequestParam("new-text") String newText) {
+        try {
+            Message message = chatService.updateMessage(messageId, newText);
+            return ResponseEntity.ok(message);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/FriendController.java b/src/main/java/com/example/tampopotest/controller/FriendController.java
new file mode 100644
index 0000000..d56bbcd
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/FriendController.java
@@ -0,0 +1,125 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.FriendPair;
+import com.example.tampopotest.entity.FriendRequest;
+import com.example.tampopotest.service.FriendService;
+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;
+
+@RestController
+public class FriendController {
+    
+    @Autowired
+    private FriendService friendService;
+    
+    // /users/{user-id}/friends
+    @GetMapping("/users/{user-id}/friends")
+    public ResponseEntity<List<String>> getFriends(@PathVariable("user-id") String userId) {
+        try {
+            List<String> friends = friendService.getFriendsByUserId(userId);
+            return ResponseEntity.ok(friends);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<FriendPair> getFriendPair(@PathVariable("user-id") String userId,
+                                                     @PathVariable("pair-id") Long pairId) {
+        try {
+            FriendPair pair = friendService.getFriendPairById(pairId);
+            return ResponseEntity.ok(pair);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @DeleteMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<Void> deleteFriendPair(@PathVariable("user-id") String userId,
+                                                  @PathVariable("pair-id") Long pairId) {
+        try {
+            friendService.deleteFriendPair(pairId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    // /friend-requests
+    @GetMapping("/friend-requests")
+    public ResponseEntity<List<FriendRequest>> getAllFriendRequests() {
+        try {
+            List<FriendRequest> requests = friendService.getAllFriendRequests();
+            return ResponseEntity.ok(requests);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/friend-requests")
+    public ResponseEntity<FriendRequest> createFriendRequest(@RequestParam("from-user-id") String fromUserId,
+                                                              @RequestParam("to-user-id") String toUserId) {
+        try {
+            FriendRequest request = friendService.createFriendRequest(fromUserId, toUserId);
+            return ResponseEntity.ok(request);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @DeleteMapping("/friend-requests/{friend-request-id}")
+    public ResponseEntity<Void> deleteFriendRequest(@PathVariable("friend-request-id") Long friendRequestId) {
+        try {
+            friendService.deleteFriendRequest(friendRequestId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    // /friends
+    @GetMapping("/friends")
+    public ResponseEntity<List<FriendPair>> getAllFriendPairs() {
+        try {
+            List<FriendPair> pairs = friendService.getAllFriendPairs();
+            return ResponseEntity.ok(pairs);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/friends")
+    public ResponseEntity<FriendPair> createFriendPair(@RequestParam("user-id1") String userId1,
+                                                        @RequestParam("user-id2") String userId2) {
+        try {
+            FriendPair pair = friendService.createFriendPair(userId1, userId2);
+            return ResponseEntity.ok(pair);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+    }
+    
+    @DeleteMapping("/friends/pairs/{pair-id}")
+    public ResponseEntity<Void> deleteFriendPairByPairId(@PathVariable("pair-id") Long pairId) {
+        try {
+            friendService.deleteFriendPairByUsers(pairId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @GetMapping("/friends/users/{user-id}")
+    public ResponseEntity<List<FriendPair>> getFriendPairsByUserId(@PathVariable("user-id") String userId) {
+        try {
+            List<FriendPair> pairs = friendService.getFriendPairsByUserId(userId);
+            return ResponseEntity.ok(pairs);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/controller/UserController.java b/src/main/java/com/example/tampopotest/controller/UserController.java
new file mode 100644
index 0000000..3eb7094
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/UserController.java
@@ -0,0 +1,223 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.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.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/users")
+public class UserController {
+    
+    @Autowired
+    private UserService userService;
+    
+    @GetMapping
+    public ResponseEntity<List<String>> getAllUsers() {
+        try {
+            List<String> userIds = userService.getAllUserIds();
+            return ResponseEntity.ok(userIds);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping
+    public ResponseEntity<Map<String, String>> createUser(@RequestParam("user-id") String userId,
+                                                           @RequestParam("password") String password) {
+        try {
+            User user = userService.createUser(userId, password);
+            Map<String, String> response = new HashMap<>();
+            response.put("user-id", user.getUserId());
+            response.put("token", user.getToken());
+            return ResponseEntity.ok(response);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("User ID already exists")) {
+                return ResponseEntity.status(HttpStatus.CONFLICT).build();
+            }
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/{user-id}")
+    public ResponseEntity<Map<String, String>> getUserInfo(@PathVariable("user-id") String userId) {
+        try {
+            User user = userService.getUserById(userId)
+                    .orElseThrow(() -> new RuntimeException("User not found"));
+            Map<String, String> response = new HashMap<>();
+            response.put("name", user.getName());
+            response.put("icon", user.getIcon());
+            return ResponseEntity.ok(response);
+        } catch (RuntimeException e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @DeleteMapping("/{user-id}")
+    public ResponseEntity<Void> deleteUser(@PathVariable("user-id") String userId,
+                                           @RequestParam("token") String token) {
+        try {
+            // Token validation should be done in service
+            userService.deleteUser(userId);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PostMapping("/{user-id}/login")
+    public ResponseEntity<Map<String, String>> login(@PathVariable("user-id") String userId,
+                                                      @RequestParam("password") String password) {
+        try {
+            String token = userService.login(userId, password);
+            Map<String, String> response = new HashMap<>();
+            response.put("token", token);
+            return ResponseEntity.ok(response);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("User not found")) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+            } else if (e.getMessage().equals("Password incorrect")) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
+            }
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/{user-id}/name")
+    public ResponseEntity<String> getName(@PathVariable("user-id") String userId) {
+        try {
+            String name = userService.getName(userId);
+            return ResponseEntity.ok(name);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @PutMapping("/{user-id}/name")
+    public ResponseEntity<String> updateName(@PathVariable("user-id") String userId,
+                                             @RequestParam("token") String token,
+                                             @RequestParam("new-name") String newName) {
+        try {
+            String name = userService.updateName(userId, token, newName);
+            return ResponseEntity.ok(name);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            } else if (e.getMessage().equals("User not found")) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+            }
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/{user-id}/password")
+    public ResponseEntity<Map<String, String>> getPassword(@PathVariable("user-id") String userId,
+                                                            @RequestParam("token") String token) {
+        try {
+            String password = userService.getPassword(userId, token);
+            Map<String, String> response = new HashMap<>();
+            response.put("password", password);
+            return ResponseEntity.ok(response);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            }
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PutMapping("/{user-id}/password")
+    public ResponseEntity<Void> updatePassword(@PathVariable("user-id") String userId,
+                                               @RequestParam("token") String token,
+                                               @RequestParam("new-password") String newPassword) {
+        try {
+            userService.updatePassword(userId, token, newPassword);
+            return ResponseEntity.ok().build();
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            }
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/{user-id}/email")
+    public ResponseEntity<Map<String, String>> getEmail(@PathVariable("user-id") String userId,
+                                                         @RequestParam("token") String token) {
+        try {
+            String email = userService.getEmail(userId, token);
+            Map<String, String> response = new HashMap<>();
+            response.put("email", email);
+            return ResponseEntity.ok(response);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            }
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @PutMapping("/{user-id}/email")
+    public ResponseEntity<String> updateEmail(@PathVariable("user-id") String userId,
+                                              @RequestParam("token") String token,
+                                              @RequestParam("new-email") String newEmail) {
+        try {
+            String email = userService.updateEmail(userId, token, newEmail);
+            return ResponseEntity.ok(email);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            }
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
+    @GetMapping("/{user-id}/icon")
+    public ResponseEntity<String> getIcon(@PathVariable("user-id") String userId) {
+        try {
+            String icon = userService.getIcon(userId);
+            return ResponseEntity.ok(icon);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+    
+    @PutMapping("/{user-id}/icon")
+    public ResponseEntity<String> updateIcon(@PathVariable("user-id") String userId,
+                                             @RequestParam("token") String token,
+                                             @RequestParam("new-icon") String newIcon) {
+        try {
+            String icon = userService.updateIcon(userId, token, newIcon);
+            return ResponseEntity.ok(icon);
+        } catch (RuntimeException e) {
+            if (e.getMessage().equals("Invalid token")) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+            }
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/Activity.java b/src/main/java/com/example/tampopotest/entity/Activity.java
new file mode 100644
index 0000000..742ed28
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/Activity.java
@@ -0,0 +1,65 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "activities")
+public class Activity {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "activity_id")
+    private Long activityId;
+    
+    @Column(name = "user_id", nullable = false)
+    private String userId;
+    
+    @Column(name = "text", length = 1000)
+    private String text;
+    
+    @Column(name = "updated_time")
+    private LocalDateTime updatedTime;
+    
+    public Activity() {
+    }
+    
+    public Activity(String userId, String text) {
+        this.userId = userId;
+        this.text = text;
+        this.updatedTime = LocalDateTime.now();
+    }
+    
+    // Getters and Setters
+    public Long getActivityId() {
+        return activityId;
+    }
+    
+    public void setActivityId(Long activityId) {
+        this.activityId = activityId;
+    }
+    
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getText() {
+        return text;
+    }
+    
+    public void setText(String text) {
+        this.text = text;
+    }
+    
+    public LocalDateTime getUpdatedTime() {
+        return updatedTime;
+    }
+    
+    public void setUpdatedTime(LocalDateTime updatedTime) {
+        this.updatedTime = updatedTime;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/ChatRequest.java b/src/main/java/com/example/tampopotest/entity/ChatRequest.java
new file mode 100644
index 0000000..b2c78da
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/ChatRequest.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "chat_requests")
+public class ChatRequest {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "chat_request_id")
+    private Long chatRequestId;
+    
+    @Column(name = "from_user_id", nullable = false)
+    private String fromUserId;
+    
+    @Column(name = "to_user_id", nullable = false)
+    private String toUserId;
+    
+    public ChatRequest() {
+    }
+    
+    public ChatRequest(String fromUserId, String toUserId) {
+        this.fromUserId = fromUserId;
+        this.toUserId = toUserId;
+    }
+    
+    // Getters and Setters
+    public Long getChatRequestId() {
+        return chatRequestId;
+    }
+    
+    public void setChatRequestId(Long chatRequestId) {
+        this.chatRequestId = chatRequestId;
+    }
+    
+    public String getFromUserId() {
+        return fromUserId;
+    }
+    
+    public void setFromUserId(String fromUserId) {
+        this.fromUserId = fromUserId;
+    }
+    
+    public String getToUserId() {
+        return toUserId;
+    }
+    
+    public void setToUserId(String toUserId) {
+        this.toUserId = toUserId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/ChatRoom.java b/src/main/java/com/example/tampopotest/entity/ChatRoom.java
new file mode 100644
index 0000000..d41ef0b
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/ChatRoom.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "chat_rooms")
+public class ChatRoom {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "chatroom_id")
+    private Long chatroomId;
+    
+    @Column(name = "user_id1", nullable = false)
+    private String userId1;
+    
+    @Column(name = "user_id2", nullable = false)
+    private String userId2;
+    
+    public ChatRoom() {
+    }
+    
+    public ChatRoom(String userId1, String userId2) {
+        this.userId1 = userId1;
+        this.userId2 = userId2;
+    }
+    
+    // Getters and Setters
+    public Long getChatroomId() {
+        return chatroomId;
+    }
+    
+    public void setChatroomId(Long chatroomId) {
+        this.chatroomId = chatroomId;
+    }
+    
+    public String getUserId1() {
+        return userId1;
+    }
+    
+    public void setUserId1(String userId1) {
+        this.userId1 = userId1;
+    }
+    
+    public String getUserId2() {
+        return userId2;
+    }
+    
+    public void setUserId2(String userId2) {
+        this.userId2 = userId2;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/FriendPair.java b/src/main/java/com/example/tampopotest/entity/FriendPair.java
new file mode 100644
index 0000000..40dcb74
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/FriendPair.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "friend_pairs")
+public class FriendPair {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "pair_id")
+    private Long pairId;
+    
+    @Column(name = "user_id1", nullable = false)
+    private String userId1;
+    
+    @Column(name = "user_id2", nullable = false)
+    private String userId2;
+    
+    public FriendPair() {
+    }
+    
+    public FriendPair(String userId1, String userId2) {
+        this.userId1 = userId1;
+        this.userId2 = userId2;
+    }
+    
+    // Getters and Setters
+    public Long getPairId() {
+        return pairId;
+    }
+    
+    public void setPairId(Long pairId) {
+        this.pairId = pairId;
+    }
+    
+    public String getUserId1() {
+        return userId1;
+    }
+    
+    public void setUserId1(String userId1) {
+        this.userId1 = userId1;
+    }
+    
+    public String getUserId2() {
+        return userId2;
+    }
+    
+    public void setUserId2(String userId2) {
+        this.userId2 = userId2;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/FriendRequest.java b/src/main/java/com/example/tampopotest/entity/FriendRequest.java
new file mode 100644
index 0000000..6832288
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/FriendRequest.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "friend_requests")
+public class FriendRequest {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "friend_request_id")
+    private Long friendRequestId;
+    
+    @Column(name = "from_user_id", nullable = false)
+    private String fromUserId;
+    
+    @Column(name = "to_user_id", nullable = false)
+    private String toUserId;
+    
+    public FriendRequest() {
+    }
+    
+    public FriendRequest(String fromUserId, String toUserId) {
+        this.fromUserId = fromUserId;
+        this.toUserId = toUserId;
+    }
+    
+    // Getters and Setters
+    public Long getFriendRequestId() {
+        return friendRequestId;
+    }
+    
+    public void setFriendRequestId(Long friendRequestId) {
+        this.friendRequestId = friendRequestId;
+    }
+    
+    public String getFromUserId() {
+        return fromUserId;
+    }
+    
+    public void setFromUserId(String fromUserId) {
+        this.fromUserId = fromUserId;
+    }
+    
+    public String getToUserId() {
+        return toUserId;
+    }
+    
+    public void setToUserId(String toUserId) {
+        this.toUserId = toUserId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/Message.java b/src/main/java/com/example/tampopotest/entity/Message.java
new file mode 100644
index 0000000..989b86a
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/Message.java
@@ -0,0 +1,77 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "messages")
+public class Message {
+    
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "message_id")
+    private Long messageId;
+    
+    @Column(name = "chatroom_id", nullable = false)
+    private Long chatroomId;
+    
+    @Column(name = "user_id", nullable = false)
+    private String userId;
+    
+    @Column(name = "text", length = 1000)
+    private String text;
+    
+    @Column(name = "timestamp")
+    private LocalDateTime timestamp;
+    
+    public Message() {
+    }
+    
+    public Message(Long chatroomId, String userId, String text) {
+        this.chatroomId = chatroomId;
+        this.userId = userId;
+        this.text = text;
+        this.timestamp = LocalDateTime.now();
+    }
+    
+    // Getters and Setters
+    public Long getMessageId() {
+        return messageId;
+    }
+    
+    public void setMessageId(Long messageId) {
+        this.messageId = messageId;
+    }
+    
+    public Long getChatroomId() {
+        return chatroomId;
+    }
+    
+    public void setChatroomId(Long chatroomId) {
+        this.chatroomId = chatroomId;
+    }
+    
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getText() {
+        return text;
+    }
+    
+    public void setText(String text) {
+        this.text = text;
+    }
+    
+    public LocalDateTime getTimestamp() {
+        return timestamp;
+    }
+    
+    public void setTimestamp(LocalDateTime timestamp) {
+        this.timestamp = timestamp;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/entity/User.java b/src/main/java/com/example/tampopotest/entity/User.java
new file mode 100644
index 0000000..9576069
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/entity/User.java
@@ -0,0 +1,86 @@
+package com.example.tampopotest.entity;
+
+import jakarta.persistence.*;
+import java.util.UUID;
+
+@Entity
+@Table(name = "users")
+public class User {
+    
+    @Id
+    @Column(name = "user_id", nullable = false, unique = true)
+    private String userId;
+    
+    @Column(name = "password", nullable = false)
+    private String password;
+    
+    @Column(name = "token")
+    private String token;
+    
+    @Column(name = "name")
+    private String name;
+    
+    @Column(name = "icon")
+    private String icon;
+    
+    @Column(name = "email")
+    private String email;
+    
+    public User() {
+    }
+    
+    public User(String userId, String password) {
+        this.userId = userId;
+        this.password = password;
+        this.token = UUID.randomUUID().toString();
+    }
+    
+    // Getters and Setters
+    public String getUserId() {
+        return userId;
+    }
+    
+    public void setUserId(String userId) {
+        this.userId = userId;
+    }
+    
+    public String getPassword() {
+        return password;
+    }
+    
+    public void setPassword(String password) {
+        this.password = password;
+    }
+    
+    public String getToken() {
+        return token;
+    }
+    
+    public void setToken(String token) {
+        this.token = token;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+    
+    public String getIcon() {
+        return icon;
+    }
+    
+    public void setIcon(String icon) {
+        this.icon = icon;
+    }
+    
+    public String getEmail() {
+        return email;
+    }
+    
+    public void setEmail(String email) {
+        this.email = email;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ActivityRepository.java b/src/main/java/com/example/tampopotest/repository/ActivityRepository.java
new file mode 100644
index 0000000..a96f03d
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ActivityRepository.java
@@ -0,0 +1,13 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.Activity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ActivityRepository extends JpaRepository<Activity, Long> {
+    List<Activity> findByUserId(String userId);
+    List<Activity> findByUserIdOrderByUpdatedTimeDesc(String userId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java b/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java
new file mode 100644
index 0000000..56df0b2
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java
@@ -0,0 +1,13 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.ChatRequest;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ChatRequestRepository extends JpaRepository<ChatRequest, Long> {
+    List<ChatRequest> findByFromUserId(String fromUserId);
+    List<ChatRequest> findByToUserId(String toUserId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java b/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java
new file mode 100644
index 0000000..aedfe61
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java
@@ -0,0 +1,18 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.ChatRoom;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface ChatRoomRepository extends JpaRepository<ChatRoom, Long> {
+    @Query("SELECT c FROM ChatRoom c WHERE c.userId1 = :userId OR c.userId2 = :userId")
+    List<ChatRoom> findByUserId(@Param("userId") String userId);
+    
+    @Query("SELECT c FROM ChatRoom c WHERE (c.userId1 = :userId1 AND c.userId2 = :userId2) OR (c.userId1 = :userId2 AND c.userId2 = :userId1)")
+    ChatRoom findByUserIds(@Param("userId1") String userId1, @Param("userId2") String userId2);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java b/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java
new file mode 100644
index 0000000..6070eee
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java
@@ -0,0 +1,18 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.FriendPair;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface FriendPairRepository extends JpaRepository<FriendPair, Long> {
+    @Query("SELECT f FROM FriendPair f WHERE f.userId1 = :userId OR f.userId2 = :userId")
+    List<FriendPair> findByUserId(@Param("userId") String userId);
+    
+    @Query("SELECT f FROM FriendPair f WHERE (f.userId1 = :userId1 AND f.userId2 = :userId2) OR (f.userId1 = :userId2 AND f.userId2 = :userId1)")
+    FriendPair findByUserIds(@Param("userId1") String userId1, @Param("userId2") String userId2);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java b/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java
new file mode 100644
index 0000000..d19c49b
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java
@@ -0,0 +1,13 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.FriendRequest;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface FriendRequestRepository extends JpaRepository<FriendRequest, Long> {
+    List<FriendRequest> findByFromUserId(String fromUserId);
+    List<FriendRequest> findByToUserId(String toUserId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/MessageRepository.java b/src/main/java/com/example/tampopotest/repository/MessageRepository.java
new file mode 100644
index 0000000..88dc873
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/MessageRepository.java
@@ -0,0 +1,13 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.Message;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface MessageRepository extends JpaRepository<Message, Long> {
+    List<Message> findByChatroomId(Long chatroomId);
+    List<Message> findByChatroomIdOrderByTimestampAsc(Long chatroomId);
+}
diff --git a/src/main/java/com/example/tampopotest/repository/UserRepository.java b/src/main/java/com/example/tampopotest/repository/UserRepository.java
new file mode 100644
index 0000000..208c6ed
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/UserRepository.java
@@ -0,0 +1,14 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.entity.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, String> {
+    Optional<User> findByUserId(String userId);
+    Optional<User> findByToken(String token);
+    boolean existsByUserId(String userId);
+}
diff --git a/src/main/java/com/example/tampopotest/service/ActivityService.java b/src/main/java/com/example/tampopotest/service/ActivityService.java
new file mode 100644
index 0000000..cb26216
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/ActivityService.java
@@ -0,0 +1,63 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.entity.Activity;
+import com.example.tampopotest.repository.ActivityRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class ActivityService {
+    
+    @Autowired
+    private ActivityRepository activityRepository;
+    
+    public List<Activity> getActivitiesByUserId(String userId) {
+        return activityRepository.findByUserIdOrderByUpdatedTimeDesc(userId);
+    }
+    
+    public Activity createActivity(String userId, String text) {
+        Activity activity = new Activity(userId, text);
+        return activityRepository.save(activity);
+    }
+    
+    public Activity getActivityById(Long activityId) {
+        return activityRepository.findById(activityId)
+                .orElseThrow(() -> new RuntimeException("Activity not found"));
+    }
+    
+    public void deleteActivity(Long activityId) {
+        activityRepository.deleteById(activityId);
+    }
+    
+    public String getActivityText(Long activityId) {
+        Activity activity = activityRepository.findById(activityId)
+                .orElseThrow(() -> new RuntimeException("Activity not found"));
+        return activity.getText();
+    }
+    
+    public String updateActivityText(Long activityId, String newText) {
+        Activity activity = activityRepository.findById(activityId)
+                .orElseThrow(() -> new RuntimeException("Activity not found"));
+        activity.setText(newText);
+        activity.setUpdatedTime(LocalDateTime.now());
+        activityRepository.save(activity);
+        return newText;
+    }
+    
+    public LocalDateTime getActivityUpdatedTime(Long activityId) {
+        Activity activity = activityRepository.findById(activityId)
+                .orElseThrow(() -> new RuntimeException("Activity not found"));
+        return activity.getUpdatedTime();
+    }
+    
+    public LocalDateTime getLastUpdatedTime(String userId) {
+        List<Activity> activities = activityRepository.findByUserIdOrderByUpdatedTimeDesc(userId);
+        if (activities.isEmpty()) {
+            return null;
+        }
+        return activities.get(0).getUpdatedTime();
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/service/ChatService.java b/src/main/java/com/example/tampopotest/service/ChatService.java
new file mode 100644
index 0000000..2c0e2d6
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/ChatService.java
@@ -0,0 +1,75 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.entity.ChatRequest;
+import com.example.tampopotest.entity.ChatRoom;
+import com.example.tampopotest.entity.Message;
+import com.example.tampopotest.repository.ChatRequestRepository;
+import com.example.tampopotest.repository.ChatRoomRepository;
+import com.example.tampopotest.repository.MessageRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ChatService {
+    
+    @Autowired
+    private ChatRequestRepository chatRequestRepository;
+    
+    @Autowired
+    private ChatRoomRepository chatRoomRepository;
+    
+    @Autowired
+    private MessageRepository messageRepository;
+    
+    // Chat Requests
+    public List<ChatRequest> getAllChatRequests() {
+        return chatRequestRepository.findAll();
+    }
+    
+    public ChatRequest createChatRequest(String fromUserId, String toUserId) {
+        ChatRequest request = new ChatRequest(fromUserId, toUserId);
+        return chatRequestRepository.save(request);
+    }
+    
+    public void deleteChatRequest(Long chatRequestId) {
+        chatRequestRepository.deleteById(chatRequestId);
+    }
+    
+    // Chat Rooms
+    public List<ChatRoom> getAllChatRooms() {
+        return chatRoomRepository.findAll();
+    }
+    
+    public ChatRoom createChatRoom(String userId1, String userId2) {
+        ChatRoom room = new ChatRoom(userId1, userId2);
+        return chatRoomRepository.save(room);
+    }
+    
+    public ChatRoom getChatRoomById(Long chatroomId) {
+        return chatRoomRepository.findById(chatroomId)
+                .orElseThrow(() -> new RuntimeException("Chat room not found"));
+    }
+    
+    public List<ChatRoom> getChatRoomsByUserId(String userId) {
+        return chatRoomRepository.findByUserId(userId);
+    }
+    
+    // Messages
+    public List<Message> getMessagesByChatroomId(Long chatroomId) {
+        return messageRepository.findByChatroomIdOrderByTimestampAsc(chatroomId);
+    }
+    
+    public Message createMessage(Long chatroomId, String userId, String text) {
+        Message message = new Message(chatroomId, userId, text);
+        return messageRepository.save(message);
+    }
+    
+    public Message updateMessage(Long messageId, String newText) {
+        Message message = messageRepository.findById(messageId)
+                .orElseThrow(() -> new RuntimeException("Message not found"));
+        message.setText(newText);
+        return messageRepository.save(message);
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/service/FriendService.java b/src/main/java/com/example/tampopotest/service/FriendService.java
new file mode 100644
index 0000000..349b0cb
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/FriendService.java
@@ -0,0 +1,73 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.entity.FriendPair;
+import com.example.tampopotest.entity.FriendRequest;
+import com.example.tampopotest.repository.FriendPairRepository;
+import com.example.tampopotest.repository.FriendRequestRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class FriendService {
+    
+    @Autowired
+    private FriendPairRepository friendPairRepository;
+    
+    @Autowired
+    private FriendRequestRepository friendRequestRepository;
+    
+    public List<String> getFriendsByUserId(String userId) {
+        List<FriendPair> pairs = friendPairRepository.findByUserId(userId);
+        List<String> friends = new ArrayList<>();
+        for (FriendPair pair : pairs) {
+            if (pair.getUserId1().equals(userId)) {
+                friends.add(pair.getUserId2());
+            } else {
+                friends.add(pair.getUserId1());
+            }
+        }
+        return friends;
+    }
+    
+    public FriendPair getFriendPairById(Long pairId) {
+        return friendPairRepository.findById(pairId)
+                .orElseThrow(() -> new RuntimeException("Friend pair not found"));
+    }
+    
+    public void deleteFriendPair(Long pairId) {
+        friendPairRepository.deleteById(pairId);
+    }
+    
+    public List<FriendRequest> getAllFriendRequests() {
+        return friendRequestRepository.findAll();
+    }
+    
+    public FriendRequest createFriendRequest(String fromUserId, String toUserId) {
+        FriendRequest request = new FriendRequest(fromUserId, toUserId);
+        return friendRequestRepository.save(request);
+    }
+    
+    public void deleteFriendRequest(Long friendRequestId) {
+        friendRequestRepository.deleteById(friendRequestId);
+    }
+    
+    public List<FriendPair> getAllFriendPairs() {
+        return friendPairRepository.findAll();
+    }
+    
+    public FriendPair createFriendPair(String userId1, String userId2) {
+        FriendPair pair = new FriendPair(userId1, userId2);
+        return friendPairRepository.save(pair);
+    }
+    
+    public void deleteFriendPairByUsers(Long pairId) {
+        friendPairRepository.deleteById(pairId);
+    }
+    
+    public List<FriendPair> getFriendPairsByUserId(String userId) {
+        return friendPairRepository.findByUserId(userId);
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/service/UserService.java b/src/main/java/com/example/tampopotest/service/UserService.java
new file mode 100644
index 0000000..4a878a6
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/UserService.java
@@ -0,0 +1,113 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.entity.User;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+public class UserService {
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    public List<String> getAllUserIds() {
+        return userRepository.findAll().stream()
+                .map(User::getUserId)
+                .collect(Collectors.toList());
+    }
+    
+    public User createUser(String userId, String password) {
+        if (userRepository.existsByUserId(userId)) {
+            throw new RuntimeException("User ID already exists");
+        }
+        User user = new User(userId, password);
+        return userRepository.save(user);
+    }
+    
+    public Optional<User> getUserById(String userId) {
+        return userRepository.findByUserId(userId);
+    }
+    
+    public void deleteUser(String userId) {
+        userRepository.deleteById(userId);
+    }
+    
+    public String login(String userId, String password) {
+        Optional<User> userOpt = userRepository.findByUserId(userId);
+        if (userOpt.isEmpty()) {
+            throw new RuntimeException("User not found");
+        }
+        User user = userOpt.get();
+        if (!user.getPassword().equals(password)) {
+            throw new RuntimeException("Password incorrect");
+        }
+        String newToken = UUID.randomUUID().toString();
+        user.setToken(newToken);
+        userRepository.save(user);
+        return newToken;
+    }
+    
+    public String getName(String userId) {
+        return userRepository.findByUserId(userId)
+                .map(User::getName)
+                .orElseThrow(() -> new RuntimeException("User not found"));
+    }
+    
+    public String updateName(String userId, String token, String newName) {
+        User user = validateToken(userId, token);
+        user.setName(newName);
+        userRepository.save(user);
+        return newName;
+    }
+    
+    public String getPassword(String userId, String token) {
+        User user = validateToken(userId, token);
+        return user.getPassword();
+    }
+    
+    public void updatePassword(String userId, String token, String newPassword) {
+        User user = validateToken(userId, token);
+        user.setPassword(newPassword);
+        userRepository.save(user);
+    }
+    
+    public String getEmail(String userId, String token) {
+        User user = validateToken(userId, token);
+        return user.getEmail();
+    }
+    
+    public String updateEmail(String userId, String token, String newEmail) {
+        User user = validateToken(userId, token);
+        user.setEmail(newEmail);
+        userRepository.save(user);
+        return newEmail;
+    }
+    
+    public String getIcon(String userId) {
+        return userRepository.findByUserId(userId)
+                .map(User::getIcon)
+                .orElseThrow(() -> new RuntimeException("User not found"));
+    }
+    
+    public String updateIcon(String userId, String token, String newIcon) {
+        User user = validateToken(userId, token);
+        user.setIcon(newIcon);
+        userRepository.save(user);
+        return newIcon;
+    }
+    
+    private User validateToken(String userId, String token) {
+        User user = userRepository.findByUserId(userId)
+                .orElseThrow(() -> new RuntimeException("User not found"));
+        if (!user.getToken().equals(token)) {
+            throw new RuntimeException("Invalid token");
+        }
+        return user;
+    }
+}