[JHipster] CRUD 게시판 만들기 - 3 (Database & front-end 연결을 위한 파일)

Junseo Kim·2019년 10월 23일
0

필요한 목록

  • src -> main -> java -> com.mycompany.myapp -> domain -> [DB 테이블과 연결할 class 파일]
  • src -> main -> java -> com.mycompany.myapp -> repository -> [repository interface 파일]
  • src -> main -> java -> com.mycompany.myapp -> web.rest -> [resource 파일(http request를 받아오는 곳)]
  • src -> main -> resources -> config -> liquibase -> changelog -> [.xml파일(테이블 구조)]
  • src -> main -> resources -> config -> liquibase -> master.xml(만들어준 .xml 파일 include)
  • src -> main -> webapp -> app -> layouts -> navbar -> navbar.component.html(메뉴 추가)
  • src -> main -> webapp -> app -> shared -> model -> [.model.ts 파일]
  • module 파일(만들어 준 후, 상위 모듈에서 import)
  • route 파일
  • service 파일
  • component.ts 파일(CRUD 각각)
  • component.html 파일(CRUD 각각)

게시판 구조 만들기

component 파일 생성(Angular)

실제 게시판 구조를 만들어 보겠다.
board에서 필요한 component들은 아래와 같다.

  • board.module.ts
  • board.route.ts
  • board.service.ts
  • board-delete-dialog.component.html
  • board-delete-dialog.components.ts
  • board-detail.component.html
  • board-detail.component.ts
  • board-update.component.html
  • board-update.component.ts

위의 파일들은 기존의 user-management의 코드를 참고하여 만들어보겠다.

전에 만들어 준, src -> main -> webapp -> app -> board 에 위의 파일들을 만들어준다.

만들어 준 component들을 board.module에 declarations 해준다.

위의 component파일들의 실제 코드는 만들어준 데이터베이스와 front end를 연결시켜준 후, 구현해보겠다.

Database & front-end 연결

database와 front-end를 연결시켜주기 위해서는, class, repository interface, resource(controller) 파일이 필요하다.


(Service, DTO, Mapper)

  1. BoardClass 만들어 주기
    src -> main -> java -> com.mycompany.myapp -> domain 안에 Board Class 파일을 만들어준다. 코드는 기존의 User class를 참고한다.
package com.mycompany.myapp.domain;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

import javax.persistence.*;
import java.io.Serializable;
import java.time.LocalDate;

@Entity
@Table(name = "board")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class Board implements Serializable {

    private static final long serialVersionUID = 1L;

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

    @Column(name = "title")
    private String title;

    @Column(name = "contents")
    private String contents;

    @Column(name = "created_date")
    private LocalDate createdDate;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public Board title(String title) {
        this.title = title;
        return this;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContents() {
        return contents;
    }

    public Board contents(String contents) {
        this.contents = contents;
        return this;
    }

    public void setContents(String contents) {
        this.contents = contents;
    }

    public LocalDate getCreatedDate() {
        return createdDate;
    }

    public Board createdDate(LocalDate createdDate) {
        this.createdDate = createdDate;
        return this;
    }

    public void setCreatedDate(LocalDate createdDate) {
        this.createdDate = createdDate;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Board)) {
            return false;
        }
        return id != null && id.equals(((Board) o).id);
    }

    @Override
    public int hashCode() {
        return 31;
    }

    @Override
    public String toString() {
        return "Board{" +
            "id=" + getId() +
            ", title='" + getTitle() + "'" +
            ", contents='" + getContents() + "'" +
            ", createdDate='" + getCreatedDate() + "'" +
            "}";
    }
}
  1. BoardRepository Interface 만들어주기
    src -> main -> java -> com.mycompany.myapp -> repository 안에 BoardRepository 파일을 만들어준다. 코드는 기존의 UserRepository를 참고한다.
  • 기본 CRUD 게시판만 구현할 때는 기능 추가를 할 필요는 없을 것 같다.
//BoardRepository

package com.mycompany.myapp.repository;

import com.mycompany.myapp.domain.Board;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;


@SuppressWarnings("unused")
@Repository
public interface BoardRepository extends JpaRepository<Board, Long> {
}
  1. BoardResource 생성
    src -> main -> java -> com.mycompany.myapp -> web.rest 안에 BoardResource class 생성. 코드는 기존의 UserResource 참고.
  • 이 부분에서 CRUD 기능을 제어 해준다. board.service.ts에서 http 통신으로 이 부분과 연결된다.
//BoardResource

package com.mycompany.myapp.web.rest;


import com.mycompany.myapp.domain.Board;
import com.mycompany.myapp.repository.BoardRepository;
import com.mycompany.myapp.web.rest.errors.BadRequestAlertException;
import io.github.jhipster.web.util.HeaderUtil;
import io.github.jhipster.web.util.ResponseUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api")
public class BoardResource {

    private final Logger log = LoggerFactory.getLogger(BoardResource.class);

    private static final String ENTITY_NAME = "board";

    @Value("${jhipster.clientApp.name}")
    private String applicationName;

    private final BoardRepository boardRepository;

    public BoardResource(BoardRepository boardRepository){
        this.boardRepository = boardRepository;
    }

    /* create a board */
    @PostMapping("/boards")
    public ResponseEntity<Board> createBoard(@RequestBody Board board) throws URISyntaxException {
        if(board.getId()!=null){
            throw new BadRequestAlertException("A new Board cannot already have an ID", ENTITY_NAME, "idexists");
        }
        Board result = boardRepository.save(board);
        return ResponseEntity.created(new URI("/api/boards/" + result.getId()))
            .headers(HeaderUtil.createEntityCreationAlert(applicationName, false, ENTITY_NAME, result.getId().toString()))
            .body(result);
    }

    /* read all boards */
    @GetMapping("/boards")
    public List<Board> getAllBoards(){
        return boardRepository.findAll();
    }

    /* read 'id' board */
    @GetMapping("/boards/{id}")
    public ResponseEntity<Board> getBoard(@PathVariable Long id){
        Optional<Board> board = boardRepository.findById(id);
        return ResponseUtil.wrapOrNotFound(board);
    }

    /* update a board */
    @PutMapping("/boards")
    public ResponseEntity<Board> updateBook(@RequestBody Board board) throws URISyntaxException {
        if(board.getId() == null){
            throw new BadRequestAlertException("Invalid id", ENTITY_NAME, "idnull");
        }
        Board result = boardRepository.save(board);
        return ResponseEntity.ok()
            .headers(HeaderUtil.createEntityUpdateAlert(applicationName, false, ENTITY_NAME, board.getId().toString()))
            .body(result);
    }

    /* delete a board */
    @DeleteMapping("/boards/{id}")
    public ResponseEntity<Void> deleteBoard(@PathVariable Long id){
        boardRepository.deleteById(id);
        return ResponseEntity.noContent().headers(HeaderUtil.createEntityDeletionAlert(applicationName, false, ENTITY_NAME, id.toString())).build();
    }
}

0개의 댓글