안녕하세요 이번 시간에는 게시물 좋아요 기능을 만들어 보도록 하겠습니다.

수정할 파일 : PostController, PostService, PostEntity, UserEntity

생성할 파일 : PostLikeEntity, PostLikeRepository

- PostController

   @PostMapping("/post/{id}/like")
    @PreAuthorize("isAuthenticated()")
    public SuccessResponse<String> postLike(@PathVariable(name = "id") Long postId, Principal principal) {
        postService.postLike(postId, principal.getName());
        return SuccessResponse.success(null);
    }

좋아요 할 게시물의 id와 현재 로그인 중인 유저의 email을 Service에 넘겨줍니다.

 

 

- PostService

   public void postLike(Long postId, String email) {
        Post post = getPostInService(postId);
        User user = getUserInService(email);
        Optional<PostLike> byPostAndUser = postLikeRepository.findByPostAndUser(post, user);

        byPostAndUser.ifPresentOrElse(
		// 좋아요 있을경우 삭제
                postLike -> {
                    postLikeRepository.delete(postLike);
                    post.discountLike(postLike);
                },
                // 좋아요가 없을 경우 좋아요 추가
                () -> {
                    PostLike postLike = PostLike.builder().build();

                    postLike.mappingPost(post);
                    postLike.mappingUser(user);
                    post.updateLikeCount();

                    postLikeRepository.save(postLike);
                }
        );
    }

ifPresentOrElse 구문은 게시물과 유저로 찾아 좋아요을 했을 경우와 하지 않았을 경우를 나눠 로직을 작성할수 있습니다.

좋아요가 있을경우 테이블에서 삭제를 한 후 Post에서 LikeCount를 하나 줄여줍니다.

좋아요가 없다면 user와 post를 매핑해 준 후 LikeCount를 업데이트 해줍니다.

 

- PostEntity

@OneToMany(fetch = LAZY, mappedBy = "post", cascade = CascadeType.REMOVE)
    private List<PostLike> postLikeList = new ArrayList<>();
    
    
public void mappingPostLike(PostLike postLike) {
        this.postLikeList.add(postLike);
    }

    public void updateLikeCount() {
        this.likeCount = (long) this.postLikeList.size();
    }

    public void discountLike(PostLike postLike) {
        this.postLikeList.remove(postLike);

    }

 

- UserEntity

 @OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.REMOVE)
    private List<PostLike> postLikeList = new ArrayList<>();
    
  public void mappingPostLike(PostLike postLike) {
        this.postLikeList.add(postLike);
    }

 

- PostLikeEntity

@Entity
@Getter
@Builder
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class PostLike {

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

    @ManyToOne(fetch = LAZY)
    @JoinColumn(name = "user_id", foreignKey = @ForeignKey(name = "FK_PostLike_User"))
    private User user;

    @ManyToOne(fetch = LAZY)
    @JoinColumn(name = "post_id", foreignKey = @ForeignKey(name = "FK_PostLike_Post"))
    private Post post;

    public static boolean isVotedPost(Optional<PostLike> optionalPostLike) {
        return optionalPostLike.isPresent();
    }

    public void mappingUser(User user) {
        this.user = user;
        user.mappingPostLike(this);
    }

    public void mappingPost(Post post) {
        this.post = post;
        post.mappingPostLike(this);
    }

}

Post와 User를 직접적으로 N : M 로 매핑하지 않고 중간 테이블을 만들어 1 : N - M : 1 로 매핑한 이유는 나중에 좋아요을 한 날짜나 다른 정보들이 필요한 경우 이렇게 중간 테이블을 만들어 놓는다면 중간 테이블에 관련된 데이터를 추가 하면 되지만 직접 적으로 연결 할 경우 등록하기 어렵기 때문입니다.

 

- PostLikeRepository

@Repository
public interface PostLikeRepository extends JpaRepository<PostLike, Long> {
    Optional<PostLike> findByPostAndUser(Post post, User user);
}

게시물과 유저로 좋아요를 찾습니다.

안녕하세요 저번 시간에는 게시물의 카테고리로 검색하는 기능을 추가하였습니다.

이번 시간에는 유저 닉네임, 게시물의 제목으로 검색하는 기능을 만들어 보도록 하겠습니다.

코드는 크게 달라진것은 없으며 SearchType이 추가되고, PostRepositoryImpl 만 수정 하면 됩니다.

- SearchType, PostRepositoryImpl

- SearchType

@RequiredArgsConstructor
public enum SearchType {
    TITLE("title", "포스트 제목으로 검색"),
    USER("user", "유저명으로 검색");

    @Getter
    private final String type;

    @Getter
    private final String description;

    public static SearchType convertToType(String stringType) {
        return Arrays.stream(values())
                .filter(searchType -> searchType.type.equals(stringType))
                .findAny()
                .orElse(TITLE);
    }
}

convertToType 메서드는 values()로 SearchType의 enum값을 배열로 가져온뒤 filter로 stringType과 enum의 type이 동일 하면 해당 enum을 리턴하고 일치하는 enum이 없을시 TITLE enum을 리턴하는 메서드 입니다.

 

- PostRepositoryImpl

@RequiredArgsConstructor
public class PostRepositoryImpl implements PostRepositoryCustom {
    private final JPAQueryFactory jpaQueryFactory;

    @Override
    public List<Post> postListQueryDSL(SearchDTO searchDTO) {
        BooleanExpression postCategoryQuery = postCategoryQuery(searchDTO.getCategory());
        BooleanExpression postSearchQuery = postSearchQuery(searchDTO);

        return jpaQueryFactory
                .selectFrom(post)
                .where(postCategoryQuery, postSearchQuery)
                .join(post.user, user).fetchJoin()
                .join(post.category, postCategory).fetchJoin()
                .fetch();
    }

    private BooleanExpression postCategoryQuery(String category) {
        if (StringUtils.hasLength(category)) {
            return post.category.eq(getPostCategory(category));
        }

        return null;
    }

    private BooleanExpression postSearchQuery(SearchDTO searchDTO) {
        SearchType searchType = SearchType.convertToType(searchDTO.getSearchType());

        if (searchType == SearchType.USER) {
            return user.nickname.eq(searchDTO.getQuery());
        }
        return post.title.contains(searchDTO.getQuery());

    }

    private PostCategory getPostCategory(String category) {
        return jpaQueryFactory
                .selectFrom(postCategory)
                .where(postCategory.name.eq(category))
                .fetchOne();
    }
}

기존의 코드에서 postSearchQuery가 추가되었습니다. 이 메서드는 searchType에 따라 유저로 검색하는지, 게시물로 검색하는지에 따라where문에 들어갈 쿼리가 달라지게 됩니다.

안녕하세요 이번 시간에는 QueryDSL을 사용하여 게시물 카테고리로 게시물을 검색하는 기능을 만들어 보겠습니다.

QueryDSL을 사용하기위해 build.gradle에 라이브러리를 추가해주도록 하겠습니다.

plugins {
    id 'org.springframework.boot' version '2.4.5'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'

    //querydsl 추가
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

group = 'hose'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    runtimeOnly 'mysql:mysql-connector-java'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // test용 assertj 추가
    testCompile 'org.assertj:assertj-core:3.19.0'

    // spring security 추가
    implementation 'org.springframework.boot:spring-boot-starter-security'

    // jwt
    compile group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.2'
    runtime group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.2'
    runtime group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.2'

    // swagger
    compile('io.springfox:springfox-swagger2:2.7.0')
    compile('io.springfox:springfox-swagger-ui:2.7.0')

    //querydsl 추가
    implementation 'com.querydsl:querydsl-jpa'
}

test {
    useJUnitPlatform()
}

// querydsl 추가 시작
def querydslDir = "$buildDir/generated/querydsl"
querydsl {
    jpa = true
    querydslSourcesDir = querydslDir
}
sourceSets {
    main.java.srcDir querydslDir
}
configurations {
    querydsl.extendsFrom compileClasspath
}
compileQuerydsl {
    options.annotationProcessorPath = configurations.querydsl
}
// querydsl 추가 끝

 

설치를 하고 나서 IntelliJ를 사용하신다면 오른쪽 Gradle에서 cleanQuerydslSourcedDir을 눌러 줍니다.

 

그 후 other에서 compileQuerydsl을 해줍니다 그러고 나면 build > generated > querydsl 디렉토리가 생기며 내부에 Q가 붙은 엔티티가 생깁니다.

 

만약 IntelliJ가 없다면 ./gradlew cleanQuerydslSourcesDir 과 ./gradlew compileQuerydsl 을 명령어를 실행시켜 줍니다.

 

그 다음 PostController, SearchDTO,  PostRepositoryCustom, PostRepositoryImpl 을 만들어주고 PostRepository를 수정해줍니다.

- PostController

@GetMapping("/board/post-list")
    @ResponseStatus(value = HttpStatus.OK)
    @ApiOperation(value = "게시물 목록 조회", notes = "게시물 목록을 조회합니다.")
    public SuccessResponse<List<PostDTO>> getPostList(SearchDTO searchDTO) {
        List<PostDTO> postList = postService.getPostList(searchDTO);

        return SuccessResponse.success(postList);
    }

 

- SearchDTO

@Builder
@Data
public class SearchDTO {
    private String category;
    private String searchType;
    private String query;

    @ConstructorProperties({"category", "search_type", "query"})
    public SearchDTO(String category, String searchType, String query) {
        this.category = category;
        this.searchType = searchType;
        this.query = query;
    }
}

@ConstructorProperties를 넣은 이유는 현재 QueryParameter를 어노테이션으로 받는게 아니라 Object로 받고 있습니다.

왜냐하면 Json은 snake_case를, 자바에서는 cameCase를 쓰고있기 때문에 통일이 되지않기 때문에

필드중 searchType이 실제 QueryParameter를 넘겨줄때도 searchType으로 적어줘야 입력받는 문제점이 있습니다.

그렇기 때문에 @ConstructorProperties에 적어줌으로써 필드 순서에 맞게 매핑이 되는것 같습니다.

 

 

- PostRepositoryCustom

public interface PostRepositoryCustom {
    List<Post> postListQueryDSL(SearchDTO searchDTO);
}

- PostRepositoryImpl

@RequiredArgsConstructor
public class PostRepositoryImpl implements PostRepositoryCustom {
    private final JPAQueryFactory jpaQueryFactory;

    @Override
    public List<Post> postListQueryDSL(SearchDTO searchDTO) {
        BooleanExpression postCategoryQuery = getPostCategoryQuery(searchDTO.getCategory());

        List<Post> postList = jpaQueryFactory
                .selectFrom(post)
                .where(postCategoryQuery)
                .join(post.user, user).fetchJoin()
                .join(post.category, postCategory).fetchJoin()
                .fetch();

        return postList;
    }

     private BooleanExpression postCategoryQuery(String category) {
        if (StringUtils.hasLength(category)) {
            return post.category.eq(getPostCategory(category));
        }

        return null;
    }

    private PostCategory getPostCategory(String category) {
        return jpaQueryFactory
                .selectFrom(postCategory)
                .where(postCategory.name.eq(category))
                .fetchOne();
    }
}

여기서 JPAQueryFactory를 주입받고 있는데 Spring boot에서 기본적으로 주입시켜주는게 아니기 때문에 자동으로 주입시켜줄수 있게 작성해야 합니다.

- QueryDslConfig

@Configuration
public class QueryDslConfig {

    @Bean
    public JPAQueryFactory jpaQueryFactory(EntityManager em) {
        return new JPAQueryFactory(em);
    }

}

QueryDslConfig를 만들어 JPAQueryFactory을 자동으로 주입시켜줄 수 있게 Bean으로 등록시켜줍니다.

 

- PostRepository

@Repository
public interface PostRepository extends JpaRepository<Post, Long>, PostRepositoryCustom {
    @EntityGraph(attributePaths = {"category", "user", "commentList.user"})
    @Override
    Optional<Post> findById(Long postId);

    @EntityGraph(attributePaths = {"user", "category"})
    @Override
    List<Post> findAll(Sort sort);
}

여기서 눈여겨 보셔야 할 점이 PostRepository에 PostRepositoryCustom을 새롭게 상속받았다는 것입니다. 그 다음 PostRepositoryCustom을 구현하는 PostRepositoryImpl 클래스에서 postListQueryDSL 메서드를 구현하고 있는점입니다.

이렇게 하게되면 ServiceLayer에서는 새롭게 PostRepositoryCustom을 추가적으로 의존할 필요없이 기존의 PostRepository를 통해 postListQueryDSL 메서드를 사용 할 수 있습니다.

 

이제 postListQueryDSL 코드를 살펴보도록 하겠습니다.

getPostCategoryQuery(String category) 메서드는 동적 쿼리입니다.

API를 요청할때 Query Parameter에 category를 명시해준다면 좋겠지만 명시하지 않을경우 카테고리와 상관없이 모든글을 가져와야 합니다. 이런 경우를 생각하면 있을 경우와 없을경우, 카테고리가 무엇이냐에 따라 분기문으로 처리해야하는데 그것을 방지하기 위해 동적 쿼리를 사용하였습니다.

QueryDSL에서는 where절에 null이 들어갈경우 자동으로 무시하기 때문에 동적쿼리를 처리하기 좋습니다.

이제 본 메서드의 post, user, postCategory는 아까 gradle로 만들어준 QueryDSL 디렉토리 내부에 있는 Q엔티티 입니다. QueryDSL 에서는 이것을 이용하여 쿼리를 작성합니다.

join을 통해 게시물을 작성한 유저와 카테고리를 한꺼번에 가져오고 fetchJoin()을 통해 N + 1 문제를 해결하였습니다.

 

전체 코드는 여기에서 볼 수 있습니다.

오늘은 게시물에 댓글 기능을 적용해보도록 하겠습니다.

- Controller, Service, Entity, Repository, DTO

- CommentController

@RestController
@RequiredArgsConstructor
public class CommentController {

    private final CommentService commentService;

    @PostMapping("/post/{id}/comment")
    @ResponseStatus(value = HttpStatus.OK)
    @PreAuthorize("isAuthenticated()")
    @ApiOperation(value = "댓글 쓰기", notes = "id에 해당하는 게시글에 댓글을 작성합니다.")
    public SuccessResponse<String> createComment(@PathVariable(name = "id") Long postId,
                                                 @Valid @RequestBody CommentDTO commentDTO,
                                                 Principal principal) {

        CommentDTO comment = commentService.createComment(postId, commentDTO, principal.getName());

        return SuccessResponse.success(null);

    }
}

- CommentService

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class CommentService {

    private final CommentRepository commentRepository;
    private final PostRepository postRepository;
    private final UserRepository userRepository;

    @Transactional
    public CommentDTO createComment(Long postId, CommentDTO commentDTO, String email) {
        Optional<Post> byId = postRepository.findById(postId);

        Post post = byId.orElseThrow(() -> new PostNotFound("게시물이 삭제되었거나 존재하지 않습니다."));

        Optional<User> byEmail = userRepository.findByEmail(email);

        User user = byEmail.orElseThrow(() -> new UsernameNotFoundException("유저를 찾을 수 없습니다."));

        Comment comment = Comment.builder()
                .contents(commentDTO.getContents())
                .build();

        comment.mappingPostAndUser(post, user);

        Comment saveComment = commentRepository.save(comment);

        return CommentDTO.convertToCommentDto(saveComment);
    }
}

- CommentEntity

@Entity
@Getter
@Builder
@AllArgsConstructor(access = PROTECTED)
@NoArgsConstructor(access = PROTECTED)
public class Comment {

    @Id
    @GeneratedValue(strategy = IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String contents;

    @ManyToOne(fetch = LAZY)
    @JoinColumn(name = "post_id", foreignKey = @ForeignKey(name = "FK_user_comment"))
    private Post post;

    @ManyToOne(fetch = LAZY)
    @JoinColumn(name = "user_id", foreignKey = @ForeignKey(name = "FK_post_comment"))
    private User user;

    public void mappingPostAndUser(Post post, User user) {
        this.post = post;
        this.user = user;

        post.mappingComment(this);
        user.mappingComment(this);
    }
}

- CommentRepository

@Repository
public interface CommentRepository extends JpaRepository<Comment, Long> {
}

- CommentDTO

@Builder
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
@Data
public class CommentDTO {
    private Long id;

    @NotBlank
    @Length(max = 100)
    private String contents;
    private UserDTO user;

    public static CommentDTO convertToCommentDto(Comment comment) {
        return CommentDTO.builder()
                .id(comment.getId())
                .contents(comment.getContents())
                .user(UserDTO.convertToUserDTO(comment.getUser()))
                .build();
    }

    public static List<CommentDTO> convertToCommentDtoList(List<Comment> commentList) {
        Stream<Comment> stream = commentList.stream();

        return stream.map(CommentDTO::convertToCommentDto).collect(Collectors.toList());

    }
}

 

여기 까지가 Comment 관련 코드이고 이제 Comment와 Post, User와 관계를 지정해주어야 합니다.

Comment와 Post는 N : 1 관계, Comment와 User는 N : 1 관계 입니다. 그러므로 PostEntity와 UserEntity에 연관관계및 연관관계 메서드를 설정해줍니다.

- PostEntity

    @OneToMany(fetch = LAZY, mappedBy = "post")
    private List<Comment> commentList = new ArrayList<>();
    
        public void mappingComment(Comment comment) {
        this.commentList.add(comment);
    }

- UserEntity

@OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
    private List<Comment> commentList = new ArrayList<>();
    
    public void mappingComment(Comment comment) {
        commentList.add(comment);
    }

 

그리고 이제 게시물에 댓글을 달고 게시물을 조회하고 나면 쿼리가 무언가 이상합니다. 

1번 게시물에 1번 유저, 2번 유저, 3번 유저가 댓글을 달경우 1번 게시물을 조회할때 1, 2, 3번 유저를 조회하는 쿼리가 나가기 때문입니다.

이를 해결하기 위해 저번에 작업한 PostRepository에 최적화 작업을 하겠습니다.

- PostRepository

@Repository
public interface PostRepository extends JpaRepository<Post, Long> {
    @EntityGraph(attributePaths = {"category", "user", "commentList.user"})
    @Override
    Optional<Post> findById(Long postId);

    @EntityGraph(attributePaths = {"user", "category"})
    @Override
    List<Post> findAll(Sort sort);
}

@EntityGraph에 "commentList.user"를 추가해줌으로써 CommentList와 여기에 댓글을 작성한 유저의 정보까지 한번에 가져오므로 쿼리 1번에 모두 조회가 가능합니다.

전체 코드는 여기에서 확인할 수 있습니다.

 

안녕하세요 이번에는 API를 테스트 할 수 있는 Swagger 문서를 추가 해보도록 하겠습니다.

build.gradle 파일에 추가해줍니다.

// swagger
    compile('io.springfox:springfox-swagger2:2.7.0')
    compile('io.springfox:springfox-swagger-ui:2.7.0')

그 다음 SwaggerConfig 파일을 만들어 줍니다.

@Configuration
public class SwaggerConfig {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot REST Sample with Swagger")
                .description("API 문서")
                .termsOfServiceUrl("")
                .contact(new Contact("user", "url", "user@example.com"))
                .version("1.0")
                .build();

    }
}

그 다음으로 Controller에 코드를 추가 해줍니다. 저는 PostController에 추가 해주도록 하겠습니다.

@RestController
@RequiredArgsConstructor
@Api(tags = {"게시물 관련 API"})
public class PostController {
    private final PostService postService;

    @GetMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    @ApiOperation(value = "게시물 조회", notes = "게시물을 조회합니다.")
    public SuccessResponse<PostDTO> getPost(@PathVariable(name = "id") Long id) {
        PostDTO post = postService.getPost(id);

        return SuccessResponse.success(post);
    }

    @PostMapping("/post")
    @ResponseStatus(value = HttpStatus.CREATED)
    @PreAuthorize("isAuthenticated()")
    @ApiOperation(value = "게시물 생성", notes = "게시물을 생성합니다.")
    public SuccessResponse<PostDTO> createPost(@Valid @RequestBody PostDTO postDTO) {
        PostDTO post = postService.createPost(postDTO);

        return SuccessResponse.success(post);
    }

    @PutMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    @PreAuthorize("isAuthenticated()")
    @ApiOperation(value = "게시물 수정", notes = "게시물을 수정합니다.")
    public SuccessResponse<PostDTO> updatePost(@Valid @RequestBody PostDTO postDTO, @PathVariable(name = "id") Long postId) {
        PostDTO postDTOResponse = postService.updatePost(postId, postDTO);

        return SuccessResponse.success(postDTOResponse);
    }

    @DeleteMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    @PreAuthorize("isAuthenticated()")
    @ApiOperation(value = "게시물 삭제", notes = "게시물을 삭제합니다.")
    public SuccessResponse<String> deletePost(@PathVariable(name = "id") Long postId) {
        postService.deletePost(postId);
        return SuccessResponse.success(null);
    }

    @GetMapping("/post-category")
    @ResponseStatus(value = HttpStatus.OK)
    @PreAuthorize("isAuthenticated()")
    @ApiOperation(value = "게시물 카테고리 조회", notes = "게시물 카테고리를 조회합니다.")
    public SuccessResponse<List<PostCategoryDTO>> postCategory() {
        List<PostCategoryDTO> postCategoryDTOS = postService.postCategoryList();

        return SuccessResponse.success(postCategoryDTOS);
    }
}

@Api : 해당 컨트롤러가 어떤 API 그룹인지 적어주세요.

@ApiOperation : value -> api의 제목? 을 적어주세요.

@ApiOperation : notes -> api에 대한 설명을 적어주세요.

그 후 Main 실행 파일에 가셔서 @EnableSwagger2 를 붙여주세요.

@SpringBootApplication
@EnableSwagger2
public class BoardRestApiApplication {

    public static void main(String[] args) {
        SpringApplication.run(BoardRestApiApplication.class, args);
    }

}

 

저 같은 경우에는 Spring Security를 사용하고 있기 때문에 swagger 관련 주소를 제외시켜주어야 합니다. SecurityConfig에 추가시켜줍니다.

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring()
                .antMatchers("/webjars/**")
                .antMatchers("/v2/api-docs/**")
                .antMatchers("/configuration/**")
                .antMatchers("/swagger*/**");
    }

 

이제 실행하신다음 http://localhost:8080/swagger-ui.html 에 접속하시면 아래와 같은 화면이 나오며 api를 테스트 할 수 있습니다.

1. 수정, 삭제 - Controller

@PutMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    public SuccessResponse<PostDTO> updatePost(@Valid @RequestBody PostDTO postDTO, @PathVariable(name = "id") Long postId) {
        PostDTO postDTOResponse = postService.updatePost(postId, postDTO);

        return SuccessResponse.success(postDTOResponse);
    }

    @DeleteMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    public SuccessResponse<String> deletePost(@PathVariable(name = "id") Long postId) {
        postService.deletePost(postId);
        return SuccessResponse.success(null);
    }

2. 수정, 삭제 - Service

public PostDTO updatePost(Long postId, PostDTO postDTO) {
        Optional<Post> byId = postRepository.findById(postId);
        Post post = byId.orElseThrow(() -> new PostNotFound("해당 포스트가 존재하지 않습니다."));

        post.changeTitle(postDTO.getTitle());
        post.changeContents(postDTO.getContents());

        return PostDTO.builder()
                .id(post.getId())
                .build();
    }

    public void deletePost(Long postId) {
        Optional<Post> byId = postRepository.findById(postId);
        Post post = byId.orElseThrow(() -> new PostNotFound("해당 포스트가 존재하지 않습니다."));

        postRepository.delete(post);
    }
}

전체 코드는 여기서 볼 수 있습니다.

왜 테스트 코드를 작성해야 하나요?

테스트 코드를 작성을 왜 하는지 궁금하신 분들이 계실겁니다.

물론 테스트 코드를 작성하지 않고 API를 만든 후에 포스트맨같은 툴로 API를 테스트 할 수도 있을겁니다. 저 역시 이전에는 그렇게 하였구요. 그러나 이 방법의 최대 단점은 손이 많이 간다는 것입니다.

예를 들어 회원가입을 한다면 확인해야 할 것이 아래와 같습니다.

  1. Email이 중복이 아닌가?
  2. 비밀번호가 양식에 맞는가?
  3. 필수로 입력해야할 칸이 비어있지는 않는가?
  4. 가입이 성공적으로 완료되었을때 응답을 올바르게 오는가?
  5. 1,2,3번에 해당하였을 경우 에러를 잘 뱉어내는가?

위와 같은 테스트 케이스들이 많습니다! 무려 회원가입 API 하나만 체크하는데도 최소 5개가 되는 케이스를 테스트 해야합니다.

이걸 포스트맨으로 일일히 옮겨 적는다면.. 예전 생각이 나서 정말 끔찍하네요.

이러한 노가다를 방지하기 위해 테스트 코드를 작성하는데요? 물론 테스트코드 역시 위와 같은 케이스를 모두 작성해주어야 하는 번거로움은 있습니다. 그러나 테스트코드를 작성하면 위와같은 케이스를 한번 클릭으로 모두 테스트할 수 있기때문에 시간 절약이 됩니다!

 

Controller Test

@ExtendWith(SpringExtension.class)
@SpringBootTest
@AutoConfigureMockMvc
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class PostControllerTest {
    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private PostService postService;

    public PostDTO initPostDTO() {
        return PostDTO.builder()
                .title("title")
                .contents("contents")
                .build();
    }

    @Test
    @DisplayName("게시물 등록 테스트")
    @Order(1)
    public void createPost() throws Exception {
        // given
        PostDTO postDTO = initPostDTO();

        //when
        ResultActions resultActions = mockMvc.perform(post("/post")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(postDTO)));

        //then
        resultActions
                .andExpect(jsonPath("data").exists())
                .andExpect(jsonPath("data").hasJsonPath())
                .andExpect(jsonPath("data.id").exists())
                .andExpect(jsonPath("message").value("success"))
                .andExpect(jsonPath("data.id").value(1))
                .andExpect(status().isCreated())
                .andDo(print());
    }

    @Test
    @DisplayName("게시물 가져오기 테스트 - 성공")
    @Order(2)
    public void getPostSuccess() throws Exception {
        // given
        PostDTO postDTO = initPostDTO();
        postService.createPost(postDTO);

        // when
        ResultActions perform = mockMvc.perform(get("/post/{id}", 1));

        // then
        perform
                .andExpect(status().isOk())
                .andExpect(jsonPath("message").exists())
                .andExpect(jsonPath("message").value("success"))
                .andExpect(jsonPath("data").exists())
                .andExpect(jsonPath("data.id").exists())
                .andExpect(jsonPath("data.title").exists())
                .andExpect(jsonPath("data.title").value("title"))
                .andExpect(jsonPath("data.contents").exists())
                .andExpect(jsonPath("data.contents").value("contents"))
                .andDo(print());
    }

    @Test
    @DisplayName("존재하지않는 게시물 가져오기")
    @Order(3)
    public void getPostFail() throws Exception {
        mockMvc.perform(get("/post/{id}", 9999999))
                .andExpect(status().isNotFound())
                .andExpect(jsonPath("message").exists())
                .andExpect(jsonPath("message").value("error"))
                .andExpect(jsonPath("errors[0]").exists())
                .andExpect(jsonPath("errors[0].field").doesNotExist())
                .andExpect(jsonPath("errors[0].message").exists())
                .andExpect(jsonPath("errors[0].message").value("해당 포스트가 존재하지 않습니다."))
                .andDo(print());
    }

    @Test
    public void 게시물_제목_입력안함() throws Exception {
        // given
        PostDTO postDTO = PostDTO.builder()
                .contents("contents")
                .build();

        //when
        ResultActions resultActions = mockMvc.perform(post("/post")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(postDTO)));

        //then
        resultActions
                .andExpect(jsonPath("errors").exists())
                .andExpect(jsonPath("errors").isArray())
                .andExpect(jsonPath("errors[*].field", containsInAnyOrder("title")))
                .andExpect(jsonPath("errors[*].message", containsInAnyOrder("제목을 입력해주세요.")))
                .andExpect(status().isBadRequest())
                .andDo(print());
    }

    @Test
    public void 게시물_내용_입력안함() throws Exception {
        // given
        PostDTO postDTO = PostDTO.builder()
                .title("title")
                .build();

        //when
        ResultActions resultActions = mockMvc.perform(post("/post")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(postDTO)));

        //then
        resultActions
                .andExpect(jsonPath("errors").exists())
                .andExpect(jsonPath("errors").isArray())
                .andExpect(jsonPath("errors[*].field", containsInAnyOrder("contents")))
                .andExpect(jsonPath("errors[*].message", containsInAnyOrder("내용을 입력해주세요.")))
                .andExpect(status().isBadRequest())
                .andDo(print());
    }

    @Test
    public void 게시물_내용_제목_입력안함() throws Exception {
        // given
        PostDTO postDTO = PostDTO.builder()
                .build();

        //when
        ResultActions resultActions = mockMvc.perform(post("/post")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(postDTO)));

        //then
        resultActions
                .andExpect(jsonPath("errors").exists())
                .andExpect(jsonPath("errors").isArray())
                .andExpect(jsonPath("errors").hasJsonPath())
                .andExpect(jsonPath("errors", hasSize(2)))
                .andExpect(jsonPath("errors[*].field", containsInAnyOrder("title", "contents")))
                .andExpect(jsonPath("errors[*].message", containsInAnyOrder("제목을 입력해주세요.", "내용을 입력해주세요.")))
                .andExpect(status().isBadRequest())
                .andDo(print());
    }

}

 

 

errors[*] 문법은 errors의 원소의 순서없이 containsInAnyOrder의 값이 있냐없냐를 체크하기 위함입니다.

진행 코드는 여기서 볼 수 있습니다.

안녕하세요. 오늘부터는 스프링 부트를 활용하여 블로그 API를 만들어 보도록 하겠습니다.

개발 환경은 아래와 같습니다.

  • 스프링부트 2.4.5
  • spring-boot-starter-web
  • spring-data-jap, h2, mysql
  • validation, lombok
  • junit5

1. application.yml 파일에 database 정보 입력하기

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/board-rest?autoReconnect=true&useUnicode=true&serverTimezone=UTC&characterEncoding=UTF8
    username: root
    password: ghd9413
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        show_sql: true
        format_sql: true
        use_sql_comments: true
  jackson:
    property-naming-strategy: SNAKE_CASE

저는 mysql로 진행하였습니다. 

property-naming-strategy는 기본값이 CamelCase인데 저는 SnakeCase를 선호하여 변경하였습니다.

 

2. 게시물 가져오기 API - Controller, Service, Repository, Entity, PostDTO

- controller

@RestController
@RequiredArgsConstructor
public class PostController {
    private final PostService postService;

    @GetMapping("post/{id}")
    @ResponseStatus(value = HttpStatus.OK)
    public SuccessResponse getPost(@PathVariable(name = "id") Long id) {
        PostDTO post = postService.getPost(id);

        return SuccessResponse.success(post);
    }
}

 

- service

@Service
@RequiredArgsConstructor
public class PostService {
    private final PostRepository postRepository;

    public PostDTO getPost(Long postId) {
        Optional<Post> byId = postRepository.findById(postId);

        Post findPost = byId.orElseThrow(() -> new PostNotFound("해당 포스트가 존재하지 않습니다."));

        return PostDTO.builder()
                .id(findPost.getId())
                .title(findPost.getTitle())
                .contents(findPost.getContents())
                .createdAt(findPost.getCreateAt().toString())
                .build();
    }
 }

 

- repository

@Repository
public interface PostRepository extends JpaRepository<Post, Long> {
}

 

- entity

@Entity
@Getter
@Builder
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor(access = AccessLevel.PROTECTED)
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    private String contents;

    private LocalDateTime createAt;
}

 

- postDTO

@Data
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@Builder
public class PostDTO {
    @NotBlank
    private String title;
    @NotBlank
    private String contents;

    private Long viewCount;

    private String createdAt;
}

API를 만들기 앞서 클라이언트와 통신할때 사용할 PostDTO를 만들도록 하겠습니다.

Client - Controller - Service 간에는 PostDTO로 작업 하였습니다.

@NoArgsConstructor와 @AllArgsConstructor에 PROTECTED를 한 이유는 PostDTO를 만들 때 Builder를 사용할 것이기 때문에 생성자를 통한 생성은 막기 위함입니다.

title과 contents에 @NotBlank를 한 이유는 validation을 통해 값을 필수로 받기 위함입니다.

3. 게시물 등록 API - Controller, Service

-controller

 @PostMapping("/post")
    @ResponseStatus(value = HttpStatus.CREATED)
    public SuccessResponse createPost(@Valid @RequestBody PostDTO postDTO) {
        PostDTO post = postService.createPost(postDTO);

        return SuccessResponse.success(post);
    }

 

- service

public PostDTO createPost(PostDTO postDTO) {
        Post post = Post.builder()
                .title(postDTO.getTitle())
                .contents(postDTO.getContents())
                .createAt(LocalDateTime.now())
                .build();

        Post save = postRepository.save(post);

        PostDTO postDTOResponse = PostDTO.builder()
                .id(save.getId())
                .build();


        return postDTOResponse;
    }

 

4. Response 양식 만들기

- SuccessResponse

@Getter
@Builder
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class SuccessResponse<T> {
    private String message;
    private T data;

    public static <T> SuccessResponse success(T data) {

        SuccessResponse responseUtil = SuccessResponse.builder()
                .message("success")
                .data(data)
                .build();

        return responseUtil;

    }
}

- ErrorResponse

@Data
@Builder
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ErrorResponse {
    private String message;
    @Builder.Default
    private List<CustomError> errors = new ArrayList<>();

    public List<CustomError> addError(CustomError error) {
        this.errors.add(error);
        return this.errors;
    }
}

- CustomError

@Data
@Builder
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class CustomError {
    private String field;
    private String message;
}

Response할때 PostDTO를 바로 return해도 되지만 클라이언트와 통신을 생각하면 고정된 Response 양식이 필요하다고 생각하여 만들었습니다.

@JsonInclude(JsonInclude.Include.NON_NULL)은 필드중 null값이 있을경우 해당 필드는 제외하고 리턴합니다.

SuccessResponse의 경우 message에는 success가, data에는 결과 데이터가 들어가있으며

ErrorResponse의 경우 message에는 error가, erorrs에는 에러가 들어있습니다! 

errors를 Array로 한 이유는 게시글 등록처럼 @Valid가 달린경우 제목과 내용을 둘다 적지 않으면 에러가 2개이기 때문에 한번에 보여주고자 하기 위함입니다.

다음 시간에는 테스트 코드를 작성하여 확인해보도록 하겠습니다.

진행 코드는 아래에서 확인할 수 있습니다.

sug5806/board-project-rest (github.com)

1. SSL 인증서 받기

먼저 AWS로 들어가서 ACM 메뉴로 들어가 줍니다.

 

 

시작하기를 눌러 줍니다.

 

 

 

 

오른쪽 하단의 인증서 요청을 눌러줍니다.

 

 

 

 

아래에 본인의 도메인을 적어줍니다. ex) *.example.com으로 적어두시면 example.com의 하위 도메인까지 모두 포함합니다. 입력 후 다음을 눌러줍니다.

 

 

 

 

검증 방법은 DNS검증을 하겠습니다. 다음을 눌러 줍니다.

 

 

 

 

태그는 딱히 추가하지 않아도 무방합니다 . 검토를 눌러줍니다.

 

 

 

 

 

그다음 오른쪽 하단에 확인 및 요청을 눌러줍니다.

 

 

 

 

그러면 이런화면이 나올텐데 Route 53에서 레코드 생성을 눌러줍니다. 그러면 자동으로 생성이됩니다. 그런다음 계속을 눌러준 후 검증이 될때까지 대기해 줍니다.

 

2. LoadBalancer 만들기

AWS 메뉴에서 EC2 메뉴로 들어가신 뒤 왼쪽 사이드메뉴에서 로드밸런서를 눌러 줍니다. 그런다음 Load Balancer 생성을 눌러 줍니다.

 

 

그 뒤 이런 화면이 나올탠데 맨 왼쪽에 Application Load Balancer를 눌러줍니다.

 

 

 

사용 하실 로드밸런서 이름과 80번 포트와 443 포트를 모두 열어줍니다. 80을 포트를 열어주는 이유는 나중에 80번 포트로 접속시 자동으로 443 포트로 리다이렉트 시키기 위함입니다. 다음을 눌러줍니다.

 

 

 

 

자동으로 방금 만든 인증서로 선택이 됩니다. 그후 다음을 눌러줍니다.

 

 

 

보안그룹을 선택해야 하는데 저는 기존에 만들어 놓은 그룹이 있어서 그것을 사용하였습니다. 만약 없으시다면 보안그룹을 새로 만든뒤 보안 안그룹 정책에서 80포트와 443포트를 열어주세요 그후 다음을 눌러줍니다

 

 

 

이제 이 로드밸런서를 이용하여 라우팅할 그룹을 설정해야 하는데요 저의 경우 그룹이 없어서 새로 만드는 작업도 같이 하겠습니다. 중간에 프로토콜과 포트가 있는데 저는 EC2 인스턴스에서 HTTP 프로토콜과 8888번 포트를 사용하여 Application을 실행하고 있기 때문에 맞춰주었습니다. 그후 다음을 눌러줍니다.

 

 

 

 

이제 방금 만든 그룹에 속할 인스턴스를 등록해야 하는데요 저는 dev 인스턴스 하나만 넣도록 하겠습니다. 그후 다음을 눌러주면 검토화면이 나오는데 확인 후 생성을 눌러줍니다.

 

 

 

 

 

3. HTTP로 들어온 요청을 HTTPS로 리다이렉트 시키기

이제 80번 포트로 들어오는 연결을 443 HTTPS로 리다이렉트 시켜보겠습니다. 로드밸런서 메뉴로 들어오신후 80번 포트 리스너를 선택 후 편집을 눌러줍니다.

 

 

 

 

휴지통을 눌러 삭제해 주신뒤 작업 추가를 누른뒤 리디렉션 대상을 눌러줍니다.

 

 

다 마친 뒤 오른쪽 위에 업데이트를 눌러 작업을 마칩니다.

 

4. ROUTE53에서 LoadBalancer 연결하기

 

 

라우트 53으로 가신다음에 호스팅 영역을 눌러줍니다

 

 

 

레코드 생성을 눌러줍니다.

 

 

 

단순 라우팅을 선택한뒤 다음을 눌러줍니다

 

 

 

그 다음 방금 만든 load balance를 연결시켜줍니다. 그 다음 단순 레코드 정의를 눌러줍니다. 

 

 

 

 

레코드 생성을 눌러주면 본인의 도메인과 loadbalance가 연결되었습니다.

 

작업이 모두 끝났지만 적용되는데까지 시간이 걸리는것 같습니다. 저의 경우 30분정도 걸린듯 싶습니다. 꽤나 오래걸린...

Spring Boot : 2.4.4 버전 입니다.

먼저 CKeditor와 AWS S3 버킷은 만들었다고 가정하겠습니다.

우선 기본적으로 CDN을 통해 CK editor를 붙이면 드래그&드롭기능은 있지만 이미지 업로드가 되지 않을텐데요. 먼저 이미지 업로드부터 활성화 시키겠습니다.

 

 

imageUploadUrl 이라는 키워드를 통해 드래그&드롭으로 이미지를 올릴 시 어떤 API로 보낼지 정할 수 있습니다. 저의 경우 /image/upload 입니다.

그 다음은 컨트롤러 부분을 보겠습니다.

 

 

CK Editor를 사용했다면서 왜 RestController있냐고 생각하실수도 있으신 분들을 위해 설명하겠습니다.

이미지 업로드를 하고 나면 정해진 형태의 json 양식으로 response를 보내주어야 CK Editor가 인식 할 수 있습니다.

 

 

response의 양식을 위와 같습니다.

그 다음은 Service 부분입니다.

코드가 길어 이미지 대신 코드블럭으로 대신하였습니다.

@Service
@RequiredArgsConstructor
@Slf4j
public class FileService {

    private final AmazonS3Client amazonS3Client;
    
    @Value("${cloud.aws.s3.bucket}")
    private String bucket;

    public FileUploadDTO fileUpload(MultipartFile upload, Principal principal) throws IOException {
        File uploadFile = convert(upload).orElseThrow(() -> new IllegalArgumentException("MultipartFile -> File 전환실패."));

        return upload(uploadFile, "static");
    }

    private FileUploadDTO upload(File uploadFile, String dir) {
        String sourceName = uploadFile.getName();
        String sourceExt = FilenameUtils.getExtension(sourceName).toLowerCase();

        String fileName = dir + "/" + LocalDateTime.now().toString().concat(".").concat(sourceExt);
        String uploadImageUrl = putS3(uploadFile, fileName);
        removeNewFile(uploadFile);

        return FileUploadDTO.builder()
                .uploaded(true)
                .fileName(fileName)
                .url(uploadImageUrl)
                .build();
    }

    private void removeNewFile(File targetFile) {
        if (targetFile.delete()) {
            log.info("파일이 삭제되었습니다.");
        } else {
            log.info("파일이 삭제되지 못했습니다.");
        }
    }

    private String putS3(File uploadFile, String fileName) {
        try {
            amazonS3Client.putObject(new PutObjectRequest(bucket, fileName, uploadFile)
                    .withCannedAcl(CannedAccessControlList.PublicRead));
        } catch (Exception e) {
            log.error("이미지 s3 업로드 실패");
            log.error(e.getMessage());
            removeNewFile(uploadFile);
            throw new RuntimeException();
        }

        return amazonS3Client.getUrl(bucket, fileName).toString();
    }

    private Optional<File> convert(MultipartFile file) throws IOException {
        File convertFile = new File(Objects.requireNonNull(file.getOriginalFilename()));
        if (convertFile.createNewFile()) {
            try (FileOutputStream fos = new FileOutputStream(convertFile)) {
                fos.write(file.getBytes());
            }

            return Optional.of(convertFile);
        }

        return Optional.empty();
    }
}

코드에 대해 자세한 설명이 필요하신 분들은 https://jojoldu.tistory.com/300 이 글을 보시면 자세히 알 수 있습니다.

저는 위의 글과는 조금 다르게 환경설정을 했습니다. 위의 글에서는 aws.yml 파일을 따로 만들어서 accessKey와 secretKey를 등록을 해줬는데요 저같은 경우에는 로컬, develop 서버, product 서버의 환경이 다르다보니 각 서버별로 RDS를 연결시켜주어야 했습니다. 그러기 때문에 yml파일을 환경별로 세팅하여서 위의 글과는 다른 점이 있습니다. 물론 하나의 yml 파일에 ---로 구분지어 환경을 나눌수 있다고 하는데 아직 해보지 않아서 모르겠습니다. 추후 해본다음에 포스트하도록 하겠습니다.

다른점은 yml파일과 main 함수 부분입니다.

 

 

spring:
  config:
    activate:
      on-profile: dev

  mvc:
    hiddenmethod:
      filter:
        enabled: false

  datasource:
    url: jdbc:mysql://${rds}:3306/board?autoReconnect=true&useUnicode=true&serverTimezone=UTC&characterEncoding=UTF8
    username: ${username}
    password: ${password}
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        show_sql: true
        format_sql: true
        use_sql_comments: true

  thymeleaf:
    prefix: classpath:/templates/
    suffix: .html
    cache: false

  loggin.level:
    org.hibernate.SQL: debug

server:
  port: 8888

cloud:
  aws:
    s3:
      bucket: hese-board
    region:
      static: ap-northeast-2
    credentials:
      accessKey: ${accessKey}
      secretKey: ${secretKey}
      use-default-aws-credentials-chain: false
      instance-profile: true
    stack:
      auto: false

accessKey와 secretKey 부분에 ${} 이렇게 되어있는걸 볼 수 있는데요 이렇게 해줌으로써 jar 파일을 실행할때 변수를 넘겨주어 acessKey와 secretKey를 설정해줄 수 있습니다.

제가 사용하는 명령어를 적어놓겠습니다.

java -Dspring.profiles.active=dev -jar /home/ubuntu/application/deploy/*.jar --rds=rds주소 --username=계정명 --password=비밀번호 --accessKey=액세스키 --secretKey=시크릿키

-Dspring.profiles.active로 사용할 application.yml 파일을 정해주고 뒤에 추가 변수로 전부 매핑시켜 줍니다.

+ Recent posts