[#95] 페어 프로그래밍으로 코드 리팩터링 하기

build.gradle

@@ -46,7 +46,7 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-oauth2-client' // OAuth2-Client dependency
     implementation 'org.springframework.boot:spring-boot-starter-actuator' // Actuator dependency
     implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE' // AWS S3 dependency
-    
+
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.security:spring-security-test'
     annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
@@ -85,7 +85,7 @@ dependencyManagement {
 }
 
 openapi3 {
-    setServer("http://localhost:8080")
+    setServer("http://43.201.105.123")
     title = "restdocs-swagger API Documentation"
     description = "Spring REST Docs with SwaggerUI."
     version = "0.0.1"
@@ -156,7 +156,8 @@ jacocoTestCoverageVerification {
                     '*.global*',
                     '*.series*',
                     '*.comment*',
-                    '*.dto*'
+                    '*.dto*',
+                    '*.exception.*'
             ]
 
         }

src/main/java/com/prgrms/prolog/domain/comment/api/CommentController.java

@@ -26,24 +26,26 @@ public class CommentController {
 
 	private final CommentService commentService;
 
-	@PostMapping("/{post_id}/comments")
-	public ResponseEntity<Void> save(
-		@PathVariable(name = "post_id") Long postId,
-		@Valid @RequestBody CreateCommentRequest request,
+	@PostMapping("/{postId}/comments")
+	public ResponseEntity<SingleCommentResponse> createComment(
+		@PathVariable(name = "postId") Long postId,
+		@Valid @RequestBody CreateCommentRequest createCommentRequest,
 		@AuthenticationPrincipal JwtAuthentication user
 	) {
-		commentService.save(request, user.id(), postId);
-		return ResponseEntity.status(CREATED).build();
+		SingleCommentResponse singleCommentResponse
+			= commentService.createComment(createCommentRequest, user.id(), postId);
+		return ResponseEntity.status(CREATED).body(singleCommentResponse);
 	}
 
-	@PatchMapping("/{post_id}/comments/{id}")
-	public ResponseEntity<Void> update(
-		@PathVariable(name = "post_id") Long postId,
-		@PathVariable(name = "id") Long commentId,
-		@Valid @RequestBody UpdateCommentRequest request,
+	@PatchMapping("/{postId}/comments/{commentId}")
+	public ResponseEntity<SingleCommentResponse> updateComment(
+		@PathVariable(name = "postId") Long postId,
+		@PathVariable(name = "commentId") Long commentId,
+		@Valid @RequestBody UpdateCommentRequest updateCommentRequest,
 		@AuthenticationPrincipal JwtAuthentication user
 	) {
-		commentService.update(request, user.id(), commentId);
-		return ResponseEntity.ok().build();
+		SingleCommentResponse singleCommentResponse
+			= commentService.updateComment(updateCommentRequest, user.id(), postId, commentId);
+		return ResponseEntity.ok(singleCommentResponse);
 	}
 }

src/main/java/com/prgrms/prolog/domain/comment/dto/CommentDto.java

@@ -1,17 +1,59 @@
 package com.prgrms.prolog.domain.comment.dto;
 
+import static com.prgrms.prolog.domain.user.dto.UserDto.*;
+
 import javax.validation.constraints.NotBlank;
 
+import com.prgrms.prolog.domain.comment.model.Comment;
+import com.prgrms.prolog.domain.post.model.Post;
+import com.prgrms.prolog.domain.user.model.User;
+
 public class CommentDto {
 
 	public record CreateCommentRequest(
 		@NotBlank String content
 	) {
+		public static CreateCommentRequest from(String content) {
+			return new CreateCommentRequest(content);
+		}
+
+		public static Comment from(
+			CreateCommentRequest createCommentRequest,
+			User user,
+			Post post
+		) {
+			return Comment.builder()
+				.content(createCommentRequest.content)
+				.user(user)
+				.post(post)
+				.build();
+		}
 	}
 
 	public record UpdateCommentRequest(
 		@NotBlank String content
 	) {
+		public static UpdateCommentRequest from(String content) {
+			return new UpdateCommentRequest(content);
+		}
+	}
+
+	public record SingleCommentResponse(
+		SimpleUserInfo user,
+		String content
+	) {
+		public static SingleCommentResponse from(UserResponse user, String content) {
+			return new SingleCommentResponse(SimpleUserInfo.from(user), content);
+		}
 	}
 
+	public record SimpleUserInfo(
+		Long userId,
+		String nickName,
+		String profileImgUrl
+	) {
+		public static SimpleUserInfo from(UserResponse user) {
+			return new SimpleUserInfo(user.id(), user.nickName(), user.profileImgUrl());
+		}
+	}
 }

src/main/java/com/prgrms/prolog/domain/comment/model/Comment.java

@@ -1,5 +1,6 @@
 package com.prgrms.prolog.domain.comment.model;
 
+import static com.prgrms.prolog.global.util.ValidateUtil.*;
 import static javax.persistence.FetchType.*;
 import static javax.persistence.GenerationType.*;
 
@@ -12,8 +13,6 @@
 import javax.persistence.ManyToOne;
 import javax.validation.constraints.Size;
 
-import org.springframework.util.Assert;
-
 import com.prgrms.prolog.domain.post.model.Post;
 import com.prgrms.prolog.domain.user.model.User;
 import com.prgrms.prolog.global.common.BaseEntity;
@@ -22,9 +21,7 @@
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
 
-@Slf4j
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @Entity
@@ -56,16 +53,6 @@ public Comment(String content, Post post, User user) {
 		this.user = Objects.requireNonNull(user, "exception.user.require");
 	}
 
-	public void changeContent(String content) {
-		this.content = validateContent(content);
-	}
-
-	private String validateContent(String content) {
-		Assert.hasText(content, CONTENT_OVER_LENGTH_MESSAGE);
-		Assert.isTrue(content.length() <= CONTENT_MAX_SIZE, CONTENT_OVER_LENGTH_MESSAGE);
-		return content;
-	}
-
 	public void setPost(Post post) {
 		if (this.post != null) {
 			this.post.getComments().remove(this);
@@ -74,9 +61,14 @@ public void setPost(Post post) {
 		post.getComments().add(this);
 	}
 
-	public boolean checkUserEmail(String email) {
-		Assert.notNull(user, "exception.user.notExists");
-		return this.user.checkSameEmail(email);
+	public void changeContent(String content) {
+		this.content = validateContent(content);
+	}
+
+	private String validateContent(String content) {
+		checkOverLength(content, CONTENT_MAX_SIZE, CONTENT_OVER_LENGTH_MESSAGE);
+		checkText(content, CONTENT_OVER_LENGTH_MESSAGE);
+		return content;
 	}
 }
 

src/main/java/com/prgrms/prolog/domain/comment/service/CommentService.java

@@ -3,6 +3,7 @@
 import static com.prgrms.prolog.domain.comment.dto.CommentDto.*;
 
 public interface CommentService {
-	Long save(CreateCommentRequest request, Long userId, Long postId);
-	Long update(UpdateCommentRequest request, Long userId, Long commentId);
+	SingleCommentResponse createComment(CreateCommentRequest createCommentRequest, Long userId, Long postId);
+
+	SingleCommentResponse updateComment(UpdateCommentRequest updateCommentRequest, Long userId, Long postId, Long commentId);
 }

src/main/java/com/prgrms/prolog/domain/comment/service/CommentServiceImpl.java

@@ -2,6 +2,8 @@
 
 import static com.prgrms.prolog.domain.comment.dto.CommentDto.*;
 
+import java.util.Objects;
+
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.Assert;
@@ -10,13 +12,14 @@
 import com.prgrms.prolog.domain.comment.repository.CommentRepository;
 import com.prgrms.prolog.domain.post.model.Post;
 import com.prgrms.prolog.domain.post.repository.PostRepository;
+import com.prgrms.prolog.domain.user.dto.UserDto;
 import com.prgrms.prolog.domain.user.model.User;
 import com.prgrms.prolog.domain.user.repository.UserRepository;
 
 import lombok.RequiredArgsConstructor;
 
-@Transactional(readOnly = true)
 @RequiredArgsConstructor
+@Transactional(readOnly = true)
 @Service
 public class CommentServiceImpl implements CommentService {
 
@@ -26,28 +29,28 @@ public class CommentServiceImpl implements CommentService {
 
 	@Override
 	@Transactional
-	public Long save(CreateCommentRequest request, Long userId, Long postId) {
-		Post findPost = getFindPostBy(postId);
+	public SingleCommentResponse createComment(CreateCommentRequest createCommentRequest, Long userId, Long postId) {
 		User findUser = getFindUserBy(userId);
-		Comment comment = buildComment(request, findPost, findUser);
-		return commentRepository.save(comment).getId();
+		Post findPost = getFindPostBy(postId);
+		Comment comment = CreateCommentRequest.from(createCommentRequest, findUser, findPost);
+		Comment savedComment = commentRepository.save(comment);
+		return SingleCommentResponse.from(UserDto.UserResponse.from(findUser), savedComment.getContent());
 	}
 
 	@Override
 	@Transactional
-	public Long update(UpdateCommentRequest request, Long userId, Long commentId) {
+	public SingleCommentResponse updateComment(UpdateCommentRequest updateCommentRequest, Long userId, Long postId, Long commentId) {
+		Post findPost = getFindPostBy(postId);
+		User findUser = getFindUserBy(userId);
 		Comment findComment = commentRepository.joinUserByCommentId(commentId);
+
+		validatePostComment(findPost, findComment);
+		validateUserComment(findUser, findComment);
+
 		validateCommentNotNull(findComment);
-		findComment.changeContent(request.content());
-		return findComment.getId();
-	}
+		findComment.changeContent(updateCommentRequest.content());
 
-	private Comment buildComment(CreateCommentRequest request, Post findPost, User findUser) {
-		return Comment.builder()
-			.content(request.content())
-			.post(findPost)
-			.user(findUser)
-			.build();
+		return SingleCommentResponse.from(UserDto.UserResponse.from(findUser), updateCommentRequest.content());
 	}
 
 	private User getFindUserBy(Long userId) {
@@ -63,4 +66,14 @@ private Post getFindPostBy(Long postId) {
 	private void validateCommentNotNull(Comment comment) {
 		Assert.notNull(comment, "exception.comment.notExists");
 	}
+
+	private void validateUserComment(User findUser, Comment findComment) {
+		Assert.isTrue(!Objects.equals(findComment.getUser().getId(), findUser.getId()),
+			"exception.comment.user.notSame");
+	}
+
+	private void validatePostComment(Post findPost, Comment findComment) {
+		Assert.isTrue(!Objects.equals(findPost.getId(), findComment.getPost().getId()),
+			"exception.comment.post.notSame");
+	}
 }

src/main/java/com/prgrms/prolog/domain/like/api/LikeController.java

@@ -1,44 +1,47 @@
 package com.prgrms.prolog.domain.like.api;
 
-import javax.validation.Valid;
+import java.net.URI;
 
-import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 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.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.util.UriComponentsBuilder;
 
-import com.prgrms.prolog.domain.like.dto.LikeDto;
-import com.prgrms.prolog.domain.like.dto.LikeDto.likeRequest;
+import com.prgrms.prolog.domain.like.dto.LikeDto.LikeRequest;
 import com.prgrms.prolog.domain.like.service.LikeServiceImpl;
 import com.prgrms.prolog.global.jwt.JwtAuthentication;
 
 import lombok.RequiredArgsConstructor;
 
-@RestController
 @RequiredArgsConstructor
 @RequestMapping("/api/v1/like")
+@RestController
 public class LikeController {
 
 	private final LikeServiceImpl likeService;
 
 	@PostMapping(value = "/{postId}")
-	@ResponseStatus(HttpStatus.NO_CONTENT)
-	public void insert(
+	public ResponseEntity<Void> insert(
 		@PathVariable Long postId,
 		@AuthenticationPrincipal JwtAuthentication user
 	) {
-		LikeDto.likeRequest request = new likeRequest(user.id(), postId);
-		likeService.save(request);
+		final LikeRequest likeRequest = new LikeRequest(user.id(), postId);
+		Long likeId = likeService.save(likeRequest);
+		URI location = UriComponentsBuilder.fromUriString("/api/v1/like/" + postId + "/" + likeId).build().toUri();
+		return ResponseEntity.created(location).build();
 	}
 
-	@DeleteMapping
-	@ResponseStatus(HttpStatus.NO_CONTENT)
-	public void delete(@RequestBody @Valid likeRequest likeRequest) {
+	@DeleteMapping("/{postId}")
+	public ResponseEntity<Void> delete(
+		@PathVariable Long postId,
+		@AuthenticationPrincipal JwtAuthentication user
+	) {
+		final LikeRequest likeRequest = new LikeRequest(user.id(), postId);
 		likeService.cancel(likeRequest);
+		return ResponseEntity.noContent().build();
 	}
 }

src/main/java/com/prgrms/prolog/domain/like/dto/LikeDto.java

@@ -2,9 +2,20 @@
 
 import javax.validation.constraints.NotNull;
 
+import com.prgrms.prolog.domain.like.model.Like;
+import com.prgrms.prolog.domain.post.model.Post;
+import com.prgrms.prolog.domain.user.model.User;
+
 public class LikeDto {
 
-	public record likeRequest(@NotNull Long userId,
-							  @NotNull Long postId) {
+	public record LikeRequest(@NotNull Long userId,
+	                          @NotNull Long postId) {
+
+		public Like from(User user, Post post) {
+			return Like.builder()
+				.user(user)
+				.post(post)
+				.build();
+		}
 	}
 }

src/main/java/com/prgrms/prolog/domain/like/service/LikeService.java

@@ -1,9 +1,9 @@
 package com.prgrms.prolog.domain.like.service;
 
-import com.prgrms.prolog.domain.like.dto.LikeDto;
+import static com.prgrms.prolog.domain.like.dto.LikeDto.*;
 
 public interface LikeService {
-	Long save(LikeDto.likeRequest likeRequest);
+	Long save(LikeRequest likeRequest);
 
-	void cancel(LikeDto.likeRequest likeRequest);
+	void cancel(LikeRequest likeRequest);
 }