diff --git "a/.github/ISSUE_TEMPLATE/\354\235\264\354\212\210-\355\205\234\355\224\214\353\246\277.md" "b/.github/ISSUE_TEMPLATE/\354\235\264\354\212\210-\355\205\234\355\224\214\353\246\277.md"
index 83a65f3..8a32412 100644
--- "a/.github/ISSUE_TEMPLATE/\354\235\264\354\212\210-\355\205\234\355\224\214\353\246\277.md"
+++ "b/.github/ISSUE_TEMPLATE/\354\235\264\354\212\210-\355\205\234\355\224\214\353\246\277.md"
@@ -7,12 +7,12 @@ assignees: ''
 
 ---
 
-##💡개발할 기능 설명  
+## 💡개발할 기능 설명  
 
 
-##📝 작업 상세 내용
-- []
-- []
-- []
+## 📝작업 상세 내용
+- [ ]
+- [ ]
+- [ ]
 
 ## 참고 자료(선택)
diff --git a/.gitignore b/.gitignore
index bf7518a..aad2a19 100644
--- a/.gitignore
+++ b/.gitignore
@@ -95,6 +95,8 @@ Icon
 # Thumbnails
 ._*
 
+node_modules
+
 # Files that might appear in the root of a volume
 .DocumentRevisions-V100
 .fseventsd
@@ -168,4 +170,7 @@ gradle-app.setting
 # Java heap dump
 *.hprof
 
-# End of https://www.toptal.com/developers/gitignore/api/windows,git,java,gradle,macos
\ No newline at end of file
+# End of https://www.toptal.com/developers/gitignore/api/windows,git,java,gradle,macos
+
+# QueryDSL 객체
+/src/main/generated/
diff --git a/README.md b/README.md
index a4f39bd..9770d60 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,40 @@
-# StudyLog-BE
\ No newline at end of file
+# StudyLog-BE
+
+### Git Flow 협업 방식
+```
+1. 원격 저장소를 로컬 컴퓨터에 origin으로 등록합니다.
+2. Origin Repository를 로컬 컴퓨터로 clone 및 pull을 합니다.
+3. 각자의 이슈 브랜치에서 작업 후 Origin Repository로 push 합니다.
+4. Develop 브랜치로 PR을 보낸 후 merge 합니다.
+```
+### 개발 시작 시
+```
+1. 새로운 Issue를 생성합니다.
+2. develop 브랜치에서 이슈에 대한 브랜치를 생성합니다.
+  - (브랜치 이름: [작업 유형]/#[이슈번호]-[작업할 기능])
+  - ex) Feature/#1-kakao-login
+3. 로컬에서 Fetch를 하여 생성된 브랜치를 반영합니다.
+4. 해당 브랜치로 이동(checkout)한 후 작업합니다.
+```
+#### 이슈 생성 시 주의사항
+```
+1. 이슈의 제목은 "[작업 유형] 작업할 기능"으로 작성합니다.
+  ex) [Feature] 회원가입
+2. 개발할 기능과 작업의 상세 내용을 작성합니다.
+3. Assignee와 Label을 설정합니다. 
+```
+### 개발 완료 후
+```
+1. 개발을 완료하면 Origin Repository로 push합니다.
+2. 해당 브랜치에서 develop 브랜치로 리뷰어를 설정하여 PR을 보냅니다.
+3. 코드 리뷰 후, 리뷰어가 merge 합니다.
+4. merge가 완료되면 로컬에서 develop 브랜치로 이동합니다.
+5. 원격 저장소의 develop 브랜치를 로컬에서 pull 합니다.
+```
+#### PR 메시지 제목 형식
+```
+[Feature/#(issue-number)] 새로운 기능 추가
+[Fix/#(issue-number)] 버그 수정
+[Refactor/#(issue-number)] 코드 리팩토링
+[Test/#(issue-number)] 테스트 로직
+```
diff --git a/build.gradle b/build.gradle
index 61037e8..84f9123 100644
--- a/build.gradle
+++ b/build.gradle
@@ -25,6 +25,8 @@ repositories {
 
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
+    implementation 'org.springframework.boot:spring-boot-starter-security'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     compileOnly 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
@@ -32,6 +34,22 @@ dependencies {
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    // jwt
+    implementation 'io.jsonwebtoken:jjwt-api:0.12.3'
+    implementation 'io.jsonwebtoken:jjwt-impl:0.12.3'
+    implementation 'io.jsonwebtoken:jjwt-jackson:0.12.3'
+    // spring-cloud-starter-aws
+    implementation platform('io.awspring.cloud:spring-cloud-aws-dependencies:3.1.1')
+    implementation 'io.awspring.cloud:spring-cloud-aws-starter-s3'
+    // test
+    testImplementation 'org.springframework.security:spring-security-test'
+    // swagger
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.9'
+    //QueryDsl
+    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
+    annotationProcessor "com.querydsl:querydsl-apt:5.0.0:jakarta"
+    annotationProcessor "jakarta.annotation:jakarta.annotation-api"
+    annotationProcessor "jakarta.persistence:jakarta.persistence-api"
 }
 
 tasks.named('test') {
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..b247914
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,18 @@
+{
+  "name": "study-log",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "claude": "^0.1.1"
+      }
+    },
+    "node_modules/claude": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/claude/-/claude-0.1.1.tgz",
+      "integrity": "sha512-j7oSibqQdIODNhkI1sEJzHMiPsF43L/GqNbcA+eDDyGM10+x2sH9NW/PK6vM3z0J2tLDKMBcc5ZjVaoRinhuCA==",
+      "license": "ISC"
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..1353701
--- /dev/null
+++ b/package.json
@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "claude": "^0.1.1"
+  }
+}
diff --git a/src/main/java/org/example/studylog/StudyLogApplication.java b/src/main/java/org/example/studylog/StudyLogApplication.java
index a7ec1ef..60f1636 100644
--- a/src/main/java/org/example/studylog/StudyLogApplication.java
+++ b/src/main/java/org/example/studylog/StudyLogApplication.java
@@ -2,7 +2,11 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
+import org.springframework.scheduling.annotation.EnableAsync;
 
+@EnableAsync
+@EnableJpaAuditing
 @SpringBootApplication
 public class StudyLogApplication {
 
diff --git a/src/main/java/org/example/studylog/client/ChatGptClient.java b/src/main/java/org/example/studylog/client/ChatGptClient.java
new file mode 100644
index 0000000..87e29c2
--- /dev/null
+++ b/src/main/java/org/example/studylog/client/ChatGptClient.java
@@ -0,0 +1,14 @@
+package org.example.studylog.client;
+
+import org.example.studylog.dto.quiz.chatGPT.ChatGptRequest;
+import org.example.studylog.dto.quiz.chatGPT.ChatGptResponse;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.service.annotation.HttpExchange;
+import org.springframework.web.service.annotation.PostExchange;
+
+@HttpExchange("/chat/completions")
+public interface ChatGptClient {
+
+    @PostExchange
+    ChatGptResponse getChatCompletions(@RequestBody ChatGptRequest request);
+}
diff --git a/src/main/java/org/example/studylog/config/.gitkeep b/src/main/java/org/example/studylog/config/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/config/CorsMvcConfig.java b/src/main/java/org/example/studylog/config/CorsMvcConfig.java
new file mode 100644
index 0000000..9c974a5
--- /dev/null
+++ b/src/main/java/org/example/studylog/config/CorsMvcConfig.java
@@ -0,0 +1,17 @@
+package org.example.studylog.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class CorsMvcConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addCorsMappings(CorsRegistry corsRegistry) {
+        corsRegistry.addMapping("/**")
+                .exposedHeaders("Set-Cookie")
+                .allowedOrigins("http://localhost:5173")
+                .allowedMethods("GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"); // PATCH & OPTIONS 포함;
+    }
+}
diff --git a/src/main/java/org/example/studylog/config/HttpClientConfig.java b/src/main/java/org/example/studylog/config/HttpClientConfig.java
new file mode 100644
index 0000000..06536fe
--- /dev/null
+++ b/src/main/java/org/example/studylog/config/HttpClientConfig.java
@@ -0,0 +1,30 @@
+package org.example.studylog.config;
+
+import org.example.studylog.client.ChatGptClient;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.support.RestClientAdapter;
+import org.springframework.web.service.invoker.HttpServiceProxyFactory;
+
+@Configuration
+public class HttpClientConfig {
+
+    @Value("${spring.openai.api-key}")
+    private String apiKey;
+
+    @Bean
+    public ChatGptClient chatGptClient(){
+        RestClient restClient = RestClient.builder()
+                .baseUrl("https://api.openai.com/v1")
+                .defaultHeader("Authorization", "Bearer " + apiKey)
+                .defaultHeader("Content-Type", "application/json")
+                .build();
+
+        RestClientAdapter adapter = RestClientAdapter.create(restClient);
+        HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();
+
+        return factory.createClient(ChatGptClient.class);
+    }
+}
diff --git a/src/main/java/org/example/studylog/config/QueryDslConfig.java b/src/main/java/org/example/studylog/config/QueryDslConfig.java
new file mode 100644
index 0000000..2512127
--- /dev/null
+++ b/src/main/java/org/example/studylog/config/QueryDslConfig.java
@@ -0,0 +1,19 @@
+package org.example.studylog.config;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class QueryDslConfig {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Bean
+    public JPAQueryFactory jpaQueryFactory(){
+        return new JPAQueryFactory(entityManager);
+    }
+}
diff --git a/src/main/java/org/example/studylog/config/SecurityConfig.java b/src/main/java/org/example/studylog/config/SecurityConfig.java
new file mode 100644
index 0000000..1bd56dc
--- /dev/null
+++ b/src/main/java/org/example/studylog/config/SecurityConfig.java
@@ -0,0 +1,121 @@
+package org.example.studylog.config;
+
+import jakarta.servlet.http.HttpServletRequest;
+import org.example.studylog.jwt.JWTFilter;
+import org.example.studylog.jwt.JWTUtil;
+import org.example.studylog.oauth2.CustomFailureHandler;
+import org.example.studylog.oauth2.CustomSuccessHandler;
+import org.example.studylog.oauth2.ProfileCheckFilter;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.oauth.CustomOAuth2UserService;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.oauth2.client.web.OAuth2LoginAuthenticationFilter;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    private final CustomOAuth2UserService customOAuth2UserService;
+    private final CustomSuccessHandler customSuccessHandler;
+    private final CustomFailureHandler customFailureHandler;
+    private final JWTUtil jwtUtil;
+    private final UserRepository userRepository;
+
+    public SecurityConfig(CustomOAuth2UserService customOAuth2UserService, CustomSuccessHandler customSuccessHandler, CustomFailureHandler customFailureHandler, JWTUtil jwtUtil, UserRepository userRepository) {
+        this.customOAuth2UserService = customOAuth2UserService;
+        this.customSuccessHandler = customSuccessHandler;
+        this.customFailureHandler = customFailureHandler;
+        this.jwtUtil = jwtUtil;
+        this.userRepository = userRepository;
+    }
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
+
+        // cors 설정
+        http
+                .cors(corsCustomizer -> corsCustomizer.configurationSource(new CorsConfigurationSource() {
+
+                    @Override
+                    public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
+
+                        CorsConfiguration configuration = new CorsConfiguration();
+
+                        configuration.setAllowedOrigins(Collections.singletonList("http://localhost:5173"));
+                        configuration.setAllowedMethods(Arrays.asList(
+                                "GET","POST","PUT","PATCH","DELETE","OPTIONS"
+                        ));
+                        configuration.setAllowCredentials(true);
+                        configuration.setAllowedHeaders(Collections.singletonList("*"));
+                        configuration.setMaxAge(3600L);
+
+//                        configuration.setExposedHeaders(Collections.singletonList("Set-Cookie"));
+//                        configuration.setExposedHeaders(Collections.singletonList("Authorization"));
+                        configuration.setExposedHeaders(Arrays.asList("Set-Cookie", "Authorization"));
+
+                        return configuration;
+                    }
+                }));
+
+        // csrf disable
+        http
+                .csrf((auth) -> auth.disable());
+
+        // Form 로그인 방식 disable
+        http
+                .formLogin((auth) -> auth.disable());
+
+        // HTTP Basic 인증 방식 disable
+        http
+                .httpBasic((auth) -> auth.disable());
+
+
+        // JWTFilter 추가
+        http
+                .addFilterAfter(new JWTFilter(jwtUtil), OAuth2LoginAuthenticationFilter.class);
+
+        // ProfileCheckFilter 추가
+        http
+                .addFilterAfter(new ProfileCheckFilter(userRepository), OAuth2LoginAuthenticationFilter.class);
+
+        // oauth2
+
+        http
+                .oauth2Login((oauth2) -> oauth2
+                        .userInfoEndpoint((UserInfoEndpointConfig) -> UserInfoEndpointConfig
+                                .userService(customOAuth2UserService))
+                        .successHandler(customSuccessHandler)
+                        .failureHandler(customFailureHandler)
+                );
+
+        // 경로별 인가 작업
+        http
+                .authorizeHttpRequests((auth) -> auth
+                        .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
+                        .requestMatchers("/", "/login", "/auth/**", "/error", "/signup",// /error 추가
+                                "/swagger-ui/**",
+                                "/v3/api-docs/**",
+                                "/swagger-resources/**",
+                                "/webjars/**").permitAll()
+                        .anyRequest().authenticated());
+
+        // 세션 설정 : STATELESS
+        http
+                .sessionManagement((session) -> session
+                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS));
+
+        return http.build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/config/SwaggerConfig.java b/src/main/java/org/example/studylog/config/SwaggerConfig.java
new file mode 100644
index 0000000..f519571
--- /dev/null
+++ b/src/main/java/org/example/studylog/config/SwaggerConfig.java
@@ -0,0 +1,33 @@
+package org.example.studylog.config;
+
+import io.swagger.v3.oas.models.security.SecurityRequirement;
+import io.swagger.v3.oas.models.security.SecurityScheme;
+import io.swagger.v3.oas.models.Components;
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SwaggerConfig {
+    @Bean
+    public OpenAPI openAPI(){
+        SecurityScheme securityScheme = new SecurityScheme()
+                .type(SecurityScheme.Type.HTTP)
+                .scheme("bearer")
+                .bearerFormat("JWT");
+        SecurityRequirement securityRequirement = new SecurityRequirement().addList("bearerAuth");
+
+        return new OpenAPI()
+                .components(new Components().addSecuritySchemes("bearerAuth", securityScheme))
+                .addSecurityItem(securityRequirement)
+                .info(apiInfo());
+    }
+
+    private Info apiInfo(){
+        return new Info()
+                .title("Study Log API")
+                .description("스터디로그의 API에 대한 명세서")
+                .version("1.0.0");
+    }
+}
diff --git a/src/main/java/org/example/studylog/controller/.gitkeep b/src/main/java/org/example/studylog/controller/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/controller/CategoryController.java b/src/main/java/org/example/studylog/controller/CategoryController.java
new file mode 100644
index 0000000..6d73286
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/CategoryController.java
@@ -0,0 +1,157 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.category.CreateCategoryRequestDTO;
+import org.example.studylog.dto.category.UpdateCategoryRequestDTO;
+import org.example.studylog.dto.category.CategoryResponseDTO;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.CategoryService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+import java.util.List;
+
+@RestController
+@RequestMapping("/categories")
+@RequiredArgsConstructor
+@Validated
+@Slf4j
+@Tag(name = "Categories", description = "카테고리 관리 API")
+public class CategoryController {
+
+    private final CategoryService categoryService;
+    private final UserRepository userRepository;
+
+    @Operation(summary = "카테고리 생성", description = "새로운 카테고리를 생성합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "201", description = "카테고리 생성 성공",
+                    content = @Content(mediaType = "application/json",
+                            examples = @ExampleObject(value = "{\"status\": 201, \"message\": \"카테고리가 성공적으로 생성되었습니다\", \"data\": {\"id\": 1, \"name\": \"Spring Boot\", \"color\": \"#FF5733\"}}"))),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청 (중복된 카테고리명 등)",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @PostMapping
+    public ResponseEntity<?> createCategory(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Valid @RequestBody CreateCategoryRequestDTO requestDTO) {
+
+        try {
+            log.info("카테고리 생성 요청: 사용자={}, 이름={}", currentUser.getName(), requestDTO.getName());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            CategoryResponseDTO responseDTO = categoryService.createCategory(user, requestDTO);
+
+            log.info("카테고리 생성 성공: ID={}, 이름={}", responseDTO.getId(), responseDTO.getName());
+
+            return ResponseUtil.buildResponse(201, "카테고리가 성공적으로 생성되었습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("카테고리 생성 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("카테고리 생성 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "카테고리 목록 조회", description = "사용자의 모든 카테고리를 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "조회 성공",
+                    content = @Content(mediaType = "application/json",
+                            examples = @ExampleObject(value = "{\"status\": 200, \"message\": \"카테고리 목록 조회 성공\", \"data\": [{\"id\": 1, \"name\": \"Spring Boot\", \"color\": \"#FF5733\"}, {\"id\": 2, \"name\": \"React\", \"color\": \"#61DAFB\"}]}"))),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @GetMapping
+    public ResponseEntity<?> getCategories(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser) {
+
+        try {
+            log.info("카테고리 목록 조회: 사용자={}", currentUser.getName());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            List<CategoryResponseDTO> categories = categoryService.getUserCategories(user);
+
+            return ResponseUtil.buildResponse(200, "카테고리 목록 조회 성공", categories);
+
+        } catch (Exception e) {
+            log.error("카테고리 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "카테고리 수정", description = "기존 카테고리의 정보를 수정합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "수정 성공",
+                    content = @Content(mediaType = "application/json",
+                            examples = @ExampleObject(value = "{\"status\": 200, \"message\": \"카테고리가 성공적으로 수정되었습니다\", \"data\": {\"id\": 1, \"name\": \"Spring Framework\", \"color\": \"#6DB33F\"}}"))),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청 (중복된 카테고리명 등)",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "404", description = "카테고리를 찾을 수 없음",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @PutMapping("/{categoryId}")
+    public ResponseEntity<?> updateCategory(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "카테고리 ID", example = "1") @PathVariable Long categoryId,
+            @Valid @RequestBody UpdateCategoryRequestDTO requestDTO) {
+
+        try {
+            log.info("카테고리 수정 요청: 사용자={}, categoryId={}, 새이름={}",
+                    currentUser.getName(), categoryId, requestDTO.getName());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            CategoryResponseDTO responseDTO = categoryService.updateCategory(user, categoryId, requestDTO);
+
+            log.info("카테고리 수정 성공: ID={}, 새이름={}", responseDTO.getId(), responseDTO.getName());
+
+            return ResponseUtil.buildResponse(200, "카테고리가 성공적으로 수정되었습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("카테고리 수정 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("카테고리 수정 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/controller/FriendController.java b/src/main/java/org/example/studylog/controller/FriendController.java
new file mode 100644
index 0000000..77aad7f
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/FriendController.java
@@ -0,0 +1,107 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.ProfileResponseDTO;
+import org.example.studylog.dto.friend.FriendNameDTO;
+import org.example.studylog.dto.friend.FriendRequestDTO;
+import org.example.studylog.dto.friend.FriendResponseDTO;
+import org.example.studylog.service.FriendService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/friends")
+public class FriendController {
+
+    private final FriendService friendService;
+
+    @Operation(summary = "code로 친구 조회", description = "친구 추가 시, code로 친구 조회하는 API")
+    @ApiResponse(responseCode = "200", description = "사용자 이름 조회 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = FriendNameDTO.class)))
+    @GetMapping("by-code")
+    public ResponseEntity<?> findUserByCode(@RequestParam String code) {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        FriendNameDTO dto = friendService.findUserByCode(oauthId, code);
+        return ResponseUtil.buildResponse(200, "사용자 이름 조회 완료", dto);
+    }
+
+    @Operation(summary = "친구 목록 조회", description = "로그인한 사용자의 친구 목록 조회 API")
+    @ApiResponse(responseCode = "200", description = "친구 목록 조회 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = FriendResponseDTO.class))))
+    @GetMapping
+    public ResponseEntity<?> getFriendList(){
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        List<FriendResponseDTO> friends = friendService.getFriendList(oauthId);
+        return ResponseUtil.buildResponse(200, "친구 목록 조회 완료", friends);
+    }
+
+    @Operation(summary = "친구 검색", description = "친구 목록에서 이름으로 친구 조회 API")
+    @ApiResponse(responseCode = "200", description = "{query}에 대한 친구 검색 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = FriendResponseDTO.class))))
+    @GetMapping("/search")
+    public ResponseEntity<?> getFriendByQuery(@RequestParam String query){
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        List<FriendResponseDTO> friends = friendService.getFriendByQuery(oauthId, query);
+        return ResponseUtil.buildResponse(200, String.format("\'%s\'에 대한 친구 검색 완료", query), friends);
+    }
+
+    @Operation(summary = "code로 친구 추가", description = "code로 친구 추가 API")
+    @ApiResponse(responseCode = "201", description = "친구 추가 완료",
+            content = @Content(
+                    mediaType = "application/json"))
+    @PostMapping
+    public ResponseEntity<?> addFriend(@RequestBody @Valid FriendRequestDTO request) {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        friendService.addFriend(request, oauthId);
+        return ResponseUtil.buildResponse(201, "친구 추가 완료", null);
+    }
+
+    @Operation(summary = "친구 삭제", description = "friendId로 친구 삭제 API")
+    @ApiResponse(responseCode = "200", description = "친구 삭제 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = FriendResponseDTO.class)))
+    @DeleteMapping("/{friendId}")
+    public ResponseEntity<?> deleteFriend(@PathVariable Long friendId){
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        FriendResponseDTO dto = friendService.deleteFriend(oauthId, friendId);
+        return ResponseUtil.buildResponse(200, "친구 삭제 완료", dto);
+    }
+
+}
+
diff --git a/src/main/java/org/example/studylog/controller/LoginController.java b/src/main/java/org/example/studylog/controller/LoginController.java
new file mode 100644
index 0000000..2006625
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/LoginController.java
@@ -0,0 +1,35 @@
+package org.example.studylog.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+public class LoginController {
+
+    @GetMapping("/")
+    public String index(){
+        return "index.html";
+    }
+
+    // 메인 페이지 구현에 따라 주석 처리 - 채민
+//    @GetMapping("/main")
+//    @ResponseBody
+//    public String main() {
+//        return "메인 페이지";
+//    }
+
+    @GetMapping("/success")
+    @ResponseBody
+    public String success(){
+        return "요청 성공!";
+    }
+
+    @GetMapping("/signup")
+    @ResponseBody
+    public String signup(){
+        return "회원가입 페이지";
+    }
+
+
+}
diff --git a/src/main/java/org/example/studylog/controller/MainController.java b/src/main/java/org/example/studylog/controller/MainController.java
new file mode 100644
index 0000000..312b648
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/MainController.java
@@ -0,0 +1,179 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.MainService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequiredArgsConstructor
+@Slf4j
+@Tag(name = "Main", description = "메인 페이지 API")
+public class MainController {
+
+    private final MainService mainService;
+    private final UserRepository userRepository;
+
+    @Operation(
+            summary = "메인 페이지 조회",
+            description = "메인 페이지 데이터를 조회합니다. 인증된 사용자 또는 공유 코드로 조회 가능합니다."
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "메인 페이지 조회 성공",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 200,"
+                                            + "\"message\": \"메인 페이지 조회에 성공하였습니다.\","
+                                            + "\"data\": {"
+                                            + "\"following\": [],"
+                                            + "\"profile\": {"
+                                            + "\"userId\": 1,"
+                                            + "\"coverImage\": null,"
+                                            + "\"profileImage\": \"https://example.com/profile.jpg\","
+                                            + "\"name\": \"홍길동\","
+                                            + "\"intro\": \"안녕하세요! 개발 공부 중입니다.\","
+                                            + "\"level\": 5,"
+                                            + "\"code\": \"ABC123\""
+                                            + "},"
+                                            + "\"streak\": {"
+                                            + "\"maxStreak\": 15,"
+                                            + "\"recordCountPerDay\": {"
+                                            + "\"2025-01-10\": 2,"
+                                            + "\"2025-01-11\": 1,"
+                                            + "\"2025-01-12\": 3"
+                                            + "}"
+                                            + "},"
+                                            + "\"categories\": ["
+                                            + "{\"name\": \"Spring Boot\", \"count\": 25},"
+                                            + "{\"name\": \"React\", \"count\": 18}"
+                                            + "],"
+                                            + "\"isFollowing\": true"
+                                            + "}"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "401",
+                    description = "인증 실패 (접근 권한 없음)",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 401,"
+                                            + "\"message\": \"접근 권한이 없습니다.\","
+                                            + "\"data\": false"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "404",
+                    description = "사용자 코드를 찾을 수 없음",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 404,"
+                                            + "\"message\": \"존재하지 않는 사용자 코드입니다.\","
+                                            + "\"data\": null"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "500",
+                    description = "서버 내부 오류",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 500,"
+                                            + "\"message\": \"내부 서버 오류입니다. 다시 접속해주세요.\","
+                                            + "\"data\": null"
+                                            + "}"
+                            )
+                    )
+            )
+    })
+    @GetMapping("/main")
+    public ResponseEntity<?> getMainPage(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "사용자 공유 코드 (선택적)", example = "ABC123") @RequestParam(required = false) String code) {
+
+        // code 파라미터가 있으면 코드로 조회, 없으면 기존 로직
+        if (code != null && !code.trim().isEmpty()) {
+            return getMainPageByCode(code, currentUser);  // private 메서드 호출
+        }
+
+        // 기존 로직 (인증된 사용자)
+        try {
+            log.info("메인 페이지 조회 요청: 사용자={}", currentUser.getName());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "접근 권한이 없습니다.", false);
+            }
+
+            Object mainPageData = mainService.getMainPageData(user);
+
+            log.info("메인 페이지 조회 성공: 사용자={}", currentUser.getName());
+
+            return ResponseUtil.buildResponse(200, "메인 페이지 조회에 성공하였습니다.", mainPageData);
+
+        } catch (Exception e) {
+            log.error("메인 페이지 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다. 다시 접속해주세요.", null);
+        }
+    }
+
+    // 동일 엔드포인트에서 쿼리 지원을 위해 private 메서드로 변경
+    private ResponseEntity<?> getMainPageByCode(String code, CustomOAuth2User currentUser) {
+        try {
+            log.info("코드로 메인 페이지 조회 요청: code={}", code);
+
+            User targetUser = userRepository.findByCode(code)
+                    .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 사용자 코드입니다."));
+
+            // 현재 사용자가 있으면 팔로우 여부 확인
+            User currentUserEntity = null;
+            if (currentUser != null) {
+                currentUserEntity = userRepository.findByOauthId(currentUser.getName());
+            }
+
+            Object mainPageData = mainService.getMainPageDataWithFollowStatus(targetUser, currentUserEntity);
+
+            log.info("코드로 메인 페이지 조회 성공: code={}, 사용자={}", code, targetUser.getOauthId());
+
+            return ResponseUtil.buildResponse(200, "메인 페이지 조회에 성공하였습니다.", mainPageData);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("코드로 메인 페이지 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(404, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("코드로 메인 페이지 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다. 다시 접속해주세요.", null);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/controller/NotificationController.java b/src/main/java/org/example/studylog/controller/NotificationController.java
new file mode 100644
index 0000000..bf95994
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/NotificationController.java
@@ -0,0 +1,62 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.dto.ProfileResponseDTO;
+import org.example.studylog.dto.notification.NotificationListResponseDTO;
+import org.example.studylog.service.NotificationService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import java.util.List;
+
+@RestController
+@RequiredArgsConstructor
+public class NotificationController {
+
+    private final NotificationService notificationService;
+
+    @Operation(summary = "SSE 구독")
+    @ApiResponse(content = @Content(schema = @Schema(implementation = SseEmitter.class)))
+    @GetMapping(value = "/subscribe", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public SseEmitter subscribe() {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        return notificationService.createEmitter(oauthId);
+    }
+
+    @Operation(summary = "알림 목록 조회")
+    @ApiResponse(responseCode = "200", description = "알림 목록 조회 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = NotificationListResponseDTO.class))))
+    @GetMapping("/notifications")
+    public ResponseEntity<?> getNotificationList(
+            @Parameter(
+                    description = "true면 읽음 처리, false면 기본 조회",
+                    example = "true"
+            )
+            @RequestParam boolean isRead) {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        List<NotificationListResponseDTO> list = notificationService.getNotificationList(oauthId, isRead);
+        return ResponseUtil.buildResponse(200, "알림 목록 조회 완료", list);
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/controller/QuizController.java b/src/main/java/org/example/studylog/controller/QuizController.java
new file mode 100644
index 0000000..119316f
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/QuizController.java
@@ -0,0 +1,122 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.BackgroundDTO;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.dto.quiz.CreateQuizRequestDTO;
+import org.example.studylog.dto.quiz.QuizListResponseDTO;
+import org.example.studylog.dto.quiz.QuizResponseDTO;
+import org.example.studylog.dto.studyrecord.CreateStudyRecordResponseDTO;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.BusinessException;
+import org.example.studylog.service.QuizService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Slf4j
+@RestController
+@RequestMapping("/quizzes")
+@RequiredArgsConstructor
+public class QuizController {
+
+    private final QuizService quizService;
+
+    @Operation(summary = "퀴즈 생성", description = "recordId로 친구 생성 API")
+    @ApiResponse(responseCode = "200", description = "퀴즈 생성 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    array = @ArraySchema(schema = @Schema(implementation = QuizResponseDTO.class))))
+    @PostMapping("/{recordId}")
+    public ResponseEntity<?> createQuiz(
+            @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @PathVariable Long recordId,
+            @Valid @RequestBody CreateQuizRequestDTO requestDTO) {
+
+        try {
+            log.info("퀴즈 생성 요청: 사용자={}, 기록ID={}", currentUser.getName(), recordId);
+
+            List<QuizResponseDTO> list = quizService.createQuiz(currentUser.getName(), recordId, requestDTO);
+            log.info("퀴즈 생성 성공: 기록ID={}", recordId);
+
+            return ResponseUtil.buildResponse(200, "퀴즈 생성 완료", list);
+
+        } catch (BusinessException e) {
+            log.warn("퀴즈 생성 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("퀴즈 생성 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "퀴즈 상세 조회", description = "quizId로 퀴즈 상세 조회 API")
+    @ApiResponse(responseCode = "200", description = "퀴즈 상세 조회 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = QuizResponseDTO.class)))
+    @GetMapping("/{quizId}")
+    public ResponseEntity<?> getQuiz(@AuthenticationPrincipal CustomOAuth2User currentUser,
+                                     @PathVariable Long quizId){
+        try {
+            log.info("퀴즈 상세 조회: 사용자={}, 퀴즈ID={}", currentUser.getName(), quizId);
+
+            QuizResponseDTO dto = quizService.getQuiz(currentUser.getName(), quizId);
+
+            return ResponseUtil.buildResponse(200, "퀴즈 상세 조회 완료", dto);
+        } catch (IllegalArgumentException e){
+            log.warn("퀴즈 상세 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+        } catch (Exception e) {
+            log.error("퀴즈 생성 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "퀴즈 목록 조회", description = "query, date, categoryId로 퀴즈 상세 조회 API")
+    @ApiResponse(responseCode = "200", description = "퀴즈 목록 조회 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = QuizListResponseDTO.class)))
+    @GetMapping
+    public ResponseEntity<?> getQuizList(
+            @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @RequestParam(required = false) String query,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate date,
+            @RequestParam(required = false) Long categoryId,
+            @RequestParam(required = false) Long lastId,
+            @RequestParam(defaultValue = "10") int size
+    ) {
+        QuizListResponseDTO quizzes = quizService.getQuizList(
+                currentUser.getName(), query, lastId, size, date, categoryId
+        );
+
+        try{
+            log.info("퀴즈 목록 조회: query = {}, date = {}, categoryId = {}, lastId = {}, szize = {}",
+                    query, date, categoryId, lastId, size);
+
+            return ResponseUtil.buildResponse(200, "퀴즈 목록 조회 완료", quizzes);
+
+        } catch (IllegalArgumentException e){
+            log.warn("퀴즈 목록 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+        } catch (Exception e) {
+            log.error("퀴즈 목록 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+
+    }
+}
diff --git a/src/main/java/org/example/studylog/controller/StreakController.java b/src/main/java/org/example/studylog/controller/StreakController.java
new file mode 100644
index 0000000..cf84cc4
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/StreakController.java
@@ -0,0 +1,193 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.StreakService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+@RestController
+@RequiredArgsConstructor
+@Slf4j
+@Tag(name = "Streak", description = "스트릭(연속 학습) 관련 API")
+public class StreakController {
+
+    private final StreakService streakService;
+    private final UserRepository userRepository;
+
+    @Operation(
+            summary = "월별 스트릭 조회",
+            description = "특정 연도와 월의 일별 학습 기록 개수를 조회합니다. 인증된 사용자 또는 공유 코드로 조회 가능합니다."
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "스트릭 조회 성공",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 200,"
+                                            + "\"message\": \"스트릭 조회에 성공하였습니다.\","
+                                            + "\"data\": {"
+                                            + "\"2025-07-01\": 0,"
+                                            + "\"2025-07-02\": 3,"
+                                            + "\"2025-07-03\": 1,"
+                                            + "\"2025-07-04\": 0,"
+                                            + "\"2025-07-05\": 2"
+                                            + "}"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "400",
+                    description = "잘못된 요청 (유효하지 않은 년도/월)",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 400,"
+                                            + "\"message\": \"잘못된 접근입니다\","
+                                            + "\"data\": {"
+                                            + "\"example\": \"올바르지 않은 월입니다\""
+                                            + "}"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "401",
+                    description = "인증 실패 (접근 권한 없음)",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 401,"
+                                            + "\"message\": \"접근 권한이 없습니다.\","
+                                            + "\"data\": false"
+                                            + "}"
+                            )
+                    )
+            ),
+            @ApiResponse(
+                    responseCode = "500",
+                    description = "서버 내부 오류",
+                    content = @Content(
+                            mediaType = "application/json",
+                            examples = @ExampleObject(
+                                    value = "{"
+                                            + "\"status\": 500,"
+                                            + "\"message\": \"내부 서버 오류입니다. 다시 접속해주세요.\","
+                                            + "\"data\": null"
+                                            + "}"
+                            )
+                    )
+            )
+    })
+    @GetMapping("/streak")
+    public ResponseEntity<?> getMonthlyStreak(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "사용자 공유 코드 (선택적)", example = "ABC123") @RequestParam(required = false) String code,
+            @Parameter(description = "조회할 년도", required = true, example = "2025") @RequestParam("year") String year,
+            @Parameter(description = "조회할 월 (1-12)", required = true, example = "7") @RequestParam("month") String month) {
+
+        // code 파라미터가 있으면 코드로 조회
+        if (code != null && !code.trim().isEmpty()) {
+            return getMonthlyStreakByCode(code, year, month);  // private 메서드 호출
+        }
+
+        // 기존 로직 (인증된 사용자)
+        try {
+            log.info("월별 스트릭 조회 요청: 사용자={}, year={}, month={}",
+                    currentUser.getName(), year, month);
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "접근 권한이 없습니다.", false);
+            }
+
+            validateYearMonth(year, month);
+            Object monthlyStreakData = streakService.getMonthlyStreakData(user, year, month);
+
+            log.info("월별 스트릭 조회 성공: 사용자={}, year={}, month={}",
+                    currentUser.getName(), year, month);
+
+            return ResponseUtil.buildResponse(200, "스트릭 조회에 성공하였습니다.", monthlyStreakData);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("월별 스트릭 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, "잘못된 접근입니다", Map.of("example", e.getMessage()));
+
+        } catch (Exception e) {
+            log.error("월별 스트릭 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다. 다시 접속해주세요.", null);
+        }
+    }
+
+    // private 메서드 추가
+    private ResponseEntity<?> getMonthlyStreakByCode(String code, String year, String month) {
+        try {
+            log.info("코드로 월별 스트릭 조회 요청: code={}, year={}, month={}", code, year, month);
+
+            User user = userRepository.findByCode(code)
+                    .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 사용자 코드입니다."));
+
+            validateYearMonth(year, month);
+            Object monthlyStreakData = streakService.getMonthlyStreakData(user, year, month);
+
+            log.info("코드로 월별 스트릭 조회 성공: code={}, 사용자={}, year={}, month={}",
+                    code, user.getOauthId(), year, month);
+
+            return ResponseUtil.buildResponse(200, "스트릭 조회에 성공하였습니다.", monthlyStreakData);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("코드로 월별 스트릭 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, "잘못된 접근입니다", Map.of("example", e.getMessage()));
+
+        } catch (Exception e) {
+            log.error("코드로 월별 스트릭 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다. 다시 접속해주세요.", null);
+        }
+    }
+
+    private void validateYearMonth(String year, String month) {
+        // 년도 검증
+        try {
+            int yearInt = Integer.parseInt(year);
+            if (yearInt < 2020 || yearInt > 2030) {
+                throw new IllegalArgumentException("올바르지 않은 년도입니다");
+            }
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("올바르지 않은 년도 형식입니다");
+        }
+
+        // 월 검증
+        try {
+            int monthInt = Integer.parseInt(month);
+            if (monthInt < 1 || monthInt > 12) {
+                throw new IllegalArgumentException("올바르지 않은 월입니다");
+            }
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("올바르지 않은 월 형식입니다");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/controller/StudyRecordController.java b/src/main/java/org/example/studylog/controller/StudyRecordController.java
new file mode 100644
index 0000000..02fda53
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/StudyRecordController.java
@@ -0,0 +1,289 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.dto.studyrecord.*;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.StudyRecordService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/records")
+@RequiredArgsConstructor
+@Validated
+@Slf4j
+@Tag(name = "Study Records", description = "학습 기록 관련 API")
+public class StudyRecordController {
+
+    private final StudyRecordService studyRecordService;
+    private final UserRepository userRepository;
+
+    @Operation(summary = "학습 기록 생성", description = "새로운 학습 기록을 생성합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "201", description = "학습 기록 생성 성공",
+                    content = @Content(mediaType = "application/json",
+                            examples = @ExampleObject(value = "{\"status\": 201, \"message\": \"기록 생성 성공\", \"data\": {\"recordId\": 1, \"title\": \"Spring Boot 학습\"}}"))),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @PostMapping
+    public ResponseEntity<?> createStudyRecord(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Valid @RequestBody CreateStudyRecordRequestDTO requestDTO) {
+
+        try {
+            log.info("기록 생성 요청: 사용자={}, 제목={}", currentUser.getName(), requestDTO.getTitle());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            CreateStudyRecordResponseDTO responseDTO = studyRecordService.createStudyRecord(user, requestDTO);
+
+            log.info("기록 생성 성공: 기록ID={}, 스트릭={}",
+                    responseDTO.getRecord().getId(), responseDTO.getStreak().getCurrentStreak());
+
+            return ResponseUtil.buildResponse(201, "학습 기록이 성공적으로 생성되었습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 생성 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("기록 생성 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "학습 기록 상세 조회", description = "특정 학습 기록의 상세 정보를 조회합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "조회 성공",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "404", description = "기록을 찾을 수 없음",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @GetMapping("/{recordId}")
+    public ResponseEntity<?> getStudyRecord(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "학습 기록 ID", example = "1") @PathVariable Long recordId) {
+
+        try {
+            log.info("기록 상세 조회 요청: 사용자={}, recordId={}", currentUser.getName(), recordId);
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            StudyRecordDetailResponseDTO responseDTO = studyRecordService.getStudyRecordDetail(user, recordId);
+
+            log.info("기록 상세 조회 성공: recordId={}", recordId);
+
+            return ResponseUtil.buildResponse(200, "기록 상세 정보를 성공적으로 조회했습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("기록 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "학습 기록 수정", description = "기존 학습 기록을 수정합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "수정 성공",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "400", description = "잘못된 요청",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "404", description = "기록을 찾을 수 없음",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @PutMapping("/{recordId}")
+    public ResponseEntity<?> updateStudyRecord(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "학습 기록 ID", example = "1") @PathVariable Long recordId,
+            @Valid @RequestBody UpdateStudyRecordRequestDTO requestDTO) {
+
+        try {
+            log.info("기록 수정 요청: 사용자={}, recordId={}, 제목={}",
+                    currentUser.getName(), recordId, requestDTO.getTitle());
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            StudyRecordDTO responseDTO = studyRecordService.updateStudyRecord(user, recordId, requestDTO);
+
+            log.info("기록 수정 성공: recordId={}", recordId);
+
+            return ResponseUtil.buildResponse(200, "기록이 성공적으로 수정되었습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 수정 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("기록 수정 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "학습 기록 삭제", description = "특정 학습 기록을 삭제합니다.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "삭제 성공",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "401", description = "인증 실패",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "404", description = "기록을 찾을 수 없음",
+                    content = @Content(mediaType = "application/json")),
+            @ApiResponse(responseCode = "500", description = "서버 오류",
+                    content = @Content(mediaType = "application/json"))
+    })
+    @DeleteMapping("/{recordId}")
+    public ResponseEntity<?> deleteStudyRecord(
+            @Parameter(hidden = true) @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Parameter(description = "학습 기록 ID", example = "1") @PathVariable Long recordId) {
+
+        try {
+            log.info("기록 삭제 요청: 사용자={}, recordId={}", currentUser.getName(), recordId);
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            studyRecordService.deleteStudyRecord(user, recordId);
+
+            log.info("기록 삭제 성공: recordId={}", recordId);
+
+            return ResponseUtil.buildResponse(200, "기록이 성공적으로 삭제되었습니다", null);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 삭제 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+
+        } catch (Exception e) {
+            log.error("기록 삭제 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "제목으로 기록 검색", description = "제목으로 학습 기록을 검색합니다")
+    @GetMapping("/search")
+    public ResponseEntity<?> searchStudyRecords(
+            @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @RequestParam("query") String query) {
+
+        try {
+            log.info("기록 검색 요청: 사용자={}, 검색어={}", currentUser.getName(), query);
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            StudyRecordListResponseDTO responseDTO = studyRecordService.searchStudyRecordsByTitle(user, query);
+
+            log.info("기록 검색 성공: 검색결과={}건", responseDTO.getRecords().size());
+
+            return ResponseUtil.buildResponse(200, "기록 목록을 성공적으로 조회했습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 검색 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, "잘못된 접근입니다",
+                    Map.of("example", e.getMessage()));
+
+        } catch (Exception e) {
+            log.error("기록 검색 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+    @Operation(summary = "카테고리/날짜로 기록 조회",
+            description = "카테고리, 날짜 조건으로 학습 기록을 조회합니다. 무한 스크롤을 지원합니다.")
+    @GetMapping
+    public ResponseEntity<?> getStudyRecordsWithFilter(
+            @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @RequestParam(value = "categoryId", required = false) Long categoryId,
+            @RequestParam(value = "date", required = false) String date,
+            @RequestParam(value = "lastId", required = false) Long lastId,
+            @RequestParam(value = "size", defaultValue = "10") Integer size) {
+
+        try {
+            log.info("기록 필터링 조회 요청: 사용자={}, categoryId={}, date={}, lastId={}, size={}",
+                    currentUser.getName(), categoryId, date, lastId, size);
+
+            User user = userRepository.findByOauthId(currentUser.getName());
+            if (user == null) {
+                return ResponseUtil.buildResponse(401, "유효하지 않은 사용자입니다", null);
+            }
+
+            // 요청 DTO 생성
+            StudyRecordFilterRequestDTO requestDTO = new StudyRecordFilterRequestDTO();
+            requestDTO.setCategoryId(categoryId);
+            requestDTO.setDate(date);
+            requestDTO.setLastId(lastId);
+            requestDTO.setSize(size);
+
+            StudyRecordFilterResponseDTO responseDTO = studyRecordService.getStudyRecordsWithFilter(user, requestDTO);
+
+            log.info("기록 필터링 조회 성공: 결과={}건, hasMore={}",
+                    responseDTO.getRecords().size(), responseDTO.getHasMore());
+
+            return ResponseUtil.buildResponse(200, "기록 목록을 성공적으로 조회했습니다", responseDTO);
+
+        } catch (IllegalArgumentException e) {
+            log.warn("기록 필터링 조회 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, "잘못된 접근입니다",
+                    Map.of("example", e.getMessage()));
+
+        } catch (Exception e) {
+            log.error("기록 필터링 조회 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+
+
+    @Operation(summary = "테스트 엔드포인트", description = "API 연결 테스트용 엔드포인트")
+    @ApiResponse(responseCode = "200", description = "테스트 성공")
+    @GetMapping("/test")
+    public ResponseEntity<?> testEndpoint() {
+        log.info("=== TEST 엔드포인트 호출됨 ===");
+        return ResponseUtil.buildResponse(200, "Controller 연결 성공!", "테스트 성공");
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/controller/UserController.java b/src/main/java/org/example/studylog/controller/UserController.java
new file mode 100644
index 0000000..7943d29
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/UserController.java
@@ -0,0 +1,124 @@
+package org.example.studylog.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.*;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.dto.oauth.TokenDTO;
+import org.example.studylog.service.UserService;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/users")
+public class UserController {
+
+    private final UserService userService;
+
+    @Operation(summary = "프로필 생성", description = "프로필 생성을 위한 api")
+    @ApiResponse(
+            responseCode = "200",
+            description = "사용자 프로필 생성 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(
+                            implementation = ProfileResponseDTO.class
+                    )))
+    @PostMapping(path = "/profile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    public ResponseEntity<?> createProfile(@Valid @ModelAttribute ProfileCreateRequestDTO request) {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+        log.info("사용자 프로필 생성 시작: oauthId = {}", oauthId);
+
+        ProfileResponseDTO dto = userService.createUserProfile(request, oauthId);
+        log.info("사용자 프로필 생성 완료: profileImage = {}, nickname = {}, intro = {}",
+                dto.getProfileImage(), dto.getNickname(), dto.getIntro());
+        return ResponseUtil.buildResponse(200, "사용자 프로필 생성 완료", dto);
+    }
+
+    @Operation(summary = "프로필 수정", description = "프로필 수정을 위한 api")
+    @ApiResponse(responseCode = "200", description = "사용자 프로필 수정 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = ProfileResponseDTO.class)))
+    @PatchMapping(path = "/profile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    public ResponseEntity<?> updateProfile(@ModelAttribute ProfileUpdateRequestDTO request) {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        ProfileResponseDTO dto = userService.updateUserProfile(request, oauthId);
+        return ResponseUtil.buildResponse(200, "사용자 프로필 수정 완료", dto);
+    }
+
+    @Operation(summary = "프로필 조회")
+    @GetMapping("/profile")
+    @ApiResponse(responseCode = "200", description = "사용자 프로필 조회 성공",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = ProfileResponseDTO.class)))
+    public ResponseEntity<?> getProfile() {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        ProfileResponseDTO dto = userService.getUserProfile(oauthId);
+        return ResponseUtil.buildResponse(200, "사용자 프로필 조회 성공", dto);
+    }
+
+    @Operation(summary = "로그인 유저의 마이페이지 조회")
+    @ApiResponse(responseCode = "200", description = "사용자 정보 조회 성공",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = UserInfoResponseDTO.class)))
+    @GetMapping
+    public ResponseEntity<?> getUserInfo() {
+        // 로그인한 사용자 oauthId 가져오기
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+        String oauthId = auth.getName();
+
+        UserInfoResponseDTO dto = userService.getUserInfo(oauthId);
+        return ResponseUtil.buildResponse(200, "사용자 정보 조회 성공", dto);
+    }
+
+    @Operation(summary = "배경화면 수정")
+    @PatchMapping(path = "/background", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
+    @ApiResponse(responseCode = "200", description = "사용자 배경화면 수정 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = BackgroundDTO.ResponseDTO.class)))
+    public ResponseEntity<?> updateBackground(
+            @AuthenticationPrincipal CustomOAuth2User currentUser,
+            @Valid @ModelAttribute BackgroundDTO.RequestDTO dto) {
+        try{
+            log.info("배경화면 수정 요청: 사용자={}", currentUser.getName());
+
+            BackgroundDTO.ResponseDTO responseDTO = userService.updateBackground(currentUser.getName(), dto);
+
+            log.info("배경화면 수정 성공: 사용자={}, 배경화면={}", currentUser.getName(), responseDTO.getCoverImage());
+
+            return ResponseUtil.buildResponse(200, "사용자 배경화면 수정 완료", responseDTO);
+        } catch (IllegalStateException e){
+            log.warn("배경화면 수정 실패 - 잘못된 요청: {}", e.getMessage());
+            return ResponseUtil.buildResponse(400, e.getMessage(), null);
+        } catch (Exception e){
+            log.error("배경화면 수정 중 오류 발생", e);
+            return ResponseUtil.buildResponse(500, "내부 서버 오류입니다", null);
+        }
+    }
+}
diff --git a/src/main/java/org/example/studylog/controller/jwt/AuthController.java b/src/main/java/org/example/studylog/controller/jwt/AuthController.java
new file mode 100644
index 0000000..91d105f
--- /dev/null
+++ b/src/main/java/org/example/studylog/controller/jwt/AuthController.java
@@ -0,0 +1,81 @@
+package org.example.studylog.controller.jwt;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.example.studylog.dto.ResponseDTO;
+import org.example.studylog.dto.oauth.TokenDTO;
+import org.example.studylog.jwt.JWTUtil;
+import org.example.studylog.service.TokenService;
+import org.example.studylog.util.CookieUtil;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/auth")
+public class AuthController {
+
+    private final JWTUtil jwtUtil;
+    private final TokenService tokenService;
+
+    public AuthController(JWTUtil jwtUtil, TokenService tokenService) {
+        this.jwtUtil = jwtUtil;
+        this.tokenService = tokenService;
+    }
+
+    @Operation(summary = "AccessToken 재발급 API",
+            parameters = {
+                @Parameter(
+                        in = ParameterIn.COOKIE,
+                        name = "refresh",
+                        required = true,
+                        description = "리프레시 토큰"
+                )
+            })
+    @ApiResponse(
+            responseCode = "200",
+            description = "토큰 재발급 완료",
+            content = @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(
+                        name = "TokenResponseDTO",
+                        implementation = TokenDTO.ResponseDTO.class
+            ))
+    )
+    @PostMapping("/token-reissue")
+    public ResponseEntity<?> reissue(HttpServletRequest request, HttpServletResponse response){
+
+        // 쿠키에서 refresh 토큰 얻기
+        String refresh = null;
+        Cookie[] cookies = request.getCookies();
+        for(Cookie cookie : cookies){
+            if(cookie.getName().equals("refresh")){
+                refresh = cookie.getValue();
+            }
+        }
+
+        TokenDTO tokenDTO = tokenService.reissueAccessToken(refresh);
+
+        // Refresh 토큰은 쿠키로 전달
+        response.addCookie(CookieUtil.createCookie("refresh", tokenDTO.getRefreshToken()));
+
+        // Access 토큰, code, isNewUser는 body로 전달
+        TokenDTO.ResponseDTO dto = TokenDTO.ResponseDTO.builder()
+                .accessToken(tokenDTO.getAccessToken())
+                .code(tokenDTO.getCode())
+                .isNewUser(tokenDTO.isNewUser())
+                .build();
+
+        return ResponseUtil.buildResponse(200, "토큰 재발급 완료", dto);
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/dto/.gitkeep b/src/main/java/org/example/studylog/dto/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/dto/BackgroundDTO.java b/src/main/java/org/example/studylog/dto/BackgroundDTO.java
new file mode 100644
index 0000000..14257b1
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/BackgroundDTO.java
@@ -0,0 +1,26 @@
+package org.example.studylog.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.*;
+import org.springframework.web.multipart.MultipartFile;
+
+public class BackgroundDTO {
+
+    @Getter
+    @Setter
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class RequestDTO {
+        @NotNull(message = "배경화면 이미지는 필수입니다.")
+        private MultipartFile coverImage;
+    }
+
+    @Getter
+    @Setter
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ResponseDTO {
+        private String coverImage;
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/dto/CategoryDTO.java b/src/main/java/org/example/studylog/dto/CategoryDTO.java
new file mode 100644
index 0000000..e72ac4e
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/CategoryDTO.java
@@ -0,0 +1,25 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.entity.category.Category;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CategoryDTO {
+    private Long id;
+    private String name;
+    private String color;
+
+    public static CategoryDTO from(Category category){
+        return CategoryDTO.builder()
+                .id(category.getId())
+                .name(category.getName())
+                .color(String.valueOf(category.getColor()))
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/MainPageResponseDTO.java b/src/main/java/org/example/studylog/dto/MainPageResponseDTO.java
new file mode 100644
index 0000000..36e0395
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/MainPageResponseDTO.java
@@ -0,0 +1,55 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.dto.friend.FriendResponseDTO;
+
+import java.util.List;
+import java.util.Map;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class MainPageResponseDTO {
+
+    private List<FriendResponseDTO> following;
+    private ProfileDTO profile;
+    private StreakDTO streak;
+    private List<CategoryCountDTO> categories;
+    private Boolean isFollowing;
+
+    @Getter
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class ProfileDTO {
+        private Long userId;
+        private String coverImage;
+        private String profileImage;
+        private String name;
+        private String intro;
+        private Integer level;
+        private String code;
+    }
+
+    @Getter
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class StreakDTO {
+        private Integer maxStreak;
+        private Map<String, Integer> recordCountPerDay; // currentStreak → recordCountPerDay로 변경
+    }
+
+    @Getter
+    @Builder
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class CategoryCountDTO {
+        private String name;
+        private Integer count;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/ProfileCreateRequestDTO.java b/src/main/java/org/example/studylog/dto/ProfileCreateRequestDTO.java
new file mode 100644
index 0000000..dd3a0a4
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/ProfileCreateRequestDTO.java
@@ -0,0 +1,18 @@
+package org.example.studylog.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.web.multipart.MultipartFile;
+
+@Getter
+@Setter
+public class ProfileCreateRequestDTO {
+    @NotNull(message = "사진은 필수입니다.")
+    private MultipartFile profileImage;
+    @NotBlank(message = "닉네임은 필수입니다.")
+    private String nickname;
+    @NotBlank(message = "한줄 소개는 필수입니다.")
+    private String intro;
+}
diff --git a/src/main/java/org/example/studylog/dto/ProfileResponseDTO.java b/src/main/java/org/example/studylog/dto/ProfileResponseDTO.java
new file mode 100644
index 0000000..cfe68b7
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/ProfileResponseDTO.java
@@ -0,0 +1,14 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class ProfileResponseDTO {
+    private String profileImage;
+    private String nickname;
+    private String intro;
+}
diff --git a/src/main/java/org/example/studylog/dto/ProfileUpdateRequestDTO.java b/src/main/java/org/example/studylog/dto/ProfileUpdateRequestDTO.java
new file mode 100644
index 0000000..5d28c18
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/ProfileUpdateRequestDTO.java
@@ -0,0 +1,13 @@
+package org.example.studylog.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.web.multipart.MultipartFile;
+
+@Getter
+@Setter
+public class ProfileUpdateRequestDTO {
+    private MultipartFile profileImage;
+    private String nickname;
+    private String intro;
+}
diff --git a/src/main/java/org/example/studylog/dto/QuizDTO.java b/src/main/java/org/example/studylog/dto/QuizDTO.java
new file mode 100644
index 0000000..2c0ad6b
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/QuizDTO.java
@@ -0,0 +1,17 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class QuizDTO {
+    private Long id;
+    private String question;
+    private String type;    // "OX" 또는 "SHORT_ANSWER"
+    private String level;   // "하", "중", "상"
+}
diff --git a/src/main/java/org/example/studylog/dto/ResponseDTO.java b/src/main/java/org/example/studylog/dto/ResponseDTO.java
new file mode 100644
index 0000000..fa42797
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/ResponseDTO.java
@@ -0,0 +1,14 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ResponseDTO<T> {
+    private int statusCode;
+    private String message;
+    private T data;
+}
diff --git a/src/main/java/org/example/studylog/dto/StreakDTO.java b/src/main/java/org/example/studylog/dto/StreakDTO.java
new file mode 100644
index 0000000..bcccfc5
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/StreakDTO.java
@@ -0,0 +1,15 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StreakDTO {
+    private Integer currentStreak;
+    private Boolean isStreakUpdated;
+}
diff --git a/src/main/java/org/example/studylog/dto/UserInfoResponseDTO.java b/src/main/java/org/example/studylog/dto/UserInfoResponseDTO.java
new file mode 100644
index 0000000..476badd
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/UserInfoResponseDTO.java
@@ -0,0 +1,18 @@
+package org.example.studylog.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class UserInfoResponseDTO {
+    private String profileImage;
+    private String nickname;
+    private String intro;
+    private Long friendCount;
+    private String code;
+}
diff --git a/src/main/java/org/example/studylog/dto/category/CategoryResponseDTO.java b/src/main/java/org/example/studylog/dto/category/CategoryResponseDTO.java
new file mode 100644
index 0000000..8d140b5
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/category/CategoryResponseDTO.java
@@ -0,0 +1,16 @@
+package org.example.studylog.dto.category;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CategoryResponseDTO {
+    private Long id;
+    private String name;
+    private String color;
+}
diff --git a/src/main/java/org/example/studylog/dto/category/CreateCategoryRequestDTO.java b/src/main/java/org/example/studylog/dto/category/CreateCategoryRequestDTO.java
new file mode 100644
index 0000000..f80fc6e
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/category/CreateCategoryRequestDTO.java
@@ -0,0 +1,21 @@
+package org.example.studylog.dto.category;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.entity.category.Color;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+@Getter
+@Setter
+public class CreateCategoryRequestDTO {
+
+    @NotBlank(message = "카테고리 이름은 필수입니다")
+    @Size(max = 10, message = "카테고리 이름은 10자를 초과할 수 없습니다")
+    private String name;
+
+    @NotNull(message = "색상은 필수입니다")
+    private Color color;
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/category/UpdateCategoryRequestDTO.java b/src/main/java/org/example/studylog/dto/category/UpdateCategoryRequestDTO.java
new file mode 100644
index 0000000..6a56612
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/category/UpdateCategoryRequestDTO.java
@@ -0,0 +1,21 @@
+package org.example.studylog.dto.category;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.entity.category.Color;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+@Getter
+@Setter
+public class UpdateCategoryRequestDTO {
+
+    @NotBlank(message = "카테고리 이름은 필수입니다")
+    @Size(max = 10, message = "카테고리 이름은 10자를 초과할 수 없습니다")
+    private String name;
+
+    @NotNull(message = "색상은 필수입니다")
+    private Color color;
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/friend/FriendNameDTO.java b/src/main/java/org/example/studylog/dto/friend/FriendNameDTO.java
new file mode 100644
index 0000000..787f9c3
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/friend/FriendNameDTO.java
@@ -0,0 +1,12 @@
+package org.example.studylog.dto.friend;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class FriendNameDTO {
+    private String nickname;
+}
diff --git a/src/main/java/org/example/studylog/dto/friend/FriendRequestDTO.java b/src/main/java/org/example/studylog/dto/friend/FriendRequestDTO.java
new file mode 100644
index 0000000..02eb173
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/friend/FriendRequestDTO.java
@@ -0,0 +1,10 @@
+package org.example.studylog.dto.friend;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+
+@Getter
+public class FriendRequestDTO {
+    @NotBlank(message = "코드는 필수입니다.")
+    private String code;
+}
diff --git a/src/main/java/org/example/studylog/dto/friend/FriendResponseDTO.java b/src/main/java/org/example/studylog/dto/friend/FriendResponseDTO.java
new file mode 100644
index 0000000..66a59df
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/friend/FriendResponseDTO.java
@@ -0,0 +1,15 @@
+package org.example.studylog.dto.friend;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class FriendResponseDTO {
+    private Long id;
+    private String nickname;
+    private String profileImage;
+    private String code;
+}
diff --git a/src/main/java/org/example/studylog/dto/notification/NotificationDTO.java b/src/main/java/org/example/studylog/dto/notification/NotificationDTO.java
new file mode 100644
index 0000000..011b446
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/notification/NotificationDTO.java
@@ -0,0 +1,15 @@
+package org.example.studylog.dto.notification;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import org.example.studylog.entity.notification.NotificationType;
+
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class NotificationDTO {
+    private NotificationType type;
+    private String content;
+}
diff --git a/src/main/java/org/example/studylog/dto/notification/NotificationListResponseDTO.java b/src/main/java/org/example/studylog/dto/notification/NotificationListResponseDTO.java
new file mode 100644
index 0000000..535a888
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/notification/NotificationListResponseDTO.java
@@ -0,0 +1,26 @@
+package org.example.studylog.dto.notification;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import org.example.studylog.entity.notification.Notification;
+import org.example.studylog.util.TimeUtil;
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class NotificationListResponseDTO {
+    private String type;
+    private String content;
+    private String timeAgo;
+    private boolean isRead;
+
+    public static NotificationListResponseDTO from(Notification notification) {
+        return NotificationListResponseDTO.builder()
+                .type(notification.getType().getLabel())
+                .content(notification.getContent())
+                .timeAgo(TimeUtil.formatTimeAgo(notification.getCreatedAt()))
+                .isRead(notification.isRead())
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/notification/NotificationResponseDTO.java b/src/main/java/org/example/studylog/dto/notification/NotificationResponseDTO.java
new file mode 100644
index 0000000..a9a581b
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/notification/NotificationResponseDTO.java
@@ -0,0 +1,13 @@
+package org.example.studylog.dto.notification;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@AllArgsConstructor
+@Getter
+public class NotificationResponseDTO {
+    private String type;
+    private String content;
+}
diff --git a/src/main/java/org/example/studylog/dto/oauth/CustomOAuth2User.java b/src/main/java/org/example/studylog/dto/oauth/CustomOAuth2User.java
new file mode 100644
index 0000000..d7182a2
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/CustomOAuth2User.java
@@ -0,0 +1,51 @@
+package org.example.studylog.dto.oauth;
+
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.oauth2.core.user.OAuth2User;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
+public class CustomOAuth2User implements OAuth2User {
+
+    private final UserDTO userDTO;
+
+    public CustomOAuth2User(UserDTO userDTO) {
+        this.userDTO = userDTO;
+    }
+
+    @Override
+    public Map<String, Object> getAttributes() {
+
+        return null;
+    }
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        Collection<GrantedAuthority> collection = new ArrayList<>();
+
+        collection.add(new GrantedAuthority() {
+
+            @Override
+            public String getAuthority() {
+                return userDTO.getRole();
+            }
+        });
+
+        return collection;
+    }
+
+    @Override
+    public String getName() {
+        return userDTO.getOauthId();
+    }
+
+    public String getNickname(){
+        return userDTO.getNickname();
+    }
+
+    public boolean isProfileCompleted(){
+        return userDTO.isProfileCompleted();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/oauth/GoogleResponse.java b/src/main/java/org/example/studylog/dto/oauth/GoogleResponse.java
new file mode 100644
index 0000000..d7c903f
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/GoogleResponse.java
@@ -0,0 +1,32 @@
+package org.example.studylog.dto.oauth;
+
+import java.util.Map;
+
+public class GoogleResponse implements OAuth2Response {
+
+    private final Map<String, Object> attribute;
+
+    public GoogleResponse(Map<String, Object> attribute){
+        this.attribute = attribute;
+    }
+
+    @Override
+    public String getProvider() {
+        return "google";
+    }
+
+    @Override
+    public String getProviderId() {
+        return attribute.get("sub").toString();
+    }
+
+    @Override
+    public String getName() {
+        return attribute.get("name").toString();
+    }
+
+    @Override
+    public String getProfileImage() {
+        return attribute.get("picture").toString();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/oauth/KakaoResponse.java b/src/main/java/org/example/studylog/dto/oauth/KakaoResponse.java
new file mode 100644
index 0000000..a45892d
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/KakaoResponse.java
@@ -0,0 +1,36 @@
+package org.example.studylog.dto.oauth;
+
+import java.util.Map;
+
+public class KakaoResponse implements OAuth2Response {
+
+    private final Map<String, Object> attribute;
+    private final Map<String, Object> kakaoAccount;
+
+    public KakaoResponse(Map<String, Object> attribute) {
+        this.attribute = (Map<String, Object>) attribute;
+        this.kakaoAccount = (Map<String, Object>) attribute.get("kakao_account");
+    }
+
+    @Override
+    public String getProvider() {
+        return "kakao";
+    }
+
+    @Override
+    public String getProviderId() {
+        return attribute.get("id").toString();
+    }
+
+    @Override
+    public String getName() {
+        Map<String, Object> profile = (Map<String, Object>) kakaoAccount.get("profile");
+        return profile.get("nickname").toString();
+    }
+
+    @Override
+    public String getProfileImage() {
+        Map<String, Object> profile = (Map<String, Object>) kakaoAccount.get("profile");
+        return profile.get("profile_image_url").toString();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/oauth/OAuth2Response.java b/src/main/java/org/example/studylog/dto/oauth/OAuth2Response.java
new file mode 100644
index 0000000..012256f
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/OAuth2Response.java
@@ -0,0 +1,17 @@
+package org.example.studylog.dto.oauth;
+
+public interface OAuth2Response {
+
+    // 제공자 (Ex. kakao, google...)
+    String getProvider();
+
+    // 제공자에서 발급해주는 아이디(번호)
+    String getProviderId();
+
+    // 사용자 이름
+    String getName();
+
+    // 사용자 프로필이미지
+    String getProfileImage();
+
+}
diff --git a/src/main/java/org/example/studylog/dto/oauth/TokenDTO.java b/src/main/java/org/example/studylog/dto/oauth/TokenDTO.java
new file mode 100644
index 0000000..49ba2c9
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/TokenDTO.java
@@ -0,0 +1,27 @@
+package org.example.studylog.dto.oauth;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+
+@Getter
+@Builder
+@Schema(name = "TokenDTO")
+public class TokenDTO {
+
+    private String refreshToken;
+    private String accessToken;
+    private String code;
+    private boolean isNewUser;
+
+    @Getter
+    @Builder
+    @Schema(name = "TokenResponseDTO")
+    public static class ResponseDTO {
+        private String accessToken;
+        private String code;
+        private boolean isNewUser;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/oauth/UserDTO.java b/src/main/java/org/example/studylog/dto/oauth/UserDTO.java
new file mode 100644
index 0000000..a659dc4
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/oauth/UserDTO.java
@@ -0,0 +1,15 @@
+package org.example.studylog.dto.oauth;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class UserDTO {
+
+    private String role;
+    private String nickname;
+    private String oauthId;
+    private boolean isProfileCompleted;
+
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/CreateQuizRequestDTO.java b/src/main/java/org/example/studylog/dto/quiz/CreateQuizRequestDTO.java
new file mode 100644
index 0000000..4b7188a
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/CreateQuizRequestDTO.java
@@ -0,0 +1,21 @@
+package org.example.studylog.dto.quiz;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.entity.quiz.QuizLevel;
+
+@Getter
+@Setter
+public class CreateQuizRequestDTO {
+
+    @NotNull(message = "난이도는 필수입니다")
+    private QuizLevel level;
+
+    @Min(value = 1, message = "퀴즈 갯수는 1 이상이어야 합니다")
+    private int quizCount;
+
+    private String requirement;
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/QuizListResponseDTO.java b/src/main/java/org/example/studylog/dto/quiz/QuizListResponseDTO.java
new file mode 100644
index 0000000..1f43dc1
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/QuizListResponseDTO.java
@@ -0,0 +1,19 @@
+package org.example.studylog.dto.quiz;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.dto.CategoryDTO;
+
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class QuizListResponseDTO {
+
+    private List<CategoryDTO> categories;
+    private List<QuizSummaryDTO> quizzes;
+    private boolean hasNext;
+    private Long lastId;
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/QuizResponseDTO.java b/src/main/java/org/example/studylog/dto/quiz/QuizResponseDTO.java
new file mode 100644
index 0000000..695f741
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/QuizResponseDTO.java
@@ -0,0 +1,41 @@
+package org.example.studylog.dto.quiz;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.dto.CategoryDTO;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.quiz.Quiz;
+
+import java.time.format.DateTimeFormatter;
+
+@Setter
+@Getter
+@Builder
+public class QuizResponseDTO {
+
+    private String createdAt;
+    private String type;
+    private CategoryDTO category;
+    private String question;
+    private String answer;
+    private String level;
+    private Long recordId;
+
+    public static QuizResponseDTO from(Quiz quiz, Category category){
+
+        return QuizResponseDTO.builder()
+                .createdAt(quiz.getCreatedAt().format(DateTimeFormatter.ofPattern("yyyy.MM.dd")))
+                .type(String.valueOf(quiz.getType()))
+                .category(CategoryDTO.builder()
+                        .id(category.getId())
+                        .name(category.getName())
+                        .color(String.valueOf(category.getColor()))
+                        .build())
+                .question(quiz.getQuestion())
+                .answer(quiz.getAnswer())
+                .level(String.valueOf(quiz.getLevel()))
+                .recordId(quiz.getRecord().getId())
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/QuizSummaryDTO.java b/src/main/java/org/example/studylog/dto/quiz/QuizSummaryDTO.java
new file mode 100644
index 0000000..3860e96
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/QuizSummaryDTO.java
@@ -0,0 +1,27 @@
+package org.example.studylog.dto.quiz;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+import org.example.studylog.entity.quiz.Quiz;
+
+@Getter
+@Setter
+@Builder
+public class QuizSummaryDTO {
+    private Long id;
+    private String category;
+    private String color;
+    private String question;
+    private String level;
+
+    public static QuizSummaryDTO from(Quiz quiz) {
+        return QuizSummaryDTO.builder()
+                .id(quiz.getId())
+                .category(quiz.getCategory().getName())
+                .color(String.valueOf(quiz.getCategory().getColor()))
+                .question(quiz.getQuestion())
+                .level(String.valueOf(quiz.getLevel()))
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptRequest.java b/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptRequest.java
new file mode 100644
index 0000000..d159f51
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptRequest.java
@@ -0,0 +1,25 @@
+package org.example.studylog.dto.quiz.chatGPT;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ChatGptRequest {
+
+    private String model = "gpt-3.5-turbo";
+    private List<Message> messages;
+    private double temperature = 0.7;
+
+    @Data
+    @AllArgsConstructor
+    @NoArgsConstructor
+    public static class Message {
+        private String role; // "user"
+        private String content;
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptResponse.java b/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptResponse.java
new file mode 100644
index 0000000..36bf94e
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/quiz/chatGPT/ChatGptResponse.java
@@ -0,0 +1,25 @@
+package org.example.studylog.dto.quiz.chatGPT;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+public class ChatGptResponse {
+
+    private List<Choice> choices;
+
+    @Data
+    public static class Choice {
+        private Message message;
+    }
+
+    @Data
+    public static class Message {
+        private String role;
+        private String content;
+    }
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordRequestDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordRequestDTO.java
new file mode 100644
index 0000000..f7292c5
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordRequestDTO.java
@@ -0,0 +1,24 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+@Getter
+@Setter
+public class CreateStudyRecordRequestDTO {
+
+    @NotNull(message = "카테고리는 필수입니다")
+    private Long categoryId; // 팀원 엔티티에서 카테고리는 필수
+
+    @NotBlank(message = "제목은 필수 입력 항목입니다")
+    @Size(max = 20, message = "제목은 20자를 초과할 수 없습니다")  // 팀원 엔티티 length=20
+    private String title;
+
+    @NotBlank(message = "내용은 필수 입력 항목입니다")
+    @Size(min = 10, message = "내용은 최소 10자 이상 입력해주세요")
+    private String content;
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordResponseDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordResponseDTO.java
new file mode 100644
index 0000000..ded569c
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/CreateStudyRecordResponseDTO.java
@@ -0,0 +1,16 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.dto.StreakDTO;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CreateStudyRecordResponseDTO {
+    private StudyRecordDTO record;
+    private StreakDTO streak;
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDTO.java
new file mode 100644
index 0000000..d66a4ff
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDTO.java
@@ -0,0 +1,20 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.dto.CategoryDTO;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StudyRecordDTO {
+    private Long id;
+    private String title;
+    private String content;
+    private CategoryDTO category;
+    private String createdAt; // "2025-06-24" 형식
+    private Boolean hasQuiz;  // API 명세서에 맞춰 hasQuiz로 유지 (내부는 isQuizCreated)
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailDTO.java
new file mode 100644
index 0000000..536f799
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailDTO.java
@@ -0,0 +1,20 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.dto.CategoryDTO;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StudyRecordDetailDTO {
+    private Long id;
+    private String title;
+    private String content;
+    private CategoryDTO category;
+    private String createdAt;   // "2025-06-24"
+    private Integer quizCount;  // 퀴즈 개수
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailResponseDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailResponseDTO.java
new file mode 100644
index 0000000..7f17d9a
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordDetailResponseDTO.java
@@ -0,0 +1,19 @@
+package org.example.studylog.dto.studyrecord;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.example.studylog.dto.QuizDTO;
+
+import java.util.List;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StudyRecordDetailResponseDTO {
+    private StudyRecordDetailDTO record;
+    private List<QuizDTO> quizzes;
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterRequestDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterRequestDTO.java
new file mode 100644
index 0000000..44fd1ff
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterRequestDTO.java
@@ -0,0 +1,13 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class StudyRecordFilterRequestDTO {
+    private Long categoryId;    // 선택적
+    private String date;        // "YYYY-MM-DD" 형식, 선택적
+    private Long lastId;        // 무한 스크롤용, 선택적
+    private Integer size = 10;  // 기본 페이지 크기
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterResponseDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterResponseDTO.java
new file mode 100644
index 0000000..d5650c1
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordFilterResponseDTO.java
@@ -0,0 +1,19 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StudyRecordFilterResponseDTO {
+    private List<StudyRecordDTO> records;
+    private Boolean hasMore;     // 더 많은 데이터가 있는지
+    private Long nextLastId;     // 다음 요청에 사용할 lastId
+}
+
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordListResponseDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordListResponseDTO.java
new file mode 100644
index 0000000..7dd4635
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/StudyRecordListResponseDTO.java
@@ -0,0 +1,16 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class StudyRecordListResponseDTO {
+    private List<StudyRecordDTO> records;
+}
diff --git a/src/main/java/org/example/studylog/dto/studyrecord/UpdateStudyRecordRequestDTO.java b/src/main/java/org/example/studylog/dto/studyrecord/UpdateStudyRecordRequestDTO.java
new file mode 100644
index 0000000..36c519e
--- /dev/null
+++ b/src/main/java/org/example/studylog/dto/studyrecord/UpdateStudyRecordRequestDTO.java
@@ -0,0 +1,24 @@
+package org.example.studylog.dto.studyrecord;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+@Getter
+@Setter
+public class UpdateStudyRecordRequestDTO {
+
+    @NotNull(message = "카테고리는 필수입니다")
+    private Long categoryId;
+
+    @NotBlank(message = "제목은 필수 입력 항목입니다")
+    @Size(max = 20, message = "제목은 20자를 초과할 수 없습니다")
+    private String title;
+
+    @NotBlank(message = "내용은 필수 입력 항목입니다")
+    @Size(min = 10, message = "내용은 최소 10자 이상 입력해주세요")
+    private String content;
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/entity/.gitkeep b/src/main/java/org/example/studylog/entity/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/entity/BaseEntity.java b/src/main/java/org/example/studylog/entity/BaseEntity.java
new file mode 100644
index 0000000..3dbce2b
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/BaseEntity.java
@@ -0,0 +1,28 @@
+package org.example.studylog.entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.MappedSuperclass;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+@Getter
+@MappedSuperclass
+@SuperBuilder
+@NoArgsConstructor
+@EntityListeners(AuditingEntityListener.class)
+public abstract class BaseEntity {
+
+    @CreatedDate
+    @Column(updatable = false)
+    private LocalDateTime createDate;
+
+    @LastModifiedDate
+    private LocalDateTime updateDate;
+}
diff --git a/src/main/java/org/example/studylog/entity/Friend.java b/src/main/java/org/example/studylog/entity/Friend.java
new file mode 100644
index 0000000..a330d9d
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/Friend.java
@@ -0,0 +1,27 @@
+package org.example.studylog.entity;
+
+import jakarta.persistence.*;
+import lombok.*;
+import org.example.studylog.entity.user.User;
+
+@Getter
+@Setter
+@Builder
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+public class Friend {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "friend_id", nullable = false)
+    private User friend;
+
+}
diff --git a/src/main/java/org/example/studylog/entity/RefreshEntity.java b/src/main/java/org/example/studylog/entity/RefreshEntity.java
new file mode 100644
index 0000000..9b66aba
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/RefreshEntity.java
@@ -0,0 +1,24 @@
+package org.example.studylog.entity;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import lombok.*;
+
+@Getter
+@Setter
+@Builder
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+public class RefreshEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String oauthId;
+    private String refresh;
+    private String expiration;
+}
diff --git a/src/main/java/org/example/studylog/entity/Streak.java b/src/main/java/org/example/studylog/entity/Streak.java
new file mode 100644
index 0000000..57fd7b3
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/Streak.java
@@ -0,0 +1,35 @@
+package org.example.studylog.entity;
+
+import jakarta.persistence.*;
+import lombok.*;
+import lombok.experimental.SuperBuilder;
+import org.example.studylog.entity.user.User;
+
+import java.time.LocalDate;
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "streak")
+public class Streak extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false, unique = true)
+    private User user;
+
+    @Column(name = "current_streak", nullable = false)
+    private Integer currentStreak = 0;
+
+    @Column(name = "max_streak", nullable = false)
+    private Integer maxStreak = 0;
+
+    @Column(name = "last_record_date")
+    private LocalDate lastRecordDate;
+}
diff --git a/src/main/java/org/example/studylog/entity/StudyRecord.java b/src/main/java/org/example/studylog/entity/StudyRecord.java
new file mode 100644
index 0000000..32d9939
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/StudyRecord.java
@@ -0,0 +1,48 @@
+package org.example.studylog.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.quiz.Quiz;
+import org.example.studylog.entity.user.User;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+@Table(name = "study_record")
+public class StudyRecord extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, length = 20)
+    private String title;
+
+    @Column(nullable = false, columnDefinition = "TEXT")
+    private String content;
+
+    @Column(name = "is_quiz_created", nullable = false)
+    private boolean isQuizCreated = false;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "category_id", nullable = false)
+    private Category category;
+
+    @OneToMany(mappedBy = "record", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Quiz> quizzes = new ArrayList<>();
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/entity/category/Category.java b/src/main/java/org/example/studylog/entity/category/Category.java
new file mode 100644
index 0000000..cb72743
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/category/Category.java
@@ -0,0 +1,43 @@
+package org.example.studylog.entity.category;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.quiz.Quiz;
+import org.example.studylog.entity.user.User;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+public class Category {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @Column(nullable = false, length = 10)
+    private String name;
+
+    @Enumerated(EnumType.STRING)
+    private Color color;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @OneToMany(mappedBy = "category")
+    private List<StudyRecord> records = new ArrayList<>();
+
+    @OneToMany(mappedBy = "category")
+    private List<Quiz> quizzes = new ArrayList<>();
+}
diff --git a/src/main/java/org/example/studylog/entity/category/Color.java b/src/main/java/org/example/studylog/entity/category/Color.java
new file mode 100644
index 0000000..be445af
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/category/Color.java
@@ -0,0 +1,14 @@
+package org.example.studylog.entity.category;
+
+public enum Color {
+    ROSE_PINK,
+    BABY_BLUE,
+    BABY_PINK,
+    COOL_GRAY,
+    MELON_GREEN,
+    LAVENDER_PURPLE,
+    PALE_YELLOW,
+    LILAC_PURPLE,
+    CEMENT_GRAY,
+    PALE_ORANGE
+}
diff --git a/src/main/java/org/example/studylog/entity/notification/Notification.java b/src/main/java/org/example/studylog/entity/notification/Notification.java
new file mode 100644
index 0000000..8668732
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/notification/Notification.java
@@ -0,0 +1,37 @@
+package org.example.studylog.entity.notification;
+
+import jakarta.persistence.*;
+import lombok.*;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Setter
+@Builder
+@Entity
+@NoArgsConstructor
+@AllArgsConstructor
+@EntityListeners(AuditingEntityListener.class)
+public class Notification {
+
+    @Id
+    @GeneratedValue
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private User user;
+
+    @Enumerated(EnumType.STRING)
+    private NotificationType type;
+
+    private String content;
+
+    @CreatedDate
+    private LocalDateTime createdAt;
+
+    @Column(nullable = false)
+    private boolean isRead = false;
+}
diff --git a/src/main/java/org/example/studylog/entity/notification/NotificationType.java b/src/main/java/org/example/studylog/entity/notification/NotificationType.java
new file mode 100644
index 0000000..818bb74
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/notification/NotificationType.java
@@ -0,0 +1,17 @@
+package org.example.studylog.entity.notification;
+
+import lombok.Getter;
+
+@Getter
+public enum NotificationType {
+    ADD_FRIEND("친구 추가"),
+    DELETE_FRIEND("친구 삭제"),
+    STREAK("스트릭"),
+    BADGE("뱃지");
+
+    private final String label;
+
+    NotificationType(String label){
+        this.label = label;
+    }
+}
diff --git a/src/main/java/org/example/studylog/entity/quiz/Quiz.java b/src/main/java/org/example/studylog/entity/quiz/Quiz.java
new file mode 100644
index 0000000..90a44b5
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/quiz/Quiz.java
@@ -0,0 +1,57 @@
+package org.example.studylog.entity.quiz;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.example.studylog.entity.BaseEntity;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.user.User;
+
+import java.time.LocalDateTime;
+
+@Getter
+@Setter
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Entity
+public class Quiz extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String question;
+
+    @Column(nullable = false)
+    private String answer;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private QuizLevel level;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private QuizType type;
+
+    @Column(nullable = false)
+    private LocalDateTime createdAt;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "record_id", nullable = false)
+    private StudyRecord record;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "category_id", nullable = false)
+    private Category category;
+
+}
diff --git a/src/main/java/org/example/studylog/entity/quiz/QuizLevel.java b/src/main/java/org/example/studylog/entity/quiz/QuizLevel.java
new file mode 100644
index 0000000..6348ad3
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/quiz/QuizLevel.java
@@ -0,0 +1,23 @@
+package org.example.studylog.entity.quiz;
+
+import lombok.Getter;
+
+@Getter
+public enum QuizLevel {
+    EASY("하"),
+    MEDIUM("중"),
+    HARD("상");
+
+    private final String label;
+
+    QuizLevel(String label){
+        this.label = label;
+    }
+
+    public static QuizLevel fromLabel(String label){
+        for (QuizLevel level : values()){
+            if(level.label.equals(label)) return level;
+        }
+        throw new IllegalArgumentException("유효하지 않은 난이도입니다.");
+    }
+}
diff --git a/src/main/java/org/example/studylog/entity/quiz/QuizType.java b/src/main/java/org/example/studylog/entity/quiz/QuizType.java
new file mode 100644
index 0000000..9370490
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/quiz/QuizType.java
@@ -0,0 +1,6 @@
+package org.example.studylog.entity.quiz;
+
+public enum QuizType {
+    OX,
+    SHORT_ANSWER
+}
diff --git a/src/main/java/org/example/studylog/entity/user/LevelThresholds.java b/src/main/java/org/example/studylog/entity/user/LevelThresholds.java
new file mode 100644
index 0000000..479b3d0
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/user/LevelThresholds.java
@@ -0,0 +1,35 @@
+package org.example.studylog.entity.user;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LevelThresholds {
+    private static final Map<Integer, Integer> thresholds =
+            new LinkedHashMap<>() {{
+                put(1, 10);
+                put(2, 30);
+                put(3, 60);
+                put(4, 100);
+                put(5, 150);
+                put(6, 210);
+                put(7, 280);
+                put(8, 360);
+                put(9, 450);
+                put(10, 550);
+            }};
+
+
+    public static int getLevelForRecordCount(long recordCount){
+        int level = 0;
+
+        for (Map.Entry<Integer, Integer> entry : thresholds.entrySet()) {
+            if(recordCount >= entry.getValue()){
+                level = entry.getKey();
+            } else{
+                break;
+            }
+        }
+
+        return level;
+    }
+}
diff --git a/src/main/java/org/example/studylog/entity/user/Role.java b/src/main/java/org/example/studylog/entity/user/Role.java
new file mode 100644
index 0000000..0c49c24
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/user/Role.java
@@ -0,0 +1,6 @@
+package org.example.studylog.entity.user;
+
+public enum Role {
+    ROLE_USER,
+    ROLE_ADMIN
+}
diff --git a/src/main/java/org/example/studylog/entity/user/User.java b/src/main/java/org/example/studylog/entity/user/User.java
new file mode 100644
index 0000000..24e9a2b
--- /dev/null
+++ b/src/main/java/org/example/studylog/entity/user/User.java
@@ -0,0 +1,80 @@
+package org.example.studylog.entity.user;
+
+import jakarta.persistence.*;
+import lombok.*;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.quiz.Quiz;
+import org.hibernate.annotations.ColumnDefault;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+@Entity
+@Getter
+@Setter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "users")
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(length = 20, nullable = false)
+    private String nickname;
+
+    @Column(length = 100)
+    private String intro;
+
+    @Column(nullable = false, length = 2048)
+    private String profileImage;
+
+    @Column(length = 2048)
+    private String backImage;
+
+    @Column(nullable = false)
+    private int level;
+
+    @Column(nullable = false)
+    @ColumnDefault("0")
+    private Long recordCount;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private Role role;
+
+    @Column(nullable = false)
+    private boolean isProfileCompleted;
+
+    @Column(nullable = false, unique = true)
+    private UUID uuid;
+
+    @Column(length = 5, unique = true)
+    private String code;
+
+    @Column(nullable = false, unique = true)
+    private String oauthId;
+
+    @OneToMany(mappedBy = "user")
+    private List<StudyRecord> records = new ArrayList<>();
+
+    @OneToMany(mappedBy = "user")
+    private List<Quiz> quizzes = new ArrayList<>();
+
+    @OneToMany(mappedBy = "user")
+    private List<Category> categories = new ArrayList<>();
+
+    // 기록 수 증가
+    public void incrementRecordCount(){
+        this.recordCount++;
+    }
+
+    // 기록 수 감소
+    public void decrementRecordCount(){
+        this.recordCount--;
+    }
+}
diff --git a/src/main/java/org/example/studylog/event/LevelEvent.java b/src/main/java/org/example/studylog/event/LevelEvent.java
new file mode 100644
index 0000000..d7f78aa
--- /dev/null
+++ b/src/main/java/org/example/studylog/event/LevelEvent.java
@@ -0,0 +1,18 @@
+package org.example.studylog.event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.example.studylog.entity.user.User;
+
+@Getter
+@AllArgsConstructor
+public class LevelEvent {
+
+    private final User user;
+    private final int newLevel;
+    private final ActionType action;
+
+    public enum ActionType{
+        UP, DOWN
+    }
+}
diff --git a/src/main/java/org/example/studylog/event/RecordEvent.java b/src/main/java/org/example/studylog/event/RecordEvent.java
new file mode 100644
index 0000000..b32ad9d
--- /dev/null
+++ b/src/main/java/org/example/studylog/event/RecordEvent.java
@@ -0,0 +1,13 @@
+package org.example.studylog.event;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.example.studylog.entity.user.User;
+
+@Getter
+@AllArgsConstructor
+public class RecordEvent {
+
+    private final User user;
+
+}
diff --git a/src/main/java/org/example/studylog/event/listener/LevelChangeListener.java b/src/main/java/org/example/studylog/event/listener/LevelChangeListener.java
new file mode 100644
index 0000000..1c74d72
--- /dev/null
+++ b/src/main/java/org/example/studylog/event/listener/LevelChangeListener.java
@@ -0,0 +1,45 @@
+package org.example.studylog.event.listener;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.entity.user.LevelThresholds;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.event.LevelEvent;
+import org.example.studylog.event.RecordEvent;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class LevelChangeListener {
+
+    private final UserRepository userRepository;
+    private final ApplicationEventPublisher eventPublisher;
+
+    @EventListener
+    @Transactional
+    public void handleRecordEvent(RecordEvent event) {
+        User currentUser = event.getUser();
+        long recordCount = currentUser.getRecordCount();
+
+        log.info("레벨 체크 시작: USER = {}, CURRENT_LEVEL = {}, RECORD_COUNT= {}",
+                currentUser.getOauthId(), currentUser.getLevel(), recordCount);
+
+        int lastLevel = currentUser.getLevel();
+        int newLevel = LevelThresholds.getLevelForRecordCount(recordCount);
+        if(lastLevel != newLevel){
+            currentUser.setLevel(newLevel); // 레벨 업데이트
+
+            if(lastLevel > newLevel){
+                eventPublisher.publishEvent(new LevelEvent(currentUser, newLevel, LevelEvent.ActionType.DOWN));
+            }
+            else if(lastLevel < newLevel){
+                eventPublisher.publishEvent(new LevelEvent(currentUser, newLevel, LevelEvent.ActionType.UP));
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/example/studylog/event/listener/NotificationListener.java b/src/main/java/org/example/studylog/event/listener/NotificationListener.java
new file mode 100644
index 0000000..3662658
--- /dev/null
+++ b/src/main/java/org/example/studylog/event/listener/NotificationListener.java
@@ -0,0 +1,45 @@
+package org.example.studylog.event.listener;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.notification.NotificationDTO;
+import org.example.studylog.entity.notification.NotificationType;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.event.LevelEvent;
+import org.example.studylog.service.NotificationService;
+import org.springframework.context.event.EventListener;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class NotificationListener {
+
+    private final NotificationService notificationService;
+
+    @Async
+    @EventListener
+    @Transactional
+    public void handleLevelChange(LevelEvent event){
+        User currentUser = event.getUser();
+        log.info("레벨 변경 알림 전송: USER={}, LEVEL={}", currentUser.getOauthId(), event.getNewLevel());
+
+        String message = "";
+        if(event.getAction() == LevelEvent.ActionType.UP){
+            message = String.format("Lv.%d 뱃지를 달성했습니다.", event.getNewLevel());
+        }
+        else if(event.getAction() == LevelEvent.ActionType.DOWN){
+            message = String.format("Lv.%d 뱃지로 하락했습니다.", event.getNewLevel());
+        }
+
+        // 알림 보내기
+        notificationService.sendToClient(
+                currentUser.getOauthId(),
+                NotificationDTO.builder()
+                        .content(message)
+                        .type(NotificationType.BADGE)
+                        .build());
+    }
+}
diff --git a/src/main/java/org/example/studylog/exception/BusinessException.java b/src/main/java/org/example/studylog/exception/BusinessException.java
new file mode 100644
index 0000000..617ae41
--- /dev/null
+++ b/src/main/java/org/example/studylog/exception/BusinessException.java
@@ -0,0 +1,14 @@
+package org.example.studylog.exception;
+
+import lombok.Getter;
+
+@Getter
+public class BusinessException extends RuntimeException{
+    private final ErrorCode errorCode;
+
+    public BusinessException(ErrorCode errorCode){
+        super(errorCode.getMessage());
+        this.errorCode = errorCode;
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/exception/ErrorCode.java b/src/main/java/org/example/studylog/exception/ErrorCode.java
new file mode 100644
index 0000000..8092bf8
--- /dev/null
+++ b/src/main/java/org/example/studylog/exception/ErrorCode.java
@@ -0,0 +1,23 @@
+package org.example.studylog.exception;
+
+import lombok.Getter;
+
+@Getter
+public enum ErrorCode {
+    USER_CODE_NOT_FOUND(404,"코드에 해당하는 사용자가 없습니다."),
+    ALREADY_FRIEND(400,"이미 친구입니다."),
+    NOT_FRIEND(400, "친구 관계가 아닙니다."),
+    FRIEND_NOT_FOUND(404, "해당하는 친구가 없습니다."),
+    SELF_LOOKUP_NOT_ALLOWED(400, "자기 자신은 조회할 수 없습니다."),
+    NOTIFICATION_CONNECTION_ERROR(500, "알림 서버와 연결이 실패하였습니다."),
+    STUDY_RECORD_NOT_FOUND(404, "기록이 존재하지 않습니다."),
+    QUIZ_ALREADY_EXISTS(400, "이미 퀴즈가 생성된 기록입니다.");
+
+    private int status;
+    private final String message;
+
+    ErrorCode(int status, String message){
+        this.status = status;
+        this.message = message;
+    }
+}
diff --git a/src/main/java/org/example/studylog/exception/TokenValidationException.java b/src/main/java/org/example/studylog/exception/TokenValidationException.java
new file mode 100644
index 0000000..d0f3d6a
--- /dev/null
+++ b/src/main/java/org/example/studylog/exception/TokenValidationException.java
@@ -0,0 +1,8 @@
+package org.example.studylog.exception;
+
+public class TokenValidationException extends RuntimeException{
+
+    public TokenValidationException(String message){
+        super(message);
+    }
+}
diff --git a/src/main/java/org/example/studylog/exception/UserNotFoundException.java b/src/main/java/org/example/studylog/exception/UserNotFoundException.java
new file mode 100644
index 0000000..811d227
--- /dev/null
+++ b/src/main/java/org/example/studylog/exception/UserNotFoundException.java
@@ -0,0 +1,7 @@
+package org.example.studylog.exception;
+
+public class UserNotFoundException extends RuntimeException {
+    public UserNotFoundException(String message){
+        super(message);
+    }
+}
diff --git a/src/main/java/org/example/studylog/exception/handler/GlobalExceptionHandler.java b/src/main/java/org/example/studylog/exception/handler/GlobalExceptionHandler.java
new file mode 100644
index 0000000..51d2d0b
--- /dev/null
+++ b/src/main/java/org/example/studylog/exception/handler/GlobalExceptionHandler.java
@@ -0,0 +1,57 @@
+package org.example.studylog.exception.handler;
+
+import org.example.studylog.exception.BusinessException;
+import org.example.studylog.exception.TokenValidationException;
+import org.example.studylog.exception.UserNotFoundException;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(TokenValidationException.class)
+    public ResponseEntity<?> handlerTokenValidationException(TokenValidationException e) {
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                .body(Map.of(
+                        "statusCode", 400,
+                        "message", e.getMessage()
+                ));
+    }
+
+    @ExceptionHandler(UserNotFoundException.class)
+    public ResponseEntity<?> handleUserNotFoundException(UserNotFoundException e) {
+        return ResponseUtil.buildResponse(404, e.getMessage(), null);
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<?> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        String message = e.getBindingResult().getFieldErrors().get(0).getDefaultMessage();
+        return ResponseUtil.buildResponse(400, message, null);
+    }
+
+    @ExceptionHandler(BusinessException.class)
+    public ResponseEntity<?> handleBusinessException(BusinessException e){
+        return ResponseUtil.buildResponse(e.getErrorCode().getStatus(), e.getErrorCode().getMessage(), null);
+    }
+
+    // 추가: body 없는 요청 처리
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    public ResponseEntity<Map<String, Object>> handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
+        Map<String, Object> response = new HashMap<>();
+        response.put("statusCode", 400);
+        response.put("message", "잘못된 접근입니다");
+        response.put("data", Map.of("example", "요청 본문이 필요합니다"));
+
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/jwt/JWTFilter.java b/src/main/java/org/example/studylog/jwt/JWTFilter.java
new file mode 100644
index 0000000..929ab19
--- /dev/null
+++ b/src/main/java/org/example/studylog/jwt/JWTFilter.java
@@ -0,0 +1,121 @@
+package org.example.studylog.jwt;
+
+import io.jsonwebtoken.ExpiredJwtException;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.Cookie;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.dto.oauth.UserDTO;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+
+@Slf4j
+public class JWTFilter extends OncePerRequestFilter {
+
+    private final JWTUtil jwtUtil;
+
+    public JWTFilter(JWTUtil jwtUtil) {
+        this.jwtUtil = jwtUtil;
+    }
+
+    @Override
+    protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {
+        String path = request.getRequestURI();
+
+        // 제외할 URI 리스트
+        // 로그인 완료 직후 접근하는 페이지들, 토큰 재발급 API, 정적 리소스 제외
+        return path.equals("/signup")          // 로그인 완료 페이지
+                || path.equals("/login-success")   // (예시) 다른 완료 페이지
+                || path.equals("/login")
+                || path.equals("/")
+                || path.equals("/index.html")
+                || path.startsWith("/static/")
+                || path.startsWith("/.well-known")
+                || path.endsWith(".css")
+                || path.endsWith(".js")
+                || path.equals("/auth/token-reissue");
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
+
+        String requestURI = request.getRequestURI();
+//        if (requestURI.equals("/auth/token-reissue") || requestURI.equals("/")) {
+//            filterChain.doFilter(request, response); // 토큰 검사 생략
+//            return;
+//        }
+
+        // 요청(request)에서 Authorization 헤더 찾기
+        String authorization = request.getHeader("Authorization");
+
+        // Authorization 헤더 검증
+        if(authorization == null || !authorization.startsWith("Bearer ")){
+            log.warn("Authorization 헤더 검증에 실패: REQUEST_URI = {}", requestURI);
+            // 해당 필더 종료
+            filterChain.doFilter(request, response);
+            // 메소드 종료
+            return;
+        }
+
+        String accessToken = authorization.split(" ")[1];
+
+        //Authorization 검증
+        if (accessToken == null) {
+            log.warn("JWT 토큰이 없음 (token null)");
+            System.out.println("token null");
+            filterChain.doFilter(request, response);
+
+            return;
+        }
+
+        //토큰 만료 여부 확인
+        try{
+            jwtUtil.isExpired(accessToken);
+        } catch (ExpiredJwtException e){
+            PrintWriter writer = response.getWriter();
+            writer.print("access token expired");
+
+            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+            return;
+        }
+
+        // access token 인지 확인
+        String category = jwtUtil.getCategory(accessToken);
+        if(!category.equals("access")){
+            PrintWriter writer = response.getWriter();
+            writer.print("invalid access token");
+
+            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
+            return;
+        }
+
+        //토큰에서 oauthId role 획득
+        String oauthId = jwtUtil.getOauthId(accessToken);
+        String role = jwtUtil.getRole(accessToken);
+
+        log.info("JWT 인증 성공: oauthId={}, role={}", oauthId, role);
+
+        //userDTO를 생성하여 값 set
+        UserDTO userDTO = new UserDTO();
+        userDTO.setOauthId(oauthId);
+        userDTO.setRole(role);
+
+        //UserDetails에 회원 정보 객체 담기
+        CustomOAuth2User customOAuth2User = new CustomOAuth2User(userDTO);
+
+        //스프링 시큐리티 인증 토큰 생성
+        Authentication authToken = new UsernamePasswordAuthenticationToken(customOAuth2User, null, customOAuth2User.getAuthorities());
+        //세션에 사용자 등록
+        SecurityContextHolder.getContext().setAuthentication(authToken);
+
+        filterChain.doFilter(request, response);
+    }
+}
diff --git a/src/main/java/org/example/studylog/jwt/JWTUtil.java b/src/main/java/org/example/studylog/jwt/JWTUtil.java
new file mode 100644
index 0000000..eb47ab0
--- /dev/null
+++ b/src/main/java/org/example/studylog/jwt/JWTUtil.java
@@ -0,0 +1,50 @@
+package org.example.studylog.jwt;
+
+import io.jsonwebtoken.Jwts;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+
+@Component
+@Slf4j
+public class JWTUtil {
+
+    private SecretKey secretKey;
+
+    public JWTUtil(@Value("${spring.jwt.secret}")String secret){
+        secretKey = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), Jwts.SIG.HS256.key().build().getAlgorithm());
+    }
+
+    public String getCategory(String token){
+        return Jwts.parser().verifyWith(secretKey).build().parseSignedClaims(token).getPayload().get("category", String.class);
+    }
+
+    public String getOauthId(String token) {
+        return Jwts.parser().verifyWith(secretKey).build().parseSignedClaims(token).getPayload().get("oauthId", String.class);
+    }
+
+    public String getRole(String token) {
+        return Jwts.parser().verifyWith(secretKey).build().parseSignedClaims(token).getPayload().get("role", String.class);
+    }
+
+    public Boolean isExpired(String token) {
+        return Jwts.parser().verifyWith(secretKey).build().parseSignedClaims(token).getPayload().getExpiration().before(new Date());
+    }
+
+    public String createJwt(String category, String oauthId, String role, Long expiredMs){
+        log.info("액세스 토큰이 발급되었습니다.");
+        return Jwts.builder()
+                .claim("category", category)
+                .claim("oauthId", oauthId)
+                .claim("role", role)
+                .issuedAt(new Date(System.currentTimeMillis()))
+                .expiration(new Date(System.currentTimeMillis() + expiredMs))
+                .signWith(secretKey)
+                .compact();
+    }
+}
diff --git a/src/main/java/org/example/studylog/oauth2/CustomFailureHandler.java b/src/main/java/org/example/studylog/oauth2/CustomFailureHandler.java
new file mode 100644
index 0000000..4b4525c
--- /dev/null
+++ b/src/main/java/org/example/studylog/oauth2/CustomFailureHandler.java
@@ -0,0 +1,21 @@
+package org.example.studylog.oauth2;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+
+@Slf4j
+@Component
+public class CustomFailureHandler extends SimpleUrlAuthenticationFailureHandler {
+    @Override
+    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
+        log.error("LOGIN FAILED : {}", exception.getMessage());
+        super.onAuthenticationFailure(request, response, exception);
+    }
+}
diff --git a/src/main/java/org/example/studylog/oauth2/CustomSuccessHandler.java b/src/main/java/org/example/studylog/oauth2/CustomSuccessHandler.java
new file mode 100644
index 0000000..d8b95c8
--- /dev/null
+++ b/src/main/java/org/example/studylog/oauth2/CustomSuccessHandler.java
@@ -0,0 +1,58 @@
+package org.example.studylog.oauth2;
+
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.jwt.JWTUtil;
+import org.example.studylog.service.TokenService;
+import org.example.studylog.util.CookieUtil;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Iterator;
+
+@Component
+@Slf4j
+public class CustomSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
+
+    private final JWTUtil jwtUtil;
+    private final TokenService tokenService;
+
+    public CustomSuccessHandler(JWTUtil jwtUtil, TokenService tokenService) {
+        this.jwtUtil = jwtUtil;
+        this.tokenService = tokenService;
+    }
+
+    @Override
+    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
+
+        //OAuth2User
+        CustomOAuth2User customUserDetails = (CustomOAuth2User) authentication.getPrincipal();
+
+        String oauthId = customUserDetails.getName();
+
+        Collection<? extends GrantedAuthority> authorities = authentication.getAuthorities();
+        Iterator<? extends GrantedAuthority> iterator = authorities.iterator();
+        GrantedAuthority auth = iterator.next();
+        String role = auth.getAuthority();
+
+        // 토큰 생성
+        String refresh = jwtUtil.createJwt("refresh", oauthId, role, 86400000L);
+
+        // refresh 토큰 저장
+        tokenService.addRefreshEntity(oauthId, refresh, 86400000L);
+
+        response.addCookie(CookieUtil.createCookie("refresh", refresh));
+
+        // 회원가입 화면으로 리다이렉션(임시: 프론트 로그인 완료 화면으로 변경 예정)
+        response.sendRedirect("http://localhost:8080/signup");
+
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/oauth2/ProfileCheckFilter.java b/src/main/java/org/example/studylog/oauth2/ProfileCheckFilter.java
new file mode 100644
index 0000000..429b180
--- /dev/null
+++ b/src/main/java/org/example/studylog/oauth2/ProfileCheckFilter.java
@@ -0,0 +1,52 @@
+package org.example.studylog.oauth2;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.CustomOAuth2User;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.security.authentication.AnonymousAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+@Slf4j
+public class ProfileCheckFilter extends OncePerRequestFilter {
+
+    private final UserRepository userRepository;
+
+    public ProfileCheckFilter(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
+
+        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
+
+        if(auth != null && auth.isAuthenticated() && !(auth instanceof AnonymousAuthenticationToken)){
+            String oauthId = auth.getName();
+            User user = userRepository.findByOauthId(oauthId);
+
+            // 사용자의 회원 정보 입력 유무
+            boolean isProfileCompleted = user.isProfileCompleted();
+            String requestURI = request.getRequestURI();
+            String method = request.getMethod();
+
+            // /signup, /users/profile의 PUT 요청은 허용, 그 외는 막음
+            if(!isProfileCompleted && !requestURI.startsWith("/signup")&&
+                    !(requestURI.equals("/users/profile") && method.equalsIgnoreCase("POST"))) {
+                log.info("ProfileCheckFilter로 인해 /signup으로 리다이렉션");
+                response.sendRedirect("/signup");
+                return;
+            }
+        }
+
+        filterChain.doFilter(request, response);
+    }
+}
diff --git a/src/main/java/org/example/studylog/repository/.gitkeep b/src/main/java/org/example/studylog/repository/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/repository/CategoryRepository.java b/src/main/java/org/example/studylog/repository/CategoryRepository.java
new file mode 100644
index 0000000..762cf3c
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/CategoryRepository.java
@@ -0,0 +1,20 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface CategoryRepository extends JpaRepository<Category, Long> {
+
+    // 사용자의 카테고리를 이름순으로 조회
+    List<Category> findByUserOrderByNameAsc(User user);
+
+    // 특정 ID와 사용자로 카테고리 조회 (권한 확인용)
+    Optional<Category> findByIdAndUser(Long id, User user);
+
+    // 사용자가 동일한 이름의 카테고리를 가지고 있는지 확인
+    boolean existsByNameAndUser(String name, User user);
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/repository/EmitterRepository.java b/src/main/java/org/example/studylog/repository/EmitterRepository.java
new file mode 100644
index 0000000..9cccbaa
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/EmitterRepository.java
@@ -0,0 +1,31 @@
+package org.example.studylog.repository;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Repository;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Slf4j
+@Repository
+public class EmitterRepository {
+    private Map<String, SseEmitter> emitterMap = new ConcurrentHashMap<>();
+
+    public SseEmitter save(String oauthId, SseEmitter sseEmitter){
+        emitterMap.put(oauthId, sseEmitter);
+        log.info("Saved SseEmitter for {}", sseEmitter);
+        return sseEmitter;
+    }
+
+    public SseEmitter get(String oauthId){
+        log.info("Got SseEmitter for {}", oauthId);
+        return emitterMap.get(oauthId);
+    }
+
+    public void delete(String oauthId) {
+        emitterMap.remove(oauthId);
+        log.info("Deleted SseEmitter for {}", oauthId);
+    }
+}
diff --git a/src/main/java/org/example/studylog/repository/FriendRepository.java b/src/main/java/org/example/studylog/repository/FriendRepository.java
new file mode 100644
index 0000000..1e2763f
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/FriendRepository.java
@@ -0,0 +1,17 @@
+package org.example.studylog.repository;
+
+
+import org.example.studylog.entity.Friend;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface FriendRepository extends JpaRepository<Friend, Long> {
+
+    boolean existsByUserAndFriend(User user, User friend);
+
+    Optional<Friend> findByUserAndFriend(User user, User friend);
+
+    long countByUser(User user);
+}
diff --git a/src/main/java/org/example/studylog/repository/NotificationRepository.java b/src/main/java/org/example/studylog/repository/NotificationRepository.java
new file mode 100644
index 0000000..b24f1a3
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/NotificationRepository.java
@@ -0,0 +1,13 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.notification.Notification;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface NotificationRepository extends JpaRepository<Notification, Long> {
+
+    List<Notification> findTop30ByUserOrderByCreatedAtDesc(User user);
+
+}
diff --git a/src/main/java/org/example/studylog/repository/QuizRepository.java b/src/main/java/org/example/studylog/repository/QuizRepository.java
new file mode 100644
index 0000000..4875d97
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/QuizRepository.java
@@ -0,0 +1,9 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.quiz.Quiz;
+import org.example.studylog.repository.custom.QuizRepositoryCustom;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+
+public interface QuizRepository extends JpaRepository<Quiz, Long>, QuizRepositoryCustom {
+}
diff --git a/src/main/java/org/example/studylog/repository/RefreshRepository.java b/src/main/java/org/example/studylog/repository/RefreshRepository.java
new file mode 100644
index 0000000..6544bbb
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/RefreshRepository.java
@@ -0,0 +1,13 @@
+package org.example.studylog.repository;
+
+import jakarta.transaction.Transactional;
+import org.example.studylog.entity.RefreshEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface RefreshRepository extends JpaRepository<RefreshEntity, Long> {
+
+    Boolean existsByRefresh(String refresh);
+
+    @Transactional
+    void deleteByRefresh(String refresh);
+}
diff --git a/src/main/java/org/example/studylog/repository/StreakRepository.java b/src/main/java/org/example/studylog/repository/StreakRepository.java
new file mode 100644
index 0000000..3621e95
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/StreakRepository.java
@@ -0,0 +1,13 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.Streak;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface StreakRepository extends JpaRepository<Streak, Long> {
+
+    // 사용자의 스트릭 정보 조회
+    Optional<Streak> findByUser(User user);
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/repository/StudyRecordRepository.java b/src/main/java/org/example/studylog/repository/StudyRecordRepository.java
new file mode 100644
index 0000000..e7efd47
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/StudyRecordRepository.java
@@ -0,0 +1,100 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.user.User;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Optional;
+
+public interface StudyRecordRepository extends JpaRepository<StudyRecord, Long> {
+
+    // 사용자의 기록을 최신순으로 조회
+    List<StudyRecord> findByUserOrderByCreateDateDesc(User user);
+
+    // 제목으로 기록 검색 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " +
+            "WHERE sr.user = :user AND LOWER(sr.title) LIKE LOWER(CONCAT('%', :title, '%')) " +
+            "ORDER BY sr.createDate DESC")
+    List<StudyRecord> findByUserAndTitleContainingIgnoreCaseOrderByCreateDateDesc(
+            @Param("user") User user,
+            @Param("title") String title);
+
+    // 기록 상세 조회 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " +
+            "LEFT JOIN FETCH sr.quizzes " +
+            "WHERE sr.id = :recordId")
+    Optional<StudyRecord> findByIdWithCategoryAndQuizzes(@Param("recordId") Long recordId);
+
+    // 카테고리별 기록 조회 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " +
+            "WHERE sr.user = :user AND sr.category = :category " +
+            "AND (:lastId IS NULL OR sr.id < :lastId) " +
+            "ORDER BY sr.id DESC")
+    List<StudyRecord> findByUserAndCategoryWithPagination(
+            @Param("user") User user,
+            @Param("category") Category category,
+            @Param("lastId") Long lastId,
+            Pageable pageable);
+
+    // 날짜별 기록 조회 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " +
+            "WHERE sr.user = :user " +
+            "AND DATE(sr.createDate) = :date " +
+            "AND (:lastId IS NULL OR sr.id < :lastId) " +
+            "ORDER BY sr.id DESC")
+    List<StudyRecord> findByUserAndDateWithPagination(
+            @Param("user") User user,
+            @Param("date") LocalDate date,
+            @Param("lastId") Long lastId,
+            Pageable pageable);
+
+    // 카테고리 + 날짜별 기록 조회 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " +
+            "WHERE sr.user = :user " +
+            "AND sr.category = :category " +
+            "AND DATE(sr.createDate) = :date " +
+            "AND (:lastId IS NULL OR sr.id < :lastId) " +
+            "ORDER BY sr.id DESC")
+    List<StudyRecord> findByUserAndCategoryAndDateWithPagination(
+            @Param("user") User user,
+            @Param("category") Category category,
+            @Param("date") LocalDate date,
+            @Param("lastId") Long lastId,
+            Pageable pageable);
+
+    // 전체 기록 조회 (N+1 방지: JOIN FETCH 적용)
+    @Query("SELECT sr FROM StudyRecord sr " +
+            "LEFT JOIN FETCH sr.category " + // ← N+1 방지
+            "WHERE sr.user = :user " +
+            "AND (:lastId IS NULL OR sr.id < :lastId) " + // ← 무한 스크롤
+            "ORDER BY sr.id DESC")
+    List<StudyRecord> findByUserWithPagination(
+            @Param("user") User user,
+            @Param("lastId") Long lastId,
+            Pageable pageable);
+
+    // 특정 날짜에 사용자가 작성한 기록 개수 조회 (스트릭 계산용)
+    @Query("SELECT COUNT(sr) FROM StudyRecord sr WHERE sr.user = :user AND DATE(sr.createDate) = :date")
+    Long countByUserAndCreateDateDate(@Param("user") User user, @Param("date") LocalDate date);
+
+    // 특정 날짜에 사용자가 작성한 기록들 조회
+    @Query("SELECT sr FROM StudyRecord sr WHERE sr.user = :user AND DATE(sr.createDate) = :date")
+    List<StudyRecord> findByUserAndCreateDateDate(@Param("user") User user, @Param("date") LocalDate date);
+
+    // ✅ 새로 추가: 카테고리별 기록 개수 조회 (N+1 쿼리 해결용)
+    @Query("SELECT sr.category.id, COUNT(sr) FROM StudyRecord sr " +
+            "WHERE sr.user = :user " +
+            "GROUP BY sr.category.id")
+    List<Object[]> findCategoryCountsByUser(@Param("user") User user);
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/repository/UserRepository.java b/src/main/java/org/example/studylog/repository/UserRepository.java
new file mode 100644
index 0000000..1caa53b
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/UserRepository.java
@@ -0,0 +1,17 @@
+package org.example.studylog.repository;
+
+import org.example.studylog.entity.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface UserRepository extends JpaRepository<User, Long> {
+
+    User findByOauthId(String oauthId);
+
+    boolean existsByCode(String code);
+
+    Optional<User> findByCode(String code);
+
+    Optional<User> findById(Long id);
+}
diff --git a/src/main/java/org/example/studylog/repository/custom/FriendRepositoryCustom.java b/src/main/java/org/example/studylog/repository/custom/FriendRepositoryCustom.java
new file mode 100644
index 0000000..a794b7f
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/custom/FriendRepositoryCustom.java
@@ -0,0 +1,11 @@
+package org.example.studylog.repository.custom;
+
+import org.example.studylog.dto.friend.FriendResponseDTO;
+import org.example.studylog.entity.user.User;
+
+import java.util.List;
+
+public interface FriendRepositoryCustom {
+    List<FriendResponseDTO> findFriendListByUser(User user);
+    List<FriendResponseDTO> findFriendListByNickname(User user, String query);
+}
diff --git a/src/main/java/org/example/studylog/repository/custom/FriendRepositoryImpl.java b/src/main/java/org/example/studylog/repository/custom/FriendRepositoryImpl.java
new file mode 100644
index 0000000..4f39b5d
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/custom/FriendRepositoryImpl.java
@@ -0,0 +1,50 @@
+package org.example.studylog.repository.custom;
+
+import com.querydsl.core.types.Projections;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.dto.friend.FriendResponseDTO;
+import org.example.studylog.entity.QFriend;
+import org.example.studylog.entity.user.QUser;
+import org.example.studylog.entity.user.User;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+@RequiredArgsConstructor
+public class FriendRepositoryImpl implements FriendRepositoryCustom{
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<FriendResponseDTO> findFriendListByUser(User user) {
+        QFriend friend = QFriend.friend1;
+
+        return queryFactory
+                .select(Projections.constructor(FriendResponseDTO.class,
+                        friend.friend.id,
+                        friend.friend.nickname,
+                        friend.friend.profileImage,
+                        friend.friend.code))
+                .from(friend)
+                .where(friend.user.eq(user))
+                .fetch();
+    }
+
+    @Override
+    public List<FriendResponseDTO> findFriendListByNickname(User user, String query) {
+        QFriend friend = QFriend.friend1;
+
+        return queryFactory
+                .select(Projections.constructor(FriendResponseDTO.class,
+                        friend.friend.id,
+                        friend.friend.nickname,
+                        friend.friend.profileImage,
+                        friend.friend.code))
+                .from(friend)
+                .where(friend.user.eq(user),
+                        friend.friend.nickname.containsIgnoreCase(query))
+                .fetch();
+    }
+}
diff --git a/src/main/java/org/example/studylog/repository/custom/QuizRepositoryCustom.java b/src/main/java/org/example/studylog/repository/custom/QuizRepositoryCustom.java
new file mode 100644
index 0000000..499f7d5
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/custom/QuizRepositoryCustom.java
@@ -0,0 +1,10 @@
+package org.example.studylog.repository.custom;
+
+import org.example.studylog.entity.quiz.Quiz;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public interface QuizRepositoryCustom {
+    List<Quiz> findQuizzes(Long userId, Long lastId, int size, LocalDate date, Long categoryId, String query);
+}
diff --git a/src/main/java/org/example/studylog/repository/custom/QuizRepositoryImpl.java b/src/main/java/org/example/studylog/repository/custom/QuizRepositoryImpl.java
new file mode 100644
index 0000000..f033eca
--- /dev/null
+++ b/src/main/java/org/example/studylog/repository/custom/QuizRepositoryImpl.java
@@ -0,0 +1,54 @@
+package org.example.studylog.repository.custom;
+
+import com.querydsl.core.BooleanBuilder;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.entity.category.QCategory;
+import org.example.studylog.entity.quiz.QQuiz;
+import org.example.studylog.entity.quiz.Quiz;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@RequiredArgsConstructor
+public class QuizRepositoryImpl implements QuizRepositoryCustom {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<Quiz> findQuizzes(Long userId, Long lastId, int size, LocalDate date, Long categoryId, String query) {
+
+        QQuiz quiz = QQuiz.quiz;
+
+        BooleanBuilder builder = new BooleanBuilder();
+        builder.and(quiz.user.id.eq(userId));
+
+        if (lastId != null){
+            builder.and(quiz.id.lt(lastId));
+        }
+
+        if (date != null){
+            builder.and(quiz.createdAt.between(
+                    date.atStartOfDay(),
+                    date.plusDays(1).atStartOfDay()
+            ));
+        }
+
+        if (categoryId != null){
+            builder.and(quiz.category.id.eq(categoryId));
+        }
+
+        if (query != null && !query.isBlank()) {
+            builder.and(
+                    quiz.question.containsIgnoreCase(query));
+        }
+
+        return queryFactory.selectFrom(quiz)
+                .join(quiz.category, QCategory.category).fetchJoin()
+                .where(builder)
+                .orderBy(quiz.id.desc())
+                .limit(size)
+                .fetch();
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/service/.gitkeep b/src/main/java/org/example/studylog/service/.gitkeep
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/org/example/studylog/service/AwsS3Service.java b/src/main/java/org/example/studylog/service/AwsS3Service.java
new file mode 100644
index 0000000..7c18a71
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/AwsS3Service.java
@@ -0,0 +1,77 @@
+package org.example.studylog.service;
+
+import io.awspring.cloud.s3.ObjectMetadata;
+import io.awspring.cloud.s3.S3Resource;
+import io.awspring.cloud.s3.S3Template;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.entity.user.User;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.InputStream;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class AwsS3Service {
+
+    @Value("${spring.cloud.aws.s3.bucket}")
+    private String bucket;
+    private final S3Template s3Template;
+
+    public String uploadProfileImage(MultipartFile file, User user){
+        // 프로필 업데이트한 유저면 프로필 이미지 URL에서 객체 키값 추출 후 삭제
+        if(user.isProfileCompleted()){
+            deleteFileByKey(user.getProfileImage());
+        }
+
+        return uploadToS3(file);
+    }
+
+    public String uploadBackImage(MultipartFile file, User user){
+        // user의 backImage가 null이 아니면 버킷에 있는 기존 이미지 삭제
+        if(user.getBackImage() != null){
+            deleteFileByKey(user.getBackImage());
+        }
+
+        return uploadToS3(file);
+    }
+
+    private String uploadToS3(MultipartFile file){
+        try (InputStream stream = file.getInputStream()){
+            // 파일 이름 고유하게 하기 위해 UUID 사용
+            String fileName = UUID.randomUUID() + "-" + file.getOriginalFilename();
+
+            // 파일의 부가 정보 담는 객체 (파일 타입)
+            ObjectMetadata metadata = ObjectMetadata.builder().contentType(file.getContentType()).build();
+
+            // 이미지 업로드
+            S3Resource s3resource = s3Template.upload(bucket, fileName, stream, metadata);
+
+            return String.valueOf(s3resource.getURL());
+
+        } catch (Exception e){
+            throw new RuntimeException("S3 업로드 실패", e);
+        }
+    }
+
+    public void deleteFileByKey(String fileUrl){
+        if(fileUrl == null || fileUrl.isEmpty()) return;
+        String key = getObjectKey(fileUrl);
+        s3Template.deleteObject(bucket, key);
+    }
+
+    public String getObjectKey(String URL){
+        // URL 에서 객체 키값 추출
+        String bucketUrl = "https://study-log-1.s3.ap-northeast-2.amazonaws.com/";
+        String fileKey = URLDecoder.decode(URL.replace(bucketUrl, ""), StandardCharsets.UTF_8);
+        return fileKey;
+    }
+
+}
diff --git a/src/main/java/org/example/studylog/service/CategoryService.java b/src/main/java/org/example/studylog/service/CategoryService.java
new file mode 100644
index 0000000..35262c6
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/CategoryService.java
@@ -0,0 +1,93 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.category.CreateCategoryRequestDTO;
+import org.example.studylog.dto.category.UpdateCategoryRequestDTO;
+import org.example.studylog.dto.category.CategoryResponseDTO;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.CategoryRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class CategoryService {
+
+    private final CategoryRepository categoryRepository;
+
+    @Transactional
+    public CategoryResponseDTO createCategory(User user, CreateCategoryRequestDTO requestDTO) {
+        log.info("사용자 {}의 카테고리 생성 시작: {}", user.getOauthId(), requestDTO.getName());
+
+        // 중복 이름 확인
+        if (categoryRepository.existsByNameAndUser(requestDTO.getName(), user)) {
+            throw new IllegalArgumentException("이미 존재하는 카테고리 이름입니다");
+        }
+
+        // 카테고리 생성
+        Category category = Category.builder()
+                .user(user)
+                .name(requestDTO.getName())
+                .color(requestDTO.getColor())
+                .build();
+
+        Category savedCategory = categoryRepository.save(category);
+        log.info("카테고리 생성 완료: ID={}, 이름={}", savedCategory.getId(), savedCategory.getName());
+
+        return convertToCategoryResponseDTO(savedCategory);
+    }
+
+    @Transactional
+    public CategoryResponseDTO updateCategory(User user, Long categoryId, UpdateCategoryRequestDTO requestDTO) {
+        log.info("사용자 {}의 카테고리 수정 시작: categoryId={}, 새이름={}",
+                user.getOauthId(), categoryId, requestDTO.getName());
+
+        // 카테고리 조회 및 권한 확인
+        Category category = categoryRepository.findByIdAndUser(categoryId, user)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 카테고리이거나 수정 권한이 없습니다"));
+
+        // 이름이 변경되는 경우에만 중복 체크
+        if (!category.getName().equals(requestDTO.getName())) {
+            if (categoryRepository.existsByNameAndUser(requestDTO.getName(), user)) {
+                throw new IllegalArgumentException("이미 존재하는 카테고리 이름입니다");
+            }
+        }
+
+        // 카테고리 수정
+        category.setName(requestDTO.getName());
+        category.setColor(requestDTO.getColor());
+
+        Category updatedCategory = categoryRepository.save(category);
+        log.info("카테고리 수정 완료: ID={}, 새이름={}", updatedCategory.getId(), updatedCategory.getName());
+
+        return convertToCategoryResponseDTO(updatedCategory);
+    }
+
+    @Transactional(readOnly = true)
+    public List<CategoryResponseDTO> getUserCategories(User user) {
+        log.info("사용자 {}의 카테고리 목록 조회", user.getOauthId());
+
+        List<Category> categories = categoryRepository.findByUserOrderByNameAsc(user);
+
+        return categories.stream()
+                .map(this::convertToCategoryResponseDTO)
+                .collect(Collectors.toList());
+    }
+
+    private CategoryResponseDTO convertToCategoryResponseDTO(Category category) {
+        // Color enum을 소문자로 변환
+        String colorValue = category.getColor().name().toLowerCase();
+
+        return CategoryResponseDTO.builder()
+                .id(category.getId())
+                .name(category.getName())
+                .color(colorValue)
+                .build();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/service/FriendService.java b/src/main/java/org/example/studylog/service/FriendService.java
new file mode 100644
index 0000000..3bce6ad
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/FriendService.java
@@ -0,0 +1,127 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.dto.notification.NotificationDTO;
+import org.example.studylog.dto.friend.FriendNameDTO;
+import org.example.studylog.dto.friend.FriendRequestDTO;
+import org.example.studylog.dto.friend.FriendResponseDTO;
+import org.example.studylog.entity.Friend;
+import org.example.studylog.entity.notification.NotificationType;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.BusinessException;
+import org.example.studylog.exception.ErrorCode;
+import org.example.studylog.repository.FriendRepository;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.repository.custom.FriendRepositoryImpl;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class FriendService {
+
+    private final UserRepository userRepository;
+    private final FriendRepository friendRepository;
+    private final FriendRepositoryImpl friendRepositoryImpl;
+    private final NotificationService notificationService;
+
+    @Transactional(readOnly = true)
+    public FriendNameDTO findUserByCode(String oauthId, String code) {
+        // 코드로 사용자 조회
+        User findUser = userRepository.findByCode(code)
+                .orElseThrow(() -> new BusinessException(ErrorCode.USER_CODE_NOT_FOUND));
+
+        if(findUser.getOauthId().equals(oauthId)){
+            throw new BusinessException(ErrorCode.SELF_LOOKUP_NOT_ALLOWED);
+        }
+
+        return FriendNameDTO.builder()
+                .nickname(findUser.getNickname())
+                .build();
+    }
+
+    @Transactional(readOnly = true)
+    public List<FriendResponseDTO> getFriendList(String oauthId) {
+        // 로그인한 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        return friendRepositoryImpl.findFriendListByUser(user);
+    }
+
+    @Transactional(readOnly = true)
+    public List<FriendResponseDTO> getFriendByQuery(String oauthId, String query) {
+        // 로그인한 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        return friendRepositoryImpl.findFriendListByNickname(user, query);
+    }
+
+    @Transactional
+    public void addFriend(FriendRequestDTO request, String oauthId) {
+        // 로그인한 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+        // 친구할 유저 찾기
+        User friend = userRepository.findByCode(request.getCode())
+                .orElseThrow(() -> new BusinessException(ErrorCode.USER_CODE_NOT_FOUND));
+
+        // 이미 친구인지 확인
+        boolean alreadyAdded = friendRepository.existsByUserAndFriend(user, friend);
+        if(alreadyAdded){
+            throw new BusinessException(ErrorCode.ALREADY_FRIEND);
+        }
+
+        // 단방향 관계 2개 설정 (양방향)
+        Friend toFriend = Friend.builder()
+                .user(user)
+                .friend(friend)
+                .build();
+        Friend fromFriend = Friend.builder()
+                .user(friend)
+                .friend(user)
+                .build();
+
+        friendRepository.save(toFriend);
+        friendRepository.save(fromFriend);
+
+        // 상대에게 친구 추가 알림 보내기
+        notificationService.sendToClient(friend.getOauthId(),
+                NotificationDTO.builder()
+                        .content(user.getNickname() + "님이 친구 추가를 하셨습니다.")
+                        .type(NotificationType.ADD_FRIEND)
+                        .build());
+    }
+
+    @Transactional
+    public FriendResponseDTO deleteFriend(String oauthId, Long friendId) {
+        // 로그인한 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+        // 삭제할 친구 찾기
+        User friend = userRepository.findById(friendId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.FRIEND_NOT_FOUND));
+
+        // 친구 관계가 맞는지 확인
+        boolean alreadyAdded = friendRepository.existsByUserAndFriend(user, friend);
+        if(!alreadyAdded){
+            throw new BusinessException(ErrorCode.NOT_FRIEND);
+        }
+
+        Friend toFriend = friendRepository.findByUserAndFriend(user, friend)
+                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FRIEND));
+        Friend fromFriend = friendRepository.findByUserAndFriend(friend, user)
+                .orElseThrow(() -> new BusinessException(ErrorCode.NOT_FRIEND));
+
+        friendRepository.delete(toFriend);
+        friendRepository.delete(fromFriend);
+
+        // 상대에게 친구 삭제 알림 보내기
+        notificationService.sendToClient(friend.getOauthId(),
+                NotificationDTO.builder()
+                        .content(user.getNickname() + "님이 친구 삭제를 하셨습니다.")
+                        .type(NotificationType.DELETE_FRIEND)
+                        .build());
+
+        return new FriendResponseDTO(friend.getId(), friend.getNickname(), friend.getProfileImage(), friend.getCode());
+    }
+}
diff --git a/src/main/java/org/example/studylog/service/MainService.java b/src/main/java/org/example/studylog/service/MainService.java
new file mode 100644
index 0000000..f56cf61
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/MainService.java
@@ -0,0 +1,196 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.MainPageResponseDTO;
+import org.example.studylog.dto.friend.FriendResponseDTO;
+import org.example.studylog.entity.Streak;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.CategoryRepository;
+import org.example.studylog.repository.StreakRepository;
+import org.example.studylog.repository.StudyRecordRepository;
+import org.example.studylog.repository.FriendRepository;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.repository.custom.FriendRepositoryImpl;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class MainService {
+
+    private final FriendRepositoryImpl friendRepositoryImpl;
+    private final FriendRepository friendRepository;
+    private final StudyRecordRepository studyRecordRepository;
+    private final StreakRepository streakRepository;
+    private final CategoryRepository categoryRepository;
+    private final UserRepository userRepository;
+
+    @Transactional(readOnly = true)
+    public MainPageResponseDTO getMainPageData(User user) {
+        log.info("메인 페이지 데이터 조회 시작: 사용자={}", user.getOauthId());
+
+        // 1. 친구 목록 조회
+        List<FriendResponseDTO> following = friendRepositoryImpl.findFriendListByUser(user);
+
+        // 2. 프로필 정보 생성
+        MainPageResponseDTO.ProfileDTO profile = MainPageResponseDTO.ProfileDTO.builder()
+                .userId(user.getId())
+                .coverImage(user.getBackImage())  // null이면 null 반환
+                .profileImage(user.getProfileImage())
+                .name(user.getNickname())
+                .intro(user.getIntro())
+                .level(user.getLevel())
+                .code(user.getCode())
+                .build();
+
+        // 3. 스트릭 정보 생성 (현재 월 데이터 활용)
+        Map<String, Integer> recordCountPerDay = getCurrentStreakData(user);
+        Integer maxStreak = getMaxStreak(user);
+        MainPageResponseDTO.StreakDTO streak = MainPageResponseDTO.StreakDTO.builder()
+                .maxStreak(maxStreak)
+                .recordCountPerDay(recordCountPerDay)
+                .build();
+
+        // 4. 카테고리별 기록 수 조회 (실제 데이터)
+        List<MainPageResponseDTO.CategoryCountDTO> categories = getCategoryCountData(user);
+
+        MainPageResponseDTO response = MainPageResponseDTO.builder()
+                .following(following)
+                .profile(profile)
+                .streak(streak)
+                .categories(categories)
+                .isFollowing(null)  // 본인 페이지는 null
+                .build();
+
+        log.info("메인 페이지 데이터 조회 완료: 친구수={}, 카테고리수={}",
+                following.size(), categories.size());
+
+        return response;
+    }
+
+    private Map<String, Integer> getCurrentStreakData(User user) {
+        Map<String, Integer> streakData = new HashMap<>();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+        // 현재 월의 모든 날짜에 대해 기록 수 조회
+        LocalDate today = LocalDate.now();
+        YearMonth currentMonth = YearMonth.from(today);
+        int daysInMonth = currentMonth.lengthOfMonth();
+
+        for (int day = 1; day <= daysInMonth; day++) {
+            LocalDate date = LocalDate.of(currentMonth.getYear(), currentMonth.getMonth(), day);
+            Long recordCount = studyRecordRepository.countByUserAndCreateDateDate(user, date);
+
+            if (recordCount > 0) {
+                streakData.put(date.format(formatter), recordCount.intValue());
+            }
+        }
+
+        return streakData;
+    }
+
+    private Integer getMaxStreak(User user) {
+        return streakRepository.findByUser(user)
+                .map(Streak::getMaxStreak)
+                .orElse(0);
+    }
+
+    private List<MainPageResponseDTO.CategoryCountDTO> getCategoryCountData(User user) {
+        // N+1 쿼리 해결: 한 번의 쿼리로 카테고리별 기록 수 조회
+        List<Object[]> categoryCountResults = studyRecordRepository.findCategoryCountsByUser(user);
+
+        Map<Long, Integer> categoryCountMap = categoryCountResults.stream()
+                .collect(Collectors.toMap(
+                        result -> (Long) result[0],     // categoryId
+                        result -> ((Long) result[1]).intValue()  // count
+                ));
+
+        // 카테고리 정보 조회
+        List<Category> categories = categoryRepository.findByUserOrderByNameAsc(user);
+
+        return categories.stream()
+                .map(category -> MainPageResponseDTO.CategoryCountDTO.builder()
+                        .name(category.getName())
+                        .count(categoryCountMap.getOrDefault(category.getId(), 0))
+                        .build())
+                .sorted((a, b) -> b.getCount().compareTo(a.getCount()))  // count 기준 내림차순 정렬
+                .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public MainPageResponseDTO getMainPageDataWithFollowStatus(User targetUser, User currentUser) {
+        log.info("메인 페이지 데이터 조회 (팔로우 확인): 대상={}, 현재 사용자={}", 
+                targetUser.getOauthId(), currentUser != null ? currentUser.getOauthId() : "guest");
+
+        // 기존 메인 페이지 데이터 조회
+        List<FriendResponseDTO> following = friendRepositoryImpl.findFriendListByUser(targetUser);
+        
+        MainPageResponseDTO.ProfileDTO profile = MainPageResponseDTO.ProfileDTO.builder()
+                .userId(targetUser.getId())
+                .coverImage(targetUser.getBackImage())  // null이면 null 반환
+                .profileImage(targetUser.getProfileImage())
+                .name(targetUser.getNickname())
+                .intro(targetUser.getIntro())
+                .level(targetUser.getLevel())
+                .code(targetUser.getCode())
+                .build();
+        
+        Map<String, Integer> recordCountPerDay = getCurrentStreakData(targetUser);
+        Integer maxStreak = getMaxStreak(targetUser);
+        MainPageResponseDTO.StreakDTO streak = MainPageResponseDTO.StreakDTO.builder()
+                .maxStreak(maxStreak)
+                .recordCountPerDay(recordCountPerDay)
+                .build();
+        
+        List<MainPageResponseDTO.CategoryCountDTO> categories = getCategoryCountData(targetUser);
+        
+        // 팔로우 여부 확인
+        Boolean isFollowing = null;
+        if (currentUser != null && !currentUser.getId().equals(targetUser.getId())) {
+            isFollowing = friendRepository.existsByUserAndFriend(currentUser, targetUser);
+        }
+        
+        MainPageResponseDTO response = MainPageResponseDTO.builder()
+                .following(following)
+                .profile(profile)
+                .streak(streak)
+                .categories(categories)
+                .isFollowing(isFollowing)
+                .build();
+
+        log.info("메인 페이지 데이터 조회 완료: 친구수={}, 카테고리수={}, 팔로우여부={}",
+                following.size(), categories.size(), isFollowing);
+
+        return response;
+    }
+
+    @Transactional(readOnly = true)
+    public MainPageResponseDTO getMainPageDataByCode(String code) {
+        log.info("코드로 메인 페이지 데이터 조회 시작: code={}", code);
+
+        // code로 사용자 조회
+        User user = userRepository.findByCode(code)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 사용자 코드입니다."));
+
+        log.info("코드로 사용자 조회 완료: code={}, 사용자={}", code, user.getOauthId());
+
+        // 기존 getMainPageData 메서드 로직 재사용
+        MainPageResponseDTO response = getMainPageData(user);
+
+        log.info("코드로 메인 페이지 데이터 조회 완료: code={}, 친구수={}, 카테고리수={}",
+                code, response.getFollowing().size(), response.getCategories().size());
+
+        return response;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/service/NotificationService.java b/src/main/java/org/example/studylog/service/NotificationService.java
new file mode 100644
index 0000000..63a4e8b
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/NotificationService.java
@@ -0,0 +1,106 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.dto.notification.NotificationDTO;
+import org.example.studylog.dto.notification.NotificationListResponseDTO;
+import org.example.studylog.dto.notification.NotificationResponseDTO;
+import org.example.studylog.entity.notification.Notification;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.BusinessException;
+import org.example.studylog.exception.ErrorCode;
+import org.example.studylog.repository.EmitterRepository;
+import org.example.studylog.repository.NotificationRepository;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.util.TimeUtil;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.stream.Collectors;
+
+
+@Service
+@RequiredArgsConstructor
+public class NotificationService {
+    private final static Long DEFAULT_TIMEOUT = 60 * 60 * 1000L;
+    private final static String NOTIFICATION_NAME = "notification";
+
+    private final EmitterRepository emitterRepository;
+    private final UserRepository userRepository;
+    private final NotificationRepository notificationRepository;
+
+    public SseEmitter createEmitter(String oauthId) {
+        // (구독 요청이 들어오면) 새로운 SseEmitter 객체를 만든다.
+        SseEmitter emitter = new SseEmitter(DEFAULT_TIMEOUT);
+
+        // oauthId로 SseEmitter를 저장한다.
+        emitterRepository.save(oauthId, emitter);
+
+        emitter.onCompletion(() -> emitterRepository.delete(oauthId));
+        emitter.onTimeout(() -> emitterRepository.delete(oauthId));
+        emitter.onError((e) -> emitterRepository.delete(oauthId));
+
+        // 첫 연결 시 응답 더미 데이터 (503 에러 방지)
+        try {
+            emitter.send(SseEmitter.event().id("").name(NOTIFICATION_NAME).data("Connection completed"));
+        } catch (IOException e) {
+            throw new BusinessException(ErrorCode.NOTIFICATION_CONNECTION_ERROR);
+        }
+
+        return emitter;
+    }
+
+    // 클라이언트로 알림 보내기
+    @Transactional
+    public void sendToClient(String oauthId, NotificationDTO dto) {
+        // 알림을 DB에 저장하기
+        User user = userRepository.findByOauthId(oauthId);
+        Notification notification = Notification.builder()
+                .user(user)
+                .type(dto.getType())
+                .content(dto.getContent())
+                .build();
+        notificationRepository.save(notification);
+
+        // 알림 보낼 대상의 SSE 객체가 있다면 알림 전송
+        SseEmitter emitter = emitterRepository.get(oauthId);
+        if(emitter != null){
+            try {
+                NotificationResponseDTO resDTO = NotificationResponseDTO.builder()
+                                .type(dto.getType().getLabel())
+                                .content(dto.getContent()).build();
+                emitter.send(SseEmitter.event()
+                        .name(NOTIFICATION_NAME)
+                        .data(resDTO));
+            } catch (IOException e){
+                // IOException 발생하면 저장된 emitter를 삭제
+                emitter.completeWithError(e);
+                emitterRepository.delete(oauthId);
+            }
+        }
+    }
+
+    @Transactional
+    public List<NotificationListResponseDTO> getNotificationList(String oauthId, boolean isRead) {
+        User user = userRepository.findByOauthId(oauthId);
+        List<Notification> notifications = notificationRepository.findTop30ByUserOrderByCreatedAtDesc(user);
+
+        List<NotificationListResponseDTO> list = notifications.stream()
+                .map(NotificationListResponseDTO::from)
+                .collect(Collectors.toList());
+
+        // isRead가 true이면 읽음 처리
+        if (isRead) {
+            notifications.stream()
+                    .filter(n -> !n.isRead()) // 아직 읽지 않은 것만
+                    .forEach(n -> n.setRead(true));
+        }
+
+        // DTO 변환 후 반환
+        return notifications.stream()
+                .map(NotificationListResponseDTO::from)
+                .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/org/example/studylog/service/QuizService.java b/src/main/java/org/example/studylog/service/QuizService.java
new file mode 100644
index 0000000..b27f979
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/QuizService.java
@@ -0,0 +1,211 @@
+package org.example.studylog.service;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import lombok.RequiredArgsConstructor;
+import org.example.studylog.client.ChatGptClient;
+import org.example.studylog.dto.CategoryDTO;
+import org.example.studylog.dto.quiz.CreateQuizRequestDTO;
+import org.example.studylog.dto.quiz.QuizListResponseDTO;
+import org.example.studylog.dto.quiz.QuizResponseDTO;
+import org.example.studylog.dto.quiz.QuizSummaryDTO;
+import org.example.studylog.dto.quiz.chatGPT.ChatGptRequest;
+import org.example.studylog.dto.quiz.chatGPT.ChatGptResponse;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.quiz.Quiz;
+import org.example.studylog.entity.quiz.QuizLevel;
+import org.example.studylog.entity.quiz.QuizType;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.BusinessException;
+import org.example.studylog.exception.ErrorCode;
+import org.example.studylog.repository.CategoryRepository;
+import org.example.studylog.repository.QuizRepository;
+import org.example.studylog.repository.StudyRecordRepository;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+public class QuizService {
+
+    private final StudyRecordRepository studyRecordRepository;
+    private final UserRepository userRepository;
+    private final QuizRepository quizRepository;
+    private final CategoryRepository categoryRepository;
+
+    private final ChatGptClient chatGptClient;
+    private final ObjectMapper objectMapper;
+
+    @Transactional
+    public List<QuizResponseDTO> createQuiz(String oauthId, Long recordId, CreateQuizRequestDTO requestDTO) {
+        // 유저 조회
+        User user = userRepository.findByOauthId(oauthId);
+
+        // 퀴즈를 만들 기록 조회
+        StudyRecord studyRecord = studyRecordRepository.findById(recordId)
+                .orElseThrow(() -> new BusinessException(ErrorCode.STUDY_RECORD_NOT_FOUND));
+        // 이미 퀴즈가 있는 기록이면 에러 반환
+//        if(studyRecord.isQuizCreated())
+//            throw new BusinessException(ErrorCode.QUIZ_ALREADY_EXISTS);
+        if (Boolean.TRUE.equals(studyRecord.isQuizCreated())) {
+            throw new BusinessException(ErrorCode.QUIZ_ALREADY_EXISTS);
+        }
+
+        // 기록에 대한 카테고리 조회 (추후 데이터 반환 시 필요함)
+        Category category = studyRecord.getCategory();
+
+        // 프롬프트 생성
+        String prompt = buildPrompt(requestDTO, studyRecord.getContent());
+
+        // GPT에게 보낼 요청 생성
+        ChatGptRequest request = new ChatGptRequest(
+                "gpt-3.5-turbo",
+                List.of(new ChatGptRequest.Message("user", prompt)),
+                0.7
+        );
+
+        // GPT에게 요청 보내고 응답 받기
+        ChatGptResponse response = chatGptClient.getChatCompletions(request);
+        String json = response.getChoices().get(0).getMessage().getContent();
+
+        // 응답 받은 문자열을 키-값 쌍으로 파싱
+        List<Map<String, String>> quizList;
+        try {
+            quizList = objectMapper.readValue(json, new TypeReference<>() {});
+        } catch (Exception e) {
+            throw new RuntimeException("퀴즈 파싱 실패: " + json, e);
+        }
+
+        // 퀴즈 목록을 DB에 저장
+        List<Quiz> quizzes = quizList.stream().map(map -> {
+            Quiz q = new Quiz();
+            q.setQuestion(map.get("question"));
+            q.setAnswer(map.get("answer"));
+            q.setLevel(QuizLevel.fromLabel(map.get("level")));
+            q.setType(QuizType.valueOf(map.get("type")));
+            q.setCreatedAt(studyRecord.getCreateDate());
+            q.setRecord(studyRecord);
+            q.setUser(user);
+            q.setCategory(studyRecord.getCategory());
+            return q;
+        }).toList();
+
+        quizRepository.saveAll(quizzes);
+
+        // 퀴즈 생성되었으니 '기록'의 isQuizCreated를 true로 설정
+        studyRecord.setQuizCreated(true);
+
+        // 응답 데이터 생성
+        List<QuizResponseDTO> quizResponseList = quizzes.stream().map(map -> {
+            QuizResponseDTO dto = QuizResponseDTO.from(map, category);
+            return dto;
+        }).toList();
+
+        return quizResponseList;
+    }
+
+    private String buildPrompt(CreateQuizRequestDTO dto, String content){
+        return String.format("""
+                        너는 퀴즈 생성 도우미야. 아래 내용을 바탕으로 퀴즈를 만들어줘.
+                                        
+                        생성 조건
+                        - 주제: %s
+                        - 난이도: %s
+                        - 개수: %d개
+                        - 문제 유형: OX 또는 단답형 중에서 무작위로 섞어서 생성해줘.
+                        %s
+                                        
+                        참고사항은 문제 유형보다 **우선되는 강력한 조건**이야. 예를 들어 "단답형으로만 생성"이라는 참고사항이 있다면, 문제 유형은 무조건 단답형이여야 해.
+                                        
+                        출력 형식은 JSON 배열로 다음 구조를 따라줘. `type`은 반드시 대문자로 작성해.
+                                        
+                        📌 난이도별 문제 생성 기준 (매우 중요 — 반드시 따를 것):
+                           - 하: 기초 정의, 용어 설명, 개념 암기 문제 (ex. "~이란?", "~의 정의는?")
+                           - 중: 개념 응용, 사례 분석, 실제 사용 예를 묻는 문제 (ex. "~을 언제 사용하나요?", "예시 중 올바른 것을 고르세요")
+                           - 상: 비교, 한계, 내부 동작 원리, 예외 상황 등 심화 개념을 묻는 문제 (ex. "~와 ~의 차이는?", "왜 ~한가요?", "다음 중 틀린 설명은?")
+                                
+                           → 난이도에 따라 문제의 **내용 자체가 달라야 하며**, 단순히 문장 표현만 다르게 만들면 안 된다.
+                           → 난이도가 높을수록 더 깊은 이해가 필요한 질문이 되도록 구성하라.
+                           → 동일한 내용을 표현만 다르게 반복하지 마. 각 난이도별로 주제의 다른 측면을 다뤄야 해.
+                        [
+                          {
+                            "question": "...",
+                            "answer": "...",
+                            "type": "OX" 또는 "SHORT_ANSWER",
+                            "level": 내가 제시한 난이도 그대로
+                          }
+                        ]
+                                        
+                        반드시 지켜야 할 작성 규칙
+                        - question에는 절대 문제 유형(O/X 등)을 포함하지 마. 단순한 문제 내용만 적어.
+                          ❌ 예: "다음 설명이 맞으면 O, 틀리면 X를 고르시오."
+                          ❌ 예: "스프링 빈은 ~이다. (O/X)"
+                          ✅ 예: "스프링 빈이란?"
+                        - answer에는 정확한 정답을 적어. OX의 경우 "O" 또는 "X"로, 단답형은 문장이나 단어로 답변해.
+                        - level은 내가 준 난이도를 그대로 넣어 (예: "하", "중", "상").
+                        - SHORT_ANSWER 유형의 answer는 반드시 20자 이내로 작성해야 해. (한 줄 요약 형태)
+                          예: "빈은 스프링이 관리하는 객체"
+                          ❌ 예: "XML 설정 파일, 자바 기반 설정 클래스..."
+                        - 단답형은 '무엇인가요?', '이유는?', '용도는?' 등 간결한 질문으로 구성해.
+                        - "나열해보세요", "설명하세요", "작성해보세요" 같은 표현은 사용하지 마. (긴 답변 유도 금지)
+                                        
+                        출력은 JSON 배열로만 응답해. 설명이나 여는 말 없이 JSON만 반환해줘.
+                """,
+                content,
+                dto.getLevel().getLabel(),
+                dto.getQuizCount(),
+                dto.getRequirement() != null ? "- 참고사항: " + dto.getRequirement() : ""
+        );
+    }
+
+    @Transactional(readOnly = true)
+    public QuizResponseDTO getQuiz(String oauthId, Long quizId) {
+        // 유저 조회
+        User user = userRepository.findByOauthId(oauthId);
+
+        // 퀴즈 조회
+        Quiz quiz = quizRepository.findById(quizId)
+                .orElseThrow(() -> new IllegalArgumentException("퀴즈가 존재하지 않습니다."));
+
+        // 해당 퀴즈가 로그인한 사용자의 것인지 확인
+        if(user != quiz.getUser())
+            throw new IllegalArgumentException("현재 유저의 퀴즈가 아닙니다.");
+
+        // 퀴즈의 카테고리 가져오기
+        Category category = quiz.getCategory();
+
+        // 응답 데이터 생성
+        QuizResponseDTO dto = QuizResponseDTO.from(quiz, category);
+
+        return dto;
+    }
+
+    @Transactional(readOnly = true)
+    public QuizListResponseDTO getQuizList(String oauthId, String query, Long lastId, int size, LocalDate date, Long categoryId) {
+        // 로그인한 유저 조회
+        User user = userRepository.findByOauthId(oauthId);
+
+        // 조건에 맞는 퀴즈 목록 조회
+        List<Quiz> quizzes = quizRepository.findQuizzes(user.getId(), lastId, size + 1, date, categoryId, query);
+
+        // 유저의 카테고리 조회
+        List<Category> categories = categoryRepository.findByUserOrderByNameAsc(user);
+
+        // 다음 데이터 존재 여부
+        boolean hasNext = quizzes.size() > size;
+        if (hasNext) quizzes.remove(size);   // 커서 확인용으로만 사용한 마지막 1개 제거
+
+        return QuizListResponseDTO.builder()
+                .categories(categories.stream().map(CategoryDTO::from).toList())
+                .quizzes(quizzes.stream().map(QuizSummaryDTO::from).toList())
+                .hasNext(hasNext)
+                .lastId(quizzes.isEmpty() ? null : quizzes.get(quizzes.size()-1).getId())
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/service/StreakService.java b/src/main/java/org/example/studylog/service/StreakService.java
new file mode 100644
index 0000000..222d8db
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/StreakService.java
@@ -0,0 +1,55 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.StudyRecordRepository;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.time.format.DateTimeFormatter;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class StreakService {
+
+    private final StudyRecordRepository studyRecordRepository;
+    private final UserRepository userRepository;
+
+
+
+    @Transactional(readOnly = true)
+    public Map<String, Integer> getMonthlyStreakData(User user, String year, String month) {
+        log.info("월별 스트릭 데이터 조회 시작: 사용자={}, {}년 {}월", user.getOauthId(), year, month);
+
+        Map<String, Integer> streakData = new LinkedHashMap<>();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+        // YearMonth 객체 생성
+        int yearInt = Integer.parseInt(year);
+        int monthInt = Integer.parseInt(month);
+        YearMonth yearMonth = YearMonth.of(yearInt, monthInt);
+
+        // 해당 월의 모든 날짜에 대해 기록 개수 조회
+        int daysInMonth = yearMonth.lengthOfMonth();
+
+        for (int day = 1; day <= daysInMonth; day++) {
+            LocalDate date = LocalDate.of(yearInt, monthInt, day);
+            Long recordCount = studyRecordRepository.countByUserAndCreateDateDate(user, date);
+
+            // 모든 날짜를 순서대로 LinkedHashMap에 추가
+            streakData.put(date.format(formatter), recordCount.intValue());
+        }
+
+        log.info("월별 스트릭 데이터 조회 완료: 사용자={}, {}년 {}월, 총 일수={}",
+                user.getOauthId(), year, month, streakData.size());
+
+        return streakData;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/service/StudyRecordService.java b/src/main/java/org/example/studylog/service/StudyRecordService.java
new file mode 100644
index 0000000..a2900e9
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/StudyRecordService.java
@@ -0,0 +1,392 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.CategoryDTO;
+import org.example.studylog.dto.QuizDTO;
+import org.example.studylog.dto.StreakDTO;
+import org.example.studylog.dto.studyrecord.*;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.Streak;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.event.RecordEvent;
+import org.example.studylog.repository.CategoryRepository;
+import org.example.studylog.repository.StudyRecordRepository;
+import org.example.studylog.repository.StreakRepository;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class StudyRecordService {
+
+    private final StudyRecordRepository studyRecordRepository;
+    private final CategoryRepository categoryRepository;
+    private final StreakRepository streakRepository;
+    private final ApplicationEventPublisher eventPublisher;
+
+    @Transactional
+    public StudyRecordDTO updateStudyRecord(User user, Long recordId, UpdateStudyRecordRequestDTO requestDTO) {
+        log.info("사용자 {}의 기록 수정 시작: recordId={}", user.getOauthId(), recordId);
+
+        // 1. 기록 조회 및 권한 확인
+        StudyRecord studyRecord = studyRecordRepository.findById(recordId)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 기록입니다"));
+
+        // 작성자 확인
+        if (!studyRecord.getUser().getId().equals(user.getId())) {
+            throw new IllegalArgumentException("해당 기록을 수정할 권한이 없습니다");
+        }
+
+        // 2. 카테고리 검증
+        Category category = categoryRepository.findByIdAndUser(requestDTO.getCategoryId(), user)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 카테고리입니다"));
+
+        // 3. 기록 수정
+        studyRecord.setTitle(requestDTO.getTitle());
+        studyRecord.setContent(requestDTO.getContent());
+        studyRecord.setCategory(category);
+
+        StudyRecord updatedStudyRecord = studyRecordRepository.save(studyRecord);
+        log.info("기록 수정 완료: ID={}", updatedStudyRecord.getId());
+
+        return convertToStudyRecordDTO(updatedStudyRecord);
+    }
+
+    @Transactional
+    public void deleteStudyRecord(User user, Long recordId) {
+        log.info("사용자 {}의 기록 삭제 시작: recordId={}", user.getOauthId(), recordId);
+
+        // 1. 기록 조회 및 권한 확인
+        StudyRecord studyRecord = studyRecordRepository.findById(recordId)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 기록입니다"));
+
+        // 작성자 확인
+        if (!studyRecord.getUser().getId().equals(user.getId())) {
+            throw new IllegalArgumentException("해당 기록을 삭제할 권한이 없습니다");
+        }
+
+        // 2. 기록 삭제 (연관된 퀴즈들도 CASCADE로 함께 삭제됨)
+        studyRecordRepository.delete(studyRecord);
+
+        // recordCount 감소
+        user.decrementRecordCount();
+        log.info("기록 삭제 이벤트 발행: USER={}, ID={}", user.getOauthId(), recordId);
+        eventPublisher.publishEvent(new RecordEvent(user));
+
+        log.info("기록 삭제 완료: ID={}", recordId);
+    }
+
+    @Transactional
+    public CreateStudyRecordResponseDTO createStudyRecord(User user, CreateStudyRecordRequestDTO requestDTO) {
+        log.info("사용자 {}의 기록 생성 시작", user.getOauthId());
+
+        // 1. 카테고리 검증 (필수)
+        Category category = categoryRepository.findByIdAndUser(requestDTO.getCategoryId(), user)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 카테고리입니다"));
+
+        // 2. 기록 생성
+        StudyRecord studyRecord = StudyRecord.builder()
+                .user(user)
+                .category(category)
+                .title(requestDTO.getTitle())
+                .content(requestDTO.getContent())
+                .isQuizCreated(false)  // 팀원 코드에 맞춰 isQuizCreated 사용
+                .build();
+
+        StudyRecord savedStudyRecord = studyRecordRepository.save(studyRecord);
+        log.info("기록 생성 완료: ID={}", savedStudyRecord.getId());
+
+        // 3. 스트릭 업데이트
+        StreakDTO streakDTO = updateUserStreak(user);
+
+        // recordCount 증가 & 이벤트 발행
+        log.info("기록 생성 이벤트 발행: USER={}, ID={}", user.getOauthId(), savedStudyRecord.getId());
+        user.incrementRecordCount();
+        eventPublisher.publishEvent(new RecordEvent(user));
+        log.info("기록 생성 이벤트 종료: USER={}, ID={}", user.getOauthId(), savedStudyRecord.getId());
+
+        // 4. 응답 DTO 생성
+        StudyRecordDTO recordDTO = convertToStudyRecordDTO(savedStudyRecord);
+
+        return CreateStudyRecordResponseDTO.builder()
+                .record(recordDTO)
+                .streak(streakDTO)
+                .build();
+    }
+
+    @Transactional(readOnly = true)
+    public StudyRecordDetailResponseDTO getStudyRecordDetail(User user, Long recordId) {
+        log.info("사용자 {}의 기록 상세 조회: recordId={}", user.getOauthId(), recordId);
+
+        // N+1 방지: JOIN FETCH로 카테고리와 퀴즈 정보까지 한 번에 조회
+        StudyRecord studyRecord = studyRecordRepository.findByIdWithCategoryAndQuizzes(recordId)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 기록입니다"));
+
+        // 작성자 확인
+        if (!studyRecord.getUser().getId().equals(user.getId())) {
+            throw new IllegalArgumentException("해당 기록에 접근할 권한이 없습니다");
+        }
+
+        // 기록 DTO 변환
+        StudyRecordDetailDTO recordDTO = convertToStudyRecordDetailDTO(studyRecord);
+
+        // 퀴즈 목록 조회 (현재는 빈 리스트, 나중에 퀴즈 기능 구현 시 수정)
+        List<QuizDTO> quizzes = getQuizzesForStudyRecord(studyRecord);
+
+        return StudyRecordDetailResponseDTO.builder()
+                .record(recordDTO)
+                .quizzes(quizzes)
+                .build();
+    }
+
+    @Transactional(readOnly = true)
+    public StudyRecordFilterResponseDTO getStudyRecordsWithFilter(User user, StudyRecordFilterRequestDTO requestDTO) {
+        log.info("사용자 {}의 기록 필터링 조회: categoryId={}, date={}, lastId={}",
+                user.getOauthId(), requestDTO.getCategoryId(), requestDTO.getDate(), requestDTO.getLastId());
+
+        // 페이지 크기 설정 (최대 20개로 제한)
+        int pageSize = Math.min(requestDTO.getSize(), 20);
+        Pageable pageable = PageRequest.of(0, pageSize + 1); // +1로 hasMore 판단
+
+        List<StudyRecord> studyRecords;
+        Category category = null;
+        LocalDate filterDate = null;
+
+        // 카테고리 검증 (제공된 경우)
+        if (requestDTO.getCategoryId() != null) {
+            category = categoryRepository.findByIdAndUser(requestDTO.getCategoryId(), user)
+                    .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 카테고리입니다"));
+        }
+
+        // 날짜 파싱 (제공된 경우)
+        if (requestDTO.getDate() != null && !requestDTO.getDate().trim().isEmpty()) {
+            try {
+                filterDate = LocalDate.parse(requestDTO.getDate());
+            } catch (Exception e) {
+                throw new IllegalArgumentException("올바르지 않은 날짜 형식입니다. YYYY-MM-DD 형식으로 입력해주세요");
+            }
+        }
+
+        // 필터 조건에 따라 쿼리 실행
+        if (category != null && filterDate != null) {
+            // 카테고리 + 날짜 필터
+            studyRecords = studyRecordRepository.findByUserAndCategoryAndDateWithPagination(
+                    user, category, filterDate, requestDTO.getLastId(), pageable);
+        } else if (category != null) {
+            // 카테고리만 필터
+            studyRecords = studyRecordRepository.findByUserAndCategoryWithPagination(
+                    user, category, requestDTO.getLastId(), pageable);
+        } else if (filterDate != null) {
+            // 날짜만 필터
+            studyRecords = studyRecordRepository.findByUserAndDateWithPagination(
+                    user, filterDate, requestDTO.getLastId(), pageable);
+        } else {
+            // 필터 없음 (전체 조회)
+            studyRecords = studyRecordRepository.findByUserWithPagination(
+                    user, requestDTO.getLastId(), pageable);
+        }
+
+        // hasMore 판단 및 실제 반환할 데이터 추출
+        boolean hasMore = studyRecords.size() > pageSize;
+        List<StudyRecord> actualRecords = hasMore ?
+                studyRecords.subList(0, pageSize) : studyRecords;
+
+        // DTO 변환
+        List<StudyRecordDTO> recordDTOs = actualRecords.stream()
+                .map(this::convertToStudyRecordDTO)
+                .collect(Collectors.toList());
+
+        // 다음 lastId 계산
+        Long nextLastId = null;
+        if (hasMore && !actualRecords.isEmpty()) {
+            nextLastId = actualRecords.get(actualRecords.size() - 1).getId();
+        }
+
+        log.info("필터링 조회 결과: {}건, hasMore={}", recordDTOs.size(), hasMore);
+
+        return StudyRecordFilterResponseDTO.builder()
+                .records(recordDTOs)
+                .hasMore(hasMore)
+                .nextLastId(nextLastId)
+                .build();
+    }
+
+    @Transactional(readOnly = true)
+    public StudyRecordListResponseDTO searchStudyRecordsByTitle(User user, String query) {
+        log.info("사용자 {}의 기록 제목 검색: query={}", user.getOauthId(), query);
+
+        // 쿼리가 비어있는지 확인
+        if (query == null || query.trim().isEmpty()) {
+            throw new IllegalArgumentException("검색어는 공백일 수 없습니다");
+        }
+
+        // 제목으로 기록 검색
+        List<StudyRecord> studyRecords = studyRecordRepository
+                .findByUserAndTitleContainingIgnoreCaseOrderByCreateDateDesc(user, query.trim());
+
+        log.info("검색 결과: {}건", studyRecords.size());
+
+        // DTO로 변환
+        List<StudyRecordDTO> recordDTOs = studyRecords.stream()
+                .map(this::convertToStudyRecordDTO)
+                .collect(Collectors.toList());
+
+        return StudyRecordListResponseDTO.builder()
+                .records(recordDTOs)
+                .build();
+    }
+
+    @Transactional
+    public StreakDTO updateUserStreak(User user) {
+        LocalDate today = LocalDate.now();
+
+        // 사용자의 스트릭 정보 조회 또는 생성
+        Streak streak = streakRepository.findByUser(user)
+                .orElse(Streak.builder()
+                        .user(user)
+                        .currentStreak(0)
+                        .maxStreak(0)
+                        .build());
+
+        boolean isStreakUpdated = false;
+
+        // 오늘 이미 기록을 작성했는지 확인
+        if (streak.getLastRecordDate() == null || !streak.getLastRecordDate().equals(today)) {
+
+            if (streak.getLastRecordDate() == null) {
+                // 첫 기록
+                streak.setCurrentStreak(1);
+                isStreakUpdated = true;
+            } else if (streak.getLastRecordDate().equals(today.minusDays(1))) {
+                // 연속 기록
+                streak.setCurrentStreak(streak.getCurrentStreak() + 1);
+                isStreakUpdated = true;
+            } else if (streak.getLastRecordDate().isBefore(today.minusDays(1))) {
+                // 스트릭 끊김 - 새로 시작
+                streak.setCurrentStreak(1);
+                isStreakUpdated = true;
+            }
+
+            // 최대 스트릭 업데이트
+            if (streak.getCurrentStreak() > streak.getMaxStreak()) {
+                streak.setMaxStreak(streak.getCurrentStreak());
+            }
+
+            streak.setLastRecordDate(today);
+            streakRepository.save(streak);
+
+            log.info("스트릭 업데이트: 사용자={}, 현재스트릭={}, 업데이트여부={}",
+                    user.getOauthId(), streak.getCurrentStreak(), isStreakUpdated);
+        }
+
+        return StreakDTO.builder()
+                .currentStreak(streak.getCurrentStreak())
+                .isStreakUpdated(isStreakUpdated)
+                .build();
+    }
+
+    private StudyRecordDTO convertToStudyRecordDTO(StudyRecord studyRecord) {
+        CategoryDTO categoryDTO = null;
+        if (studyRecord.getCategory() != null) {
+            // Color enum을 문자열로 변환 (예: BABY_BLUE -> "baby_blue")
+            String colorValue = studyRecord.getCategory().getColor().name().toLowerCase();
+
+            categoryDTO = CategoryDTO.builder()
+                    .id(studyRecord.getCategory().getId())
+                    .name(studyRecord.getCategory().getName())
+                    .color(colorValue)
+                    .build();
+        }
+
+        // BaseEntity의 createDate 사용하여 날짜를 "2025-06-24" 형식으로 변환
+        String formattedDate = studyRecord.getCreateDate().toLocalDate().toString();
+
+        return StudyRecordDTO.builder()
+                .id(studyRecord.getId())
+                .title(studyRecord.getTitle())
+                .content(studyRecord.getContent())
+                .category(categoryDTO)
+                .createdAt(formattedDate)
+                .hasQuiz(studyRecord.isQuizCreated())  // isQuizCreated -> hasQuiz로 변환
+                .build();
+    }
+
+    private StudyRecordDetailDTO convertToStudyRecordDetailDTO(StudyRecord studyRecord) {
+        CategoryDTO categoryDTO = null;
+        if (studyRecord.getCategory() != null) {
+            String colorValue = studyRecord.getCategory().getColor().name().toLowerCase();
+
+            categoryDTO = CategoryDTO.builder()
+                    .id(studyRecord.getCategory().getId())
+                    .name(studyRecord.getCategory().getName())
+                    .color(colorValue)
+                    .build();
+        }
+
+        // BaseEntity의 createDate 사용하여 날짜를 "2025-06-24" 형식으로 변환
+        String formattedDate = studyRecord.getCreateDate().toLocalDate().toString();
+
+        // 퀴즈 개수 계산 (현재는 0, 나중에 실제 퀴즈 개수로 변경)
+        int quizCount = studyRecord.getQuizzes() != null ? studyRecord.getQuizzes().size() : 0;
+
+        return StudyRecordDetailDTO.builder()
+                .id(studyRecord.getId())
+                .title(studyRecord.getTitle())
+                .content(studyRecord.getContent())
+                .category(categoryDTO)
+                .createdAt(formattedDate)
+                .quizCount(quizCount)
+                .build();
+    }
+
+    private List<QuizDTO> getQuizzesForStudyRecord(StudyRecord studyRecord) {
+        // 현재는 빈 리스트 반환 (퀴즈 기능 구현 시 실제 퀴즈 조회로 변경)
+        // TODO: Quiz 엔티티와 QuizRepository 구현 후 실제 퀴즈 조회
+        if (studyRecord.getQuizzes() == null || studyRecord.getQuizzes().isEmpty()) {
+            return List.of(); // 빈 리스트 반환
+        }
+
+        return studyRecord.getQuizzes().stream()
+                .map(this::convertToQuizDTO)
+                .toList();
+    }
+
+    private QuizDTO convertToQuizDTO(org.example.studylog.entity.quiz.Quiz quiz) {
+        // Quiz 엔티티가 완전히 구현되면 실제 변환 로직 추가
+        // 현재는 기본 구조만 제공
+        String levelStr = convertQuizLevelToString(quiz.getLevel());
+        String typeStr = convertQuizTypeToString(quiz.getType());
+
+        return QuizDTO.builder()
+                .id(quiz.getId())
+                .question(quiz.getQuestion())
+                .type(typeStr)
+                .level(levelStr)
+                .build();
+    }
+
+    private String convertQuizLevelToString(org.example.studylog.entity.quiz.QuizLevel level) {
+        return switch (level) {
+            case EASY -> "하";
+            case MEDIUM -> "중";
+            case HARD -> "상";
+        };
+    }
+
+    private String convertQuizTypeToString(org.example.studylog.entity.quiz.QuizType type) {
+        return switch (type) {
+            case OX -> "OX";
+            case SHORT_ANSWER -> "SHORT_ANSWER";
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/org/example/studylog/service/TokenService.java b/src/main/java/org/example/studylog/service/TokenService.java
new file mode 100644
index 0000000..0fa5b55
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/TokenService.java
@@ -0,0 +1,94 @@
+package org.example.studylog.service;
+
+import io.jsonwebtoken.ExpiredJwtException;
+import org.example.studylog.dto.oauth.TokenDTO;
+import org.example.studylog.entity.RefreshEntity;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.TokenValidationException;
+import org.example.studylog.jwt.JWTUtil;
+import org.example.studylog.repository.RefreshRepository;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.Date;
+
+@Service
+public class TokenService {
+
+    private final UserRepository userRepository;
+    private final RefreshRepository refreshRepository;
+    private final JWTUtil jwtUtil;
+
+    public TokenService(UserRepository userRepository, RefreshRepository refreshRepository, JWTUtil jwtUtil) {
+        this.userRepository = userRepository;
+        this.refreshRepository = refreshRepository;
+        this.jwtUtil = jwtUtil;
+    }
+
+    public void addRefreshEntity(String oauthId, String refresh, Long expiredMs){
+        Date date = new Date(System.currentTimeMillis() + expiredMs);
+
+        RefreshEntity refreshEntity = RefreshEntity.builder()
+                .oauthId(oauthId)
+                .refresh(refresh)
+                .expiration(date.toString())
+                .build();
+
+        refreshRepository.save(refreshEntity);
+    }
+
+    public void validateRefreshToken(String refresh){
+        // refresh가 없을 때
+        if(refresh == null){
+            throw new TokenValidationException("refresh token null");
+        }
+
+        // refresh 토큰의 만료 여부 확인
+        try{
+            jwtUtil.isExpired(refresh);
+        } catch (ExpiredJwtException e){
+            throw new TokenValidationException("invalid refresh token");
+        }
+
+        // 토큰이 refresh 인지 확인
+        String category = jwtUtil.getCategory(refresh);
+        if(!category.equals("refresh")){
+            throw new TokenValidationException("invalid refresh token");
+        }
+
+        // refreshToken이 존재하는지 확인
+        Boolean isExist = refreshRepository.existsByRefresh(refresh);
+        if(!isExist){
+            throw new TokenValidationException("invalid refresh token");
+        }
+    }
+
+    public void replaceRefreshToken(String oldRefresh, String newRefresh, String oauthId, long expiredMs){
+        refreshRepository.deleteByRefresh(oldRefresh);
+        addRefreshEntity(oauthId, newRefresh, expiredMs);
+    }
+
+    public TokenDTO reissueAccessToken(String refresh) {
+
+        // 리프레시 토큰 검증
+        validateRefreshToken(refresh);
+
+        // 새로운 access 토큰 발급
+        String oauthId = jwtUtil.getOauthId(refresh);
+        String role = jwtUtil.getRole(refresh);
+
+        String newAccess = jwtUtil.createJwt("access", oauthId, role, 86400000L);
+        String newRefresh = jwtUtil.createJwt("refresh", oauthId, role, 86400000L);
+
+        // Refresh DB에 기존의 Refresh 토큰 삭제 후 새로운 Refresh 토큰 저장
+        replaceRefreshToken(refresh, newRefresh, oauthId, 86400000L);
+
+        User user = userRepository.findByOauthId(oauthId);
+        return TokenDTO.builder()
+                .refreshToken(newRefresh)
+                .accessToken(newAccess)
+                .code(user.getCode())
+                .isNewUser(user.isProfileCompleted())
+                .build();
+    }
+}
diff --git a/src/main/java/org/example/studylog/service/UserService.java b/src/main/java/org/example/studylog/service/UserService.java
new file mode 100644
index 0000000..bdb3905
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/UserService.java
@@ -0,0 +1,137 @@
+package org.example.studylog.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.*;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.exception.UserNotFoundException;
+import org.example.studylog.repository.FriendRepository;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.util.ResponseUtil;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class UserService {
+
+    private final UserRepository userRepository;
+    private final AwsS3Service awsS3Service;
+    private final FriendRepository friendRepository;
+
+    @Transactional
+    public ProfileResponseDTO createUserProfile(ProfileCreateRequestDTO request, String oauthId){
+        // 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        MultipartFile file = request.getProfileImage();
+        // S3 업로드
+        String imageUrl = awsS3Service.uploadProfileImage(file, user);
+
+        // User 엔티티에 프로필 정보 업데이트
+        user.setNickname(request.getNickname());
+        user.setIntro(request.getIntro());
+        user.setProfileImage(imageUrl);
+
+        // 프로필 정보 업데이트 상태 바꾸기
+        if(!user.isProfileCompleted())
+            user.setProfileCompleted(true);
+
+        userRepository.save(user);
+
+        // 생성된 데이터로 응답 객체 반환
+        return ProfileResponseDTO.builder()
+                .nickname(user.getNickname())
+                .intro(user.getIntro())
+                .profileImage(imageUrl)
+                .build();
+    }
+
+    @Transactional
+    public ProfileResponseDTO updateUserProfile(ProfileUpdateRequestDTO request, String oauthId) {
+        // 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        // 닉네임 수정
+        if(request.getNickname() != null){
+            user.setNickname(request.getNickname());
+        }
+
+        // 한줄 소개 수정
+        if(request.getIntro() != null){
+            user.setIntro(request.getIntro());
+        }
+
+        // 프로필 이미지 수정
+        if(request.getProfileImage() != null){
+            MultipartFile newImage = request.getProfileImage();
+            // S3 업로드
+            String imageUrl = awsS3Service.uploadProfileImage(newImage, user);
+            user.setProfileImage(imageUrl);
+        }
+
+        // 수정된 데이터로 응답 객체 반환
+        return ProfileResponseDTO.builder()
+                .nickname(user.getNickname())
+                .intro(user.getIntro())
+                .profileImage(user.getProfileImage())
+                .build();
+    }
+
+    @Transactional(readOnly = true)
+    public ProfileResponseDTO getUserProfile(String oauthId) {
+        // 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        ProfileResponseDTO dto = ProfileResponseDTO.builder()
+                .nickname(user.getNickname())
+                .intro(user.getIntro())
+                .profileImage(user.getProfileImage())
+                .build();
+
+        return dto;
+    }
+
+    @Transactional(readOnly = true)
+    public UserInfoResponseDTO getUserInfo(String oauthId) {
+        // 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        Long count = friendRepository.countByUser(user);
+        UserInfoResponseDTO dto = UserInfoResponseDTO.builder()
+                .profileImage(user.getProfileImage())
+                .nickname(user.getNickname())
+                .intro(user.getIntro())
+                .friendCount(count)
+                .code(user.getCode())
+                .build();
+
+        return dto;
+    }
+
+    @Transactional
+    public BackgroundDTO.ResponseDTO updateBackground(String oauthId, BackgroundDTO.RequestDTO dto) {
+        // 유저 찾기
+        User user = userRepository.findByOauthId(oauthId);
+
+        log.info("배경화면 수정 시작: 사용자={}", oauthId);
+
+        MultipartFile file = dto.getCoverImage();
+        if(file.isEmpty()){
+            throw new IllegalStateException("빈 파일은 업로드할 수 없습니다.");
+        }
+
+        // 이미지 URL을 DB에 저장
+        String backImageUrl = awsS3Service.uploadBackImage(file, user);
+        user.setBackImage(backImageUrl);
+
+        // 응답 생성
+        BackgroundDTO.ResponseDTO responseDTO = new BackgroundDTO.ResponseDTO(backImageUrl);
+
+        log.info("배경화면 수정 완료: 사용자={}, 배경화면 url = {}", oauthId, backImageUrl);
+
+        return responseDTO;
+    }
+}
diff --git a/src/main/java/org/example/studylog/service/oauth/CustomOAuth2UserService.java b/src/main/java/org/example/studylog/service/oauth/CustomOAuth2UserService.java
new file mode 100644
index 0000000..24f6aeb
--- /dev/null
+++ b/src/main/java/org/example/studylog/service/oauth/CustomOAuth2UserService.java
@@ -0,0 +1,105 @@
+package org.example.studylog.service.oauth;
+
+import lombok.extern.slf4j.Slf4j;
+import org.example.studylog.dto.oauth.*;
+import org.example.studylog.entity.user.Role;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.UserRepository;
+import org.springframework.security.oauth2.client.userinfo.DefaultOAuth2UserService;
+import org.springframework.security.oauth2.client.userinfo.OAuth2UserRequest;
+import org.springframework.security.oauth2.core.OAuth2AuthenticationException;
+import org.springframework.security.oauth2.core.user.OAuth2User;
+import org.springframework.stereotype.Service;
+
+import java.util.Random;
+import java.util.UUID;
+
+@Service
+@Slf4j
+public class CustomOAuth2UserService extends DefaultOAuth2UserService {
+
+    private final UserRepository userRepository;
+
+    public CustomOAuth2UserService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
+
+        OAuth2User oAuth2User = super.loadUser(userRequest);
+        System.out.println(oAuth2User);
+
+        String registrationId = userRequest.getClientRegistration().getRegistrationId();
+        System.out.println(registrationId);
+
+        OAuth2Response oAuth2Response = null;
+        if (registrationId.equals("kakao")){
+            oAuth2Response = new KakaoResponse(oAuth2User.getAttributes());
+
+        } else if (registrationId.equals("google")) {
+            oAuth2Response = new GoogleResponse(oAuth2User.getAttributes());
+        } else {
+            return null;
+        }
+
+        // 로그인 완료시 로직
+        String oauthId = oAuth2Response.getProvider()+"_"+oAuth2Response.getProviderId();
+        System.out.println("유저네임: " + oauthId);
+
+        // oauthId으로 로그인한 유저가 이미 존재하는지 확인
+        User existData = userRepository.findByOauthId(oauthId);
+        System.out.println("현재 데이터: " + existData);
+
+        if (existData == null) {
+            User user = User.builder()
+                    .nickname(oAuth2Response.getName())
+                    .profileImage(oAuth2Response.getProfileImage())
+                    .level(0)
+                    .recordCount(0L)
+                    .role(Role.ROLE_USER)
+                    .isProfileCompleted(false)
+                    .uuid(UUID.randomUUID())
+                    .code(generateCode())
+                    .oauthId(oauthId)
+                    .build();
+
+            userRepository.save(user);
+
+            UserDTO userDTO = new UserDTO();
+            userDTO.setOauthId(oauthId);
+            userDTO.setNickname(oAuth2Response.getName());
+            userDTO.setRole(String.valueOf(user.getRole()));
+            userDTO.setProfileCompleted(user.isProfileCompleted());
+
+            return new CustomOAuth2User(userDTO);
+        }
+        else {
+            UserDTO userDTO = new UserDTO();
+            userDTO.setOauthId(existData.getOauthId());
+            userDTO.setNickname(existData.getNickname());
+            userDTO.setRole(String.valueOf(existData.getRole()));
+            userDTO.setProfileCompleted(existData.isProfileCompleted());
+
+            return new CustomOAuth2User(userDTO);
+        }
+    }
+
+    private String generateCode(){
+        String code;
+        do{
+            code = createCode(5);
+        } while(userRepository.existsByCode(code));
+        return code;
+    }
+
+    private String createCode(int length){
+        String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        StringBuilder sb = new StringBuilder();
+        Random rand = new Random();
+        for(int i=0; i<length; i++){
+            sb.append(chars.charAt(rand.nextInt(chars.length())));
+        }
+        return sb.toString();
+    }
+}
diff --git a/src/main/java/org/example/studylog/util/CookieUtil.java b/src/main/java/org/example/studylog/util/CookieUtil.java
new file mode 100644
index 0000000..97bd840
--- /dev/null
+++ b/src/main/java/org/example/studylog/util/CookieUtil.java
@@ -0,0 +1,15 @@
+package org.example.studylog.util;
+
+import jakarta.servlet.http.Cookie;
+
+public class CookieUtil {
+    public static Cookie createCookie(String key, String value){
+        Cookie cookie = new Cookie(key, value);
+        cookie.setMaxAge(60*60*60);
+        //cookie.setSecure(true);
+        cookie.setPath("/");
+        cookie.setHttpOnly(true);
+
+        return cookie;
+    }
+}
diff --git a/src/main/java/org/example/studylog/util/ResponseUtil.java b/src/main/java/org/example/studylog/util/ResponseUtil.java
new file mode 100644
index 0000000..2ee8262
--- /dev/null
+++ b/src/main/java/org/example/studylog/util/ResponseUtil.java
@@ -0,0 +1,11 @@
+package org.example.studylog.util;
+
+import org.example.studylog.dto.ResponseDTO;
+import org.springframework.http.ResponseEntity;
+
+public class ResponseUtil {
+    public static <T> ResponseEntity<ResponseDTO<T>> buildResponse(int statusCode, String message, T data) {
+        return ResponseEntity.status(statusCode)
+                .body(new ResponseDTO<>(statusCode, message, data));
+    }
+}
diff --git a/src/main/java/org/example/studylog/util/TimeUtil.java b/src/main/java/org/example/studylog/util/TimeUtil.java
new file mode 100644
index 0000000..1cadce8
--- /dev/null
+++ b/src/main/java/org/example/studylog/util/TimeUtil.java
@@ -0,0 +1,20 @@
+package org.example.studylog.util;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+
+public class TimeUtil {
+    public static String formatTimeAgo(LocalDateTime createdAt) {
+        LocalDateTime now = LocalDateTime.now();
+        Duration duration = Duration.between(createdAt, now);
+
+        long minutes = duration.toMinutes();
+        long hours = duration.toHours();
+        long days = duration.toDays();
+
+        if (minutes < 1) return "방금 전";
+        if (minutes < 60) return minutes + "분 전";
+        if (hours < 24) return hours + "시간 전";
+        return days + "일 전";
+    }
+}
diff --git a/src/main/resources/static/index.html b/src/main/resources/static/index.html
new file mode 100644
index 0000000..da0d063
--- /dev/null
+++ b/src/main/resources/static/index.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>카카오 로그인</title>
+</head>
+<body>
+<h2>카카오 로그인 테스트</h2>
+<a href="/oauth2/authorization/kakao">
+    <button>카카오로 로그인</button>
+</a>
+</body>
+</html>
\ No newline at end of file
diff --git a/src/test/java/org/example/studylog/controller/UserControllerTest.java b/src/test/java/org/example/studylog/controller/UserControllerTest.java
new file mode 100644
index 0000000..af65fe7
--- /dev/null
+++ b/src/test/java/org/example/studylog/controller/UserControllerTest.java
@@ -0,0 +1,121 @@
+package org.example.studylog.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.servlet.http.Cookie;
+import org.example.studylog.dto.ProfileCreateRequestDTO;
+import org.example.studylog.dto.ProfileResponseDTO;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.jwt.JWTUtil;
+import org.example.studylog.repository.UserRepository;
+import org.example.studylog.service.UserService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@AutoConfigureMockMvc
+class UserControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockitoBean
+    private UserService userService;
+
+    @MockitoBean
+    private UserRepository userRepository;
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Autowired
+    private JWTUtil jwtUtil;
+
+    @Test
+    void 프로필_업데이트_성공() throws Exception {
+        // given
+        // ProfileCheckFilter에서 참조할 User mock 객체 설정
+        User user = new User();
+        user.setNickname("사용자");
+        user.setIntro("한줄 소개입니다.");
+        user.setProfileImage("https://example.com/test.png");
+        user.setProfileCompleted(true);
+
+        // 해당 user가 반환되도록 userRepository mocking
+        when(userRepository.findByOauthId("abc1234")).thenReturn(user);
+
+        MockMultipartFile profileImage = new MockMultipartFile(
+                "profileImage", "test.png", "image/png", "fake-image".getBytes());
+        String nickname = "사용자11";
+        String intro = "한줄 소개입니다.11";
+
+        // 사용자 프로필 업데이트시, 컨트롤러가 반환하도록 기대하는 응답 값
+        ProfileResponseDTO dto = ProfileResponseDTO.builder()
+                .nickname(nickname)
+                .intro(intro)
+                .profileImage("https://example.com/test.png")
+                .build();
+
+        when(userService.createUserProfile(any(ProfileCreateRequestDTO.class), eq("abc1234")))
+                .thenReturn(dto);
+
+        // access 토큰을 쿠키에 담아 요청
+        String token = jwtUtil.createJwt("access", "abc1234", "ROLE_USER", 60000L);
+        mockMvc.perform(multipart("/users/profile")
+                .file(profileImage)
+                .param("nickname", nickname)
+                .param("intro", intro)
+                .with(request -> {request.setMethod("PUT"); return request; })
+                                .cookie(new Cookie("access", token))
+                ).andExpect(status().isOk())
+                .andExpect(jsonPath("$.message").value("사용자 프로필 업데이트 완료"))
+                .andExpect(jsonPath("$.data.nickname").value("사용자11"))
+                .andExpect(jsonPath("$.data.intro").value("한줄 소개입니다.11"));
+    }
+
+    @Test
+    @WithMockUser(username = "abc1234")
+    void 프로필_조회_성공() throws Exception {
+        // given
+        // ProfileCheckFilter에서 참조할 User mock 객체 설정
+        User user = new User();
+        user.setNickname("사용자");
+        user.setIntro("한줄 소개입니다.");
+        user.setProfileImage("https://example.com/test.png");
+        user.setProfileCompleted(true);
+
+        // 해당 user가 반환되도록 userRepository mocking
+        when(userRepository.findByOauthId("abc1234")).thenReturn(user);
+
+        ProfileResponseDTO dto = ProfileResponseDTO.builder()
+                .nickname("사용자")
+                .intro("안녕하세요")
+                .profileImage("https://example.com/image.png")
+                .build();
+
+        when(userService.getUserProfile("abc1234")).thenReturn(dto);
+
+        String token = jwtUtil.createJwt("access", "abc1234", "ROLE_USER", 60000L);
+        mockMvc.perform(get("/users/profile")
+                        .cookie(new Cookie("access", token)))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.statusCode").value(200))
+                .andExpect(jsonPath("$.message").value("사용자 프로필 조회 성공"))
+                .andExpect(jsonPath("$.data.nickname").value("사용자"));
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/org/example/studylog/service/StudyRecordServiceTest.java b/src/test/java/org/example/studylog/service/StudyRecordServiceTest.java
new file mode 100644
index 0000000..7db4331
--- /dev/null
+++ b/src/test/java/org/example/studylog/service/StudyRecordServiceTest.java
@@ -0,0 +1,287 @@
+package org.example.studylog.service;
+
+import org.example.studylog.dto.studyrecord.*;
+import org.example.studylog.entity.Streak;
+import org.example.studylog.entity.StudyRecord;
+import org.example.studylog.entity.category.Category;
+import org.example.studylog.entity.category.Color;
+import org.example.studylog.entity.user.Role;
+import org.example.studylog.entity.user.User;
+import org.example.studylog.repository.CategoryRepository;
+import org.example.studylog.repository.StreakRepository;
+import org.example.studylog.repository.StudyRecordRepository;
+import org.example.studylog.repository.UserRepository;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@SpringBootTest
+@Transactional
+class StudyRecordServiceTest {
+
+    @Autowired
+    private StudyRecordService studyRecordService;
+    @Autowired
+    private UserRepository userRepository;
+    @Autowired
+    private CategoryRepository categoryRepository;
+    @Autowired
+    private StudyRecordRepository studyRecordRepository;
+    @Autowired
+    private StreakRepository streakRepository;
+
+    // === 1. 데이터 무결성 테스트 ===
+
+    @Test
+    @DisplayName("기록 생성 중 카테고리가 삭제되는 경우")
+    void createRecord_CategoryDeletedDuringCreation_ShouldFail() {
+        // Given
+        User user = createTestUser();
+        Category category = createTestCategory(user);
+        CreateStudyRecordRequestDTO requestDTO = createValidRequestDTO(category.getId());
+
+        // 다른 스레드에서 카테고리 삭제 시뮬레이션
+        CompletableFuture.runAsync(() -> {
+            categoryRepository.delete(category);
+            categoryRepository.flush();
+        });
+
+        // When & Then
+        assertThrows(IllegalArgumentException.class,
+                () -> studyRecordService.createStudyRecord(user, requestDTO));
+    }
+
+    @Test
+    @DisplayName("기록 생성 시 제목 길이 경계값 테스트")
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 19, 20, 21, 50})
+    void createRecord_TitleLengthBoundary(int titleLength) {
+        // Given
+        User user = createTestUser();
+        Category category = createTestCategory(user);
+
+        CreateStudyRecordRequestDTO requestDTO = new CreateStudyRecordRequestDTO();
+        requestDTO.setCategoryId(category.getId());
+        requestDTO.setTitle("a".repeat(titleLength));
+        requestDTO.setContent("유효한 내용입니다. 최소 10자 이상 작성");
+
+        // When & Then
+        if (titleLength == 0 || titleLength > 20) {
+            assertThrows(Exception.class,
+                    () -> studyRecordService.createStudyRecord(user, requestDTO));
+        } else {
+            assertDoesNotThrow(
+                    () -> studyRecordService.createStudyRecord(user, requestDTO));
+        }
+    }
+
+    @Test
+    @DisplayName("기록 내용에 특수 문자 및 이모지 포함")
+    void createRecord_SpecialCharactersAndEmojis() {
+        // Given
+        User user = createTestUser();
+        Category category = createTestCategory(user);
+
+        String specialContent = "특수문자 테스트 !@#$%^&*()_+ 이모지 테스트 😀🎉📚 " +
+                "HTML 태그 <script>alert('xss')</script> " +
+                "SQL 문자 '; DROP TABLE study_record; --";
+
+        CreateStudyRecordRequestDTO requestDTO = new CreateStudyRecordRequestDTO();
+        requestDTO.setCategoryId(category.getId());
+        requestDTO.setTitle("특수문자 테스트");
+        requestDTO.setContent(specialContent);
+
+        // When
+        CreateStudyRecordResponseDTO result = studyRecordService.createStudyRecord(user, requestDTO);
+
+        // Then
+        assertThat(result.getRecord().getContent()).contains("특수문자 테스트");
+        // XSS 공격 문자열이 그대로 저장되지 않았는지 확인
+        assertThat(result.getRecord().getContent()).doesNotContain("<script>");
+    }
+
+    // === 2. 동시성 테스트 ===
+
+    @Test
+    @DisplayName("동일 사용자가 동시에 여러 기록 생성")
+    void createRecord_ConcurrentCreation_ShouldMaintainDataIntegrity() throws InterruptedException {
+        // Given
+        User user = createTestUser();
+        Category category = createTestCategory(user);
+
+        int threadCount = 10;
+        CountDownLatch latch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+        List<Exception> exceptions = Collections.synchronizedList(new ArrayList<>());
+
+        // When - 동시에 10개 기록 생성
+        for (int i = 0; i < threadCount; i++) {
+            final int index = i;
+            CompletableFuture.runAsync(() -> {
+                try {
+                    CreateStudyRecordRequestDTO requestDTO = new CreateStudyRecordRequestDTO();
+                    requestDTO.setCategoryId(category.getId());
+                    requestDTO.setTitle("동시 생성 테스트 " + index);
+                    requestDTO.setContent("동시 생성 테스트 내용입니다. " + index);
+
+                    studyRecordService.createStudyRecord(user, requestDTO);
+                    successCount.incrementAndGet();
+                } catch (Exception e) {
+                    exceptions.add(e);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await(30, TimeUnit.SECONDS);
+
+        // Then
+        assertThat(successCount.get()).isEqualTo(threadCount);
+        assertThat(exceptions).isEmpty();
+
+        // 실제 DB에 모든 기록이 저장되었는지 확인
+        List<StudyRecord> records = studyRecordRepository.findByUserOrderByCreateDateDesc(user);
+        assertThat(records).hasSize(threadCount);
+
+        // 스트릭이 정확히 계산되었는지 확인 (같은 날이므로 1이어야 함)
+        Optional<Streak> streak = streakRepository.findByUser(user);
+        assertThat(streak).isPresent();
+        assertThat(streak.get().getCurrentStreak()).isEqualTo(1);
+    }
+
+    // === 3. 필터링 및 검색 테스트 ===
+
+    @Test
+    @DisplayName("페이징 경계값 테스트 - lastId가 Long.MAX_VALUE인 경우")
+    void getRecordsWithFilter_MaxLastId_ShouldReturnEmpty() {
+        // Given
+        User user = createTestUser();
+        createMultipleTestRecords(user, 20);
+
+        StudyRecordFilterRequestDTO requestDTO = new StudyRecordFilterRequestDTO();
+        requestDTO.setLastId(Long.MAX_VALUE);
+        requestDTO.setSize(10);
+
+        // When
+        StudyRecordFilterResponseDTO result = studyRecordService.getStudyRecordsWithFilter(user, requestDTO);
+
+        // Then
+        assertThat(result.getRecords()).isEmpty();
+        assertThat(result.getHasMore()).isFalse();
+        assertThat(result.getNextLastId()).isNull();
+    }
+
+    @Test
+    @DisplayName("잘못된 날짜 형식으로 필터링")
+    @ParameterizedTest
+    @ValueSource(strings = {"2024-13-01", "2024-02-30", "invalid-date", "2024/01/01", ""})
+    void getRecordsWithFilter_InvalidDateFormats_ShouldThrowException(String invalidDate) {
+        // Given
+        User user = createTestUser();
+        StudyRecordFilterRequestDTO requestDTO = new StudyRecordFilterRequestDTO();
+        requestDTO.setDate(invalidDate);
+
+        // When & Then
+        assertThrows(IllegalArgumentException.class,
+                () -> studyRecordService.getStudyRecordsWithFilter(user, requestDTO));
+    }
+
+    @Test
+    @DisplayName("검색어에 SQL Injection 시도")
+    void searchRecords_SqlInjectionAttempt_ShouldBeSafe() {
+        // Given
+        User user = createTestUser();
+        createMultipleTestRecords(user, 5);
+
+        String maliciousQuery = "'; DROP TABLE study_record; SELECT * FROM study_record WHERE '1'='1";
+
+        // When
+        StudyRecordListResponseDTO result = studyRecordService.searchStudyRecordsByTitle(user, maliciousQuery);
+
+        // Then
+        assertThat(result.getRecords()).isEmpty(); // 검색 결과는 없어야 함
+
+        // 테이블이 여전히 존재하는지 확인
+        long recordCount = studyRecordRepository.count();
+        assertThat(recordCount).isGreaterThanOrEqualTo(5);
+    }
+
+    // === 4. 업데이트 및 삭제 테스트 ===
+
+    @Test
+    @DisplayName("기록 수정 중 카테고리 변경 - 존재하지 않는 카테고리로")
+    void updateRecord_NonExistentCategory_ShouldFail() {
+        // Given
+        User user = createTestUser();
+        Category originalCategory = createTestCategory(user);
+        StudyRecord record = createTestRecord(user, originalCategory);
+
+        UpdateStudyRecordRequestDTO requestDTO = new UpdateStudyRecordRequestDTO();
+        requestDTO.setCategoryId(999L); // 존재하지 않는 카테고리
+        requestDTO.setTitle("수정된 제목");
+        requestDTO.setContent("수정된 내용입니다. 최소 10자 이상");
+
+        // When & Then
+        assertThrows(IllegalArgumentException.class,
+                () -> studyRecordService.updateStudyRecord(user, record.getId(), requestDTO));
+    }
+
+    @Test
+    @DisplayName("이미 삭제된 기록 수정 시도")
+    void updateRecord_AlreadyDeletedRecord_ShouldFail() {
+        // Given
+        User user = createTestUser();
+        Category category = createTestCategory(user);
+        StudyRecord record = createTestRecord(user, category);
+        Long recordId = record.getId();
+
+        // 기록 삭제
+        studyRecordService.deleteStudyRecord(user, recordId);
+
+        UpdateStudyRecordRequestDTO requestDTO = createValidUpdateRequestDTO(category.getId());
+
+        // When & Then
+        assertThrows(IllegalArgumentException.class,
+                () -> studyRecordService.updateStudyRecord(user, recordId, requestDTO));
+    }
+
+    // 테스트 데이터 생성 헬퍼 메서드들
+    private User createTestUser() {
+        User user = User.builder()
+                .nickname("테스트유저")
+                .profileImage("test.jpg")
+                .intro("테스트 소개")
+                .level(1)
+                .role(Role.ROLE_USER)
+                .isProfileCompleted(true)
+                .uuid(UUID.randomUUID())
+                .code("TEST1")
+                .oauthId("test_oauth_id")
+                .build();
+        return userRepository.save(user);
+    }
+
+    private Category createTestCategory(User user) {
+        Category category = Category.builder()
+                .user(user)
+                .name("테스트 카테고리")
+                .color(Color.BABY_BLUE)
+                .build();
+        return categoryRepository.save(category);
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/application-test.yml b/src/test/resources/application-test.yml
new file mode 100644
index 0000000..c00d4c6
--- /dev/null
+++ b/src/test/resources/application-test.yml
@@ -0,0 +1,3 @@
+spring:
+  jwt:
+    secret: test-secret-key-test-secret-key-123456
\ No newline at end of file