fix: resolved conflict

feat: delete movie API
refactor: movieService test code
2022-07-14 03:40:01 +09:00 · 2022-07-14 03:37:46 +09:00 · 2022-07-14 03:24:46 +09:00 · 2022-07-14 03:18:49 +09:00 · 2022-07-14 03:00:52 +09:00 · 2022-07-14 02:55:41 +09:00
165 changed files with 4508 additions and 690 deletions
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # 🍿 Ticketing
-영화 예매 서비스
+영화 예매 사이트를 대용량 트래픽에 대응할 수 있도록 설계.

 <br/>

@@ -8,32 +8,59 @@
 - 기획 및 설계 : 22.04.13 ~ 
 - 프로젝트 구현 :   

+<br/>

-<br/><br/>
+## 🎯 프로젝트 주요 관심사
+- OOP(객체 지향 프로그래밍)의 장점을 최대한 활용
+- 테스트 코드를 통한 믿을 수 있는 코드 작성
+- 대용량 트래픽을 고려한 확장 가능한 설계 및 성능 튜닝
+- 코드리뷰를 통해 코드 품질 향상
+- 코드 컨벤션 준수하여 코드 통일성 유지

-## 🎯 프로젝트 목표
+<br/>

+## 🛠 기술스택
+- Java 11
+- Spring Boot 2.6.7 (당시 최신 GA 버전)
+- Gradle Kotlin DSL
+- Spring Security
+- Junit 5
+- Hibernate / SpringJPA
+- MySQL 8.0
+- Redis

-<br/><br/>
+<br/>
+
+## Wiki
+- [Git Branch 전략](https://github.com/f-lab-edu/Ticketing/wiki#-git-branch-%EC%A0%84%EB%9E%B5)
+- [Code Convention](https://github.com/f-lab-edu/Ticketing/wiki#-code-convention)
+- [패키지 구조](https://github.com/f-lab-edu/Ticketing/wiki#-%ED%8C%A8%ED%82%A4%EC%A7%80-%EA%B5%AC%EC%A1%B0)
+- [Use Case](https://github.com/f-lab-edu/Ticketing/wiki/Use-Case)
+- [Prototype](https://github.com/f-lab-edu/Ticketing/wiki/Prototype)
+- [Issue Posting](https://github.com/f-lab-edu/Ticketing/wiki/Issue-Posting)
+
+<br/>

 ## 🧩 ERD

 ``` mermaid
 erDiagram
-    MOVIE ||--o{ MOVIE_TIMES : ""
+    MOVIE ||--o{ MOVIE_TIME : ""
    MOVIE {
        bigint id PK "영화 ID"
        varchar title "영화제목"
        int running_time "러닝타임"
+        datetime deleted_at "삭제일시"
        datetime created_at "등록일시"
        datetime updated_at "수정일시"
    }
-    THEATER ||--o{ MOVIE_TIMES : ""
+    THEATER ||--o{ MOVIE_TIME : ""
    THEATER ||--|{ SEAT : ""
    THEATER {
        bigint id PK "상영관 ID"
        int theater_number "상영관 번호"
        int seat_count "좌석수"
+        datetime deleted_at "삭제일시"
        datetime created_at "등록일시"
        datetime updated_at "수정일시"
    }
@@ -43,56 +70,58 @@ erDiagram
        bigint theater_id FK "상영관 ID"
        int column "열"
        int row "행"
+        datetime deleted_at "삭제일시"
        datetime created_at "등록일시"
        datetime updated_at "수정일시"
    }
-    MOVIE_TIMES ||--o{ TICKET : ""
-    MOVIE_TIMES {
+    MOVIE_TIME ||--o{ TICKET : ""
+    MOVIE_TIME {
        bigint id PK "상영시간표 ID"
        bigint movie_id FK "영화 ID"
        bigint theater_id FK "상영관 ID"
-        date running_date "상영 날짜"
        int round "회차"
        time start_at "시작 시간"
        time end_at "종료 시간"
+        datetime deleted_at "삭제일시"
        datetime created_at "등록일시"
        datetime updated_at "수정일시"
    }
    TICKET {
        bigint id PK "티켓 ID"
        bigint seat_id FK "좌석 ID"
-        bigint movie_times_id FK "상영시간표 ID"
-        bigint payment_id FK "결제 ID"
+        bigint movie_time_id FK "상영시간표 ID"
+        bigint payment_id "결제 ID"
        varchar status "상태 - 구매가능/예약진행중/판매완료"
        int ticket_price "가격"
+        datetime deleted_at "삭제일시"
        datetime created_at "등록일시"
        datetime updated_at "수정일시"
    }
    TICKET }|--|| PAYMENT : ""
    PAYMENT {
        bigint id PK "결제 ID"
-        bigint user_id FK "유저ID"
+        bigint user_alternate_id "유저 대체ID"
+        varchar movie_title "영화제목"
        varchar type "결제 타입 - 예) 네이버페이, 카카오페이"
        varchar status "상태 - 완료/환불/실패"
        varchar failed_message "실패사유 - 컬럼명을 알아보기 쉬운가?"
        varchar payment_number "예매번호"
        int total_price "결제 금액"
+        datetime deleted_at "삭제일시"
        datetime created_at "결제일시"
        datetime updated_at "수정일시"
    }
    USER ||--o{ PAYMENT : ""
    USER {
        bigint id "회원"
+        bigint alternate_id "대체ID"
        varchar name "이름"
        varchar email "이메일"
        varchar password "비밀번호"
        varchar grade "등급 - 고객/임직원"
        varchar phone "휴대폰 번호"
-        boolean is_deleted "탈퇴여부"
        datetime deleted_at "탈퇴일시"
        datetime created_at "가입일시"
        datetime updated_at "수정일시"
    }
 ```
-
-<br/><br/>
--- a/server/build.gradle.kts
+++ b/server/build.gradle.kts
@@ -1,7 +1,7 @@
 plugins {
-    java
-    id("org.springframework.boot") version "2.6.7"
-    id("io.spring.dependency-management") version "1.0.11.RELEASE"
+	java
+	id("org.springframework.boot") version "2.6.7"
+	id("io.spring.dependency-management") version "1.0.11.RELEASE"
 }

 group = "com.ticketing"
@@ -9,59 +9,80 @@ version = "0.0.1-SNAPSHOT"

 val javaVersion = JavaVersion.VERSION_11
 java {
-    sourceCompatibility = javaVersion
-    targetCompatibility = javaVersion
+	sourceCompatibility = javaVersion
+	targetCompatibility = javaVersion
 }

 configurations {
-    compileOnly {
-        extendsFrom(configurations.annotationProcessor.get())
-    }
+	compileOnly {
+		extendsFrom(configurations.annotationProcessor.get())
+	}
 }

 repositories {
-    mavenCentral()
+	mavenCentral()
 }

-
-
 dependencies {
-    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
-    implementation("org.springframework.boot:spring-boot-starter-security")
-    implementation("org.springframework.boot:spring-boot-starter-validation")
-    implementation("org.springframework.boot:spring-boot-starter-web")
-    implementation("org.springframework.boot:spring-boot-starter-actuator")
-    implementation("org.springframework.boot:spring-boot-starter-log4j2")
-    implementation("org.projectlombok:lombok:1.18.20")
-    implementation("io.springfox:springfox-swagger2:3.0.0")
-    implementation("io.springfox:springfox-swagger-ui:3.0.0")
-    implementation("com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4")
-    implementation("com.lmax:disruptor:3.4.2")
-    implementation("io.jsonwebtoken:jjwt-api:0.11.2")
-    implementation("com.googlecode.json-simple:json-simple:1.1.1")
+	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+	implementation("org.springframework.boot:spring-boot-starter-security")
+	implementation("org.springframework.boot:spring-boot-starter-validation")
+	implementation("org.springframework.boot:spring-boot-starter-web")
+	implementation("org.springframework.boot:spring-boot-starter-actuator")
+	implementation("org.springframework.boot:spring-boot-starter-log4j2")
+	implementation("org.projectlombok:lombok:1.18.24")
+	implementation("io.springfox:springfox-boot-starter:3.0.0")
+	implementation("io.springfox:springfox-swagger-ui:3.0.0")
+	implementation("com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4")
+	implementation("com.lmax:disruptor:3.4.4")
+	implementation("io.jsonwebtoken:jjwt-api:0.11.5")
+	implementation("com.googlecode.json-simple:json-simple:1.1.1")
+	implementation("org.springframework.boot:spring-boot-starter-data-redis")
+	implementation("com.google.code.findbugs:jsr305:3.0.2")

-    modules {
-        module("org.springframework.boot:spring-boot-starter-logging") {
-            replacedBy("org.springframework.boot:spring-boot-starter-log4j2", "Use Log4j2 instead of Logback")
-        }
-    }
+	modules {
+		module("org.springframework.boot:spring-boot-starter-logging") {
+			replacedBy("org.springframework.boot:spring-boot-starter-log4j2", "Use Log4j2 instead of Logback")
+		}
+	}

-    testImplementation("org.springframework.boot:spring-boot-starter-test")
-    testImplementation("org.springframework.security:spring-security-test")
-    testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
+	compileOnly("org.projectlombok:lombok")
+	runtimeOnly("mysql:mysql-connector-java")
+	runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")
+	runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")
+	annotationProcessor("org.projectlombok:lombok")
+	annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")

-    compileOnly("org.projectlombok:lombok")
-    runtimeOnly("mysql:mysql-connector-java")
-    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.2")
-    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.2")
-    annotationProcessor("org.projectlombok:lombok")
-    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
-
-    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.1")
-    testImplementation("org.springframework.boot:spring-boot-starter-test")
-    testImplementation("org.springframework.security:spring-security-test")
+	testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.1")
+	testImplementation("org.springframework.boot:spring-boot-starter-test")
+	testImplementation("org.springframework.security:spring-security-test")
 }

 tasks.withType<Test> {
-    useJUnitPlatform()
+	useJUnitPlatform()
 }
+
+sourceSets {
+	create("intTest") {
+		compileClasspath += sourceSets.main.get().output
+		runtimeClasspath += sourceSets.main.get().output
+	}
+}
+
+val intTestImplementation by configurations.getting {
+	extendsFrom(configurations.implementation.get())
+}
+
+configurations["intTestRuntimeOnly"].extendsFrom(configurations.runtimeOnly.get())
+configurations["intTestImplementation"].extendsFrom(configurations.testImplementation.get())
+
+val integrationTest = task<Test>("integrationTest") {
+	description = "Runs integration tests."
+	group = "verification"
+
+	testClassesDirs = sourceSets["intTest"].output.classesDirs
+	classpath = sourceSets["intTest"].runtimeClasspath
+	shouldRunAfter("test")
+}
+
+tasks.check { dependsOn(integrationTest) }
--- a/server/src/intTest/java/com/ticketing/server/global/health/L7checkControllerTest.java
+++ b/server/src/intTest/java/com/ticketing/server/global/health/L7checkControllerTest.java
--- a/server/src/intTest/java/com/ticketing/server/global/redis/RefreshRedisRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/global/redis/RefreshRedisRepositoryTest.java
@@ -0,0 +1,75 @@
+package com.ticketing.server.global.redis;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class RefreshRedisRepositoryTest {
+
+	@Autowired
+	RefreshRedisRepository refreshRedisRepository;
+
+	@AfterEach
+	void tearDown() {
+		refreshRedisRepository.deleteAll();
+	}
+
+	@Test
+	@DisplayName("기본 등록 및 조회기능")
+	void saveAndFind() {
+		// given
+		RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
+
+		// when
+		refreshRedisRepository.save(refreshToken);
+
+		// then
+		RefreshToken findRefreshToken = refreshRedisRepository.findById(refreshToken.getId()).get();
+		assertAll(
+			() -> assertThat(findRefreshToken.getEmail()).isEqualTo("ticketing@gmail.com")
+			, () -> assertThat(findRefreshToken.getToken()).isEqualTo("refreshToken")
+		);
+	}
+
+	@Test
+	@DisplayName("기본 등록 및 이메일 조회")
+	void saveAndFindByEmail() {
+		// given
+		RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
+
+		// when
+		refreshRedisRepository.save(refreshToken);
+
+		// then
+		RefreshToken findRefreshToken = refreshRedisRepository.findByEmail(refreshToken.getEmail()).get();
+		assertAll(
+			() -> assertThat(findRefreshToken.getEmail()).isEqualTo("ticketing@gmail.com")
+			, () -> assertThat(findRefreshToken.getToken()).isEqualTo("refreshToken")
+		);
+	}
+
+	@Test
+	@DisplayName("기본 등록 및 수정기능")
+	void saveAndSave() {
+		// given
+		RefreshToken refreshToken = new RefreshToken("ticketing@gmail.com", "refreshToken");
+		refreshRedisRepository.save(refreshToken);
+		Long id = refreshToken.getId();
+
+		// when
+		RefreshToken savedRefreshToken = refreshRedisRepository.findById(id).get();
+		savedRefreshToken.changeToken("refreshToken2");
+		refreshRedisRepository.save(savedRefreshToken);
+
+		// then
+		RefreshToken lastSavedRefreshToken = refreshRedisRepository.findById(id).get();
+		assertThat(lastSavedRefreshToken.getToken()).isEqualTo("refreshToken2");
+	}
+
+}
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/MovieTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/MovieTest.java
@@ -0,0 +1,5 @@
+package com.ticketing.server.movie.domain;
+
+public class MovieTest {
+
+}
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/repository/MovieRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/repository/MovieRepositoryTest.java
@@ -27,10 +27,10 @@ public class MovieRepositoryTest {
    @Order(1)
    @Test
    @Rollback(value = false)
-    @DisplayName("Movie Repository - test saving movie")
+    @DisplayName("Movie Repository Test - saving movie")
    void shouldAbleToSaveMovie() {
        // given
-        Movie movie = new Movie("범죄도시 2", 106);
+        Movie movie = new Movie("범죄도시 2", 106L);

        // when
        Movie savedMovie = movieRepository.save(movie);
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/repository/MovieTimesRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/repository/MovieTimesRepositoryTest.java
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/repository/SeatRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/repository/SeatRepositoryTest.java
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/repository/TheaterRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/repository/TheaterRepositoryTest.java
@@ -20,7 +20,7 @@ public class TheaterRepositoryTest {
    @DisplayName("Theater Repository Test - saving theater")
    void ShouldAbleToSaveTheater() {
        // given
-        Theater theater = new Theater(1, 100);
+        Theater theater = new Theater(1);

        // when
        Theater savedTheater = theaterRepository.save(theater);
--- a/server/src/intTest/java/com/ticketing/server/movie/domain/repository/TicketRepositoryTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/domain/repository/TicketRepositoryTest.java
--- a/server/src/intTest/java/com/ticketing/server/movie/service/TMDBServiceImplTest.java
+++ b/server/src/intTest/java/com/ticketing/server/movie/service/TMDBServiceImplTest.java
--- a/server/src/intTest/java/com/ticketing/server/user/application/AuthControllerTest.java
+++ b/server/src/intTest/java/com/ticketing/server/user/application/AuthControllerTest.java
@@ -3,14 +3,15 @@ package com.ticketing.server.user.application;
 import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
 import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.ticketing.server.global.redis.RefreshRedisRepository;
 import com.ticketing.server.user.application.request.LoginRequest;
 import com.ticketing.server.user.application.request.SignUpRequest;
 import com.ticketing.server.user.service.interfaces.UserService;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -26,7 +27,11 @@ import org.springframework.web.context.WebApplicationContext;

@SpringBootTest
@Transactional
-class UserControllerTest {
+class AuthControllerTest {
+
+	private static final String LOGIN_URL = "/api/auth/token";
+	private static final String REGISTER_URL = "/api/users";
+	private static final String USER_EMAIL = "ticketing@gmail.com";

 	@Autowired
 	WebApplicationContext context;
@@ -40,47 +45,35 @@ class UserControllerTest {
 	@Autowired
 	ObjectMapper objectMapper;

+	@Autowired
+	RefreshRedisRepository refreshRedisRepository;
+
 	MockMvc mvc;

-	@BeforeEach
-	void init() throws Exception {
-		mvc = MockMvcBuilders
-			.webAppContextSetup(context)
-			.apply(springSecurity())
-			.build();
-
-		SignUpRequest signUpRequest = new SignUpRequest("ticketing", "ticketing@gmail.com", "qwe123", "010-2240-7920");
-
-		mvc.perform(post("/user")
-			.content(asJsonString(signUpRequest))
-			.contentType(MediaType.APPLICATION_JSON));
-	}
-
 	@Test
 	@DisplayName("로그인 인증 성공")
 	void loginSuccess() throws Exception {
 		// given
-		LoginRequest request = new LoginRequest("ticketing@gmail.com", "qwe123");
+		LoginRequest request = new LoginRequest(USER_EMAIL, "qwe123");

 		// when
-		ResultActions actions = mvc.perform(post("/user/login")
+		ResultActions actions = mvc.perform(post(LOGIN_URL)
 			.content(asJsonString(request))
 			.contentType(MediaType.APPLICATION_JSON));

 		// then
 		actions.andDo(print())
-			.andExpect(status().isOk())
-			.andExpect(header().exists("ACCESS_TOKEN"));
+			.andExpect(status().isOk());
 	}

 	@Test
 	@DisplayName("로그인 패스워드 인증 실패")
 	void loginPasswordFail() throws Exception {
 		// given
-		LoginRequest request = new LoginRequest("ticketing@gmail.com", "qwe1234");
+		LoginRequest request = new LoginRequest(USER_EMAIL, "qwe1234");

 		// when
-		ResultActions actions = mvc.perform(post("/user/login")
+		ResultActions actions = mvc.perform(post(LOGIN_URL)
 			.content(asJsonString(request))
 			.contentType(MediaType.APPLICATION_JSON));

@@ -89,6 +82,25 @@ class UserControllerTest {
 			.andExpect(status().isUnauthorized());
 	}

+	@BeforeEach
+	void init() throws Exception {
+		mvc = MockMvcBuilders
+			.webAppContextSetup(context)
+			.apply(springSecurity())
+			.build();
+
+		SignUpRequest signUpRequest = new SignUpRequest("ticketing", USER_EMAIL, "qwe123", "010-1234-5678");
+
+		mvc.perform(post(REGISTER_URL)
+			.content(asJsonString(signUpRequest))
+			.contentType(MediaType.APPLICATION_JSON));
+	}
+
+	@AfterEach
+	void tearDown() {
+		refreshRedisRepository.deleteAll();
+	}
+
 	private String asJsonString(Object object) throws JsonProcessingException {
 		return objectMapper.writeValueAsString(object);
 	}
--- a/server/src/intTest/java/com/ticketing/server/user/application/UserControllerTest.java
+++ b/server/src/intTest/java/com/ticketing/server/user/application/UserControllerTest.java
@@ -0,0 +1,7 @@
+package com.ticketing.server.user.application;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserControllerTest {
+
+}
--- a/server/src/intTest/resources/application.yml
+++ b/server/src/intTest/resources/application.yml
@@ -0,0 +1,37 @@
+spring:
+  datasource:
+    url: jdbc:mysql://localhost:3306/ticketing_test?serverTimezone=Asia/Seoul&characterEncoding=UTF-8
+    username: ENC(LowN1n4w0Ep/DqLD8+q5Bq6AXM4b8e3V)
+    password: ENC(OMvGcpZLpggFTiGNkqNe66Zq/SmJXF6o)
+    driver-class-name: com.mysql.cj.jdbc.Driver
+  redis:
+    host: localhost
+    port: 6379
+
+  jpa:
+    properties:
+      hibernate:
+        show_sql: true
+        format_sql: true
+    hibernate:
+      ddl-auto: create
+
+  mvc:
+    pathmatch:
+      matching-strategy: ant_path_matcher
+
+jasypt:
+  encryptor:
+    bean: jasyptStringEncryptor
+
+jwt:
+  access-header: Authorization
+  refresh-header: REFRESH_TOKEN
+  prefix: Bearer
+  secret-key: Zi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXktZi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXkK
+  access-token-validity-in-seconds: 60
+  refresh-token-validity-in-seconds: 259200
+
+tmdb:
+  api-key: 0d1503b6dcbfe1c514299b5564c649b8
+  read-access-token: eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiIwZDE1MDNiNmRjYmZlMWM1MTQyOTliNTU2NGM2NDliOCIsInN1YiI6IjYyOWYwODRlNzI2ZmIxMTA2NDA4MjI2NCIsInNjb3BlcyI6WyJhcGlfcmVhZCJdLCJ2ZXJzaW9uIjoxfQ.rs8KZea8QLyashILiggWFx2s46lgUtzo-xSWoDgE58A
--- a/server/src/main/java/com/ticketing/server/ServerApplication.java
+++ b/server/src/main/java/com/ticketing/server/ServerApplication.java
@@ -1,6 +1,6 @@
 package com.ticketing.server;

-import com.ticketing.server.global.jwt.JwtProperties;
+import com.ticketing.server.global.security.jwt.JwtProperties;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
--- a/server/src/main/java/com/ticketing/server/global/config/SwaggerConfig.java
+++ b/server/src/main/java/com/ticketing/server/global/config/SwaggerConfig.java
@@ -1,14 +1,28 @@
 package com.ticketing.server.global.config;

+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.web.server.ManagementPortType;
+import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
+import org.springframework.boot.actuate.endpoint.web.EndpointLinksResolver;
+import org.springframework.boot.actuate.endpoint.web.EndpointMapping;
+import org.springframework.boot.actuate.endpoint.web.EndpointMediaTypes;
+import org.springframework.boot.actuate.endpoint.web.ExposableWebEndpoint;
+import org.springframework.boot.actuate.endpoint.web.WebEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.annotation.ControllerEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.annotation.ServletEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.servlet.WebMvcEndpointHandlerMapping;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import springfox.documentation.builders.ApiInfoBuilder;
+import org.springframework.core.env.Environment;
+import org.springframework.util.StringUtils;
 import springfox.documentation.builders.PathSelectors;
 import springfox.documentation.builders.RequestHandlerSelectors;
-import springfox.documentation.service.ApiInfo;
 import springfox.documentation.service.ApiKey;
 import springfox.documentation.service.AuthorizationScope;
 import springfox.documentation.service.SecurityReference;
@@ -22,27 +36,29 @@ import springfox.documentation.swagger.web.UiConfigurationBuilder;
@RequiredArgsConstructor
 public class SwaggerConfig {

-    public static final String SECURITY_SCHEMA_NAME = "Authorization";
-    public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
-    public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
-
    @Bean
    public Docket api() {
-        return new Docket(DocumentationType.OAS_30)
-            .useDefaultResponseMessages(false)
-            .select()
-            .apis(RequestHandlerSelectors.any())
-            .paths(PathSelectors.ant("/api/**")).build()
-            .apiInfo(apiInfo())
+        return new Docket(DocumentationType.OAS_30).useDefaultResponseMessages(false).select()
+            .apis(RequestHandlerSelectors.any()).paths(PathSelectors.ant("/api/**")).build()
            .securityContexts(Arrays.asList(securityContext()))
            .securitySchemes(Arrays.asList(apiKey()));
    }

-    private ApiInfo apiInfo() {
-        return new ApiInfoBuilder()
-            .title("Ticketing REST API Document")
-            .version("v1")
-            .description("Ticketing REST API 문서").build();
+    @Bean
+    public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier, ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier, EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties, WebEndpointProperties webEndpointProperties, Environment environment) {
+        List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
+        Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
+        allEndpoints.addAll(webEndpoints);
+        allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
+        allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
+        String basePath = webEndpointProperties.getBasePath();
+        EndpointMapping endpointMapping = new EndpointMapping(basePath);
+        boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(webEndpointProperties, environment, basePath);
+        return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes, corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath), shouldRegisterLinksMapping, null);
+    }
+
+    private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties, Environment environment, String basePath) {
+        return webEndpointProperties.getDiscovery().isEnabled() && (StringUtils.hasText(basePath) || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
    }

    private ApiKey apiKey() {
@@ -53,6 +69,10 @@ public class SwaggerConfig {
        return SecurityContext.builder().securityReferences(defaultAuth()).build();
    }

+    public static final String SECURITY_SCHEMA_NAME = "Authorization";
+    public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
+    public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
+
    private List<SecurityReference> defaultAuth() {
        AuthorizationScope authorizationScope = new AuthorizationScope(AUTHORIZATION_SCOPE_GLOBAL,
            AUTHORIZATION_SCOPE_GLOBAL_DESC);
--- a/server/src/main/java/com/ticketing/server/global/dto/repository/AbstractEntity.java
+++ b/server/src/main/java/com/ticketing/server/global/dto/repository/AbstractEntity.java
@@ -19,13 +19,15 @@ public abstract class AbstractEntity {

 	@Id
 	@GeneratedValue(strategy = GenerationType.IDENTITY)
-	private Long id;
+	protected Long id;

 	@Column(nullable = false, updatable = false)
 	@CreatedDate
-	private LocalDateTime createdAt;
+	protected LocalDateTime createdAt;

 	@LastModifiedDate
-	private LocalDateTime updatedAt;
+	protected LocalDateTime updatedAt;
+
+	protected LocalDateTime deletedAt;

 }
--- a/server/src/main/java/com/ticketing/server/global/exception/AlreadyDeletedException.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/AlreadyDeletedException.java
@@ -1,9 +0,0 @@
-package com.ticketing.server.global.exception;
-
-public class AlreadyDeletedException extends RuntimeException {
-
-	public AlreadyDeletedException(String message) {
-		super(message);
-	}
-
-}
--- a/server/src/main/java/com/ticketing/server/global/exception/ErrorCode.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/ErrorCode.java
@@ -0,0 +1,106 @@
+package com.ticketing.server.global.exception;
+
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.CONFLICT;
+import static org.springframework.http.HttpStatus.FORBIDDEN;
+import static org.springframework.http.HttpStatus.NOT_FOUND;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+@Getter
+@AllArgsConstructor
+public enum ErrorCode {
+
+	/* 400 BAD_REQUEST : 잘못된 요청 */
+	MISMATCH_PASSWORD(BAD_REQUEST, "비밀번호가 일치하지 않습니다."),
+	TOKEN_TYPE(BAD_REQUEST, "토큰 타입이 올바르지 않습니다."),
+	UNAVAILABLE_REFRESH_TOKEN(BAD_REQUEST, "사용할 수 없는 토큰 입니다."),
+	UNABLE_CHANGE_GRADE(BAD_REQUEST, "동일한 등급으로 변경할 수 없습니다."),
+
+	/* 403 FORBIDDEN : 접근 권한 제한 */
+	VALID_USER_ID(FORBIDDEN, "해당 정보에 접근 권한이 존재하지 않습니다."),
+
+	/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
+	USER_NOT_FOUND(NOT_FOUND, "해당 유저 정보를 찾을 수 없습니다."),
+	EMAIL_NOT_FOUND(NOT_FOUND, "해당 이메일을 찾을 수 없습니다."),
+	MOVIE_NOT_FOUND(NOT_FOUND, "해당 제목의 영화를 찾을 수 없습니다."),
+	REFRESH_TOKEN_NOT_FOUND(NOT_FOUND, "리프레쉬 토큰을 찾을 수 없습니다."),
+	PAYMENT_ID_NOT_FOUND(NOT_FOUND, "결제정보를 찾을 수 없습니다."),
+
+	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
+	DUPLICATE_EMAIL(CONFLICT, "이메일이 이미 존재합니다."),
+	DUPLICATE_PAYMENT(CONFLICT, "해당 좌석은 현재 판매된 좌석입니다."),
+	DUPLICATE_MOVIE(CONFLICT, "해당 영화 정보가 이미 존재합니다."),
+	DELETED_EMAIL(CONFLICT, "이미 삭제된 이메일 입니다."),
+	DELETED_MOVIE(CONFLICT, "이미 삭제된 영화 입니다.");
+
+	private final HttpStatus httpStatus;
+	private final String detail;
+
+	/* 400 BAD_REQUEST : 잘못된 요청 */
+	public static TicketingException throwMismatchPassword() {
+		throw new TicketingException(MISMATCH_PASSWORD);
+	}
+
+	public static TicketingException throwTokenType() {
+		throw new TicketingException(TOKEN_TYPE);
+	}
+
+	public static TicketingException throwUnavailableRefreshToken() {
+		throw new TicketingException(UNAVAILABLE_REFRESH_TOKEN);
+	}
+
+	public static TicketingException throwUnableChangeGrade() {
+		throw new TicketingException(UNABLE_CHANGE_GRADE);
+	}
+
+	/* 403 FORBIDDEN : 접근 권한 제한 */
+	public static TicketingException throwValidUserId() {
+		throw new TicketingException(VALID_USER_ID);
+	}
+
+	/* 404 NOT_FOUND : Resource 를 찾을 수 없음 */
+	public static TicketingException throwUserNotFound() {
+		throw new TicketingException(USER_NOT_FOUND);
+	}
+
+	public static TicketingException throwEmailNotFound() {
+		throw new TicketingException(EMAIL_NOT_FOUND);
+	}
+
+	public static TicketingException throwMovieNotFound() {
+		throw new TicketingException(MOVIE_NOT_FOUND);
+	}
+
+	public static TicketingException throwRefreshTokenNotFound() {
+		throw new TicketingException(REFRESH_TOKEN_NOT_FOUND);
+	}
+
+	public static TicketingException throwPaymentIdNotFound() {
+		throw new TicketingException(PAYMENT_ID_NOT_FOUND);
+	}
+
+	/* 409 CONFLICT : Resource 의 현재 상태와 충돌. 보통 중복된 데이터 존재 */
+	public static TicketingException throwDuplicateEmail() {
+		throw new TicketingException(DUPLICATE_EMAIL);
+	}
+
+	public static TicketingException throwDuplicatePayment() {
+		throw new TicketingException(DUPLICATE_PAYMENT);
+	}
+
+	public static TicketingException throwDuplicateMovie() {
+		throw new TicketingException(DUPLICATE_MOVIE);
+	}
+
+	public static TicketingException throwDeletedEmail() {
+		throw new TicketingException(DELETED_EMAIL);
+	}
+
+	public static TicketingException throwDeletedMovie() {
+		throw new TicketingException(DELETED_MOVIE);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/exception/ErrorResponse.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/ErrorResponse.java
@@ -0,0 +1,35 @@
+package com.ticketing.server.global.exception;
+
+import java.util.List;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+@Getter
+@EqualsAndHashCode
+public class ErrorResponse {
+
+	private final HttpStatus status;
+	private final String message;
+	private final List<String> errors;
+
+	public ErrorResponse(HttpStatus status, String message, List<String> errors) {
+		this.status = status;
+		this.message = message;
+		this.errors = errors;
+	}
+
+	public ErrorResponse(HttpStatus status, String message, String error) {
+		this.status = status;
+		this.message = message;
+		this.errors = List.of(error);
+	}
+
+	public static ErrorResponse toErrorResponse(ErrorCode errorCode) {
+		return new ErrorResponse(
+			errorCode.getHttpStatus(),
+			errorCode.name(),
+			errorCode.getDetail());
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/exception/GlobalExceptionHandler.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/GlobalExceptionHandler.java
@@ -0,0 +1,248 @@
+package com.ticketing.server.global.exception;
+
+import static org.springframework.http.HttpStatus.BAD_REQUEST;
+import static org.springframework.http.HttpStatus.FORBIDDEN;
+import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR;
+import static org.springframework.http.HttpStatus.METHOD_NOT_ALLOWED;
+import static org.springframework.http.HttpStatus.NOT_FOUND;
+import static org.springframework.http.HttpStatus.UNAUTHORIZED;
+import static org.springframework.http.HttpStatus.UNSUPPORTED_MEDIA_TYPE;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import javax.validation.ConstraintViolation;
+import javax.validation.ConstraintViolationException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.TypeMismatchException;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.validation.BindException;
+import org.springframework.validation.FieldError;
+import org.springframework.validation.ObjectError;
+import org.springframework.web.HttpMediaTypeNotSupportedException;
+import org.springframework.web.HttpRequestMethodNotSupportedException;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.MissingServletRequestParameterException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
+import org.springframework.web.multipart.support.MissingServletRequestPartException;
+import org.springframework.web.servlet.NoHandlerFoundException;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+
+@Slf4j
+@RestControllerAdvice
+public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
+
+	/* 400 START */
+
+	/**
+	 * Valid 유효성 검사 실패
+	 */
+	@Override
+	protected ResponseEntity<Object> handleMethodArgumentNotValid(
+		MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("MethodArgumentNotValidException :: ", ex);
+
+		List<String> errors = generateErrors(ex);
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
+
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/***
+	 * ModelAttribute 으로 binding error 발생
+	 */
+	@Override
+	protected ResponseEntity<Object> handleBindException(
+		BindException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("BindException :: ", ex);
+
+		List<String> errors = generateErrors(ex);
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/**
+	 * 잘못된 유형으로 Bean 속성 설정
+	 */
+	@Override
+	protected ResponseEntity<Object> handleTypeMismatch(
+		TypeMismatchException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("TypeMismatchException :: ", ex);
+
+		String error = ex.getValue() + " value for " + ex.getPropertyName() + " should be of type " + ex.getRequiredType();
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/**
+	 * multipart/form-data 요청 실패
+	 */
+	@Override
+	protected ResponseEntity<Object> handleMissingServletRequestPart(
+		MissingServletRequestPartException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("MissingServletRequestPartException :: ", ex);
+
+		String error = ex.getRequestPartName() + " part is missing";
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/**
+	 * 필수 인수 누락
+	 */
+	@Override
+	protected ResponseEntity<Object> handleMissingServletRequestParameter(
+		MissingServletRequestParameterException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("MissingServletRequestParameterException :: ", ex);
+
+		String error = ex.getParameterName() + " parameter is missing";
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/**
+	 * 인수가 예상한 형식이 아닐 시
+	 */
+	@ExceptionHandler(value = MethodArgumentTypeMismatchException.class)
+	protected ResponseEntity<Object> handleMethodArgumentTypeMismatch(MethodArgumentTypeMismatchException ex) {
+		log.error("MethodArgumentTypeMismatchException :: ", ex);
+
+		String error = ex.getName() + " should be of type " + Objects.requireNonNull(ex.getRequiredType()).getName();
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), error);
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 제약 조건 위반
+	 */
+	@ExceptionHandler(value = ConstraintViolationException.class)
+	protected ResponseEntity<Object> handleConstraintViolation(ConstraintViolationException ex) {
+		log.error("ConstraintViolationException :: ", ex);
+
+		List<String> errors = new ArrayList<>();
+		for (ConstraintViolation<?> violation : ex.getConstraintViolations()) {
+			errors.add(violation.getRootBeanClass().getName() + " " + violation.getPropertyPath() + ": " + violation.getMessage());
+		}
+
+		ErrorResponse response = new ErrorResponse(BAD_REQUEST, ex.getLocalizedMessage(), errors);
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/* 400 END */
+
+	/**
+	 * 404 발생
+	 */
+	@Override
+	protected ResponseEntity<Object> handleNoHandlerFoundException(
+		NoHandlerFoundException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("NoHandlerFoundException :: ", ex);
+
+		String error = "No handler found for " + ex.getHttpMethod() + " " + ex.getRequestURL();
+		ErrorResponse response = new ErrorResponse(NOT_FOUND, ex.getLocalizedMessage(), error);
+		return ResponseEntity.status(response.getStatus()).headers(headers).body(response);
+	}
+
+	/**
+	 * 지원하지 않는 HTTP 메서드로 요청 405
+	 */
+	@Override
+	protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(
+		HttpRequestMethodNotSupportedException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("HttpRequestMethodNotSupportedException :: ", ex);
+
+		StringBuilder builder = new StringBuilder();
+		builder.append(ex.getMethod());
+		builder.append(" method is not supported for this request. Supported methods are ");
+
+		Set<HttpMethod> supportedHttpMethods = ex.getSupportedHttpMethods();
+		if (supportedHttpMethods != null) {
+			supportedHttpMethods.forEach(t -> builder.append(t).append(" "));
+		}
+
+		ErrorResponse response = new ErrorResponse(METHOD_NOT_ALLOWED, ex.getLocalizedMessage(), builder.toString());
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 지원되지 않는 미디어 유형으로 요청 415
+	 */
+	@Override
+	protected ResponseEntity<Object> handleHttpMediaTypeNotSupported(
+		HttpMediaTypeNotSupportedException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
+		log.error("HttpMediaTypeNotSupportedException :: ", ex);
+
+		StringBuilder builder = new StringBuilder();
+		builder.append(ex.getContentType());
+		builder.append(" media type is not supported. Supported media types are ");
+		ex.getSupportedMediaTypes().forEach(t -> builder.append(t).append(" "));
+
+		ErrorResponse response = new ErrorResponse(UNSUPPORTED_MEDIA_TYPE, ex.getLocalizedMessage(), builder.substring(0, builder.length() - 2));
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 특정 핸들러 없는 모든 예외 500
+	 */
+	@ExceptionHandler(value = Exception.class)
+	protected ResponseEntity<Object> handleAll(Exception ex) {
+		log.error("Exception :: ", ex);
+
+		ErrorResponse response = new ErrorResponse(INTERNAL_SERVER_ERROR, ex.getLocalizedMessage(), "오류가 발생했습니다.");
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 접근 권한이 없을 때
+	 */
+	@ExceptionHandler(value = AccessDeniedException.class)
+	protected ResponseEntity<ErrorResponse> handleAccessDeniedException(Exception ex) {
+		log.error("AccessDeniedException :: ", ex);
+
+		ErrorResponse response = new ErrorResponse(FORBIDDEN, ex.getLocalizedMessage(), "접근 권한이 없습니다.");
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 인증 정보가 없을 때
+	 */
+	@ExceptionHandler(value = AuthenticationException.class)
+	protected ResponseEntity<ErrorResponse> handleAuthenticationException(Exception ex) {
+		log.error("AuthenticationException :: ", ex);
+
+		ErrorResponse response = new ErrorResponse(UNAUTHORIZED, ex.getLocalizedMessage(), "로그인 후 이용하실 수 있습니다.");
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
+	/**
+	 * 커스텀 예외 발생 시
+	 */
+	@ExceptionHandler(value = TicketingException.class)
+	protected ResponseEntity<ErrorResponse> ticketingException(TicketingException ex) {
+		log.error("TicketingException :: ", ex);
+
+		ErrorCode errorCode = ex.getErrorCode();
+		return ResponseEntity.status(errorCode.getHttpStatus()).body(ErrorResponse.toErrorResponse(errorCode));
+	}
+
+	private List<String> generateErrors(BindException ex) {
+		List<String> errors = new ArrayList<>();
+		List<ObjectError> allErrors = ex.getBindingResult().getAllErrors();
+
+		for (ObjectError error : allErrors) {
+			errors.add(error.getDefaultMessage());
+		}
+		return errors;
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/exception/NotFoundEmailException.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/NotFoundEmailException.java
@@ -1,11 +0,0 @@
-package com.ticketing.server.global.exception;
-
-public class NotFoundEmailException extends IllegalArgumentException {
-
-	private static final String MESSAGE = "존재하지 않는 이메일 입니다.";
-
-	public NotFoundEmailException() {
-		super(MESSAGE);
-	}
-
-}
--- a/server/src/main/java/com/ticketing/server/global/exception/PasswordMismatchException.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/PasswordMismatchException.java
@@ -1,11 +0,0 @@
-package com.ticketing.server.global.exception;
-
-public class PasswordMismatchException extends RuntimeException {
-
-	private static final String MESSAGE = "패스워드가 일치하지 않습니다";
-
-	public PasswordMismatchException() {
-		super(MESSAGE);
-	}
-
-}
--- a/server/src/main/java/com/ticketing/server/global/exception/TicketingException.java
+++ b/server/src/main/java/com/ticketing/server/global/exception/TicketingException.java
@@ -0,0 +1,12 @@
+package com.ticketing.server.global.exception;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketingException extends RuntimeException {
+
+	private final ErrorCode errorCode;
+
+}
--- a/server/src/main/java/com/ticketing/server/global/factory/YamlPropertySourceFactory.java
+++ b/server/src/main/java/com/ticketing/server/global/factory/YamlPropertySourceFactory.java
@@ -5,19 +5,23 @@ import java.util.Properties;
 import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
 import org.springframework.core.env.PropertiesPropertySource;
 import org.springframework.core.env.PropertySource;
-import org.springframework.core.io.Resource;
 import org.springframework.core.io.support.EncodedResource;
 import org.springframework.core.io.support.PropertySourceFactory;
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;

 public class YamlPropertySourceFactory implements PropertySourceFactory {

 	@Override
-	public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource) {
-		Resource resource = encodedResource.getResource();
-		YamlPropertiesFactoryBean factoryBean = new YamlPropertiesFactoryBean();
-		factoryBean.setResources(resource);
+	public PropertySource<?> createPropertySource(@Nullable String name, EncodedResource resource) {
+		Properties yamlProperties = loadYamlProperties(resource);
+		String sourceName = StringUtils.hasText(name) ? name : resource.getResource().getFilename();
+		return new PropertiesPropertySource(Objects.requireNonNull(sourceName), Objects.requireNonNull(yamlProperties));
+	}

-		Properties properties = factoryBean.getObject();
-		return new PropertiesPropertySource(Objects.requireNonNull(resource.getFilename()), Objects.requireNonNull(properties));
+	private Properties loadYamlProperties(EncodedResource resource) {
+		YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
+		factory.setResources(resource.getResource());
+		return factory.getObject();
 	}
 }
--- a/server/src/main/java/com/ticketing/server/global/redis/RedisConfig.java
+++ b/server/src/main/java/com/ticketing/server/global/redis/RedisConfig.java
@@ -0,0 +1,44 @@
+package com.ticketing.server.global.redis;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.transaction.PlatformTransactionManager;
+
+@Configuration
+@EnableRedisRepositories
+public class RedisConfig {
+
+	@Value("${spring.redis.host}")
+	private String host;
+
+	@Value("${spring.redis.port}")
+	private int port;
+
+	@Bean
+	public RedisConnectionFactory redisConnectionFactory() {
+		return new LettuceConnectionFactory(host, port);
+	}
+
+	@Bean
+	public RedisTemplate<String, Object> redisTemplate() {
+		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
+		redisTemplate.setConnectionFactory(redisConnectionFactory());
+		redisTemplate.setKeySerializer(new StringRedisSerializer());
+		redisTemplate.setValueSerializer(new StringRedisSerializer());
+
+		return redisTemplate;
+	}
+
+	@Bean
+	public PlatformTransactionManager transactionManager() {
+		return new JpaTransactionManager();
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/redis/RefreshRedisRepository.java
+++ b/server/src/main/java/com/ticketing/server/global/redis/RefreshRedisRepository.java
@@ -0,0 +1,10 @@
+package com.ticketing.server.global.redis;
+
+import java.util.Optional;
+import org.springframework.data.repository.CrudRepository;
+
+public interface RefreshRedisRepository extends CrudRepository<RefreshToken, Long> {
+
+	Optional<RefreshToken> findByEmail(String email);
+
+}
--- a/server/src/main/java/com/ticketing/server/global/redis/RefreshToken.java
+++ b/server/src/main/java/com/ticketing/server/global/redis/RefreshToken.java
@@ -0,0 +1,35 @@
+package com.ticketing.server.global.redis;
+
+import javax.persistence.Column;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.springframework.data.redis.core.RedisHash;
+import org.springframework.data.redis.core.index.Indexed;
+
+@Getter
+@RedisHash("RefreshToken")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class RefreshToken {
+
+	@Id
+	@GeneratedValue
+	@Column(name = "refresh_token_id")
+	private Long id;
+
+	@Indexed
+	private String email;
+	private String token;
+
+	public RefreshToken(String email, String token) {
+		this.email = email;
+		this.token = token;
+	}
+
+	public void changeToken(String token) {
+		this.token = token;
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/security/RoleConfig.java
+++ b/server/src/main/java/com/ticketing/server/global/security/RoleConfig.java
@@ -0,0 +1,56 @@
+package com.ticketing.server.global.security;
+
+import com.ticketing.server.user.domain.UserGrade;
+import java.util.ArrayList;
+import java.util.List;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.access.AccessDecisionManager;
+import org.springframework.security.access.AccessDecisionVoter;
+import org.springframework.security.access.annotation.Jsr250Voter;
+import org.springframework.security.access.expression.method.ExpressionBasedPreInvocationAdvice;
+import org.springframework.security.access.hierarchicalroles.RoleHierarchy;
+import org.springframework.security.access.hierarchicalroles.RoleHierarchyImpl;
+import org.springframework.security.access.prepost.PreInvocationAuthorizationAdviceVoter;
+import org.springframework.security.access.vote.AffirmativeBased;
+import org.springframework.security.access.vote.AuthenticatedVoter;
+import org.springframework.security.access.vote.RoleHierarchyVoter;
+import org.springframework.security.access.vote.RoleVoter;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;
+
+@EnableGlobalMethodSecurity(
+	securedEnabled = true,
+	jsr250Enabled = true,
+	prePostEnabled = true
+)
+@Configuration
+public class RoleConfig extends GlobalMethodSecurityConfiguration {
+
+	@Override
+	protected AccessDecisionManager accessDecisionManager() {
+		List<AccessDecisionVoter<?>> decisionVoters = new ArrayList<>();
+		ExpressionBasedPreInvocationAdvice expressionAdvice = new ExpressionBasedPreInvocationAdvice();
+		expressionAdvice.setExpressionHandler(getExpressionHandler());
+		decisionVoters.add(new PreInvocationAuthorizationAdviceVoter(expressionAdvice));
+		decisionVoters.add(new Jsr250Voter());
+
+		decisionVoters.add(new RoleVoter());
+		decisionVoters.add(roleHierarchyVoter());
+		decisionVoters.add(new AuthenticatedVoter());
+		return new AffirmativeBased(decisionVoters);
+	}
+
+	@Bean
+	public RoleHierarchyVoter roleHierarchyVoter() {
+		return new RoleHierarchyVoter(roleHierarchy());
+	}
+
+	@Bean
+	public RoleHierarchy roleHierarchy() {
+		RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
+		roleHierarchy.setHierarchy(UserGrade.getRoleHierarchy());
+		return roleHierarchy;
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/global/security/WebSecurityConfig.java
+++ b/server/src/main/java/com/ticketing/server/global/security/WebSecurityConfig.java
@@ -1,14 +1,13 @@
 package com.ticketing.server.global.security;

-import com.ticketing.server.global.jwt.JwtFilter;
-import com.ticketing.server.global.jwt.JwtSecurityConfig;
-import com.ticketing.server.global.jwt.handle.JwtAccessDeniedHandler;
-import com.ticketing.server.global.jwt.handle.JwtAuthenticationEntryPoint;
+import com.ticketing.server.global.security.jwt.JwtFilter;
+import com.ticketing.server.global.security.jwt.JwtSecurityConfig;
+import com.ticketing.server.global.security.jwt.handle.JwtAccessDeniedHandler;
+import com.ticketing.server.global.security.jwt.handle.JwtAuthenticationEntryPoint;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpMethod;
-import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@@ -18,7 +17,6 @@ import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
-@EnableGlobalMethodSecurity(securedEnabled = true)
@RequiredArgsConstructor
 public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@@ -52,12 +50,15 @@ public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

 			.and()
 			.authorizeRequests()
-			.antMatchers(HttpMethod.POST, "/user").permitAll()
-			.antMatchers(HttpMethod.POST, "/user/login").permitAll()
+			.antMatchers(HttpMethod.POST, "/api/auth/token").permitAll()
+			.antMatchers(HttpMethod.POST, "/api/auth/refresh").permitAll()
+			.antMatchers(HttpMethod.POST, "/api/users").permitAll()
+			.antMatchers(HttpMethod.GET,"/api/movies").permitAll()
+			.antMatchers("/api/movieTimes/**").permitAll()
 			.antMatchers("/l7check").permitAll()
-			.antMatchers("/actuator/health").permitAll()
+			.antMatchers("/actuator/**").permitAll()
+			.antMatchers("/api/v3/", "/swagger-ui/**", "/swagger/", "/swagger-resources/**", "/v3/api-docs").permitAll()
 			.anyRequest().authenticated()
-
 			.and()
 			.apply(new JwtSecurityConfig(jwtFilter));
 	}
--- a/server/src/main/java/com/ticketing/server/global/security/jwt/JwtFilter.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/JwtFilter.java
@@ -1,4 +1,4 @@
-package com.ticketing.server.global.jwt;
+package com.ticketing.server.global.security.jwt;

 import java.io.IOException;
 import javax.servlet.FilterChain;
@@ -17,12 +17,10 @@ import org.springframework.web.filter.OncePerRequestFilter;
 public class JwtFilter extends OncePerRequestFilter {

 	private final JwtProvider tokenProvider;
-	private final String accessHeader;
-	private final String tokenPrefix;
+	private final JwtProperties jwtProperties;

 	public JwtFilter(JwtProperties jwtProperties, JwtProvider tokenProvider) {
-		this.accessHeader = jwtProperties.getAccessHeader();
-		this.tokenPrefix = jwtProperties.getPrefix();
+		this.jwtProperties = jwtProperties;
 		this.tokenProvider = tokenProvider;
 	}

@@ -40,11 +38,10 @@ public class JwtFilter extends OncePerRequestFilter {
 	}

 	private String resolveToken(HttpServletRequest request) {
-		String bearerToken = request.getHeader(accessHeader);
-		if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(tokenPrefix)) {
+		String bearerToken = request.getHeader(jwtProperties.getAccessHeader());
+		if (StringUtils.hasText(bearerToken) && jwtProperties.hasTokenStartsWith(bearerToken)) {
 			return bearerToken.substring(7);
 		}
-
 		return null;
 	}

--- a/server/src/main/java/com/ticketing/server/global/security/jwt/JwtProperties.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/JwtProperties.java
@@ -1,4 +1,4 @@
-package com.ticketing.server.global.jwt;
+package com.ticketing.server.global.security.jwt;

 import com.ticketing.server.global.factory.YamlPropertySourceFactory;
 import lombok.Getter;
@@ -10,13 +10,18 @@ import org.springframework.context.annotation.PropertySource;
@Getter
@RequiredArgsConstructor
@ConstructorBinding
-@ConfigurationProperties("jwt")
+@ConfigurationProperties(value = "jwt")
@PropertySource(value = "classpath:application.yml", factory = YamlPropertySourceFactory.class)
 public class JwtProperties {

 	private final String accessHeader;
+	private final String refreshHeader;
 	private final String prefix;
 	private final String secretKey;
-	private final Integer tokenValidityInSeconds;
+	private final Integer accessTokenValidityInSeconds;
+	private final Integer refreshTokenValidityInSeconds;

+	public boolean hasTokenStartsWith(String token) {
+		return token.startsWith(prefix);
+	}
 }
--- a/server/src/main/java/com/ticketing/server/global/security/jwt/JwtProvider.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/JwtProvider.java
@@ -1,14 +1,11 @@
-package com.ticketing.server.global.jwt;
+package com.ticketing.server.global.security.jwt;

+import com.ticketing.server.user.service.dto.TokenDTO;
 import io.jsonwebtoken.Claims;
-import io.jsonwebtoken.ExpiredJwtException;
 import io.jsonwebtoken.Jwts;
-import io.jsonwebtoken.MalformedJwtException;
 import io.jsonwebtoken.SignatureAlgorithm;
-import io.jsonwebtoken.UnsupportedJwtException;
 import io.jsonwebtoken.io.Decoders;
 import io.jsonwebtoken.security.Keys;
-import io.jsonwebtoken.security.SecurityException;
 import java.security.Key;
 import java.util.Arrays;
 import java.util.Date;
@@ -31,29 +28,53 @@ public class JwtProvider {
 	private static final String AUTHORITIES_KEY = "auth";
 	private static final String AUTHORITIES_DELIMITER = ",";

-	private final long tokenValidityInMilliseconds;
 	private final Key key;
+	private final String prefix;
+	private final long accessTokenValidityInMilliseconds;
+	private final long refreshTokenValidityInMilliseconds;

 	public JwtProvider(JwtProperties jwtProperties) {
-		this.tokenValidityInMilliseconds = jwtProperties.getTokenValidityInSeconds();
-
 		byte[] keyBytes = Decoders.BASE64.decode(jwtProperties.getSecretKey());
 		this.key = Keys.hmacShaKeyFor(keyBytes);
+
+		this.prefix = jwtProperties.getPrefix();
+		this.accessTokenValidityInMilliseconds = jwtProperties.getAccessTokenValidityInSeconds() * 1000L;
+		this.refreshTokenValidityInMilliseconds = jwtProperties.getRefreshTokenValidityInSeconds() * 1000L;
 	}

-	public String createToken(Authentication authentication) {
+	public TokenDTO generateTokenDto(Authentication authentication) {
+		String accessToken = createAccessToken(authentication);
+		String refreshToken = createRefreshToken(authentication);
+		long expiresIn = accessTokenValidityInMilliseconds / 1000L;
+
+		return new TokenDTO(accessToken, refreshToken, prefix, expiresIn);
+	}
+
+	private String createAccessToken(Authentication authentication) {
+		// 만료시간 계산
+		long now = (new Date()).getTime();
+		Date accessTokenExpiresIn = new Date(now + this.accessTokenValidityInMilliseconds);
+
+		return createToken(authentication, accessTokenExpiresIn);
+	}
+
+	private String createRefreshToken(Authentication authentication) {
+		// 만료시간 계산
+		long now = (new Date()).getTime();
+		Date refreshTokenExpiresIn = new Date(now + this.refreshTokenValidityInMilliseconds);
+
+		return createToken(authentication, refreshTokenExpiresIn);
+	}
+
+	private String createToken(Authentication authentication, Date expiration) {
 		// 권한 정보 가져오기
 		String authorities = generateStringToAuthorities(authentication);

-		// 만료시간 계산
-		long now = new Date().getTime();
-		Date accessTokenExpiresIn = new Date(now + this.tokenValidityInMilliseconds);
-
 		// JWT 생성
 		return Jwts.builder()
 			.setSubject(authentication.getName()) // email
 			.claim(AUTHORITIES_KEY, authorities) // payload
-			.setExpiration(accessTokenExpiresIn) // 만료일
+			.setExpiration(expiration) // 만료일
 			.signWith(key, SignatureAlgorithm.HS512) // 서명 키 값
 			.compact();
 	}
@@ -75,6 +96,7 @@ public class JwtProvider {
 		// 토큰 복호화
 		Claims claims = parseClaims(token);

+		// 권한조회
 		List<SimpleGrantedAuthority> authorities =
 			Arrays.stream(claims.get(AUTHORITIES_KEY).toString().split(AUTHORITIES_DELIMITER))
 				.map(SimpleGrantedAuthority::new)
@@ -85,25 +107,12 @@ public class JwtProvider {
 	}

 	public boolean validateToken(String token) {
-		try {
-			parseClaims(token);
-			return true;
-		} catch (SecurityException | MalformedJwtException exception) {
-			log.info("잘못된 JWT 서명입니다.");
-		} catch (ExpiredJwtException e) {
-			log.info("잘못된 JWT 토큰입니다.");
-		} catch (UnsupportedJwtException e) {
-			log.info("지원되지 않는 JWT 토큰입니다.");
-		} catch (IllegalArgumentException e) {
-			log.info("JWT 토큰이 잘못되었습니다.");
-		}
-
-		return false;
+		parseClaims(token);
+		return true;
 	}

 	private Claims parseClaims(String token) {
-		return Jwts
-			.parserBuilder()
+		return Jwts.parserBuilder()
 			.setSigningKey(key)
 			.build()
 			.parseClaimsJws(token)
--- a/server/src/main/java/com/ticketing/server/global/security/jwt/JwtSecurityConfig.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/JwtSecurityConfig.java
@@ -1,4 +1,4 @@
-package com.ticketing.server.global.jwt;
+package com.ticketing.server.global.security.jwt;

 import lombok.RequiredArgsConstructor;
 import org.springframework.security.config.annotation.SecurityConfigurerAdapter;
--- a/server/src/main/java/com/ticketing/server/global/security/jwt/handle/JwtAccessDeniedHandler.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/handle/JwtAccessDeniedHandler.java
@@ -1,17 +1,26 @@
-package com.ticketing.server.global.jwt.handle;
+package com.ticketing.server.global.security.jwt.handle;

 import java.io.IOException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.security.web.access.AccessDeniedHandler;
 import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerExceptionResolver;

-@Component
+@Component("JwtAccessDeniedHandler")
 public class JwtAccessDeniedHandler implements AccessDeniedHandler {

+	private final HandlerExceptionResolver resolver;
+
+	public JwtAccessDeniedHandler(@Qualifier("handlerExceptionResolver") HandlerExceptionResolver resolver) {
+		this.resolver = resolver;
+	}
+
 	@Override
 	public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException {
 		response.sendError(HttpServletResponse.SC_FORBIDDEN);
+		resolver.resolveException(request, response, null, accessDeniedException);
 	}
 }
--- a/server/src/main/java/com/ticketing/server/global/security/jwt/handle/JwtAuthenticationEntryPoint.java
+++ b/server/src/main/java/com/ticketing/server/global/security/jwt/handle/JwtAuthenticationEntryPoint.java
@@ -1,17 +1,26 @@
-package com.ticketing.server.global.jwt.handle;
+package com.ticketing.server.global.security.jwt.handle;

 import java.io.IOException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.security.web.AuthenticationEntryPoint;
 import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerExceptionResolver;

-@Component
+@Component("JwtAuthenticationEntryPoint")
 public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

+	private final HandlerExceptionResolver resolver;
+
+	public JwtAuthenticationEntryPoint(@Qualifier("handlerExceptionResolver") HandlerExceptionResolver resolver) {
+		this.resolver = resolver;
+	}
+
 	@Override
 	public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException {
-		response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
+		resolver.resolveException(request, response, null, authException);
 	}
+
 }
--- a/server/src/main/java/com/ticketing/server/global/validator/constraints/FieldsValueNotMatch.java
+++ b/server/src/main/java/com/ticketing/server/global/validator/constraints/FieldsValueNotMatch.java
@@ -0,0 +1,28 @@
+package com.ticketing.server.global.validator.constraints;
+
+import com.ticketing.server.global.validator.constraintvalidators.FieldsValueNotMatchValidator;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import javax.validation.Constraint;
+import javax.validation.Payload;
+
+@Constraint(validatedBy = FieldsValueNotMatchValidator.class)
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface FieldsValueNotMatch {
+
+	String message() default "validation.password.not.change";
+
+	String field();
+
+	String fieldMatch();
+
+	Class<?>[] groups() default {};
+
+	Class<? extends Payload>[] payload() default {};
+
+}
--- a/server/src/main/java/com/ticketing/server/global/validator/constraintvalidators/FieldsValueNotMatchValidator.java
+++ b/server/src/main/java/com/ticketing/server/global/validator/constraintvalidators/FieldsValueNotMatchValidator.java
@@ -0,0 +1,29 @@
+package com.ticketing.server.global.validator.constraintvalidators;
+
+import com.ticketing.server.global.validator.constraints.FieldsValueNotMatch;
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import org.springframework.beans.BeanWrapperImpl;
+
+public class FieldsValueNotMatchValidator implements ConstraintValidator<FieldsValueNotMatch, Object> {
+
+	private String field;
+	private String fieldMatch;
+
+	public void initialize(FieldsValueNotMatch constraintAnnotation) {
+		this.field = constraintAnnotation.field();
+		this.fieldMatch = constraintAnnotation.fieldMatch();
+	}
+
+	@Override
+	public boolean isValid(Object value, ConstraintValidatorContext context) {
+		Object fieldValue = new BeanWrapperImpl(value).getPropertyValue(field);
+		Object fieldMatchValue = new BeanWrapperImpl(value).getPropertyValue(fieldMatch);
+
+		if (fieldValue != null) {
+			return !fieldValue.equals(fieldMatchValue);
+		} else {
+			return fieldMatchValue != null;
+		}
+	}
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/MovieController.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/MovieController.java
@@ -1,8 +1,73 @@
 package com.ticketing.server.movie.application;

+import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
+
+import com.ticketing.server.movie.application.request.MovieDeleteRequest;
+import com.ticketing.server.movie.application.request.MovieRegisterRequest;
+import com.ticketing.server.movie.application.response.MovieDeleteResponse;
+import com.ticketing.server.movie.application.response.MovieListResponse;
+import com.ticketing.server.movie.application.response.MovieInfoResponse;
+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
+import com.ticketing.server.movie.service.interfaces.MovieService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import javax.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

@RestController
+@RequestMapping("/api/movies")
+@Api(value = "Movie API", tags = {"Movie"})
+@RequiredArgsConstructor
+@Slf4j
 public class MovieController {

+	private final MovieService movieService;
+
+	@PostMapping()
+	@ApiOperation(value = "영화 정보 등록")
+	@Secured(STAFF)
+	public ResponseEntity<MovieInfoResponse> registerMovie(@RequestBody @Valid MovieRegisterRequest request) {
+		RegisteredMovieDTO registeredMovieDto =
+			movieService.registerMovie(request.getTitle(), request.getRunningTime());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				registeredMovieDto.toResponse()
+			);
+	}
+
+	@GetMapping()
+	@ApiOperation(value = "영화 목록 조회")
+	public ResponseEntity<MovieListResponse> getMovies() {
+		MovieListDTO movieListDto = movieService.getMovies();
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				movieListDto.toResponse()
+			);
+	}
+
+	@DeleteMapping()
+	@ApiOperation(value = "영화 정보 삭제")
+	@Secured(STAFF)
+	public ResponseEntity<MovieDeleteResponse> deleteMovie(@RequestBody @Valid MovieDeleteRequest request) {
+		DeletedMovieDTO deletedMovieDto = movieService.deleteMovie(request.getId());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				deletedMovieDto.toResponse()
+			);
+	}
 }
--- a/server/src/main/java/com/ticketing/server/movie/application/MovieTimeController.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/MovieTimeController.java
@@ -0,0 +1,39 @@
+package com.ticketing.server.movie.application;
+
+import com.ticketing.server.movie.application.response.MovieTimeListResponse;
+import com.ticketing.server.movie.service.interfaces.MovieTimeService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import java.time.LocalDate;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/movieTimes")
+@Api(value = "MovieTime API", tags = {"Movie Time"})
+@RequiredArgsConstructor
+@Slf4j
+public class MovieTimeController {
+
+    private final MovieTimeService movieTimeService;
+
+    @GetMapping
+    @ApiOperation(value = "영화 시간표 조회")
+    @Validated
+    public ResponseEntity<MovieTimeListResponse> getMovieTimes(
+        @ApiParam(value = "영화 제목", required = true) @RequestParam String title,
+        @ApiParam(value = "상영 날짜", required = true) @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate runningDate) {
+        return ResponseEntity.status(HttpStatus.OK).body(MovieTimeListResponse.from(movieTimeService.getMovieTimes(title, runningDate)));
+    }
+
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/MovieTimesController.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/MovieTimesController.java
@@ -1,8 +0,0 @@
-package com.ticketing.server.movie.application;
-
-import org.springframework.web.bind.annotation.RestController;
-
-@RestController
-public class MovieTimesController {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/application/TicketController.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/TicketController.java
@@ -1,8 +1,30 @@
 package com.ticketing.server.movie.application;

+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.service.interfaces.TicketService;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/tickets")
+@Validated
 public class TicketController {

+	private final TicketService ticketService;
+
+	@GetMapping("payments/{paymentId}")
+	public ResponseEntity<TicketDetailsResponse> findTicketsByPaymentId(@PathVariable("paymentId") @NotNull Long paymentId) {
+		TicketDetailsDTO tickets = ticketService.findTicketsByPaymentId(paymentId);
+		return ResponseEntity.status(HttpStatus.OK).body(tickets.toResponse());
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/application/request/MovieDeleteRequest.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/request/MovieDeleteRequest.java
@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.request;
+
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieDeleteRequest {
+
+	@NotNull(message = "{validation.not.null.id}")
+	private Long id;
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/request/MovieRegisterRequest.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/request/MovieRegisterRequest.java
@@ -0,0 +1,25 @@
+package com.ticketing.server.movie.application.request;
+
+import com.ticketing.server.movie.service.dto.MovieRegisterDTO;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieRegisterRequest {
+
+	@NotEmpty(message = "{validation.not.empty.title}")
+	private String title;
+
+	@NotNull(message = "{validation.not.null.runningTime}")
+	private Long runningTime;
+
+	public MovieRegisterDTO toMovieRegisterDTO() {
+		return new MovieRegisterDTO(this.title, this.runningTime);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/response/MovieDeleteResponse.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/response/MovieDeleteResponse.java
@@ -0,0 +1,17 @@
+package com.ticketing.server.movie.application.response;
+
+import java.time.LocalDateTime;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieDeleteResponse {
+
+	private final Long id;
+
+	private final String title;
+
+	private final LocalDateTime deletedAt;
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/response/MovieInfoResponse.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/response/MovieInfoResponse.java
@@ -0,0 +1,17 @@
+package com.ticketing.server.movie.application.response;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieInfoResponse {
+
+	@ApiModelProperty(value = "영화 ID")
+	private Long movieId;
+
+	@ApiModelProperty(value = "영화 제목")
+	private String title;
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/response/MovieListResponse.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/response/MovieListResponse.java
@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieListResponse {
+
+    @ApiModelProperty(value = "영화 제목")
+    private List<MovieDTO> movieDtos;
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/response/MovieTimeListResponse.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/response/MovieTimeListResponse.java
@@ -0,0 +1,21 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieTimeListResponse {
+
+    @ApiModelProperty(value = "영화 시간표 정보")
+    private List<MovieTimeDTO> movieTimeDTOS;
+
+    public static MovieTimeListResponse from(List<MovieTimeDTO> movieTimeDtos) {
+        return new MovieTimeListResponse(movieTimeDtos);
+    }
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/application/response/TicketDetailsResponse.java
+++ b/server/src/main/java/com/ticketing/server/movie/application/response/TicketDetailsResponse.java
@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import lombok.Getter;
+
+@Getter
+public class TicketDetailsResponse {
+
+	private final List<TicketDetailDTO> ticketDetails;
+
+	public TicketDetailsResponse(List<TicketDetailDTO> ticketDetails) {
+		this.ticketDetails = ticketDetails;
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/domain/Movie.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/Movie.java
@@ -1,24 +1,46 @@
 package com.ticketing.server.movie.domain;

 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import javax.persistence.Column;
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import java.time.LocalDateTime;
 import javax.persistence.Entity;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;

@Entity
@Getter
-@NoArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
 public class Movie extends AbstractEntity {

-    @NotNull
-    @Column(unique = true)
-    private String title;
+	@NotNull
+	private String title;

-    @NotNull
-    private Integer runningTime;
+	@NotNull
+	private Long runningTime;
+
+	Movie(Long id, String title, Long runningTime) {
+		this.id = id;
+		this.title = title;
+		this.runningTime = runningTime;
+	}
+
+	public Movie delete() {
+		if (deletedAt != null) {
+			throw ErrorCode.throwDeletedMovie();
+		}
+
+		deletedAt = LocalDateTime.now();
+
+		return this;
+	}
+
+	public MovieDTO toMovieDTO() {
+		return new MovieDTO(this.id, this.title);
+	}

 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/MovieTime.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/MovieTime.java
@@ -0,0 +1,75 @@
+package com.ticketing.server.movie.domain;
+
+import com.ticketing.server.global.dto.repository.AbstractEntity;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
+import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MovieTime extends AbstractEntity {
+
+	@NotNull
+	@ManyToOne(fetch = FetchType.LAZY)
+	@JoinColumn(name = "movie_id", referencedColumnName = "id", updatable = false)
+	private Movie movie;
+
+	@NotNull
+	@ManyToOne(fetch = FetchType.LAZY)
+	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
+	private Theater theater;
+
+	@NotNull
+	private Integer round;
+
+	@NotNull
+	private LocalDateTime startAt;
+
+	@NotNull
+	private LocalDateTime endAt;
+
+	@OneToMany(mappedBy = "movieTime", cascade = CascadeType.ALL)
+	private List<Ticket> tickets = new ArrayList<>();
+
+	public MovieTime(Movie movie, Theater theater, int round, LocalDateTime startAt) {
+		this.movie = movie;
+		this.theater = theater;
+		this.round = round;
+		this.startAt = startAt;
+		this.endAt = generateEndAt(startAt);
+	}
+
+	MovieTime(Long id, Movie movie, Theater theater, int round, LocalDateTime startAt) {
+		this.id = id;
+		this.movie = movie;
+		this.theater = theater;
+		this.round = round;
+		this.startAt = startAt;
+		this.endAt = generateEndAt(startAt);
+	}
+
+	private LocalDateTime generateEndAt(LocalDateTime startAt) {
+		Long runningTime = movie.getRunningTime();
+		return startAt.plusMinutes(runningTime);
+	}
+
+	public String getMovieTitle() {
+		return this.movie.getTitle();
+	}
+
+	public List<Seat> getSeats() {
+		return this.theater.getSeats();
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/domain/MovieTimes.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/MovieTimes.java
@@ -1,38 +0,0 @@
-package com.ticketing.server.movie.domain;
-
-import com.ticketing.server.global.dto.repository.AbstractEntity;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import javax.persistence.Entity;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
-import javax.validation.constraints.NotNull;
-import lombok.Getter;
-
-@Entity
-@Getter
-public class MovieTimes extends AbstractEntity {
-
-	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "movie_id", referencedColumnName = "id", updatable = false)
-	private Movie movie;
-
-	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
-	private Theater theater;
-
-	@NotNull
-	private LocalDate runningDate;
-
-	@NotNull
-	private Integer round;
-
-	@NotNull
-	private LocalDateTime startAt;
-
-	@NotNull
-	private LocalDateTime endAt;
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/domain/Seat.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/Seat.java
@@ -2,17 +2,21 @@ package com.ticketing.server.movie.domain;

 import com.ticketing.server.global.dto.repository.AbstractEntity;
 import javax.persistence.Entity;
+import javax.persistence.FetchType;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;

@Entity
@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Seat extends AbstractEntity {

 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "theater_id", referencedColumnName = "id", updatable = false)
 	private Theater theater;

@@ -22,4 +26,26 @@ public class Seat extends AbstractEntity {
 	@NotNull
 	private Integer seatRow;

+	public Seat(Integer seatColumn, Integer seatRow, Theater theater) {
+		this.seatColumn = seatColumn;
+		this.seatRow = seatRow;
+		setTheater(theater);
+	}
+
+	Seat(Long id, int column, int row, Theater theater) {
+		this.id = id;
+		this.seatColumn = column;
+		this.seatRow = row;
+		setTheater(theater);
+	}
+
+	private void setTheater(Theater theater) {
+		this.theater = theater;
+		theater.addSeat(this);
+	}
+
+	public Integer getTheaterNumber() {
+		return this.theater.getTheaterNumber();
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/Theater.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/Theater.java
@@ -1,21 +1,38 @@
 package com.ticketing.server.movie.domain;

 import com.ticketing.server.global.dto.repository.AbstractEntity;
+import java.util.ArrayList;
+import java.util.List;
+import javax.persistence.CascadeType;
 import javax.persistence.Entity;
+import javax.persistence.OneToMany;
 import javax.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;

@Entity
@Getter
-@NoArgsConstructor
-@AllArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Theater extends AbstractEntity {

 	@NotNull
 	private Integer theaterNumber;

-	private Integer seatCount;
+	@OneToMany(mappedBy = "theater", cascade = CascadeType.ALL)
+	private List<Seat> seats = new ArrayList<>();
+
+	Theater(Long id, Integer theaterNumber) {
+		this.id = id;
+		this.theaterNumber = theaterNumber;
+	}
+
+	public Theater(Integer theaterNumber) {
+		this.theaterNumber = theaterNumber;
+	}
+
+	public void addSeat(Seat seat) {
+		seats.add(seat);
+	}

 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/Ticket.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/Ticket.java
@@ -1,35 +1,89 @@
 package com.ticketing.server.movie.domain;

 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.global.exception.ErrorCode;
+import java.time.LocalDateTime;
 import javax.persistence.Entity;
+import javax.persistence.EnumType;
+import javax.persistence.Enumerated;
+import javax.persistence.FetchType;
 import javax.persistence.JoinColumn;
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;

@Entity
@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Ticket extends AbstractEntity {

 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "seat_id", referencedColumnName = "id", updatable = false)
 	private Seat seat;

 	@NotNull
-	@ManyToOne
+	@ManyToOne(fetch = FetchType.LAZY)
 	@JoinColumn(name = "movie_times_id", referencedColumnName = "id", updatable = false)
-	private MovieTimes movieTimes;
+	private MovieTime movieTime;

-	@ManyToOne
-	@JoinColumn(name = "payment_id", referencedColumnName = "id", updatable = false)
-	private Payment payment;
+	private Long paymentId;

 	@NotNull
+	@Enumerated(EnumType.STRING)
 	private TicketStatus status;

 	@NotNull
 	private Integer ticketPrice;

+	public Ticket(Seat seat, MovieTime movieTime, Integer ticketPrice) {
+		this.seat = seat;
+		this.movieTime = movieTime;
+		this.ticketPrice = ticketPrice;
+		this.status = TicketStatus.SALE;
+	}
+
+	Ticket(Long id, Seat seat, MovieTime movieTime, Integer ticketPrice) {
+		this.id = id;
+		this.seat = seat;
+		this.movieTime = movieTime;
+		this.ticketPrice = ticketPrice;
+		this.status = TicketStatus.SALE;
+	}
+
+	public Integer getColumn() {
+		return this.seat.getSeatColumn();
+	}
+
+	public Integer getRow() {
+		return this.seat.getSeatRow();
+	}
+
+	public LocalDateTime getStartAt() {
+		return this.movieTime.getStartAt();
+	}
+
+	public LocalDateTime getEndAt() {
+		return this.movieTime.getEndAt();
+	}
+
+	public Integer getTheaterNumber() {
+		return this.seat.getTheaterNumber();
+	}
+
+	public String getMovieTitle() {
+		return this.movieTime.getMovieTitle();
+	}
+
+	public void registerPayment(Long id) {
+		if (this.paymentId != null) {
+			throw ErrorCode.throwDuplicatePayment();
+		}
+
+		this.paymentId = id;
+	}
+
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/TicketStatus.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/TicketStatus.java
@@ -6,10 +6,11 @@ import lombok.Getter;
@Getter
@AllArgsConstructor
 public enum TicketStatus {
-    SALE("판매가능"),
-    SCHEDULED("환불"),
-    SOLD("판매완료");

-    private String name;
+	SALE("판매가능"),
+	SCHEDULED("환불"),
+	SOLD("판매완료");
+
+	private String name;

 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieRepository.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieRepository.java
@@ -1,8 +1,11 @@
 package com.ticketing.server.movie.domain.repository;

 import com.ticketing.server.movie.domain.Movie;
+import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;

@Repository
@@ -10,4 +13,17 @@ public interface MovieRepository extends JpaRepository<Movie, Long> {

    Optional<Movie> findByTitle(String title);

+	Optional<Movie> findByIdAndDeletedAtNull(Long id);
+
+	@Query(value = "SELECT m "
+		+ "FROM Movie m "
+		+ "WHERE title = :title "
+		+ "AND deleted_at IS NULL")
+	Optional<Movie> findValidMovieWithTitle(String title);
+
+    @Query(value = "SELECT * "
+        + "FROM movie "
+        + "WHERE deleted_at IS NULL", nativeQuery = true)
+    List<Movie> findValidMovies();
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimeRepository.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimeRepository.java
@@ -0,0 +1,21 @@
+package com.ticketing.server.movie.domain.repository;
+
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import java.time.LocalDateTime;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface MovieTimeRepository extends JpaRepository<MovieTime, Long> {
+
+    @Query(value = "SELECT mt "
+        + "FROM MovieTime mt "
+        + "JOIN FETCH mt.movie "
+        + "WHERE mt.movie = :movie "
+        + "AND mt.startAt BETWEEN :startOfDay AND :endOfDay ")
+    List<MovieTime> findValidMovieTimes(Movie movie, LocalDateTime startOfDay, LocalDateTime endOfDay);
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimesRepository.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/repository/MovieTimesRepository.java
@@ -1,10 +0,0 @@
-package com.ticketing.server.movie.domain.repository;
-
-import com.ticketing.server.movie.domain.MovieTimes;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface MovieTimesRepository extends JpaRepository<MovieTimes, Long> {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/domain/repository/TicketRepository.java
+++ b/server/src/main/java/com/ticketing/server/movie/domain/repository/TicketRepository.java
@@ -1,10 +1,24 @@
 package com.ticketing.server.movie.domain.repository;

 import com.ticketing.server.movie.domain.Ticket;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;

@Repository
 public interface TicketRepository extends JpaRepository<Ticket, Long> {

+	@Query(
+		value =
+			"SELECT t "
+			+ "FROM Ticket t "
+			+ "JOIN FETCH t.movieTime mt "
+			+ "JOIN FETCH t.seat s "
+			+ "JOIN FETCH s.theater th "
+			+ "WHERE t.paymentId = :paymentId "
+	)
+	List<Ticket> findTicketFetchJoinByPaymentId(@Param("paymentId") Long paymentId);
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/service/MovieServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/MovieServiceImpl.java
@@ -1,9 +1,62 @@
 package com.ticketing.server.movie.service;

+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
+import com.ticketing.server.movie.service.dto.MovieDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import javax.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;

@Service
+@RequiredArgsConstructor
+@Slf4j
 public class MovieServiceImpl implements MovieService {

+	private final MovieRepository movieRepository;
+
+	@Override
+	public RegisteredMovieDTO registerMovie(String title, Long runningTime) {
+		Optional<Movie> movie = movieRepository.findValidMovieWithTitle(title);
+
+		if(movie.isEmpty()) {
+			Movie newMovie = movieRepository.save(
+				new Movie(title, runningTime)
+			);
+
+			return new RegisteredMovieDTO(newMovie);
+		}
+
+		throw ErrorCode.throwDuplicateMovie();
+	}
+
+	@Override
+	public MovieListDTO getMovies() {
+		List<Movie> movies = movieRepository.findValidMovies();
+
+		List<MovieDTO> movieDtos = movies.stream()
+			.map(movie -> movie.toMovieDTO())
+			.collect(Collectors.toList());
+
+		return new MovieListDTO(movieDtos);
+	}
+
+	@Override
+	@Transactional
+	public DeletedMovieDTO deleteMovie(Long id) {
+		Movie movie = movieRepository.findByIdAndDeletedAtNull(id)
+			.orElseThrow(ErrorCode::throwMovieNotFound);
+
+		Movie deletedMovie = movie.delete();
+
+		return new DeletedMovieDTO(deletedMovie);
+	}
 }
--- a/server/src/main/java/com/ticketing/server/movie/service/MovieTimeServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/MovieTimeServiceImpl.java
@@ -0,0 +1,43 @@
+package com.ticketing.server.movie.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import com.ticketing.server.movie.service.interfaces.MovieTimeService;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class MovieTimeServiceImpl implements MovieTimeService {
+
+	private final MovieRepository movieRepository;
+
+	private final MovieTimeRepository movieTimeRepository;
+
+	@Override
+	public List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate) {
+		Movie movie = movieRepository.findByTitle(title)
+			.orElseThrow(ErrorCode::throwMovieNotFound);
+
+		LocalDateTime startOfDay = runningDate.atStartOfDay().plusHours(6);
+		LocalDateTime endOfDay = startOfDay.plusDays(1);
+
+		List<MovieTime> movieTimes = movieTimeRepository.findValidMovieTimes(movie, startOfDay, endOfDay);
+
+		return movieTimes.stream()
+			.map(MovieTimeDTO::from)
+			.collect(Collectors.toList());
+
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/MovieTimesServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/MovieTimesServiceImpl.java
@@ -1,9 +0,0 @@
-package com.ticketing.server.movie.service;
-
-import com.ticketing.server.movie.service.interfaces.MovieTimesService;
-import org.springframework.stereotype.Service;
-
-@Service
-public class MovieTimesServiceImpl implements MovieTimesService {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/service/TMBDServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/TMBDServiceImpl.java
@@ -1,9 +0,0 @@
-package com.ticketing.server.movie.service;
-
-import com.ticketing.server.movie.service.interfaces.TMDBService;
-import org.springframework.stereotype.Service;
-
-@Service
-public class TMBDServiceImpl implements TMDBService {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/service/TicketServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/TicketServiceImpl.java
@@ -1,9 +1,40 @@
 package com.ticketing.server.movie.service;

+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.domain.repository.TicketRepository;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
 import com.ticketing.server.movie.service.interfaces.TicketService;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;

@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
 public class TicketServiceImpl implements TicketService {

+	private final TicketRepository ticketRepository;
+
+	@Override
+	public TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId) {
+		List<TicketDetailDTO> ticketDetails = ticketRepository.findTicketFetchJoinByPaymentId(paymentId)
+			.stream()
+			.map(TicketDetailDTO::new)
+			.collect(Collectors.toList());
+
+		if (ticketDetails.isEmpty()) {
+			throw ErrorCode.throwPaymentIdNotFound();
+		}
+
+		return new TicketDetailsDTO(ticketDetails);
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/DeletedMovieDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/DeletedMovieDTO.java
@@ -0,0 +1,32 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieDeleteResponse;
+import com.ticketing.server.movie.domain.Movie;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class DeletedMovieDTO {
+
+	private final Long id;
+
+	private final String title;
+
+	private final LocalDateTime deletedAt;
+
+	public DeletedMovieDTO(Movie movie) {
+		this(
+			movie.getId(),
+			movie.getTitle(),
+			movie.getDeletedAt()
+		);
+	}
+
+	public MovieDeleteResponse toResponse() {
+		return new MovieDeleteResponse(id, title, deletedAt);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/MovieDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/MovieDTO.java
@@ -0,0 +1,14 @@
+package com.ticketing.server.movie.service.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class MovieDTO {
+
+	private Long movieId;
+
+    private String title;
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/MovieListDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/MovieListDTO.java
@@ -0,0 +1,18 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieListResponse;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor()
+public class MovieListDTO {
+
+	private final List<MovieDTO> movieDtos;
+
+	public MovieListResponse toResponse() {
+		return new MovieListResponse(movieDtos);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/MovieRegisterDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/MovieRegisterDTO.java
@@ -0,0 +1,24 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.Movie;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class MovieRegisterDTO {
+
+	@NotEmpty(message = "{validation.not.empty.title}")
+	private String title;
+
+	@NotNull(message = "{validation.not.null.runningTime}")
+	private Long runningTime;
+
+	public Movie toMovie() {
+		return new Movie(this.title, this.runningTime);
+	}
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/MovieTimeDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/MovieTimeDTO.java
@@ -0,0 +1,28 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.MovieTime;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieTimeDTO {
+
+    private Long movieTimeId;
+
+    private Integer theaterNumber;
+
+    private Integer round;
+
+    private LocalDateTime startAt;
+
+    private LocalDateTime endAt;
+
+    public static MovieTimeDTO from(MovieTime movieTime) {
+        return new MovieTimeDTO(movieTime.getId(), movieTime.getTheater().getTheaterNumber(),
+            movieTime.getRound(), movieTime.getStartAt(), movieTime.getEndAt());
+    }
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/RegisteredMovieDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/RegisteredMovieDTO.java
@@ -0,0 +1,28 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.MovieInfoResponse;
+import com.ticketing.server.movie.domain.Movie;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class RegisteredMovieDTO {
+
+	private final Long id;
+
+	private final String title;
+
+	public RegisteredMovieDTO(Movie movie) {
+		this(
+			movie.getId(),
+			movie.getTitle()
+		);
+	}
+
+	public MovieInfoResponse toResponse() {
+		return new MovieInfoResponse(id, title);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/dto/TicketDetailsDTO.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/dto/TicketDetailsDTO.java
@@ -0,0 +1,18 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketDetailsDTO {
+
+	private final List<TicketDetailDTO> ticketDetails;
+
+	public TicketDetailsResponse toResponse() {
+		return new TicketDetailsResponse(ticketDetails);
+	}
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieService.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieService.java
@@ -1,5 +1,14 @@
 package com.ticketing.server.movie.service.interfaces;

+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
+import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
+
 public interface MovieService {

+	RegisteredMovieDTO registerMovie(String title, Long runningTime);
+
+	MovieListDTO getMovies();
+
+	DeletedMovieDTO deleteMovie(Long id);
 }
--- a/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimeService.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimeService.java
@@ -0,0 +1,11 @@
+package com.ticketing.server.movie.service.interfaces;
+
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import java.time.LocalDate;
+import java.util.List;
+
+public interface MovieTimeService {
+
+    List<MovieTimeDTO> getMovieTimes(String title, LocalDate runningDate);
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimesService.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimesService.java
@@ -1,5 +0,0 @@
-package com.ticketing.server.movie.service.interfaces;
-
-public interface MovieTimesService {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/service/interfaces/TMDBService.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/interfaces/TMDBService.java
@@ -1,5 +0,0 @@
-package com.ticketing.server.movie.service.interfaces;
-
-public interface TMDBService {
-
-}
--- a/server/src/main/java/com/ticketing/server/movie/service/interfaces/TicketService.java
+++ b/server/src/main/java/com/ticketing/server/movie/service/interfaces/TicketService.java
@@ -1,5 +1,10 @@
 package com.ticketing.server.movie.service.interfaces;

+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import javax.validation.constraints.NotNull;
+
 public interface TicketService {

+	TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId);
+
 }
--- a/server/src/main/java/com/ticketing/server/movie/setup/MovieSetupController.java
+++ b/server/src/main/java/com/ticketing/server/movie/setup/MovieSetupController.java
@@ -0,0 +1,20 @@
+package com.ticketing.server.movie.setup;
+
+import javax.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Profile;
+import org.springframework.web.bind.annotation.RestController;
+
+@Profile(value = {"local"})
+@RestController
+@RequiredArgsConstructor
+public class MovieSetupController {
+
+	private final MovieSetupService movieSetupService;
+
+	@PostConstruct
+	public void setup() {
+		movieSetupService.init();
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/movie/setup/MovieSetupService.java
+++ b/server/src/main/java/com/ticketing/server/movie/setup/MovieSetupService.java
@@ -0,0 +1,131 @@
+package com.ticketing.server.movie.setup;
+
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.MovieTime;
+import com.ticketing.server.movie.domain.Seat;
+import com.ticketing.server.movie.domain.Theater;
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
+import com.ticketing.server.movie.domain.repository.TheaterRepository;
+import com.ticketing.server.movie.domain.repository.TicketRepository;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.PaymentStatus;
+import com.ticketing.server.payment.domain.PaymentType;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.CreatePaymentDTO;
+import com.ticketing.server.user.domain.User;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.domain.repository.UserRepository;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class
+MovieSetupService {
+
+	private final UserRepository userRepository;
+	private final MovieRepository movieRepository;
+	private final MovieTimeRepository movieTimeRepository;
+	private final TheaterRepository theaterRepository;
+	private final TicketRepository ticketRepository;
+	private final PaymentRepository paymentRepository;
+
+	private final PasswordEncoder passwordEncoder;
+
+	@Transactional
+	public void init() {
+		initMovie();
+		initTheater();
+		initMovieTime();
+		initTicket();
+		initPayment();
+	}
+
+	private void initMovie() {
+		List<Movie> movies = Arrays.asList(
+			new Movie("탑건: 매버릭", 130L),
+			new Movie("헤어질 결심", 138L),
+			new Movie("마녀2", 137L),
+			new Movie("범죄도시2", 106L),
+			new Movie("버즈 라이트이어", 105L)
+		);
+
+		movieRepository.saveAll(movies);
+	}
+
+	private void initTheater() {
+		List<Theater> theaters = Arrays.asList(
+			new Theater(1),
+			new Theater(2)
+		);
+
+		for (Theater theater : theaters) {
+			for (int col = 1; col <= 2; col++) {
+				for (int row = 1; row <= 10; row++) {
+					new Seat(col, row, theater);
+				}
+			}
+		}
+
+		theaterRepository.saveAll(theaters);
+	}
+
+	private void initMovieTime() {
+		List<Movie> movies = movieRepository.findAll();
+		List<Theater> theaters = theaterRepository.findAll();
+
+		LocalDateTime now = LocalDateTime.now();
+
+		List<MovieTime> movieTimes = new ArrayList<>();
+		for (Theater theater : theaters) {
+			movieTimes.add(new MovieTime(movies.get(0), theater, 1, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 8, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 3, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 12, 0)));
+			movieTimes.add(new MovieTime(movies.get(1), theater, 2, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 10, 0)));
+			movieTimes.add(new MovieTime(movies.get(2), theater, 4, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 14, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 5, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 16, 0)));
+			movieTimes.add(new MovieTime(movies.get(3), theater, 6, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 18, 0)));
+			movieTimes.add(new MovieTime(movies.get(0), theater, 7, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 21, 0)));
+			movieTimes.add(new MovieTime(movies.get(4), theater, 8, LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 23, 0)));
+		}
+
+		movieTimeRepository.saveAll(movieTimes);
+	}
+
+	private void initTicket() {
+		List<MovieTime> movieTimes = movieTimeRepository.findAll();
+
+		List<Ticket> tickets = new ArrayList<>();
+		Integer ticketPrice = 15_000;
+		for (MovieTime movieTime : movieTimes) {
+			for (Seat seat : movieTime.getSeats()) {
+				tickets.add(new Ticket(seat, movieTime, ticketPrice));
+			}
+		}
+
+		ticketRepository.saveAll(tickets);
+	}
+
+	private void initPayment() {
+		User user = userRepository.save(new User(123L, "김동효", "kdhyo98@gmail.com", passwordEncoder.encode("123123"), UserGrade.USER, "010-1234-5678"));
+
+		List<Ticket> tickets = ticketRepository.findAll();
+		Ticket ticket = tickets.get(0);
+		String title = ticket.getMovieTime().getMovie().getTitle();
+		CreatePaymentDTO createPaymentDto = new CreatePaymentDTO(user.getAlternateId(), title, PaymentType.KAKAO_PAY, PaymentStatus.COMPLETED, "2022-0710-4142", 30_000);
+		Payment payment = createPaymentDto.toEntity();
+
+		paymentRepository.save(payment);
+
+		ticket.registerPayment(payment.getId());
+		tickets.get(1).registerPayment(payment.getId());
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/api/MovieClient.java
+++ b/server/src/main/java/com/ticketing/server/payment/api/MovieClient.java
@@ -0,0 +1,10 @@
+package com.ticketing.server.payment.api;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import javax.validation.constraints.NotNull;
+
+public interface MovieClient {
+
+	TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId);
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/api/UserClient.java
+++ b/server/src/main/java/com/ticketing/server/payment/api/UserClient.java
@@ -0,0 +1,8 @@
+package com.ticketing.server.payment.api;
+
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+
+public interface UserClient {
+
+	UserDetailResponse detail();
+}
--- a/server/src/main/java/com/ticketing/server/payment/api/dto/response/UserDetailResponse.java
+++ b/server/src/main/java/com/ticketing/server/payment/api/dto/response/UserDetailResponse.java
@@ -0,0 +1,34 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class UserDetailResponse {
+
+	private final Long userAlternateId;
+	private final String name;
+	private final String email;
+	private final UserGrade grade;
+	private final String phone;
+
+	public UserDetailResponse(UserDetailDTO userDetailDto) {
+		this(
+			userDetailDto.getAlternateId(),
+			userDetailDto.getName(),
+			userDetailDto.getEmail(),
+			userDetailDto.getGrade(),
+			userDetailDto.getPhone()
+		);
+	}
+
+	public boolean hasUserAlternateId(Payment payment) {
+		return userAlternateId.equals(payment.getUserAlternateId());
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/api/impl/MovieClientImpl.java
+++ b/server/src/main/java/com/ticketing/server/payment/api/impl/MovieClientImpl.java
@@ -0,0 +1,25 @@
+package com.ticketing.server.payment.api.impl;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.service.interfaces.TicketService;
+import com.ticketing.server.payment.api.MovieClient;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+@Service
+@RequiredArgsConstructor
+@Validated
+public class MovieClientImpl implements MovieClient {
+
+	private final TicketService ticketService;
+
+	@Override
+	public TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId) {
+		TicketDetailsDTO ticketDetails = ticketService.findTicketsByPaymentId(paymentId);
+		return ticketDetails.toResponse();
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/api/impl/UserClientImpl.java
+++ b/server/src/main/java/com/ticketing/server/payment/api/impl/UserClientImpl.java
@@ -0,0 +1,28 @@
+package com.ticketing.server.payment.api.impl;
+
+import com.ticketing.server.payment.api.UserClient;
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+import com.ticketing.server.user.service.dto.UserDetailDTO;
+import com.ticketing.server.user.service.interfaces.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class UserClientImpl implements UserClient {
+
+	private final UserService userService;
+
+	@Override
+	public UserDetailResponse detail() {
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		UserDetails details = (UserDetails) authentication.getPrincipal();
+
+		UserDetailDTO userDetail = userService.findDetailByEmail(details.getUsername());
+		return new UserDetailResponse(userDetail);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/application/PaymentController.java
+++ b/server/src/main/java/com/ticketing/server/payment/application/PaymentController.java
@@ -1,8 +1,47 @@
 package com.ticketing.server.payment.application;

+import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentApisService;
+import com.ticketing.server.payment.service.interfaces.PaymentService;
+import com.ticketing.server.user.domain.UserGrade;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/payments")
+@Validated
 public class PaymentController {

+	private final PaymentApisService paymentApisService;
+	private final PaymentService paymentService;
+
+	@GetMapping
+	@Secured(UserGrade.ROLES.USER)
+	public ResponseEntity<SimplePaymentsResponse> simplePayments(@NotNull Long userAlternateId) {
+		SimplePaymentsDTO simplePayments = paymentService.findSimplePayments(userAlternateId);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(simplePayments.toResponse());
+	}
+
+	@GetMapping("/detail")
+	@Secured(UserGrade.ROLES.USER)
+	public ResponseEntity<PaymentDetailResponse> detail(@NotNull Long paymentId) {
+		PaymentDetailDTO paymentDetail = paymentApisService.findPaymentDetail(paymentId);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentDetail.toResponse());
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/payment/application/response/PaymentDetailResponse.java
+++ b/server/src/main/java/com/ticketing/server/payment/application/response/PaymentDetailResponse.java
@@ -0,0 +1,20 @@
+package com.ticketing.server.payment.application.response;
+
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class PaymentDetailResponse {
+
+	private Long paymentId;
+	private String movieTitle;
+	private String paymentNumber;
+	private Integer totalPrice;
+	private LocalDateTime createdAt;
+	private List<TicketDetailDTO> tickets;
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/application/response/SimplePaymentsResponse.java
+++ b/server/src/main/java/com/ticketing/server/payment/application/response/SimplePaymentsResponse.java
@@ -0,0 +1,15 @@
+package com.ticketing.server.payment.application.response;
+
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class SimplePaymentsResponse {
+
+	private final Long userAlternateId;
+	private final List<SimplePaymentDTO> payments;
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/domain/Payment.java
+++ b/server/src/main/java/com/ticketing/server/payment/domain/Payment.java
@@ -1,38 +1,67 @@
 package com.ticketing.server.payment.domain;

 import com.ticketing.server.global.dto.repository.AbstractEntity;
-import com.ticketing.server.user.domain.User;
+import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.persistence.EnumType;
 import javax.persistence.Enumerated;
-import javax.persistence.JoinColumn;
-import javax.persistence.ManyToOne;
+import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
+import lombok.AccessLevel;
 import lombok.Getter;
+import lombok.NoArgsConstructor;

@Entity
@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Payment extends AbstractEntity {

 	@NotNull
-	@ManyToOne
-	@JoinColumn(name = "user_id", referencedColumnName = "id", updatable = false)
-	private User user;
+	@Column(name = "user_alternate_id", nullable = false)
+	private Long userAlternateId;
+
+	@NotEmpty
+	@Column(name = "movie_title", nullable = false)
+	private String movieTitle;

 	@NotNull
+	@Column(name = "type", nullable = false)
 	@Enumerated(value = EnumType.STRING)
 	private PaymentType type;

 	@NotNull
+	@Column(name = "status", nullable = false)
 	@Enumerated(value = EnumType.STRING)
 	private PaymentStatus status;

+	@Column(name = "failed_message")
 	private String failedMessage;

-	@NotNull
+	@NotEmpty
+	@Column(name = "payment_number", nullable = false)
 	private String paymentNumber;

 	@NotNull
+	@Column(name = "total_price", nullable = false)
 	private Integer totalPrice;

+	public Payment(Long userAlternateId, String movieTitle, PaymentType type, PaymentStatus status, String paymentNumber, Integer totalPrice) {
+		this.userAlternateId = userAlternateId;
+		this.movieTitle = movieTitle;
+		this.type = type;
+		this.status = status;
+		this.paymentNumber = paymentNumber;
+		this.totalPrice = totalPrice;
+	}
+
+	Payment(Long id, Long userAlternateId, String movieTitle, PaymentType type, PaymentStatus status, String paymentNumber, Integer totalPrice) {
+		this.id = id;
+		this.userAlternateId = userAlternateId;
+		this.movieTitle = movieTitle;
+		this.type = type;
+		this.status = status;
+		this.paymentNumber = paymentNumber;
+		this.totalPrice = totalPrice;
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/payment/domain/repository/PaymentRepository.java
+++ b/server/src/main/java/com/ticketing/server/payment/domain/repository/PaymentRepository.java
@@ -1,10 +1,13 @@
 package com.ticketing.server.payment.domain.repository;

 import com.ticketing.server.payment.domain.Payment;
+import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;

@Repository
 public interface PaymentRepository extends JpaRepository<Payment, Long> {

+	List<Payment> findByUserAlternateId(Long userId);
+
 }
--- a/server/src/main/java/com/ticketing/server/payment/service/PaymentApisServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/PaymentApisServiceImpl.java
@@ -0,0 +1,44 @@
+package com.ticketing.server.payment.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.api.MovieClient;
+import com.ticketing.server.payment.api.UserClient;
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentApisService;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
+public class PaymentApisServiceImpl implements PaymentApisService {
+
+	private final PaymentRepository paymentRepository;
+	private final MovieClient movieClient;
+	private final UserClient userClient;
+
+	@Override
+	public PaymentDetailDTO findPaymentDetail(@NotNull Long paymentId) {
+		Payment payment = paymentRepository.findById(paymentId)
+			.orElseThrow(ErrorCode::throwPaymentIdNotFound);
+
+		UserDetailResponse userDetail = userClient.detail();
+		if (!userDetail.hasUserAlternateId(payment)) {
+			throw ErrorCode.throwValidUserId();
+		}
+
+		TicketDetailsResponse tickets = movieClient.getTicketsByPaymentId(payment.getId());
+		return new PaymentDetailDTO(payment, tickets);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/PaymentServiceImpl.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/PaymentServiceImpl.java
@@ -1,9 +1,37 @@
 package com.ticketing.server.payment.service;

+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.dto.SimplePaymentDTO;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
 import com.ticketing.server.payment.service.interfaces.PaymentService;
+import java.util.stream.Collectors;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;

@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+@Validated
+@Slf4j
 public class PaymentServiceImpl implements PaymentService {

+	private final PaymentRepository paymentRepository;
+
+	@Override
+	public SimplePaymentsDTO findSimplePayments(@NotNull Long userAlternateId) {
+		return paymentRepository.findByUserAlternateId(userAlternateId)
+			.stream()
+			.map(SimplePaymentDTO::new)
+			.collect(Collectors
+				.collectingAndThen(
+					Collectors.toList()
+					, payments -> new SimplePaymentsDTO(userAlternateId, payments)
+				)
+			);
+	}
+
 }
--- a/server/src/main/java/com/ticketing/server/payment/service/dto/CreatePaymentDTO.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/dto/CreatePaymentDTO.java
@@ -0,0 +1,32 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.PaymentStatus;
+import com.ticketing.server.payment.domain.PaymentType;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class CreatePaymentDTO {
+
+	private final Long userAlternateId;
+	private final String movieTitle;
+	private final PaymentType type;
+	private final PaymentStatus status;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+
+	public Payment toEntity() {
+		return new Payment
+			(
+				this.getUserAlternateId(),
+				this.getMovieTitle(),
+				this.getType(),
+				this.getStatus(),
+				this.getPaymentNumber(),
+				this.getTotalPrice()
+			);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/dto/PaymentDetailDTO.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/dto/PaymentDetailDTO.java
@@ -0,0 +1,39 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.movie.application.response.TicketDetailsResponse;
+import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class PaymentDetailDTO {
+
+	private final Long paymentId;
+	private final String movieTitle;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+	private final LocalDateTime createdAt;
+	private final List<TicketDetailDTO> tickets;
+
+	public PaymentDetailDTO(Payment payment, TicketDetailsResponse ticketDetails) {
+		this(
+			payment.getId(),
+			payment.getMovieTitle(),
+			payment.getPaymentNumber(),
+			payment.getTotalPrice(),
+			payment.getCreatedAt(),
+			ticketDetails.getTicketDetails()
+		);
+	}
+
+	public PaymentDetailResponse toResponse() {
+		return new PaymentDetailResponse(paymentId, movieTitle, paymentNumber, totalPrice, createdAt, tickets);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentDTO.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentDTO.java
@@ -0,0 +1,25 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.domain.Payment;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class SimplePaymentDTO {
+
+	private final Long paymentId;
+	private final String movieTitle;
+	private final String paymentNumber;
+	private final Integer totalPrice;
+
+	public SimplePaymentDTO(Payment payment) {
+		this(
+			payment.getId(),
+			payment.getMovieTitle(),
+			payment.getPaymentNumber(),
+			payment.getTotalPrice()
+		);
+	}
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentsDTO.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/dto/SimplePaymentsDTO.java
@@ -0,0 +1,19 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class SimplePaymentsDTO {
+
+	private final Long userAlternateId;
+	private final List<SimplePaymentDTO> payments;
+
+	public SimplePaymentsResponse toResponse() {
+		return new SimplePaymentsResponse(userAlternateId, payments);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/dto/TicketDetailDTO.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/dto/TicketDetailDTO.java
@@ -0,0 +1,31 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.movie.domain.Ticket;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class TicketDetailDTO {
+
+	private final Integer price;
+	private final Integer theaterNumber;
+	private final Integer column;
+	private final Integer row;
+	private final LocalDateTime startAt;
+	private final LocalDateTime endAt;
+
+	public TicketDetailDTO(Ticket ticket) {
+		this(
+			ticket.getTicketPrice(),
+			ticket.getTheaterNumber(),
+			ticket.getColumn(),
+			ticket.getRow(),
+			ticket.getStartAt(),
+			ticket.getEndAt()
+		);
+	}
+
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentApisService.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentApisService.java
@@ -0,0 +1,9 @@
+package com.ticketing.server.payment.service.interfaces;
+
+import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
+import javax.validation.constraints.NotNull;
+
+public interface PaymentApisService {
+
+	PaymentDetailDTO findPaymentDetail(@NotNull Long paymentId);
+}
--- a/server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentService.java
+++ b/server/src/main/java/com/ticketing/server/payment/service/interfaces/PaymentService.java
@@ -1,5 +1,10 @@
 package com.ticketing.server.payment.service.interfaces;

+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import javax.validation.constraints.NotNull;
+
 public interface PaymentService {

+	SimplePaymentsDTO findSimplePayments(@NotNull Long userAlternateId);
+
 }
--- a/server/src/main/java/com/ticketing/server/user/api/PaymentClient.java
+++ b/server/src/main/java/com/ticketing/server/user/api/PaymentClient.java
@@ -0,0 +1,10 @@
+package com.ticketing.server.user.api;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import javax.validation.constraints.NotNull;
+
+public interface PaymentClient {
+
+	SimplePaymentsResponse getPayments(@NotNull Long alternateId);
+
+}
--- a/server/src/main/java/com/ticketing/server/user/api/impl/PaymentClientImpl.java
+++ b/server/src/main/java/com/ticketing/server/user/api/impl/PaymentClientImpl.java
@@ -0,0 +1,23 @@
+package com.ticketing.server.user.api.impl;
+
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
+import com.ticketing.server.payment.service.interfaces.PaymentService;
+import com.ticketing.server.user.api.PaymentClient;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class PaymentClientImpl implements PaymentClient {
+
+	private final PaymentService paymentService;
+
+	@Override
+	public SimplePaymentsResponse getPayments(@NotNull Long alternateId) {
+		SimplePaymentsDTO payments = paymentService.findSimplePayments(alternateId);
+		return payments.toResponse();
+	}
+
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
손창현	1cbb2bd721	fix: resolved conflict	2022-07-14 03:40:01 +09:00
손창현	9f2d053a8d	feat: delete movie API	2022-07-14 03:37:46 +09:00
손창현	e74095932a	refactor: movieService test code	2022-07-14 03:24:46 +09:00
손창현	1691d9e9d8	refactor: get movie list API	2022-07-14 03:18:49 +09:00
손창현	2093a168c9	add: deleteMovie() in movieService	2022-07-14 03:00:52 +09:00
손창현	9fc7be9fb6	add: throwDeletedMovie() exception	2022-07-14 02:55:41 +09:00
손창현	3c80a86f36	refactor: register Movie API	2022-07-14 02:47:32 +09:00
손창현	a98e3609f2	refactor: changed MovieTitleResponse -> MovieInfoResponse	2022-07-14 01:46:39 +09:00
Kim DongHyo	12f1d6b9be	fix: 브런치 merge 중 import 가 잘못되서 수정 (#70 )	2022-07-13 14:13:48 +09:00
손창현	1d1485c69a	add: findValidMovieWithTitle() in MovieRepository	2022-07-13 01:19:17 +09:00
손창현	fea31a4e80	refactor: set movie title unique -> not unique	2022-07-13 01:02:11 +09:00
Kim DongHyo	db5e8272b6	Update README.md	2022-07-12 23:18:47 +09:00
Kim DongHyo	9780a84609	refactor: 정적팩토리 -> 생성자 변경 (#69 ) Co-authored-by: 손창현 <gganzii1215@gmail.com>	2022-07-12 18:51:44 +09:00
Kim DongHyo	7283eeb5d3	feat: 권한변경 API 구현 (#67 )	2022-07-12 18:31:18 +09:00
Kim DongHyo	0521b85dd9	Update README.md	2022-07-12 13:43:40 +09:00
Kim DongHyo	b836598be3	Update README.md	2022-07-12 13:42:32 +09:00
Kim DongHyo	0173fc92ed	[User] 결제내역 상세 조회 구현 및 전반적인 코드 수정 (#66 ) * feat: 결제내역 상세 조회 alternatedId 컬럼추가 GUEST -> USER 권한명칭변경 User Entity: isDeleted, deletedAt closed #53, #61, #62, #63 * refactor: 프로퍼티 권한 private -> protected 변경 closed #60 * refactor: access Token 시간 변경 closed #65 * refactor: 에러코드 부분 수정 * feat: id 포함 생성자 추가	2022-07-12 01:57:30 +09:00
손창현	73cc0241d3	Feature/add movie (#59 ) * add: MovieTitleResponse * add: MovieRegisterDTO * add: DUPLICATE MOVIE exception * add: registerMovie() in MovieService * feat: add movie information - STAFF * refactor: variable DTO -> Dto	2022-07-11 16:02:40 +09:00
Kim DongHyo	720c495b51	Update README.md	2022-07-09 13:47:25 +09:00
Kim DongHyo	bd7b761636	Update README.md	2022-07-09 13:46:27 +09:00
Kim DongHyo	c9c4201920	Update README.md	2022-07-09 13:46:11 +09:00
Kim DongHyo	16eed0cbed	[User] 회원 결제목록 조회 및 Exception Method 한 곳으로 이동 (#50 ) * feat: findPayments * refactor: Exception Method 한 곳으로 이동	2022-07-08 11:33:21 +09:00
Kim DongHyo	8d5f179647	Update README.md	2022-07-06 04:28:09 +09:00
Kim DongHyo	fca765e9c3	feat: movie test data setup (#48 ) feat: 영화 테스트 데이터 setup 구현	2022-07-05 19:03:01 +09:00
손창현	3ea3b88b1f	Feature/get movie time list (#46 ) * refactor: MovieTimeRepository - findValidMovieTimes 네이티브 쿼리 -> JPQL 변경 * refactor: MovieTimeServiceImpl JPQL 적용 - movie.getId() -> movie * feat: MovieTimeServiceImplTest - get movie times 케이스 작성 * refactor: MovieServiceImplTest - static factory method 적용 * feat: MovieTimeServiceImplTest - get movie time list 케이스 작성	2022-07-04 18:35:01 +09:00
Kim DongHyo	09cb4a3767	refactor: 통합테스트, 유닛테스트 환경 분리 (#45 ) * refactor: 통합테스트, 유닛테스트 환경 분리 * refactor: testImplementation 와 다른 게 없어서 통합	2022-07-04 00:36:15 +09:00
손창현	648638860c	Feature/get movie times list (#42 ) * refactor: 영화 시작, 종료 시간 LocalTime 적용 * refactor: 영화 시간표 테이블 이름 변경 movie_times -> movie_time * feat: getMovieTimes API * refactor: 영화 시간표 조회 runningDate ApiParam 상영 날짜로 변경 * fix: MovieTimeRepositoryTest 오타 수정 * refactor: MovieTime start_at, end_at LocalDateTime으로 변경 * refactor: find List<MovieTime> with native query * add: comment for endOfDay variable * add: MovieTimeDto - AccessLevel.PRIVATE for static factory method * refactor: startOfDay 06:00 설정 * refactor: removed tmdb settings * refactor: removed unnecessary comments * refactor: removed unnecessary comments * refactor: removed unnecessary imports * add: MovieDto - AcessLevel.PRIVATE for static factory method	2022-07-04 00:36:07 +09:00
Kim DongHyo	6f14c96931	Update README.md	2022-07-03 21:35:38 +09:00
Kim DongHyo	e009c2786c	Update README.md	2022-07-03 19:32:01 +09:00
Kim DongHyo	cb79ec5e57	Update README.md	2022-07-03 19:30:38 +09:00
Kim DongHyo	d0af7e4444	feat: 로그아웃 시 refreshToken 제거 (#44 ) * feat: 로그아웃 시 refreshToken 제거 * refactor: deleteRefreshToken 메서드 람다활용 문법으로 변경	2022-06-30 16:31:54 +09:00
Kim DongHyo	ab32f435b1	Feature/exception handler (#41 ) * feat: Exception Handler 구현 * feat: 컨트롤러 예외처리 구현	2022-06-24 12:14:22 +09:00
Kim DongHyo	a5cc6f2513	refactor: restful API 에 맞게 수정 및 메서드 명 변경 (#38 ) * refactor: restful API 에 맞게 수정 및 메서드 명 변경 * refactor: 코드리뷰 피드백 반영	2022-06-23 00:33:50 +09:00
Kim DongHyo	9ddfc24d2f	[#30 ] Feature/role hierarchy (#34 ) * feat: 계층권한 구현 * refactor: 생성자 메서드 위치 변경	2022-06-21 11:57:10 +09:00
Kim DongHyo	8d9a86df64	[#31 ] Feature/find token info (#35 ) * feat: 토큰 email 상세 정보 조회 * refactor: access token header key naming change * refactor: 재정렬 * refactor: findByEmail 중복코드 제거 * refactor: user delete test code refactoring	2022-06-21 11:56:26 +09:00
손창현	69fe793afa	Feature/get movie list (#28 ) * feat: getMovies API * fix: swagger - changed dependencies and permit swagger-resources * feat: Movie ServiceImpl Test - get movies * refactor: movieRepository 메서드 변경 findByDeletedAt() -> findValidMovies() * refactor: movieService 메서드 변경 findByDeletedAt() -> findValidMovies() * refactor: Request Mapping /api/movie to /api/movies * refactor: MovieDto 필드에 @JsonProperty 추가	2022-06-17 14:13:41 +09:00
Kim DongHyo	928958dd45	refactor: 인수 name 사용할 수 있도록 수정 (#33 )	2022-06-16 19:35:30 +09:00
Kim DongHyo	a235983475	refactor: 정적팩토리메서드 네이밍 통일 (#27 )	2022-06-14 00:30:28 +09:00
Kim DongHyo	183e61188e	Feature/redis set up and refresh token add (#24 ) * feat: 로그인 시 refreshToken 추가 발행 * feat: redis 연결 및 refreshToken redis 저장 * refactor: Exception Class Naming 변경	2022-06-11 00:36:36 +09:00