diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 5115826..9e8c7b3 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -5,17 +5,8 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="c2345091-076c-4d33-bc14-d7566481fe8b" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/.gitattributes" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/.gitignore" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/build.gradle" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/gradle/wrapper/gradle-wrapper.jar" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/gradle/wrapper/gradle-wrapper.properties" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/gradlew" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/gradlew.bat" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/settings.gradle" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/main/java/com/example/tampopotest/TampopotestApplication.java" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/main/resources/application.properties" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/src/test/java/com/example/tampopotest/TampopotestApplicationTests.java" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/main/resources/application.properties" beforeDir="false" afterPath="$PROJECT_DIR$/src/main/resources/application.properties" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -31,6 +22,11 @@
     </projectState>
   </component>
   <component name="Git.Settings">
+    <option name="RECENT_BRANCH_BY_REPOSITORY">
+      <map>
+        <entry key="$PROJECT_DIR$" value="master" />
+      </map>
+    </option>
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
   <component name="GradleLocalSettings">
@@ -43,9 +39,9 @@
       </map>
     </option>
   </component>
-  <component name="ProjectColorInfo"><![CDATA[{
-  "associatedIndex": 8
-}]]></component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 8
+}</component>
   <component name="ProjectId" id="363TmaS4dc9aRxdEXNJ6ZCJUakN" />
   <component name="ProjectViewState">
     <option name="hideEmptyMiddlePackages" value="true" />
@@ -62,10 +58,13 @@
     "RunOnceActivity.ShowReadmeOnStart": "true",
     "Spring Boot.TampopotestApplication.executor": "Run",
     "com.intellij.ml.llm.matterhorn.ej.ui.settings.DefaultModelSelectionForGA.v1": "true",
-    "git-widget-placeholder": "master",
+    "git-widget-placeholder": "swclaude",
     "junie.onboarding.icon.badge.shown": "true",
     "kotlin-language-version-configured": "true",
     "last_opened_file_path": "C:/Users/student/IdeaProjects/tampopo-server",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "junie.application.models",
     "to.speed.mode.migration.done": "true",
     "vue.rearranger.settings.migration": "true"
   }
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..b03448d
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ActivityController.java
@@ -0,0 +1,172 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.model.Activity;
+import com.example.tampopotest.service.ActivityService;
+import com.example.tampopotest.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/users/{user-id}/activities")
+public class ActivityController {
+    private final ActivityService activityService;
+    private final UserService userService;
+
+    public ActivityController(ActivityService activityService, UserService userService) {
+        this.activityService = activityService;
+        this.userService = userService;
+    }
+
+    @GetMapping
+    public ResponseEntity<?> getActivities(@PathVariable("user-id") String userId,
+                                          @RequestParam(value = "filter", required = false) String filter) {
+        try {
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+
+            if ("LATEST".equals(filter)) {
+                Activity latest = activityService.getLatestActivity(userId);
+                if (latest == null) {
+                    return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+                }
+                Map<String, Object> response = new LinkedHashMap<>();
+                Map<String, String> activityData = new HashMap<>();
+                activityData.put("text", latest.getText());
+                activityData.put("updated-time", latest.getUpdatedTime());
+                response.put(latest.getActivityId(), activityData);
+                return ResponseEntity.ok(response);
+            } else {
+                List<Activity> activities = activityService.getActivitiesByUserId(userId);
+                if (activities.isEmpty()) {
+                    return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+                }
+                Map<String, Object> response = new LinkedHashMap<>();
+                for (Activity activity : activities) {
+                    Map<String, String> activityData = new HashMap<>();
+                    activityData.put("text", activity.getText());
+                    activityData.put("updated-time", activity.getUpdatedTime());
+                    response.put(activity.getActivityId(), activityData);
+                }
+                return ResponseEntity.ok(response);
+            }
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PostMapping
+    public ResponseEntity<?> createActivity(@PathVariable("user-id") String userId,
+                                           @RequestParam("token") String token,
+                                           @RequestParam("new-activity") String newActivity) {
+        try {
+            if (token == null || newActivity == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            Activity activity = activityService.createActivity(userId, token, newActivity);
+            if (activity == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("activity-id", activity.getActivityId());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{activity-id}")
+    public ResponseEntity<?> getActivity(@PathVariable("user-id") String userId,
+                                        @PathVariable("activity-id") String activityId) {
+        try {
+            Activity activity = activityService.getActivityById(activityId);
+            if (activity == null || !activity.getUserId().equals(userId)) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("activity-id", activity.getActivityId());
+            response.put("text", activity.getText());
+            response.put("updated-time", activity.getUpdatedTime());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @DeleteMapping("/{activity-id}")
+    public ResponseEntity<?> deleteActivity(@PathVariable("user-id") String userId,
+                                           @PathVariable("activity-id") String activityId,
+                                           @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            boolean deleted = activityService.deleteActivity(userId, activityId, token);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{activity-id}/text")
+    public ResponseEntity<?> getActivityText(@PathVariable("user-id") String userId,
+                                             @PathVariable("activity-id") String activityId) {
+        try {
+            Activity activity = activityService.getActivityById(activityId);
+            if (activity == null || !activity.getUserId().equals(userId)) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(activity.getText());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{activity-id}/updated-time")
+    public ResponseEntity<?> getActivityUpdatedTime(@PathVariable("user-id") String userId,
+                                                    @PathVariable("activity-id") String activityId) {
+        try {
+            Activity activity = activityService.getActivityById(activityId);
+            if (activity == null || !activity.getUserId().equals(userId)) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(activity.getUpdatedTime());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/last-updated-time")
+    public ResponseEntity<?> getLastUpdatedTime(@PathVariable("user-id") String userId) {
+        try {
+            Activity latest = activityService.getLatestActivity(userId);
+            if (latest == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(latest.getUpdatedTime());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
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..51aeeb2
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/ChatController.java
@@ -0,0 +1,192 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.model.ChatRequest;
+import com.example.tampopotest.model.ChatRoom;
+import com.example.tampopotest.service.ChatService;
+import com.example.tampopotest.service.UserService;
+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
+public class ChatController {
+    private final ChatService chatService;
+    private final UserService userService;
+
+    public ChatController(ChatService chatService, UserService userService) {
+        this.chatService = chatService;
+        this.userService = userService;
+    }
+
+    // /chat-requests endpoints
+    @PostMapping("/chat-requests")
+    public ResponseEntity<?> createChatRequest(@RequestParam("token") String token,
+                                               @RequestParam("sender-id") String senderId,
+                                               @RequestParam("receiver-id") String receiverId) {
+        try {
+            if (token == null || senderId == null || receiverId == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            ChatRequest request = chatService.createChatRequest(senderId, receiverId, token);
+            if (request == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            Map<String, Integer> response = new HashMap<>();
+            response.put("chat-request-id", request.getChatRequestId());
+            return ResponseEntity.status(HttpStatus.NO_CONTENT).body(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @DeleteMapping("/chat-requests/{chat-request-id}")
+    public ResponseEntity<?> deleteChatRequest(@PathVariable("chat-request-id") Integer chatRequestId,
+                                               @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("認証が必要です");
+            }
+            boolean deleted = chatService.deleteChatRequest(chatRequestId, token);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("チャットリクエストが見つかりません。");
+            }
+            return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    // /chat-rooms endpoints
+    @PostMapping("/chat-rooms")
+    public ResponseEntity<?> createChatRoom(@RequestParam("user0-id") String user0Id,
+                                           @RequestParam("user1-id") String user1Id,
+                                           @RequestParam("token") String token) {
+        try {
+            if (token == null || user0Id == null || user1Id == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            ChatRoom room = chatService.createChatRoom(user0Id, user1Id, token);
+            if (room == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("認証失敗");
+            }
+            Map<String, Integer> response = new HashMap<>();
+            response.put("room-id", room.getRoomId());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @GetMapping("/chat-rooms")
+    public ResponseEntity<?> getChatRooms(@RequestParam("user0-id") String user0Id,
+                                         @RequestParam("token") String token) {
+        try {
+            if (token == null || user0Id == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            List<ChatRoom> rooms = chatService.getChatRoomsByUserId(user0Id, token);
+            if (rooms == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("認証失敗");
+            }
+            if (rooms.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("IDが存在しません");
+            }
+            // Return the first room's ID (as per the spec expectation)
+            Map<String, Integer> response = new HashMap<>();
+            response.put("room-id", rooms.get(0).getRoomId());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @GetMapping("/chat-rooms/{chatroom-id}/{user-id}")
+    public ResponseEntity<?> getMessage(@PathVariable("chatroom-id") Integer chatroomId,
+                                       @PathVariable("user-id") String userId,
+                                       @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証されていません");
+            }
+            String message = chatService.getMessage(chatroomId, userId, token);
+            if (message == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証されていません");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("message", message);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @DeleteMapping("/chat-rooms/{chatroom-id}/{user-id}")
+    public ResponseEntity<?> deleteChatRoom(@PathVariable("chatroom-id") Integer chatroomId,
+                                           @PathVariable("user-id") String userId,
+                                           @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("IDが存在しません。");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("IDが存在しません。");
+            }
+            boolean deleted = chatService.deleteChatRoom(chatroomId, userId, token);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NO_CONTENT).body("チャットルームidが見つかりません。");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("message", "ユーザをルームから退出しました");
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("チャットリクエストが見つかりません。");
+        }
+    }
+
+    @PutMapping("/chat-rooms/{chatroom-id}/{user-id}")
+    public ResponseEntity<?> addUserToChatRoom(@PathVariable("chatroom-id") Integer chatroomId,
+                                              @PathVariable("user-id") String userId,
+                                              @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証されていません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証されていません");
+            }
+            boolean added = chatService.addUserToChatRoom(chatroomId, userId, token);
+            if (!added) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("チャットルームが見つかりません");
+            }
+            return ResponseEntity.ok("参加に成功しました");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @PutMapping("/chat-rooms/{chatroom-id}/{user-id}/message")
+    public ResponseEntity<?> updateMessage(@PathVariable("chatroom-id") Integer chatroomId,
+                                          @PathVariable("user-id") String userId,
+                                          @RequestParam("token") String token,
+                                          @RequestParam("message") String message) {
+        try {
+            if (token == null || message == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("リクエスト形式が不正です");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("リクエスト形式が不正です");
+            }
+            boolean updated = chatService.updateMessage(chatroomId, userId, message, token);
+            if (!updated) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("チャットルームが見つかりません");
+            }
+            return ResponseEntity.ok("正常にメッセージが更新されました");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+}
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..ce2128d
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/FriendController.java
@@ -0,0 +1,251 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.model.FriendPair;
+import com.example.tampopotest.model.FriendRequest;
+import com.example.tampopotest.service.FriendService;
+import com.example.tampopotest.service.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+public class FriendController {
+    private final FriendService friendService;
+    private final UserService userService;
+
+    public FriendController(FriendService friendService, UserService userService) {
+        this.friendService = friendService;
+        this.userService = userService;
+    }
+
+    // /users/{user-id}/friends endpoints
+    @GetMapping("/users/{user-id}/friends")
+    public ResponseEntity<?> getFriendPairs(@PathVariable("user-id") String userId,
+                                            @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            List<FriendPair> pairs = friendService.getFriendPairsByUserId(userId, token);
+            if (pairs == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            Map<String, Object> response = new LinkedHashMap<>();
+            for (FriendPair pair : pairs) {
+                Map<String, String> pairData = new HashMap<>();
+                pairData.put("user0-id", pair.getUser0Id());
+                pairData.put("user1-id", pair.getUser1Id());
+                response.put("pid" + pair.getPairId(), pairData);
+            }
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<?> getFriendPair(@PathVariable("user-id") String userId,
+                                          @PathVariable("pair-id") Integer pairId,
+                                          @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            FriendPair pair = friendService.getFriendPairById(pairId, userId, token);
+            if (pair == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("user-id", pair.getOtherUserId(userId));
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @DeleteMapping("/users/{user-id}/friends/{pair-id}")
+    public ResponseEntity<?> deleteFriendPair(@PathVariable("user-id") String userId,
+                                             @PathVariable("pair-id") Integer pairId,
+                                             @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            boolean deleted = friendService.deleteFriendPair(pairId, userId, token);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    // /friend-requests endpoints
+    @GetMapping("/friend-requests")
+    public ResponseEntity<?> getFriendRequests(@RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効です");
+            }
+            List<FriendRequest> requests = friendService.getFriendRequestsByUserId(token);
+            if (requests == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効です");
+            }
+            if (requests.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(requests);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @PostMapping("/friend-requests")
+    public ResponseEntity<?> createFriendRequest(@RequestParam("token") String token,
+                                                 @RequestParam("sender-id") String senderId,
+                                                 @RequestParam("receiver-id") String receiverId) {
+        try {
+            if (token == null || senderId == null || receiverId == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            FriendRequest request = friendService.createFriendRequest(senderId, receiverId, token);
+            if (request == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            return ResponseEntity.status(HttpStatus.CREATED).body(request.getId().toString());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    @DeleteMapping("/friend-requests/{friend-request-id}")
+    public ResponseEntity<?> deleteFriendRequest(@PathVariable("friend-request-id") Integer friendRequestId,
+                                                @RequestParam("receiver-token") String receiverToken) {
+        try {
+            if (receiverToken == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            boolean deleted = friendService.deleteFriendRequest(friendRequestId, receiverToken);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("指定されたIDのフレンドリクエストが見つかりませんでした");
+            }
+            return ResponseEntity.ok("フレンドリクエストの削除に成功しました");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("サーバー内部でエラーが発生しました");
+        }
+    }
+
+    // /friends endpoints
+    @PostMapping("/friends")
+    public ResponseEntity<?> createFriend(@RequestParam("token") String token,
+                                         @RequestParam("user0-id") String user0Id,
+                                         @RequestParam("user1-id") String user1Id) {
+        try {
+            if (token == null || user0Id == null || user1Id == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            FriendPair pair = friendService.createFriendPair(user0Id, user1Id, token);
+            if (pair == null) {
+                return ResponseEntity.status(HttpStatus.CONFLICT).body("重複している");
+            }
+            Map<String, Integer> response = new HashMap<>();
+            response.put("pair-id", pair.getPairId());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("エラー");
+        }
+    }
+
+    @GetMapping("/friends/pairs/{pair-id}")
+    public ResponseEntity<?> getFriendPairInfo(@PathVariable("pair-id") Integer pairId,
+                                               @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効");
+            }
+            var user = userService.getUserByToken(token);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効");
+            }
+            FriendPair pair = friendService.getFriendPairById(pairId, user.getUserId(), token);
+            if (pair == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("削除が失敗したとき");
+            }
+            Map<String, Object> response = new HashMap<>();
+            response.put("id", pair.getPairId().toString());
+            response.put("user0id", pair.getUser0Id());
+            response.put("user1Id", pair.getUser1Id());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("エラー");
+        }
+    }
+
+    @DeleteMapping("/friends/pairs/{pair-id}")
+    public ResponseEntity<?> deleteFriend(@PathVariable("pair-id") Integer pairId,
+                                         @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効");
+            }
+            var user = userService.getUserByToken(token);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("トークンが無効");
+            }
+            boolean deleted = friendService.deleteFriendPair(pairId, user.getUserId(), token);
+            if (!deleted) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しない");
+            }
+            return ResponseEntity.ok("削除が成功したとき");
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("エラー");
+        }
+    }
+
+    @GetMapping("/friends/users/{user-id}")
+    public ResponseEntity<?> getFriendList(@PathVariable("user-id") String userId,
+                                          @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            List<String> friendIds = friendService.getFriendIdsByUserId(userId, token);
+            if (friendIds == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            return ResponseEntity.ok(friendIds);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
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..ab8ec53
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/controller/UserController.java
@@ -0,0 +1,272 @@
+package com.example.tampopotest.controller;
+
+import com.example.tampopotest.model.User;
+import com.example.tampopotest.service.UserService;
+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 {
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @GetMapping
+    public ResponseEntity<?> getAllUsers() {
+        try {
+            List<String> userIds = userService.getAllUserIds();
+            if (userIds.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(userIds);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PostMapping
+    public ResponseEntity<?> createUser(@RequestParam("user-id") String userId,
+                                       @RequestParam("password") String password) {
+        try {
+            if (userId == null || password == null || userId.isEmpty() || password.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            User user = userService.createUser(userId, password);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.CONFLICT).body("ユーザーIDの重複");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("user-id", user.getUserId());
+            response.put("token", user.getToken());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{user-id}")
+    public ResponseEntity<?> getUser(@PathVariable("user-id") String userId) {
+        try {
+            User user = userService.getUserById(userId);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("name", user.getName());
+            response.put("icon", user.getIcon());
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @DeleteMapping("/{user-id}")
+    public ResponseEntity<?> deleteUser(@PathVariable("user-id") String userId,
+                                       @RequestParam("token") String token) {
+        try {
+            if (token == null || token.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            User user = userService.getUserById(userId);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            userService.deleteUser(userId, token);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PostMapping("/{user-id}/login")
+    public ResponseEntity<?> login(@PathVariable("user-id") String userId,
+                                   @RequestParam("password") String password) {
+        try {
+            if (password == null || password.isEmpty()) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("IDが存在しません");
+            }
+            String token = userService.loginUser(userId, password);
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("パスワード間違い");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("token", token);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{user-id}/name")
+    public ResponseEntity<?> getName(@PathVariable("user-id") String userId) {
+        try {
+            User user = userService.getUserById(userId);
+            if (user == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(user.getName());
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PutMapping("/{user-id}/name")
+    public ResponseEntity<?> updateName(@PathVariable("user-id") String userId,
+                                       @RequestParam("token") String token,
+                                       @RequestParam("new-name") String newName) {
+        try {
+            if (token == null || newName == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            userService.updateName(userId, token, newName);
+            return ResponseEntity.ok(newName);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{user-id}/password")
+    public ResponseEntity<?> getPassword(@PathVariable("user-id") String userId,
+                                        @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            String password = userService.getPassword(userId, token);
+            if (password == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("password", password);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PutMapping("/{user-id}/password")
+    public ResponseEntity<?> updatePassword(@PathVariable("user-id") String userId,
+                                           @RequestParam("token") String token,
+                                           @RequestParam("new-password") String newPassword) {
+        try {
+            if (token == null || newPassword == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("見つかりませんでした");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証トークンエラー");
+            }
+            userService.updatePassword(userId, token, newPassword);
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{user-id}/email")
+    public ResponseEntity<?> getEmail(@PathVariable("user-id") String userId,
+                                     @RequestParam("token") String token) {
+        try {
+            if (token == null) {
+                return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("未認証");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("IDが存在しません");
+            }
+            String email = userService.getEmail(userId, token);
+            if (email == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証トークンエラー");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("email", email);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PutMapping("/{user-id}/email")
+    public ResponseEntity<?> updateEmail(@PathVariable("user-id") String userId,
+                                        @RequestParam("token") String token,
+                                        @RequestParam("new-email") String newEmail) {
+        try {
+            if (token == null || newEmail == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("見つかりませんでした");
+            }
+            if (!userService.verifyToken(userId, token)) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("認証トークンエラー");
+            }
+            boolean updated = userService.updateEmail(userId, token, newEmail);
+            if (!updated) {
+                return ResponseEntity.status(HttpStatus.CONFLICT).body("メールアドレスの重複");
+            }
+            return ResponseEntity.ok().build();
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @GetMapping("/{user-id}/icon")
+    public ResponseEntity<?> getIcon(@PathVariable("user-id") String userId) {
+        try {
+            String icon = userService.getIcon(userId);
+            if (icon == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            return ResponseEntity.ok(icon);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+
+    @PutMapping("/{user-id}/icon")
+    public ResponseEntity<?> updateIcon(@PathVariable("user-id") String userId,
+                                       @RequestParam("token") String token,
+                                       @RequestParam("new-icon") String newIcon) {
+        try {
+            if (token == null || newIcon == null) {
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("不正なリクエスト");
+            }
+            if (userService.getUserById(userId) == null) {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND).body("データが存在しません");
+            }
+            String iconId = userService.updateIcon(userId, token, newIcon);
+            if (iconId == null) {
+                return ResponseEntity.status(HttpStatus.FORBIDDEN).body("トークンの不一致");
+            }
+            Map<String, String> response = new HashMap<>();
+            response.put("icon", iconId);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("予期せぬエラー");
+        }
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/Activity.java b/src/main/java/com/example/tampopotest/model/Activity.java
new file mode 100644
index 0000000..758faed
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/Activity.java
@@ -0,0 +1,53 @@
+package com.example.tampopotest.model;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class Activity {
+    private String activityId;
+    private String userId;
+    private String text;
+    private String updatedTime;
+
+    public Activity() {
+    }
+
+    public Activity(String activityId, String userId, String text) {
+        this.activityId = activityId;
+        this.userId = userId;
+        this.text = text;
+        this.updatedTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm"));
+    }
+
+    public String getActivityId() {
+        return activityId;
+    }
+
+    public void setActivityId(String 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 String getUpdatedTime() {
+        return updatedTime;
+    }
+
+    public void setUpdatedTime(String updatedTime) {
+        this.updatedTime = updatedTime;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/ChatRequest.java b/src/main/java/com/example/tampopotest/model/ChatRequest.java
new file mode 100644
index 0000000..b2e4fab
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/ChatRequest.java
@@ -0,0 +1,40 @@
+package com.example.tampopotest.model;
+
+public class ChatRequest {
+    private Integer chatRequestId;
+    private String senderId;
+    private String receiverId;
+
+    public ChatRequest() {
+    }
+
+    public ChatRequest(Integer chatRequestId, String senderId, String receiverId) {
+        this.chatRequestId = chatRequestId;
+        this.senderId = senderId;
+        this.receiverId = receiverId;
+    }
+
+    public Integer getChatRequestId() {
+        return chatRequestId;
+    }
+
+    public void setChatRequestId(Integer chatRequestId) {
+        this.chatRequestId = chatRequestId;
+    }
+
+    public String getSenderId() {
+        return senderId;
+    }
+
+    public void setSenderId(String senderId) {
+        this.senderId = senderId;
+    }
+
+    public String getReceiverId() {
+        return receiverId;
+    }
+
+    public void setReceiverId(String receiverId) {
+        this.receiverId = receiverId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/ChatRoom.java b/src/main/java/com/example/tampopotest/model/ChatRoom.java
new file mode 100644
index 0000000..236b059
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/ChatRoom.java
@@ -0,0 +1,67 @@
+package com.example.tampopotest.model;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ChatRoom {
+    private Integer roomId;
+    private String user0Id;
+    private String user1Id;
+    private Map<String, String> messages;
+
+    public ChatRoom() {
+        this.messages = new HashMap<>();
+    }
+
+    public ChatRoom(Integer roomId, String user0Id, String user1Id) {
+        this.roomId = roomId;
+        this.user0Id = user0Id;
+        this.user1Id = user1Id;
+        this.messages = new HashMap<>();
+    }
+
+    public Integer getRoomId() {
+        return roomId;
+    }
+
+    public void setRoomId(Integer roomId) {
+        this.roomId = roomId;
+    }
+
+    public String getUser0Id() {
+        return user0Id;
+    }
+
+    public void setUser0Id(String user0Id) {
+        this.user0Id = user0Id;
+    }
+
+    public String getUser1Id() {
+        return user1Id;
+    }
+
+    public void setUser1Id(String user1Id) {
+        this.user1Id = user1Id;
+    }
+
+    public Map<String, String> getMessages() {
+        return messages;
+    }
+
+    public void setMessages(Map<String, String> messages) {
+        this.messages = messages;
+    }
+
+    public boolean containsUser(String userId) {
+        return user0Id.equals(userId) || user1Id.equals(userId);
+    }
+
+    public String getOtherUserId(String userId) {
+        if (user0Id.equals(userId)) {
+            return user1Id;
+        } else if (user1Id.equals(userId)) {
+            return user0Id;
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/FriendPair.java b/src/main/java/com/example/tampopotest/model/FriendPair.java
new file mode 100644
index 0000000..ec1440d
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/FriendPair.java
@@ -0,0 +1,53 @@
+package com.example.tampopotest.model;
+
+public class FriendPair {
+    private Integer pairId;
+    private String user0Id;
+    private String user1Id;
+
+    public FriendPair() {
+    }
+
+    public FriendPair(Integer pairId, String user0Id, String user1Id) {
+        this.pairId = pairId;
+        this.user0Id = user0Id;
+        this.user1Id = user1Id;
+    }
+
+    public Integer getPairId() {
+        return pairId;
+    }
+
+    public void setPairId(Integer pairId) {
+        this.pairId = pairId;
+    }
+
+    public String getUser0Id() {
+        return user0Id;
+    }
+
+    public void setUser0Id(String user0Id) {
+        this.user0Id = user0Id;
+    }
+
+    public String getUser1Id() {
+        return user1Id;
+    }
+
+    public void setUser1Id(String user1Id) {
+        this.user1Id = user1Id;
+    }
+
+    public String getOtherUserId(String userId) {
+        if (user0Id.equals(userId)) {
+            return user1Id;
+        } else if (user1Id.equals(userId)) {
+            return user0Id;
+        }
+        return null;
+    }
+
+    public boolean containsUser(String userId) {
+        return user0Id.equals(userId) || user1Id.equals(userId);
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/FriendRequest.java b/src/main/java/com/example/tampopotest/model/FriendRequest.java
new file mode 100644
index 0000000..7e84bd7
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/FriendRequest.java
@@ -0,0 +1,40 @@
+package com.example.tampopotest.model;
+
+public class FriendRequest {
+    private Integer id;
+    private String senderId;
+    private String receiverId;
+
+    public FriendRequest() {
+    }
+
+    public FriendRequest(Integer id, String senderId, String receiverId) {
+        this.id = id;
+        this.senderId = senderId;
+        this.receiverId = receiverId;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getSenderId() {
+        return senderId;
+    }
+
+    public void setSenderId(String senderId) {
+        this.senderId = senderId;
+    }
+
+    public String getReceiverId() {
+        return receiverId;
+    }
+
+    public void setReceiverId(String receiverId) {
+        this.receiverId = receiverId;
+    }
+}
diff --git a/src/main/java/com/example/tampopotest/model/User.java b/src/main/java/com/example/tampopotest/model/User.java
new file mode 100644
index 0000000..f26d5bc
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/model/User.java
@@ -0,0 +1,80 @@
+package com.example.tampopotest.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class User {
+    private String userId;
+    private String password;
+    private String name;
+    private String icon;
+    private String email;
+    private String token;
+    private List<Activity> activities;
+
+    public User() {
+        this.activities = new ArrayList<>();
+    }
+
+    public User(String userId, String password) {
+        this.userId = userId;
+        this.password = password;
+        this.activities = new ArrayList<>();
+    }
+
+    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 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;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public List<Activity> getActivities() {
+        return activities;
+    }
+
+    public void setActivities(List<Activity> activities) {
+        this.activities = activities;
+    }
+}
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..75ba830
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ActivityRepository.java
@@ -0,0 +1,42 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.Activity;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+@Repository
+public class ActivityRepository {
+    private final Map<String, Activity> activities = new ConcurrentHashMap<>();
+
+    public Optional<Activity> findByActivityId(String activityId) {
+        return Optional.ofNullable(activities.get(activityId));
+    }
+
+    public List<Activity> findByUserId(String userId) {
+        return activities.values().stream()
+                .filter(activity -> userId.equals(activity.getUserId()))
+                .collect(Collectors.toList());
+    }
+
+    public Optional<Activity> findLatestByUserId(String userId) {
+        return activities.values().stream()
+                .filter(activity -> userId.equals(activity.getUserId()))
+                .max(Comparator.comparing(Activity::getUpdatedTime));
+    }
+
+    public Activity save(Activity activity) {
+        activities.put(activity.getActivityId(), activity);
+        return activity;
+    }
+
+    public void delete(String activityId) {
+        activities.remove(activityId);
+    }
+
+    public boolean existsByActivityId(String activityId) {
+        return activities.containsKey(activityId);
+    }
+}
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..174c94c
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRequestRepository.java
@@ -0,0 +1,46 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.ChatRequest;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+@Repository
+public class ChatRequestRepository {
+    private final Map<Integer, ChatRequest> chatRequests = new ConcurrentHashMap<>();
+    private final AtomicInteger idGenerator = new AtomicInteger(1);
+
+    public List<ChatRequest> findAll() {
+        return new ArrayList<>(chatRequests.values());
+    }
+
+    public Optional<ChatRequest> findById(Integer id) {
+        return Optional.ofNullable(chatRequests.get(id));
+    }
+
+    public List<ChatRequest> findByUserId(String userId) {
+        return chatRequests.values().stream()
+                .filter(request -> userId.equals(request.getSenderId()) || 
+                                  userId.equals(request.getReceiverId()))
+                .collect(Collectors.toList());
+    }
+
+    public ChatRequest save(ChatRequest chatRequest) {
+        if (chatRequest.getChatRequestId() == null) {
+            chatRequest.setChatRequestId(idGenerator.getAndIncrement());
+        }
+        chatRequests.put(chatRequest.getChatRequestId(), chatRequest);
+        return chatRequest;
+    }
+
+    public void delete(Integer id) {
+        chatRequests.remove(id);
+    }
+
+    public boolean existsById(Integer id) {
+        return chatRequests.containsKey(id);
+    }
+}
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..557f8c6
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/ChatRoomRepository.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.ChatRoom;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+@Repository
+public class ChatRoomRepository {
+    private final Map<Integer, ChatRoom> chatRooms = new ConcurrentHashMap<>();
+    private final AtomicInteger idGenerator = new AtomicInteger(1);
+
+    public List<ChatRoom> findAll() {
+        return new ArrayList<>(chatRooms.values());
+    }
+
+    public Optional<ChatRoom> findById(Integer roomId) {
+        return Optional.ofNullable(chatRooms.get(roomId));
+    }
+
+    public List<ChatRoom> findByUserId(String userId) {
+        return chatRooms.values().stream()
+                .filter(room -> room.containsUser(userId))
+                .collect(Collectors.toList());
+    }
+
+    public Optional<ChatRoom> findByUserIds(String user0Id, String user1Id) {
+        return chatRooms.values().stream()
+                .filter(room -> (room.getUser0Id().equals(user0Id) && room.getUser1Id().equals(user1Id)) ||
+                               (room.getUser0Id().equals(user1Id) && room.getUser1Id().equals(user0Id)))
+                .findFirst();
+    }
+
+    public ChatRoom save(ChatRoom chatRoom) {
+        if (chatRoom.getRoomId() == null) {
+            chatRoom.setRoomId(idGenerator.getAndIncrement());
+        }
+        chatRooms.put(chatRoom.getRoomId(), chatRoom);
+        return chatRoom;
+    }
+
+    public void delete(Integer roomId) {
+        chatRooms.remove(roomId);
+    }
+
+    public boolean existsById(Integer roomId) {
+        return chatRooms.containsKey(roomId);
+    }
+}
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..e471c16
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendPairRepository.java
@@ -0,0 +1,48 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.FriendPair;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+@Repository
+public class FriendPairRepository {
+    private final Map<Integer, FriendPair> friendPairs = new ConcurrentHashMap<>();
+    private final AtomicInteger idGenerator = new AtomicInteger(1);
+
+    public Optional<FriendPair> findByPairId(Integer pairId) {
+        return Optional.ofNullable(friendPairs.get(pairId));
+    }
+
+    public List<FriendPair> findByUserId(String userId) {
+        return friendPairs.values().stream()
+                .filter(pair -> pair.containsUser(userId))
+                .collect(Collectors.toList());
+    }
+
+    public Optional<FriendPair> findByUserIds(String user0Id, String user1Id) {
+        return friendPairs.values().stream()
+                .filter(pair -> (pair.getUser0Id().equals(user0Id) && pair.getUser1Id().equals(user1Id)) ||
+                                (pair.getUser0Id().equals(user1Id) && pair.getUser1Id().equals(user0Id)))
+                .findFirst();
+    }
+
+    public FriendPair save(FriendPair friendPair) {
+        if (friendPair.getPairId() == null) {
+            friendPair.setPairId(idGenerator.getAndIncrement());
+        }
+        friendPairs.put(friendPair.getPairId(), friendPair);
+        return friendPair;
+    }
+
+    public void delete(Integer pairId) {
+        friendPairs.remove(pairId);
+    }
+
+    public boolean existsByPairId(Integer pairId) {
+        return friendPairs.containsKey(pairId);
+    }
+}
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..2119e7b
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/FriendRequestRepository.java
@@ -0,0 +1,46 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.FriendRequest;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+@Repository
+public class FriendRequestRepository {
+    private final Map<Integer, FriendRequest> friendRequests = new ConcurrentHashMap<>();
+    private final AtomicInteger idGenerator = new AtomicInteger(1);
+
+    public List<FriendRequest> findAll() {
+        return new ArrayList<>(friendRequests.values());
+    }
+
+    public Optional<FriendRequest> findById(Integer id) {
+        return Optional.ofNullable(friendRequests.get(id));
+    }
+
+    public List<FriendRequest> findByUserId(String userId) {
+        return friendRequests.values().stream()
+                .filter(request -> userId.equals(request.getSenderId()) || 
+                                  userId.equals(request.getReceiverId()))
+                .collect(Collectors.toList());
+    }
+
+    public FriendRequest save(FriendRequest friendRequest) {
+        if (friendRequest.getId() == null) {
+            friendRequest.setId(idGenerator.getAndIncrement());
+        }
+        friendRequests.put(friendRequest.getId(), friendRequest);
+        return friendRequest;
+    }
+
+    public void delete(Integer id) {
+        friendRequests.remove(id);
+    }
+
+    public boolean existsById(Integer id) {
+        return friendRequests.containsKey(id);
+    }
+}
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..d510333
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/repository/UserRepository.java
@@ -0,0 +1,44 @@
+package com.example.tampopotest.repository;
+
+import com.example.tampopotest.model.User;
+import org.springframework.stereotype.Repository;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Repository
+public class UserRepository {
+    private final Map<String, User> users = new ConcurrentHashMap<>();
+
+    public List<String> findAllUserIds() {
+        return new ArrayList<>(users.keySet());
+    }
+
+    public Optional<User> findByUserId(String userId) {
+        return Optional.ofNullable(users.get(userId));
+    }
+
+    public Optional<User> findByToken(String token) {
+        return users.values().stream()
+                .filter(user -> token.equals(user.getToken()))
+                .findFirst();
+    }
+
+    public User save(User user) {
+        users.put(user.getUserId(), user);
+        return user;
+    }
+
+    public void delete(String userId) {
+        users.remove(userId);
+    }
+
+    public boolean existsByUserId(String userId) {
+        return users.containsKey(userId);
+    }
+
+    public boolean existsByEmail(String email) {
+        return users.values().stream()
+                .anyMatch(user -> email.equals(user.getEmail()));
+    }
+}
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..49b0639
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/ActivityService.java
@@ -0,0 +1,52 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.model.Activity;
+import com.example.tampopotest.repository.ActivityRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.UUID;
+
+@Service
+public class ActivityService {
+    private final ActivityRepository activityRepository;
+    private final UserService userService;
+
+    public ActivityService(ActivityRepository activityRepository, UserService userService) {
+        this.activityRepository = activityRepository;
+        this.userService = userService;
+    }
+
+    public List<Activity> getActivitiesByUserId(String userId) {
+        return activityRepository.findByUserId(userId);
+    }
+
+    public Activity getLatestActivity(String userId) {
+        return activityRepository.findLatestByUserId(userId).orElse(null);
+    }
+
+    public Activity getActivityById(String activityId) {
+        return activityRepository.findByActivityId(activityId).orElse(null);
+    }
+
+    public Activity createActivity(String userId, String token, String text) {
+        if (!userService.verifyToken(userId, token)) {
+            return null;
+        }
+        String activityId = UUID.randomUUID().toString().substring(0, 8);
+        Activity activity = new Activity(activityId, userId, text);
+        return activityRepository.save(activity);
+    }
+
+    public boolean deleteActivity(String userId, String activityId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return false;
+        }
+        Activity activity = activityRepository.findByActivityId(activityId).orElse(null);
+        if (activity == null || !activity.getUserId().equals(userId)) {
+            return false;
+        }
+        activityRepository.delete(activityId);
+        return true;
+    }
+}
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..83128a8
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/ChatService.java
@@ -0,0 +1,130 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.model.ChatRequest;
+import com.example.tampopotest.model.ChatRoom;
+import com.example.tampopotest.repository.ChatRequestRepository;
+import com.example.tampopotest.repository.ChatRoomRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class ChatService {
+    private final ChatRequestRepository chatRequestRepository;
+    private final ChatRoomRepository chatRoomRepository;
+    private final UserService userService;
+
+    public ChatService(ChatRequestRepository chatRequestRepository,
+                      ChatRoomRepository chatRoomRepository,
+                      UserService userService) {
+        this.chatRequestRepository = chatRequestRepository;
+        this.chatRoomRepository = chatRoomRepository;
+        this.userService = userService;
+    }
+
+    // Chat Request methods
+    public ChatRequest createChatRequest(String senderId, String receiverId, String token) {
+        if (!userService.verifyToken(senderId, token)) {
+            return null;
+        }
+        if (userService.getUserById(receiverId) == null) {
+            return null;
+        }
+        ChatRequest request = new ChatRequest(null, senderId, receiverId);
+        return chatRequestRepository.save(request);
+    }
+
+    public boolean deleteChatRequest(Integer chatRequestId, String token) {
+        var user = userService.getUserByToken(token);
+        if (user == null) {
+            return false;
+        }
+        ChatRequest request = chatRequestRepository.findById(chatRequestId).orElse(null);
+        if (request == null) {
+            return false;
+        }
+        chatRequestRepository.delete(chatRequestId);
+        return true;
+    }
+
+    // Chat Room methods
+    public ChatRoom createChatRoom(String user0Id, String user1Id, String token) {
+        if (!userService.verifyToken(user0Id, token)) {
+            return null;
+        }
+        // Check if room already exists
+        if (chatRoomRepository.findByUserIds(user0Id, user1Id).isPresent()) {
+            return null;
+        }
+        ChatRoom room = new ChatRoom(null, user0Id, user1Id);
+        return chatRoomRepository.save(room);
+    }
+
+    public List<ChatRoom> getChatRoomsByUserId(String user0Id, String token) {
+        if (!userService.verifyToken(user0Id, token)) {
+            return null;
+        }
+        return chatRoomRepository.findByUserId(user0Id);
+    }
+
+    public ChatRoom getChatRoomById(Integer roomId, String token) {
+        var user = userService.getUserByToken(token);
+        if (user == null) {
+            return null;
+        }
+        ChatRoom room = chatRoomRepository.findById(roomId).orElse(null);
+        if (room == null || !room.containsUser(user.getUserId())) {
+            return null;
+        }
+        return room;
+    }
+
+    public String getMessage(Integer roomId, String userId, String token) {
+        var user = userService.getUserByToken(token);
+        if (user == null) {
+            return null;
+        }
+        ChatRoom room = chatRoomRepository.findById(roomId).orElse(null);
+        if (room == null || !room.containsUser(user.getUserId())) {
+            return null;
+        }
+        return room.getMessages().get(userId);
+    }
+
+    public boolean updateMessage(Integer roomId, String userId, String message, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return false;
+        }
+        ChatRoom room = chatRoomRepository.findById(roomId).orElse(null);
+        if (room == null || !room.containsUser(userId)) {
+            return false;
+        }
+        room.getMessages().put(userId, message);
+        chatRoomRepository.save(room);
+        return true;
+    }
+
+    public boolean deleteChatRoom(Integer roomId, String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return false;
+        }
+        ChatRoom room = chatRoomRepository.findById(roomId).orElse(null);
+        if (room == null || !room.containsUser(userId)) {
+            return false;
+        }
+        chatRoomRepository.delete(roomId);
+        return true;
+    }
+
+    public boolean addUserToChatRoom(Integer roomId, String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return false;
+        }
+        ChatRoom room = chatRoomRepository.findById(roomId).orElse(null);
+        if (room == null) {
+            return false;
+        }
+        // In this simple implementation, users are already in the room when created
+        return true;
+    }
+}
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..aaf0df8
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/FriendService.java
@@ -0,0 +1,114 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.model.FriendPair;
+import com.example.tampopotest.model.FriendRequest;
+import com.example.tampopotest.repository.FriendPairRepository;
+import com.example.tampopotest.repository.FriendRequestRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+public class FriendService {
+    private final FriendPairRepository friendPairRepository;
+    private final FriendRequestRepository friendRequestRepository;
+    private final UserService userService;
+
+    public FriendService(FriendPairRepository friendPairRepository, 
+                        FriendRequestRepository friendRequestRepository,
+                        UserService userService) {
+        this.friendPairRepository = friendPairRepository;
+        this.friendRequestRepository = friendRequestRepository;
+        this.userService = userService;
+    }
+
+    // Friend Pair methods
+    public List<FriendPair> getFriendPairsByUserId(String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return null;
+        }
+        return friendPairRepository.findByUserId(userId);
+    }
+
+    public FriendPair getFriendPairById(Integer pairId, String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return null;
+        }
+        FriendPair pair = friendPairRepository.findByPairId(pairId).orElse(null);
+        if (pair == null || !pair.containsUser(userId)) {
+            return null;
+        }
+        return pair;
+    }
+
+    public FriendPair createFriendPair(String user0Id, String user1Id, String token) {
+        if (!userService.verifyToken(user0Id, token) && !userService.verifyToken(user1Id, token)) {
+            return null;
+        }
+        // Check if pair already exists
+        if (friendPairRepository.findByUserIds(user0Id, user1Id).isPresent()) {
+            return null;
+        }
+        FriendPair friendPair = new FriendPair(null, user0Id, user1Id);
+        return friendPairRepository.save(friendPair);
+    }
+
+    public boolean deleteFriendPair(Integer pairId, String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return false;
+        }
+        FriendPair pair = friendPairRepository.findByPairId(pairId).orElse(null);
+        if (pair == null || !pair.containsUser(userId)) {
+            return false;
+        }
+        friendPairRepository.delete(pairId);
+        return true;
+    }
+
+    public List<String> getFriendIdsByUserId(String userId, String token) {
+        if (!userService.verifyToken(userId, token)) {
+            return null;
+        }
+        return friendPairRepository.findByUserId(userId).stream()
+                .map(pair -> pair.getOtherUserId(userId))
+                .collect(Collectors.toList());
+    }
+
+    // Friend Request methods
+    public List<FriendRequest> getFriendRequestsByUserId(String token) {
+        var user = userService.getUserByToken(token);
+        if (user == null) {
+            return null;
+        }
+        return friendRequestRepository.findByUserId(user.getUserId());
+    }
+
+    public FriendRequest createFriendRequest(String senderId, String receiverId, String token) {
+        if (!userService.verifyToken(senderId, token)) {
+            return null;
+        }
+        if (userService.getUserById(receiverId) == null) {
+            return null;
+        }
+        FriendRequest request = new FriendRequest(null, senderId, receiverId);
+        return friendRequestRepository.save(request);
+    }
+
+    public boolean deleteFriendRequest(Integer requestId, String receiverToken) {
+        var user = userService.getUserByToken(receiverToken);
+        if (user == null) {
+            return false;
+        }
+        FriendRequest request = friendRequestRepository.findById(requestId).orElse(null);
+        if (request == null || !request.getReceiverId().equals(user.getUserId())) {
+            return false;
+        }
+        friendRequestRepository.delete(requestId);
+        return true;
+    }
+
+    public FriendRequest getFriendRequestById(Integer requestId) {
+        return friendRequestRepository.findById(requestId).orElse(null);
+    }
+}
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..3e3c0c8
--- /dev/null
+++ b/src/main/java/com/example/tampopotest/service/UserService.java
@@ -0,0 +1,137 @@
+package com.example.tampopotest.service;
+
+import com.example.tampopotest.model.User;
+import com.example.tampopotest.repository.UserRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.UUID;
+
+@Service
+public class UserService {
+    private final UserRepository userRepository;
+
+    public UserService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    public List<String> getAllUserIds() {
+        return userRepository.findAllUserIds();
+    }
+
+    public User getUserById(String userId) {
+        return userRepository.findByUserId(userId).orElse(null);
+    }
+
+    public User createUser(String userId, String password) {
+        if (userRepository.existsByUserId(userId)) {
+            return null;
+        }
+        User user = new User(userId, password);
+        user.setToken(UUID.randomUUID().toString());
+        return userRepository.save(user);
+    }
+
+    public String loginUser(String userId, String password) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null) {
+            return null;
+        }
+        if (!password.equals(user.getPassword())) {
+            return null;
+        }
+        String newToken = UUID.randomUUID().toString();
+        user.setToken(newToken);
+        userRepository.save(user);
+        return newToken;
+    }
+
+    public boolean deleteUser(String userId, String token) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null) {
+            return false;
+        }
+        if (!token.equals(user.getToken())) {
+            return false;
+        }
+        userRepository.delete(userId);
+        return true;
+    }
+
+    public boolean updateName(String userId, String token, String newName) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return false;
+        }
+        user.setName(newName);
+        userRepository.save(user);
+        return true;
+    }
+
+    public boolean updatePassword(String userId, String token, String newPassword) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return false;
+        }
+        user.setPassword(newPassword);
+        userRepository.save(user);
+        return true;
+    }
+
+    public String getPassword(String userId, String token) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return null;
+        }
+        return user.getPassword();
+    }
+
+    public boolean updateEmail(String userId, String token, String newEmail) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return false;
+        }
+        if (userRepository.existsByEmail(newEmail) && !newEmail.equals(user.getEmail())) {
+            return false;
+        }
+        user.setEmail(newEmail);
+        userRepository.save(user);
+        return true;
+    }
+
+    public String getEmail(String userId, String token) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return null;
+        }
+        return user.getEmail();
+    }
+
+    public String updateIcon(String userId, String token, String newIcon) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null || !token.equals(user.getToken())) {
+            return null;
+        }
+        String iconId = UUID.randomUUID().toString().replace("-", "").substring(0, 16).toUpperCase();
+        user.setIcon(iconId);
+        userRepository.save(user);
+        return iconId;
+    }
+
+    public String getIcon(String userId) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        if (user == null) {
+            return null;
+        }
+        return user.getIcon();
+    }
+
+    public User getUserByToken(String token) {
+        return userRepository.findByToken(token).orElse(null);
+    }
+
+    public boolean verifyToken(String userId, String token) {
+        User user = userRepository.findByUserId(userId).orElse(null);
+        return user != null && token.equals(user.getToken());
+    }
+}
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
index 4649332..5cf8813 100644
--- a/src/main/resources/application.properties
+++ b/src/main/resources/application.properties
@@ -1 +1,2 @@
 spring.application.name=tampopotest
+server.port=8080