Project Lab 6. 게시판 개발(DTO, MapStruct) - 3

<module-domain-core/src/main/java/kr/ac/univ/common/dto/mapper/EntityMapper>

package kr.ac.univ.common.dto.mapper;

import java.util.List;

public interface EntityMapper <Dto, Entity> {
   Entity toEntity(Dto dto);
   Dto toDto(Entity entity);
   List<Entity> toEntity(List<Dto> dto);
   List<Dto> toDto(List<Entity> entity);
}

<module-domain-core/src/main/java/kr/ac/univ/noticeBoard/NoticeBoardMapper>

package kr.ac.univ.noticeBoard.dto.mapper;

import kr.ac.univ.common.dto.mapper.EntityMapper;
import kr.ac.univ.noticeBoard.domain.NoticeBoard;
import kr.ac.univ.noticeBoard.dto.NoticeBoardDto;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper(componentModel = "spring")
public interface NoticeBoardMapper extends EntityMapper<NoticeBoardDto, NoticeBoard> {
   NoticeBoardMapper INSTANCE = Mappers.getMapper(NoticeBoardMapper.class);

}

<module-domain-core/src/main/java/kr/ac/univ/common/domain/CommonAudit>

package kr.ac.univ.common.domain;

import kr.ac.univ.common.domain.enums.ActiveStatus;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.time.LocalDateTime;

@MappedSuperclass
@Getter
@Setter
@ToString
@EntityListeners(AuditingEntityListener.class)
public abstract class CommonAudit {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long idx;

   @Column(nullable = false, updatable = false)
   @CreatedDate
   private LocalDateTime createdDate;

   @LastModifiedDate
   private LocalDateTime lastModifiedDate;

   private String createdBy;

   private String lastModifiedBy;

   @Enumerated(EnumType.STRING)
   private ActiveStatus activeStatus;

   private Long views = 0L;
}

<module-domain-core/src/main/java/kr/ac/univ/noticeBoard/dto/NoticeBoard>

package kr.ac.univ.noticeBoard.domain;

import kr.ac.univ.common.domain.CommonAudit;
import kr.ac.univ.common.domain.enums.ActiveStatus;
import kr.ac.univ.noticeBoard.listener.NoticeBoardListener;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.ToString;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.Table;

@Getter
@NoArgsConstructor
@Entity
@Table
@ToString
public class NoticeBoard extends CommonAudit {
   private String title;

   private Long mainPagePriority;

   private String content;

   @Builder
   public NoticeBoard(Long idx, String createdBy, String lastModifiedBy, ActiveStatus activeStatus, String title, Long mainPagePriority, String content) {
       setIdx(idx);
       setCreatedBy(createdBy);
       setLastModifiedBy(lastModifiedBy);
       setActiveStatus(activeStatus);
       this.title = title;
       this.mainPagePriority = mainPagePriority;
       this.content = content;
   }

   public void update(NoticeBoard noticeBoard) {
       setActiveStatus(noticeBoard.getActiveStatus());
       this.title = noticeBoard.getTitle();
       this.mainPagePriority = noticeBoard.getMainPagePriority();
       this.content = noticeBoard.getContent();
   }
}

<module-domain-core/src/main/java/kr/ac/univ/common/dto/CommonDto>

package kr.ac.univ.common.dto;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

import java.time.LocalDateTime;

@Getter
@Setter
@NoArgsConstructor
@ToString
public class CommonDto {
   private Long idx;
   private LocalDateTime createdDate;
   private LocalDateTime lastModifiedDate;
   private String createdBy;
   private String lastModifiedBy;
   private boolean isAccess;
}

<module-domain-core/src/main/java/kr/ac/univ/noticeBoard/dto/NoticeBoardDto>

import kr.ac.univ.common.domain.enums.ActiveStatus;
import kr.ac.univ.common.dto.CommonDto;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@NoArgsConstructor
@ToString
public class NoticeBoardDto extends CommonDto {
   /* CommonDto: JPA Audit */

   /* 기본 정보 */
   private String title;
   private String content;
   private ActiveStatus activeStatus;
   private Long viewCount;
}

<module-app-web/src/test/java/kr/ac/univ/MapStructTest>

package kr.ac.univ;

import kr.ac.univ.noticeBoard.domain.NoticeBoard;
import kr.ac.univ.noticeBoard.dto.NoticeBoardDto;
import kr.ac.univ.noticeBoard.dto.mapper.NoticeBoardMapper;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;


@SpringBootTest
@EnableAutoConfiguration
@ExtendWith(SpringExtension.class)
@Slf4j
public class MapStructTest {

   @Test
   @DisplayName("Mapstrcut 테스트")
   public void Test() {
       NoticeBoardDto noticeBoardDto = new NoticeBoardDto();
       noticeBoardDto.setTitle("제목입니다");
       noticeBoardDto.setContent("글입니다");

       NoticeBoard noticeBoard = NoticeBoardMapper.INSTANCE.toEntity(noticeBoardDto); // DTO -> Entity

       Assert.assertEquals(noticeBoardDto.getTitle(), noticeBoard.getTitle());
       Assert.assertEquals(noticeBoardDto.getContent(), noticeBoard.getContent());
   }
}

<module-domain-core/src/main/java/kr/ac/univ/noticeBoard/service/NoticeBoardService>

package kr.ac.univ.noticeBoard.service;

import kr.ac.univ.noticeBoard.domain.NoticeBoard;
import kr.ac.univ.noticeBoard.dto.NoticeBoardDto;
import kr.ac.univ.noticeBoard.dto.mapper.NoticeBoardMapper;
import kr.ac.univ.noticeBoard.repository.NoticeBoardRepository;
import kr.ac.univ.noticeBoard.repository.NoticeBoardRepositoryImpl;
import org.springframework.data.domain.*;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;

@Service
public class NoticeBoardService {
   private final NoticeBoardRepository noticeBoardRepository;
   private final NoticeBoardRepositoryImpl noticeBoardRepositoryImpl;

   public NoticeBoardService(NoticeBoardRepository noticeBoardRepository, NoticeBoardRepositoryImpl noticeBoardRepositoryImpl) {
       this.noticeBoardRepository = noticeBoardRepository;
       this.noticeBoardRepositoryImpl = noticeBoardRepositoryImpl;
   }

   public Page<NoticeBoardDto> findNoticeBoardList(Pageable pageable) {
       Page<NoticeBoard> noticeBoardList = null;

       pageable = PageRequest.of(pageable.getPageNumber() <= 0 ? 0 : pageable.getPageNumber() - 1, pageable.getPageSize(), Sort.Direction.DESC, "idx");
       noticeBoardList = noticeBoardRepository.findAll(pageable);

       return new PageImpl<NoticeBoardDto>(NoticeBoardMapper.INSTANCE.toDto(noticeBoardList.getContent()), pageable, noticeBoardList.getTotalElements());
   }

   public Long insertNoticeBoard(NoticeBoard noticeBoard) {

       return noticeBoardRepository.save(noticeBoard).getIdx();
   }

   public NoticeBoardDto findNoticeBoardByIdx(Long idx) {
       noticeBoardRepositoryImpl.updateViewCountById(idx);

       return NoticeBoardMapper.INSTANCE.toDto(noticeBoardRepository.findById(idx).orElse(new NoticeBoard()));
   }

   @Transactional
   public Long updateNoticeBoard(Long idx, NoticeBoard noticeBoard) {
       noticeBoardRepository.getOne(idx).update(noticeBoard);

       return noticeBoardRepository.save(noticeBoard).getIdx();
   }

   public void deleteNoticeBoardByIdx(Long idx) {
       noticeBoardRepository.deleteById(idx);
   }
}

<module-app-web/src/main/java/kr/ac/univ/controller/NoticeBoardController>

model.addAttribute("noticeBoardDtoList", noticeBoardService.findNoticeBoardByIdx(idx));

<module-app-web/src/main/resources/templates/noticeBoard/list, form, read>

<tr th:each="noticeBoardDto : ${noticeBoardDtoList}">