📌 https://github.com/LEEEUNCHEOL96/demo241106

Rest Api CRUD test

작업 진행 순서
1. IntelliJ 개발 환경 설정
2. BaseEntity 및 ArticleEntity 설정
3. Article Controller, DTO, RsData 설정
4. 요청 및 응답 설정
5. Service 설정
6. 컨트롤러에 구현하기

1. IntelliJ 개발 환경 설정

• IntelliJ 개발환경 설정

• MariaDB 데이터베이스를 사용하고, JPA와 Hibernate를 활용하여 데이터베이스와의 효율적인 연동.

  application.yml 파일에서 주요 설정 항목을 설명한 내용이다.

// application.yml 
spring:
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    url: jdbc:mariadb://localhost:3306/demo241106
    username: *****
    password: *****
  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        show_sql: true
        format_sql: true
        use_sql_comments: true
logging:
  level:
    root: INFO
    example.demo.rest_api: DEBUG
    org.hibernate.orm.jdbc.bind: TRACE
    org.hibernate.orm.jdbc.extract: TRACE

• DB 생성하기
  

2. BaseEntity 및 ArticleEntity 설정

• BaseEntity 설정

// global.jpa > BaseEntity

@Getter
@SuperBuilder
@MappedSuperclass
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@EntityListeners(AuditingEntityListener.class)
@ToString
public class BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @CreatedDate
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime modifiedDate;
}

어노테이션

• @SuperBuilder: 빌더 패턴을 통해 객체를 생성할 수 있게 지원, 상속 관계에서도 사용 가능.
• @MappedSuperclass: 이 클래스는 직접 테이블에 매핑되지 않지만, 상속받은 클래스들이 이를 상속하여 매핑될 수 있도록 함.
• @EntityListeners(AuditingEntityListener.class): Auditing 기능을 활성화하여 createdDate와 modifiedDate 필드가 자동으로 관리되도록 함.

• ArticleEntity 설정

// domain.article.entity > Article
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder
@ToString(callSuper = true)
public class Article extends BaseEntity {
    private String subject;
    private String content;
    private String author;
}

Entity 를 초기 설정하는 이유
JPA와 Spring Data JPA에서 엔티티를 중심으로 데이터베이스와의 상호작용을 처리하기 때문이다. Article 엔티티와 같은 JPA 엔티티 클래스는 데이터베이스 테이블과 매핑되는 객체로, 애플리케이션의 데이터 모델을 정의하고, 데이터베이스 CRUD 작업을 수행하는 데 핵심적인 역할을 한다.

3. Article Controller, DTO, RsData 설정

이번 작업에서는 HTML 기반의 프론트엔드 구현 없이, Postman을 이용하여 API 테스트 및 검증을 진행할 예정이다.

• ArticleDTO 설정

//domain.article.dto > ArticleDTO
@Getter
public class ArticleDTO {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private final Long id;

    private final String subject;

    private final String content;

    private final String author;

    private final LocalDateTime createdDate;

    @LastModifiedDate
    private final LocalDateTime modifiedDate;

    public ArticleDTO(Article article){
        this.id = article.getId();
        this.subject = article.getSubject();
        this.content = article.getContent();
        this.author = article.getAuthor();
        this.createdDate = article.getCreatedDate();
        this.modifiedDate = article.getModifiedDate();
    }
}

DTO 를 만든 이유
애플리케이션의 각 계층 간 데이터 교환을 보다 명확하고 효율적으로 처리하기 위해서이다. 특히 ArticleDTO는 Article 엔티티와 컨트롤러 또는 서비스 간의 데이터를 변환하는 데 사용된다. 또한 유지보수와 확장성을 높일 수 있다.

• Article Controller 에서 초기 Test 진행

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/demo241106/articles")
public class ArticleController {
    private final ArticleService articleService;

    @GetMapping("") // 다건조회
    public List<ArticleDTO> list() {
        List<ArticleDTO> articleDTOS = new ArrayList<>();
        Article article = new Article("첫 번째 게시글", "내용입니다.", "작성자");
        articleDTOS.add(new ArticleDTO(article));

        Article article2 = new Article("두 번째 게시글", "내용입니다.2", "작성자2");
        articleDTOS.add(new ArticleDTO(article2));

        Article article3 = new Article("세 번째 게시글", "내용입니다.3", "작성자3");
        articleDTOS.add(new ArticleDTO(article3));

        return articleDTOS;
    }

    @GetExchange("/{id}") //단건조회
    public ArticleDTO getArticle(@PathVariable("id") Long id){
        Article article = new Article("첫 번째 게시글","내용입니다.","작성자");
        ArticleDTO articleDTO = new ArticleDTO(article);

        return articleDTO;
    }

    @PostMapping("") // 생성
    public String create(@RequestParam("subject") String subject,
                         @RequestParam("content") String content,
                         @RequestParam("author") String author){

        System.out.println(subject);
        System.out.println(content);
        System.out.println(author);

        return "등록";
    }

    @PatchMapping("/{id}") // 수정
    public String modify(@PathVariable("id") Long id,
                         @RequestParam("subject") String subject,
                         @RequestParam("content") String content,
                         @RequestParam("author") String author){

        System.out.println(id);
        System.out.println(subject);
        System.out.println(content);
        System.out.println(author);

        return "수정";
    }

    @DeleteMapping("/{id}")  // 샂게
    public String delete(@PathVariable("id") Long id){
        System.out.println(id);

        return "삭제";
    }
}

Postman에서 위의 ArticleController의 REST API를 간단하게 테스트해보자. 각 엔드포인트에 맞는 요청을 보내고 그 결과를 확인한다.

4. 요청 및 응답 설정

• 다음으로는 요청 및 응답에 대한 값을 불러오자

global.RsData > RsData

@Getter
@Setter
@AllArgsConstructor
public class RsData<T> {
    private String resultCode;
    private String msg;
    private T data;
    public static <T> RsData<T> of(String resultCode, String msg, T data) {
        return new RsData<>(resultCode, msg, data);
    }
    public static <T> RsData<T> of(String resultCode, String msg) {
        return of(resultCode, msg, null);
    }
    @JsonIgnore
    public boolean isSuccess() {
        return resultCode.startsWith("200");
    }
    @JsonIgnore
    public boolean isFail() {
        return !isSuccess();
    }
}

RsData란?
API 응답을 일관된 형식으로 반환하기 위해 사용된다. 주로 응답 코드, 메시지, 그리고 응답 데이터를 포함하는 객체로, 클라이언트에게 전달할 API 응답의 구조를 정의된다.

• Controller 에 RsData 를 적용시키기 위해 응답 및 요청을 생성한다.

• 요청

// domain.article.request > ArticleCreateRequest 
// domain.article.request > ArticleModifyRequest 
@Getter
@Setter
public class Article_____Request{
    @NotBlank
    private String subject;
    @NotBlank
    private String content;
    @NotBlank
    private String author;
}

• 응답

// domain.article.response > ArticleResponse 단건
// domain.article.response > ArticlesResponse 다건
@Getter
@AllArgsConstructor
public class ArticleResponse {
    private final ArticleDTO article;
}

RsData 와 Requset,Response 적용하기

• 이번에는 Postman을 사용하여 RsData, Request, Response를 기반으로 한 ArticleController의 REST API를 간단히 테스트해보자.

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/demo241106/articles")
public class ArticleController {
    private final ArticleService articleService;

    @GetMapping("") // 다건조회
    public RsData<ArticlesResponse> list() {
        List<ArticleDTO> articleDTOS = new ArrayList<>();
        Article article = new Article("첫 번째 게시글", "내용입니다.", "작성자");
        articleDTOS.add(new ArticleDTO(article));

        Article article2 = new Article("두 번째 게시글", "내용입니다.2", "작성자2");
        articleDTOS.add(new ArticleDTO(article2));

        Article article3 = new Article("세 번째 게시글", "내용입니다.3", "작성자3");
        articleDTOS.add(new ArticleDTO(article3));

        return RsData.of("200","게시글 다건 조회 성공", new ArticlesResponse(articleDTOS));
    }


    @GetExchange("/{id}") //단건조회
    public RsData<ArticleResponse> getArticle(@PathVariable("id") Long id){
        Article article = new Article("첫 번째 게시글","내용입니다.","작성자");
        ArticleDTO articleDTO = new ArticleDTO(article);

        return RsData.of("200","게시글 단건 조회 성공", new ArticleResponse(articleDTO));
    }

    @PostMapping("") // 생성
    public String create(@Valid @RequestBody ArticleCreateRequest articleCreateRequest){

        System.out.println(articleCreateRequest.getSubject());
        System.out.println(articleCreateRequest.getContent());
        System.out.println(articleCreateRequest.getAuthor());

        return "등록완료";
    }

    @PatchMapping("/{id}") // 수정
    public String modify(@PathVariable("id") Long id, @Valid @RequestBody ArticleModifyRequest articleModifyRequest){

        System.out.println(id);
        System.out.println(articleModifyRequest.getSubject());
        System.out.println(articleModifyRequest.getContent());
        System.out.println(articleModifyRequest.getAuthor());

        return "수정";
    }

    @DeleteMapping("/{id}")  // 샂게
    public String delete(@PathVariable("id") Long id){
        System.out.println(id);

        return "삭제";
    }
}

5. Service 설정

• 간단한 테스트들이 잘 실행 되었다.이제는 본격적으로 DB에 저장하고 불러와보자.

@Service
@RequiredArgsConstructor
public class ArticleService {
    private final ArticleRepository articleRepository;

    public List<ArticleDTO> getList() {
        List<Article> articleList = this.articleRepository.findAll();

        List<ArticleDTO> articleDTOList = articleList.stream()
                .map(article -> new ArticleDTO(article))
                .collect(Collectors.toList());
        return articleDTOList;
    }

    public Article getArticle(Long id) {
        Optional<Article> optionalArticle = this.articleRepository.findById(id);

        return optionalArticle.orElse(null);
    }


    public Article write(String subject, String content,String author){
        Article article = Article.builder()
                .subject(subject)
                .content(content)
                .author(author)
                .build();
        this.articleRepository.save(article);
        return article;
    }

    public Article update(Article article, String content, String subject,String author) {
        article.setSubject(subject);
        article.setContent(content);
        article.setAuthor(author);
        this.articleRepository.save(article);
        return article;
    }

    public void delete(Article article) {
        this.articleRepository.delete(article);
    }
} 

서비스 계층

• getList : 모든 게시글을 조회 (다건 조회)
• getAritlce(Long id) : 특정 게시글을 ID로 조회 (단건 조회)
• write : 새로운 게시글을 작성하고 저장 (게시글 생성)
• update : 기존 게시글을 수정 (게시글 수정)
• delete : 특정 게시글을 삭제 (게시글 삭제)

Response 추가

• create,modify 에 관한 응답을 추가!

// domain.article.response > ArticleCreateResponse 생성
// domain.article.response > ArticlesModifyResponse 수정
@Getter
@AllArgsConstructor
public class Article______Response {
    private final Article article;
}

why delete response 는 만들지 않고 articleResponse 를 재사용할까?

• 재사용한 이유는 삭제된 게시글에 대한 최소한의 정보를 포함한 응답을 제공며, 삭제된 게시글에 대한 세부 정보를 ArticleResponse로 담아서 클라이언트가 어떤 게시글이 삭제되었는지 알 수 있도록 하는 것이 일관성 있는 응답 방식이기 때문이다.
  다른 CRUD 작업(조회, 수정 등)과 응답 형식을 통일하는 것이 API의 유지보수와 사용자 경험에 유리하다!

6. 컨트롤러에 구현하기

• service 를 만들었으니 이젠 마무리해보자

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/demo241106/articles")
public class ArticleController {
    private final ArticleService articleService;

    @GetMapping("") // 다건조회
    public RsData<ArticlesResponse> list() {
        List<ArticleDTO> articleDTOS = this.articleService.getList();

        return RsData.of("200","게시글 다건 조회 성공", new ArticlesResponse(articleDTOS));
    }


    @GetMapping("/{id}") //단건조회
    public RsData<ArticleResponse> getArticle(@PathVariable("id") Long id){
        Article article = this.articleService.getArticle(id);

        if(article ==null)
            return RsData.of("500","%d 번게시물은 존재하지 않습니다.".formatted(id),null);

        ArticleDTO articleDTO = new ArticleDTO(article);
        return RsData.of("200","게시글 단건 조회 성공", new ArticleResponse(articleDTO));
    }

    @PostMapping("") // 생성
    public RsData<ArticleCreateResponse> create(@Valid @RequestBody ArticleCreateRequest articleCreateRequest){
        Article article = this.articleService.write(articleCreateRequest.getSubject(),articleCreateRequest.getContent(),articleCreateRequest.getAuthor());

        return RsData.of("200","게시글 등록 성공", new ArticleCreateResponse(article));
    }

    @PatchMapping("/{id}") // 수정
    public RsData<ArticleModifyResponse> modify(@PathVariable("id") Long id, @Valid @RequestBody ArticleModifyRequest articleModifyRequest){
        Article article = this.articleService.getArticle(id);

        if(article ==null)
            return RsData.of("500","%d 번게시물은 존재하지 않습니다.".formatted(id),null);

        article = this.articleService.update(article,articleModifyRequest.getSubject(),articleModifyRequest.getContent(),articleModifyRequest.getAuthor());


        return RsData.of("200","게시글 수정 성공",new ArticleModifyResponse(article));
    }

    @DeleteMapping("/{id}")  // 샂게
    public RsData<ArticleResponse> delete(@PathVariable("id") Long id){
        Article article = this.articleService.getArticle(id);

        if(article ==null)
            return RsData.of("500","%d 번게시물은 존재하지 않습니다.".formatted(id),null);

        this.articleService.delete(article);
        ArticleDTO articleDTO = new ArticleDTO(article);

        return RsData.of("200","%d 번 게시물 삭제 성공".formatted(id), new ArticleResponse(articleDTO));
    }
}

모든 Service 들을 적용 시켰다. 이제 PostMan 에서 확인해보자

• 게시글 생성
  

• 단건 조회
  

• 다건 조회
  

• 게시글 수정
  

• 게시글 삭제
  

• 조회, 수정, 삭제 오류 메세지 출력
  

마무리하며

• Spring Boot를 활용하여 게시글 CRUD API를 구현 TEST를 진행했다. API를 설계하고 구현하는 과정에서 중요한 부분들을 짚어보자.

1. RESTful API 설계
   이번 프로젝트에서는 게시글을 다루는 API를 설계하면서, HTTP 메서드(GET, POST, PATCH, DELETE)를 적절히 사용하여 RESTful한 API를 구현했다.

2. DTO(Data Transfer Object)와 Response 처리
   DTO를 사용하여 데이터의 구조를 명확히 분리하고 이를 통해 API의 데이터 처리 방식이 깔끔하고 유지보수하기 쉬운 구조로 관리한다.
   또한 RsData 클래스를 도입하여 API의 결과를 표준화 이를 통해 각 API 응답의 상태 코드와 메시지를 일관되게 처리하고, 클라이언트가 API 응답을 쉽게 해석할 수 있다.

3. 코드의 유지보수와 확장성
   REST API를 설계하면서 각 기능별로 서비스와 컨트롤러를 명확히 분리하고, DTO와 응답 클래스를 활용하여 응답 형식을 일관성 있게 처리한다. 이런 방식은 향후 새로운 기능 추가나 수정 시 확장성과 유지보수성을 높이는 데 큰 도움된다.