게시판 - 파일 업로드

스타 좀 눌러주세요

github.com

https://github.com/ALOHA-CLASS/React_TJE/tree/main/board-file

Spring Boot (Back-End)

Spring Boot 로 파일 업로드, 조회, 삭제 기능을 구현합니다.

구현 기능

•

 파일 업로드

◦

데이터베이스에 등록

◦

파일 시스템에 등록

•

︎ 파일 조회

◦

파일 목록 조회

◦

다운로드

◦

썸네일 이미지 보기

•

 파일 삭제

◦

게시글에 종속된 여러 파일 삭제

◦

선택 파일 삭제

◦

개별 파일 삭제

React (Front-End)

React 로 파일 업로드, 조회, 삭제 UI 및 API 를 구현합니다.

•

 파일 업로드

◦

파일 등록 UI 추가

◦

파일 업로드 요청 API 

•

︎ 파일 조회

◦

파일 목록 조회 UI 및 API 추가

◦

다운로드 UI 및 API 추가

◦

썸네일 이미지 UI 추가

•

 파일 삭제

◦

게시글에 종속된 여러 파일 삭제 (게시글 삭제 시, 백엔드에서 처리함)

◦

삭제할 파일 체크박스 UI 추가 및 수정 요청 시, 삭제할 파일 번호 리스트 데이터 추가

◦

개별 파일 삭제 UI 및 API 추가

Spring Boot (Back-End)

Spring Boot 로 파일 업로드, 조회, 삭제 기능을 구현합니다.

파일 업로드

데이터베이스에 등록

데이터 베이스 - 테이블 생성

SQL 쿼리 Mapper 작성

DTO

Mapper

Service 

Controller

데이터 베이스 - 테이블 생성

CREATE TABLE `file` (
  `no` int NOT NULL AUTO_INCREMENT,       -- 파일 번호 (자동증가)
  `parent_table` varchar(45) NOT NULL,         -- 부모 테이블명 (예: 'board')
  `parent_no` int NOT NULL,                     -- 부모 테이블에서의 번호
  `file_name` text NOT NULL,                   -- 저장된 파일명
  `origin_name` text,                          -- 원본 파일명
  `file_path` text NOT NULL,                   -- 파일 경로
  `file_size` int NOT NULL DEFAULT '0',        -- 파일 크기 (기본값 0)
  `reg_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 등록일시
  `upd_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 수정일시
  `file_code` int NOT NULL DEFAULT '0',        -- 파일 코드 (기본값 0)
  PRIMARY KEY (`no`)                      -- 주키 설정
) COMMENT='파일';
SQL
복사

SQL 쿼리 Mapper 작성

•

FileMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace="매퍼 인터페이스 경로" --> 
<mapper namespace="com.joeun.server.mapper.FileMapper">

    <!-- 파일 목록 -->
    <select id="list" resultType="Files">
        SELECT *
        FROM file
        ORDER BY reg_date DESC
    </select>

    <!-- 파일 목록 - 부모 테이블 기준 -->
    <!-- * 파일이 종속되는 테이블을 기준으로 파일 목록을 조회 -->
    <!-- * 게시글 번호 10 
           📄 파일 번호 1
           📄 파일 번호 2
           📄 파일 번호 3
     -->
    <select id="listByParent" resultType="Files">
        SELECT *
        FROM file
        WHERE parent_table = #{parentTable}
          AND parent_no = #{parentNo}
        ORDER BY reg_date DESC
    </select>

    <!-- 파일 조회 -->
    <select id="select" resultType="Files">
        SELECT *
        FROM file
        WHERE no = #{no}
    </select>

    <!-- 파일 등록 -->
    <insert id="insert">
        INSERT INTO file( parent_table, parent_no, file_name, origin_name, file_path, file_size, file_code )
        VALUES ( #{parentTable}, #{parentNo}, #{fileName}, #{originName}, #{filePath}, #{fileSize}, #{fileCode} )
    </insert>

    <!-- 파일 수정 -->
    <update id="update">
        UPDATE file
           SET parent_table = #{parentTable}
              ,parent_no = #{parentNo}
              ,file_name = #{fileName}
              ,origin_name = #{originName}
              ,file_path = #{filePath}
              ,file_size = #{fileSize}
              ,file_code = #{fileCode}
        WHERE no = #{no}
    </update>

    <!-- 파일 삭제 -->
    <delete id="delete">
        DELETE FROM file
        WHERE no = #{no}
    </delete>


    <!-- 파일 목록 삭제 - 부모 테이블 기준 파일 목록 삭제 -->
    <delete id="deleteByParent">
        DELETE FROM file
        WHERE parent_table = #{parentTable}
          AND parent_no = #{parentNo}
    </delete>

    <!-- 게시글 번호 최댓값 -->
    <select id="maxPk" resultType="int">
        SELECT MAX(no)
        FROM file
    </select>


</mapper>
SQL
복사

DTO

•

Files.java

package com.joeun.server.dto;

import java.util.Date;
import lombok.Data;

@Data
public class Files {
    private int no;
    private String parentTable;
    private int parentNo;
    private String fileName;
    private String originName;
    private String filePath;
    private long fileSize;
    private Date regDate;
    private Date updDate;
    private int fileCode;

}
Java
복사

Mapper

•

FileMapper.java

package com.joeun.server.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.joeun.server.dto.Files;

@Mapper
public interface FileMapper {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;
    // 파일 번호(기본키) 최댓값
    public int maxPk() throws Exception;
    

    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files file) throws Exception;
    
    
    
}
Java
복사

Service

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;


    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;

    // 파일 업로드
    public int upload(Files file) throws Exception;
    
}
Java
복사

•

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }


  
    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file );
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

  

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }

		public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();

        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        // DB 에 데이터 등록
        result = fileMapper.insert(uploadedFile);

        return result;

    }
   

    
}
Java
복사

•

BoardServiceImpl.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        // ✅(New) 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    // ✅(New) 파일 업로드 
    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }

}
Java
복사

Controller

•

FileController.java

package com.joeun.server.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {



    
}
Java
복사

파일 시스템에 등록

DTO

Service

DTO

•

Files.java

package com.joeun.server.dto;

import java.util.Date;

import org.springframework.web.multipart.MultipartFile;

import lombok.Data;

@Data
public class Files {
    private int no;
    private String parentTable;
    private int parentNo;
    private String fileName;
    private String originName;
    private String filePath;
    private long fileSize;
    private Date regDate;
    private Date updDate;
    private int fileCode;

    MultipartFile file;       // ✅ 추가
}
Java
복사

Service

•

FileServiceImpl.java

추가할 코드

// ✅(New) 파일업로드
// - 서버 측, 파일 시스템에 파일 복사
File uploadFile = new File(uploadPath, fileName);
FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    

    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  
    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // ✅(New) 파일업로드
        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    
}
Java
복사

︎ 파일 조회

파일 목록 조회

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

BoardController.java

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
   
   
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    

    // ✅(New) 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;
    
}
Java
복사

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }


    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // ✅ (New) - 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }
    
}
Java
복사

BoardController.java

추가할 코드

@GetMapping("/{no}")
public ResponseEntity<?> getOne(@PathVariable Integer no, Files files) {
    log.info("[GET] - /boards/" + no  + " - 게시글 조회");
    try {
        Board board = boardService.select(no);
        
        files.setParentTable("board");
        files.setParentNo(no);
        List<Files> fileList = fileService.listByParent(files); // 파일 정보
        
        Map<String, Object> response = new HashMap<>();
        response.put("board", board);
        response.put("fileList", fileList);

        if( board == null ) {
            board = new Board();
            board.setTitle("데이터 없음");
        }

        return new ResponseEntity<>(response, HttpStatus.OK); 

            
    } catch (Exception e) {
        log.error(null, e);
        return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
}
Java
복사

package com.joeun.server.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.service.BoardService;
import com.joeun.server.service.FileService;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@RestController
@RequestMapping("/boards")
public class BoardController {
    
    @Autowired
    private BoardService boardService;

    @Autowired
    private FileService fileService;

    // 👩‍💻 CRUD 메소드 자동 생성 : sp-crud
    // 👩‍💻 자동 import : alt + shift + O      
    // 👩‍💻 한 줄 삭제 : ctrl + shift + K
    @GetMapping()
    public ResponseEntity<?> getAll() {
        log.info("[GET] - /boards - 게시글 목록");
        try {
            List<Board> boardList = boardService.list();
            if( boardList == null )
                log.info("조회된 게시글 없음");
            else 
                log.info("게시글 수 : " + boardList.size());

            return new ResponseEntity<>(boardList, HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @GetMapping("/{no}")
    public ResponseEntity<?> getOne(@PathVariable Integer no, Files files) {
        log.info("[GET] - /boards/" + no  + " - 게시글 조회");
        try {
            Board board = boardService.select(no);
            
            files.setParentTable("board");
            files.setParentNo(no);
            List<Files> fileList = fileService.listByParent(files); // 파일 정보
            
            Map<String, Object> response = new HashMap<>();
            response.put("board", board);
            response.put("fileList", fileList);

            if( board == null ) {
                board = new Board();
                board.setTitle("데이터 없음");
            }

            return new ResponseEntity<>(response, HttpStatus.OK); 

                
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @PostMapping()
    // public ResponseEntity<?> create(@RequestBody Board board) {   // Content-Type : application/json
    public ResponseEntity<?> create(Board board) {                   // Content-Type : multipart/form-data
        log.info("[POST] - /boards - 게시글 등록");

        log.info("board : " + board.toString());
        List<MultipartFile> files = board.getFiles();

        if( files != null )
            for (MultipartFile file : files) {
                log.info("file : " +  file.getOriginalFilename());
        }

        try {
            int result = boardService.insert(board);
            if( result > 0 )
                return new ResponseEntity<>("게시글 등록 완료", HttpStatus.CREATED);  // 201
            else
                return new ResponseEntity<>("게시글 등록 실패", HttpStatus.OK);  

        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @PutMapping()
    // public ResponseEntity<?> update(@RequestBody Board board) {      // Content-Type : application/json
    public ResponseEntity<?> update(Board board) {                      // Content-Type : multipart/form-data
        log.info("[PUT] - /boards - 게시글 수정");
        try {
            int result = boardService.update(board);
            log.info("수정 : " + board);
            if( result > 0 )
                return new ResponseEntity<>("게시글 수정 완료", HttpStatus.OK); 
            else
                return new ResponseEntity<>("게시글 수정 실패", HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @DeleteMapping("/{no}")
    public ResponseEntity<?> destroy(@PathVariable Integer no) {
        log.info("[DELETE] - /boards/" + no + " - 게시글 삭제");
        try {
            int result = boardService.delete(no);
            if( result > 0 )
                return new ResponseEntity<>("게시글 삭제 완료", HttpStatus.OK); 
            else
                return new ResponseEntity<>("게시글 삭제 실패", HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}
Java
복사

다운로드

•

FileService.java

•

FileServiceImpl.java

•

FileController.java

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;


   
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    

    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // ✅(New) - 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;
}
Java
복사

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


    
}
Java
복사

FileController.java

package com.joeun.server.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {


  @Autowired
  private FileService fileService;

	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}


    
}
Java
복사

썸네일 이미지 보기

•

FileController.java

FileController.java

package com.joeun.server.controller;

import java.io.File;
import java.io.FileInputStream;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.joeun.server.dto.Files;
import com.joeun.server.service.FileService;
import com.joeun.server.utils.MediaUtil;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {

  @Autowired
  private FileService fileService;

	@Autowired
	private ResourceLoader resourceLoader;


	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}



	/**
	 * 이미지 썸네일 
	 * @param no
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/img/{no}")
	public void showImg(@PathVariable Integer no, HttpServletResponse response) throws Exception {

		Files file = fileService.select(no);
		String filePath = (file != null) ? file.getFilePath() : null;
		Resource resource = resourceLoader.getResource("classpath:static/img/no-image.png");

		File imgFile;

		if (filePath == null || !(imgFile = new File(filePath)).exists()) {
			// 파일이 존재하지 않거나 파일 경로가 null인 경우
			imgFile = resource.getFile();
		}

		String ext = filePath.substring(filePath.lastIndexOf(".") + 1);
		MediaType mType = MediaUtil.getMediaType(ext);

		if (mType == null) {
			// 이미지 타입이 아닐 경우
			response.setContentType(MediaType.IMAGE_PNG_VALUE); // 기본적으로 PNG로 설정
			imgFile = resource.getFile();
		} else {
			// 이미지 타입일 경우
			response.setContentType(mType.toString());
		}

		FileInputStream fis = new FileInputStream(imgFile);
		ServletOutputStream sos = response.getOutputStream();
		FileCopyUtils.copy(fis, sos);
	}



    
}
Java
복사

파일 삭제

게시글에 종속된 여러 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throwsdeleteByParent Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // ✅(New) 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;

    
}
Java
복사

•

FileServiceImpl.java

추가할 코드

@Override
public int deleteByParent(Files fileInfo) throws Exception {
    int result = 0;
    List<Files> fileList = fileMapper.listByParent(fileInfo);

    for (Files file : fileList) {
        File deleteFile = new File(file.getFilePath());
        if( !deleteFile.exists() ) continue;
        if( !deleteFile.delete() ) continue;
        int deleted = fileMapper.delete(file.getNo());
        if( deleted > 0 ) result++;
    }
    log.info(result + "개의 파일을 삭제하였습니다.");
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


		@Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }


    
}
Java
복사

•

BoardServiceImpl.java

추가할 코드

@Override
@Transactional
public int delete(int no) throws Exception {
    int result = boardMapper.delete(no);
    String parentTable = "board";
    int parentNo = no;

    if( result > 0 ) {
        Files fileInfo = new Files();
        fileInfo.setParentTable(parentTable);
        fileInfo.setParentNo(parentNo);
        int fileResult = fileService.deleteByParent(fileInfo);
        result = fileResult;
    }

    return result;
}
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }



    @Override
    @Transactional
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        String parentTable = "board";
        int parentNo = no;

				// ✅(New) - 게시글에 종속된 파일 삭제
        if( result > 0 ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            int fileResult = fileService.deleteByParent(fileInfo);
            result = fileResult;
        }

        return result;
    }

}
Java
복사

선택 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;
    // 파일 삭제 - noList 기준
    public int deleteByNoList(List<Integer> noList) throws Exception;
    
}
Java
복사

•

FileServiceImpl.java

추가할 코드

@Override
public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
    int result = 0;
    if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
    for (Integer deleteFileNo : deleteFileNoList) {
        if( deleteFileNo == null ) continue;
        fileMapper.delete(deleteFileNo);
        log.info(deleteFileNo + "번 파일 삭제");
        result++;
    }
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


		@Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

		@Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }
    
}
Java
복사

•

BoardServiceImpl.java

추가할 코드

@Override
public int update(Board board) throws Exception {
    int result = boardMapper.update(board);

    // 파일 업로드 
    result += uploadFiles(board);

    // 개별 파일 삭제
    List<Integer> deleteFileNoList = board.getDeleteFileNoList();
    result += fileService.deleteByNoList(deleteFileNoList);

    return result;
}
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        // ✅(New) 개별 파일 삭제
        List<Integer> deleteFileNoList = board.getDeleteFileNoList();
        result += fileService.deleteByNoList(deleteFileNoList);

        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }


    @Override
    @Transactional
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        String parentTable = "board";
        int parentNo = no;

        if( result > 0 ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            int fileResult = fileService.deleteByParent(fileInfo);
            result = fileResult;
        }

        return result;
    }

}
Java
복사

개별 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

FileController.java

FileService.java

// 파일 삭제
public int delete(int no) throws Exception;
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;
    // 파일 삭제 - noList 기준
    public int deleteByNoList(List<Integer> noList) throws Exception;
    
}
Java
복사

FileServiceImpl.java

@Override
public int delete(int no) throws Exception {
    Files file = fileMapper.select(no);

    if( file == null ) return 0;

    String filePath = file.getFilePath();
    File deleteFile = new File(filePath);

    if( !deleteFile.exists() ) return 0;

    boolean deleted = deleteFile.delete();

    int result = 0;
    if( deleted ) {
        result = fileMapper.delete(no);
    }
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }

    @Override
    public int delete(int no) throws Exception {
        Files file = fileMapper.select(no);

        if( file == null ) return 0;

        String filePath = file.getFilePath();
        File deleteFile = new File(filePath);

        if( !deleteFile.exists() ) return 0;

        boolean deleted = deleteFile.delete();

        int result = 0;
        if( deleted ) {
            result = fileMapper.delete(no);
        }
        return result;
    }

    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

    @Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        // byte[] buffer = new byte[1024];             // 1024bytes = 1KB 단위 버퍼
        // int data;
        // while( (data = fis.read(buffer)) != -1 ) {  // 1KB 씩 파일입력
        //     sos.write(buffer, 0, data);         // 1KB 씩 파일출력
        // }
        fis.close();
        sos.close();

        return 1;
    }

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    
}
Java
복사

FileController.java

package com.joeun.server.controller;

import java.io.File;
import java.io.FileInputStream;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.joeun.server.dto.Files;
import com.joeun.server.service.FileService;
import com.joeun.server.utils.MediaUtil;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {

  @Autowired
  private FileService fileService;

	@Autowired
	private ResourceLoader resourceLoader;



	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}

	/**
	 * 이미지 썸네일 
	 * @param no
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/img/{no}")
	public void showImg(@PathVariable Integer no, HttpServletResponse response) throws Exception {

		Files file = fileService.select(no);
		String filePath = (file != null) ? file.getFilePath() : null;
		Resource resource = resourceLoader.getResource("classpath:static/img/no-image.png");

		File imgFile;

		if (filePath == null || !(imgFile = new File(filePath)).exists()) {
			// 파일이 존재하지 않거나 파일 경로가 null인 경우
			imgFile = resource.getFile();
		}

		String ext = filePath.substring(filePath.lastIndexOf(".") + 1);
		MediaType mType = MediaUtil.getMediaType(ext);

		if (mType == null) {
			// 이미지 타입이 아닐 경우
			response.setContentType(MediaType.IMAGE_PNG_VALUE); // 기본적으로 PNG로 설정
			imgFile = resource.getFile();
		} else {
			// 이미지 타입일 경우
			response.setContentType(mType.toString());
		}

		FileInputStream fis = new FileInputStream(imgFile);
		ServletOutputStream sos = response.getOutputStream();
		FileCopyUtils.copy(fis, sos);
	}
	

	
	 /**
     *  파일 삭제
     * @param file
     * @return
     * @throws Exception
     */
    @DeleteMapping("/{no}")
    public ResponseEntity<String> deleteFile(@PathVariable Integer no) throws Exception {
        log.info("[DELETE] - /file");
        int fileNo = no;
        log.info("fileNo : " + fileNo);
        if( fileNo == 0 )
            return new ResponseEntity<String>("FAIL", HttpStatus.BAD_REQUEST);       

        int result = fileService.delete(fileNo);

        if( result == 0 )
            return new ResponseEntity<String>("FAIL", HttpStatus.OK);    
        
        return new ResponseEntity<String>("SUCCESS", HttpStatus.OK);
    }

    
}
Java
복사

React (Front-End)

React 로 파일 업로드, 조회, 삭제 UI 및 API 를 구현합니다.

파일 업로드

파일 등록 UI 추가

BoardInsertForm.jsx

import React, { useState } from 'react'
import { Link } from 'react-router-dom'
import './BoardInsertForm.css'


const BoardInsertForm = ({ onInsert }) => {

    // state 설정
    const [title, setTitle] = useState('');
    const [writer, setWriter] = useState('');
    const [content, setContent] = useState('');
    const [files, setFiles] = useState(null);     // ✅ files state 추가

    const handleChangeTitle = (e) => {
        setTitle(e.target.value)
    }

    const handleChangeWriter = (e) => {
        setWriter(e.target.value)
    }

    const handleChangeContent = (e) => {
        setContent(e.target.value)
    }

    // ✅ 파일 핸들러 추가
    const handleFileChange = (e) => {
        setFiles(e.target.files);
    };

    const onSubmit = () => {
        const formData = new FormData();
        formData.append('title', title);
        formData.append('writer', writer);
        formData.append('content', content);

        const headers = {
            headers: {
                'Content-Type' : 'multipart/form-data',
            },
        };
        
        if (files) {
            for (let i = 0; i < files.length; i++) {
                formData.append(`files[${i}]`, files[i]);
            }
        }

        // onInsert(title, writer, content)
        // onInsert({title,writer,content,files}, headers)      // formData 사용 ❌
        onInsert(formData, headers)                             // formData 사용 ⭕
        
    }

    return (
        <div className='container'>
            <h1 className='title'>게시글 등록</h1>
            <table className='table'>
                <tbody>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input  type="text" 
                                    className='form-input'
                                    value={title} 
                                    onChange={handleChangeTitle} />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input  type="text" 
                                    className='form-input'
                                    value={writer} 
                                    onChange={handleChangeWriter} />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10"
                                        className='form-input'
                                        value={content}
                                        onChange={handleChangeContent}
                            ></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td>파일</td>
                        <td>
                        <input type='file' onChange={handleFileChange} multiple />
                        </td>
                    </tr>

                </tbody>
            </table>

            <div className='btn-box'>
                <Link to="/boards" className='btn'>목록</Link>
                <button onClick={ onSubmit } className='btn'>등록</button>
            </div>

        </div>
    )
}

export default BoardInsertForm
JavaScript
복사

파일 업로드 요청 API

files.js

import axios from 'axios';

// 업로드
export const upload = (formData, headers) => axios.post(`/file/upload`, formData, headers)
JavaScript
복사

︎ 파일 조회

파일 목록 조회 UI 및 API 추가

BoardReadContainer.jsx

import React, { useEffect, useState } from 'react';
import { useParams } from 'react-router-dom';
import * as boards from '../apis/boards';
import BoardRead from '../components/BoardRead/BoardRead';

// 👩‍💻 게시글 조회
const BoardReadContainer = () => {
    const { no } = useParams()

    const [board, setBoard] = useState({});
    const [fileList, setFileList] = useState([]);
    const [isLoading, setLoading] = useState(false);

    const getBoard = async () => {
        setLoading(true)
        try {
            const response = await boards.select(no);
            const data = response.data;
            console.log(data);

            const board = data.board;
            const fileList = data.fileList;
            setBoard(board);
            setFileList(fileList);
        }
        catch(e) {
            console.log(e);
        }
        setLoading(false)
    }


    useEffect( () => {
        getBoard()
    },[])

    return (<BoardRead  no={no}
                        board={board}
                        fileList={fileList}
                        isLoading={isLoading}
           />)
}

export default BoardReadContainer
JavaScript
복사

BoardRead.jsx

import React, { useEffect } from 'react';
import { Link } from 'react-router-dom';
import * as format from '../../apis/format';
import './BoardRead.css';

const BoardRead = ({ no, board, fileList, isLoading }) => {


    return (
        <div className='container'>
            <h1 className='title'>게시글 조회</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={format.formatDate( board.regDate )} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={board.title} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={board.writer} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={board.content} 
                                        readOnly></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>파일</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            { fileList.map( (file) => (
                                <div className='file-box' key={file.no}>
                                    <div className="item">
                                        <img src={`/file/img/${file.no}`} alt={file.fileName} />
                                        <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                    </div>

                                    <div className="item">
                                        
                                    </div>

                                </div>
                            ))}
                        </td>
                    </tr>
                </tbody>
            </table>
            )}
            <hr />

            <div className="btn-box">
                <Link className='btn' to="/boards">목록</Link>
                <Link className='btn' to={`/boards/update/${no}`}>수정</Link>
            </div>
        </div>
    )
}

export default BoardRead
JavaScript
복사

다운로드 UI 및 API 추가

BoardRead.jsx

import React, { useEffect } from 'react';
import { Link } from 'react-router-dom';
import * as format from '../../apis/format';
import './BoardRead.css';

const BoardRead = ({ no, board, fileList, isLoading }) => {


    return (
        <div className='container'>
            <h1 className='title'>게시글 조회</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={format.formatDate( board.regDate )} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={board.title} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={board.writer} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={board.content} 
                                        readOnly></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>파일</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            { fileList.map( (file) => (
                                <div className='file-box' key={file.no}>
                                    <div className="item">
                                        <img src={`/file/img/${file.no}`} alt={file.fileName} />
                                        <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                    </div>

                                    <div className="item">
                                        <button className="btn" onClick={() => handleDownload(file.no, file.originName)}>다운로드</button>
                                    </div>

                                </div>
                            ))}
                        </td>
                    </tr>
                </tbody>
            </table>
            )}
            <hr />

            <div className="btn-box">
                <Link className='btn' to="/boards">목록</Link>
                <Link className='btn' to={`/boards/update/${no}`}>수정</Link>
            </div>
        </div>
    )
}

export default BoardRead
JavaScript
복사

files.js

JavaScript
복사

썸네일 이미지 UI 추가

파일 삭제

삭제할 파일 체크박스 UI 추가 및 수정 요청 시, 삭제할 파일 번호 리스트 데이터 추가

개별 파일 삭제 UI 및 API 추가

게시판 - 파일 업로드

Spring Boot (Back-End)

Spring Boot 로 파일 업로드, 조회, 삭제 기능을 구현합니다.

구현 기능

•

 파일 업로드

◦

데이터베이스에 등록

◦

파일 시스템에 등록

•

︎ 파일 조회

◦

파일 목록 조회

◦

다운로드

◦

썸네일 이미지 보기

•

 파일 삭제

◦

게시글에 종속된 여러 파일 삭제

◦

선택 파일 삭제

◦

개별 파일 삭제

React (Front-End)

React 로 파일 업로드, 조회, 삭제 UI 및 API 를 구현합니다.

•

 파일 업로드

◦

파일 등록 UI 추가

◦

파일 업로드 요청 API 

•

︎ 파일 조회

◦

파일 목록 조회 UI 및 API 추가

◦

다운로드 UI 및 API 추가

◦

썸네일 이미지 UI 추가

•

 파일 삭제

◦

게시글에 종속된 여러 파일 삭제 (게시글 삭제 시, 백엔드에서 처리함)

◦

삭제할 파일 체크박스 UI 추가 및 수정 요청 시, 삭제할 파일 번호 리스트 데이터 추가

◦

개별 파일 삭제 UI 및 API 추가

Spring Boot (Back-End)

Spring Boot 로 파일 업로드, 조회, 삭제 기능을 구현합니다.

파일 업로드

데이터베이스에 등록

데이터 베이스 - 테이블 생성

SQL 쿼리 Mapper 작성

DTO

Mapper

Service 

Controller

데이터 베이스 - 테이블 생성

CREATE TABLE `file` (
  `no` int NOT NULL AUTO_INCREMENT,       -- 파일 번호 (자동증가)
  `parent_table` varchar(45) NOT NULL,         -- 부모 테이블명 (예: 'board')
  `parent_no` int NOT NULL,                     -- 부모 테이블에서의 번호
  `file_name` text NOT NULL,                   -- 저장된 파일명
  `origin_name` text,                          -- 원본 파일명
  `file_path` text NOT NULL,                   -- 파일 경로
  `file_size` int NOT NULL DEFAULT '0',        -- 파일 크기 (기본값 0)
  `reg_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 등록일시
  `upd_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 수정일시
  `file_code` int NOT NULL DEFAULT '0',        -- 파일 코드 (기본값 0)
  PRIMARY KEY (`no`)                      -- 주키 설정
) COMMENT='파일';
SQL
복사

SQL 쿼리 Mapper 작성

•

FileMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- namespace="매퍼 인터페이스 경로" --> 
<mapper namespace="com.joeun.server.mapper.FileMapper">

    <!-- 파일 목록 -->
    <select id="list" resultType="Files">
        SELECT *
        FROM file
        ORDER BY reg_date DESC
    </select>

    <!-- 파일 목록 - 부모 테이블 기준 -->
    <!-- * 파일이 종속되는 테이블을 기준으로 파일 목록을 조회 -->
    <!-- * 게시글 번호 10 
           📄 파일 번호 1
           📄 파일 번호 2
           📄 파일 번호 3
     -->
    <select id="listByParent" resultType="Files">
        SELECT *
        FROM file
        WHERE parent_table = #{parentTable}
          AND parent_no = #{parentNo}
        ORDER BY reg_date DESC
    </select>

    <!-- 파일 조회 -->
    <select id="select" resultType="Files">
        SELECT *
        FROM file
        WHERE no = #{no}
    </select>

    <!-- 파일 등록 -->
    <insert id="insert">
        INSERT INTO file( parent_table, parent_no, file_name, origin_name, file_path, file_size, file_code )
        VALUES ( #{parentTable}, #{parentNo}, #{fileName}, #{originName}, #{filePath}, #{fileSize}, #{fileCode} )
    </insert>

    <!-- 파일 수정 -->
    <update id="update">
        UPDATE file
           SET parent_table = #{parentTable}
              ,parent_no = #{parentNo}
              ,file_name = #{fileName}
              ,origin_name = #{originName}
              ,file_path = #{filePath}
              ,file_size = #{fileSize}
              ,file_code = #{fileCode}
        WHERE no = #{no}
    </update>

    <!-- 파일 삭제 -->
    <delete id="delete">
        DELETE FROM file
        WHERE no = #{no}
    </delete>


    <!-- 파일 목록 삭제 - 부모 테이블 기준 파일 목록 삭제 -->
    <delete id="deleteByParent">
        DELETE FROM file
        WHERE parent_table = #{parentTable}
          AND parent_no = #{parentNo}
    </delete>

    <!-- 게시글 번호 최댓값 -->
    <select id="maxPk" resultType="int">
        SELECT MAX(no)
        FROM file
    </select>


</mapper>
SQL
복사

DTO

•

Files.java

package com.joeun.server.dto;

import java.util.Date;
import lombok.Data;

@Data
public class Files {
    private int no;
    private String parentTable;
    private int parentNo;
    private String fileName;
    private String originName;
    private String filePath;
    private long fileSize;
    private Date regDate;
    private Date updDate;
    private int fileCode;

}
Java
복사

Mapper

•

FileMapper.java

package com.joeun.server.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.joeun.server.dto.Files;

@Mapper
public interface FileMapper {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;
    // 파일 번호(기본키) 최댓값
    public int maxPk() throws Exception;
    

    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files file) throws Exception;
    
    
    
}
Java
복사

Service

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;


    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;

    // 파일 업로드
    public int upload(Files file) throws Exception;
    
}
Java
복사

•

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }


  
    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file );
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

  

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }

		public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();

        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        // DB 에 데이터 등록
        result = fileMapper.insert(uploadedFile);

        return result;

    }
   

    
}
Java
복사

•

BoardServiceImpl.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        // ✅(New) 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    // ✅(New) 파일 업로드 
    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }

}
Java
복사

Controller

•

FileController.java

package com.joeun.server.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {



    
}
Java
복사

파일 시스템에 등록

DTO

Service

DTO

•

Files.java

package com.joeun.server.dto;

import java.util.Date;

import org.springframework.web.multipart.MultipartFile;

import lombok.Data;

@Data
public class Files {
    private int no;
    private String parentTable;
    private int parentNo;
    private String fileName;
    private String originName;
    private String filePath;
    private long fileSize;
    private Date regDate;
    private Date updDate;
    private int fileCode;

    MultipartFile file;       // ✅ 추가
}
Java
복사

Service

•

FileServiceImpl.java

추가할 코드

// ✅(New) 파일업로드
// - 서버 측, 파일 시스템에 파일 복사
File uploadFile = new File(uploadPath, fileName);
FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    

    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  
    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // ✅(New) 파일업로드
        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    
}
Java
복사

︎ 파일 조회

파일 목록 조회

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

BoardController.java

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
   
   
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    

    // ✅(New) 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;
    
}
Java
복사

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }


    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // ✅ (New) - 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }
    
}
Java
복사

BoardController.java

추가할 코드

@GetMapping("/{no}")
public ResponseEntity<?> getOne(@PathVariable Integer no, Files files) {
    log.info("[GET] - /boards/" + no  + " - 게시글 조회");
    try {
        Board board = boardService.select(no);
        
        files.setParentTable("board");
        files.setParentNo(no);
        List<Files> fileList = fileService.listByParent(files); // 파일 정보
        
        Map<String, Object> response = new HashMap<>();
        response.put("board", board);
        response.put("fileList", fileList);

        if( board == null ) {
            board = new Board();
            board.setTitle("데이터 없음");
        }

        return new ResponseEntity<>(response, HttpStatus.OK); 

            
    } catch (Exception e) {
        log.error(null, e);
        return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
}
Java
복사

package com.joeun.server.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.service.BoardService;
import com.joeun.server.service.FileService;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@RestController
@RequestMapping("/boards")
public class BoardController {
    
    @Autowired
    private BoardService boardService;

    @Autowired
    private FileService fileService;

    // 👩‍💻 CRUD 메소드 자동 생성 : sp-crud
    // 👩‍💻 자동 import : alt + shift + O      
    // 👩‍💻 한 줄 삭제 : ctrl + shift + K
    @GetMapping()
    public ResponseEntity<?> getAll() {
        log.info("[GET] - /boards - 게시글 목록");
        try {
            List<Board> boardList = boardService.list();
            if( boardList == null )
                log.info("조회된 게시글 없음");
            else 
                log.info("게시글 수 : " + boardList.size());

            return new ResponseEntity<>(boardList, HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @GetMapping("/{no}")
    public ResponseEntity<?> getOne(@PathVariable Integer no, Files files) {
        log.info("[GET] - /boards/" + no  + " - 게시글 조회");
        try {
            Board board = boardService.select(no);
            
            files.setParentTable("board");
            files.setParentNo(no);
            List<Files> fileList = fileService.listByParent(files); // 파일 정보
            
            Map<String, Object> response = new HashMap<>();
            response.put("board", board);
            response.put("fileList", fileList);

            if( board == null ) {
                board = new Board();
                board.setTitle("데이터 없음");
            }

            return new ResponseEntity<>(response, HttpStatus.OK); 

                
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @PostMapping()
    // public ResponseEntity<?> create(@RequestBody Board board) {   // Content-Type : application/json
    public ResponseEntity<?> create(Board board) {                   // Content-Type : multipart/form-data
        log.info("[POST] - /boards - 게시글 등록");

        log.info("board : " + board.toString());
        List<MultipartFile> files = board.getFiles();

        if( files != null )
            for (MultipartFile file : files) {
                log.info("file : " +  file.getOriginalFilename());
        }

        try {
            int result = boardService.insert(board);
            if( result > 0 )
                return new ResponseEntity<>("게시글 등록 완료", HttpStatus.CREATED);  // 201
            else
                return new ResponseEntity<>("게시글 등록 실패", HttpStatus.OK);  

        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @PutMapping()
    // public ResponseEntity<?> update(@RequestBody Board board) {      // Content-Type : application/json
    public ResponseEntity<?> update(Board board) {                      // Content-Type : multipart/form-data
        log.info("[PUT] - /boards - 게시글 수정");
        try {
            int result = boardService.update(board);
            log.info("수정 : " + board);
            if( result > 0 )
                return new ResponseEntity<>("게시글 수정 완료", HttpStatus.OK); 
            else
                return new ResponseEntity<>("게시글 수정 실패", HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    
    @DeleteMapping("/{no}")
    public ResponseEntity<?> destroy(@PathVariable Integer no) {
        log.info("[DELETE] - /boards/" + no + " - 게시글 삭제");
        try {
            int result = boardService.delete(no);
            if( result > 0 )
                return new ResponseEntity<>("게시글 삭제 완료", HttpStatus.OK); 
            else
                return new ResponseEntity<>("게시글 삭제 실패", HttpStatus.OK);
        } catch (Exception e) {
            log.error(null, e);
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}
Java
복사

다운로드

•

FileService.java

•

FileServiceImpl.java

•

FileController.java

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;


   
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    

    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // ✅(New) - 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;
}
Java
복사

FileServiceImpl.java

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


    
}
Java
복사

FileController.java

package com.joeun.server.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {


  @Autowired
  private FileService fileService;

	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}


    
}
Java
복사

썸네일 이미지 보기

•

FileController.java

FileController.java

package com.joeun.server.controller;

import java.io.File;
import java.io.FileInputStream;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.joeun.server.dto.Files;
import com.joeun.server.service.FileService;
import com.joeun.server.utils.MediaUtil;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {

  @Autowired
  private FileService fileService;

	@Autowired
	private ResourceLoader resourceLoader;


	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}



	/**
	 * 이미지 썸네일 
	 * @param no
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/img/{no}")
	public void showImg(@PathVariable Integer no, HttpServletResponse response) throws Exception {

		Files file = fileService.select(no);
		String filePath = (file != null) ? file.getFilePath() : null;
		Resource resource = resourceLoader.getResource("classpath:static/img/no-image.png");

		File imgFile;

		if (filePath == null || !(imgFile = new File(filePath)).exists()) {
			// 파일이 존재하지 않거나 파일 경로가 null인 경우
			imgFile = resource.getFile();
		}

		String ext = filePath.substring(filePath.lastIndexOf(".") + 1);
		MediaType mType = MediaUtil.getMediaType(ext);

		if (mType == null) {
			// 이미지 타입이 아닐 경우
			response.setContentType(MediaType.IMAGE_PNG_VALUE); // 기본적으로 PNG로 설정
			imgFile = resource.getFile();
		} else {
			// 이미지 타입일 경우
			response.setContentType(mType.toString());
		}

		FileInputStream fis = new FileInputStream(imgFile);
		ServletOutputStream sos = response.getOutputStream();
		FileCopyUtils.copy(fis, sos);
	}



    
}
Java
복사

파일 삭제

게시글에 종속된 여러 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throwsdeleteByParent Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // ✅(New) 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;

    
}
Java
복사

•

FileServiceImpl.java

추가할 코드

@Override
public int deleteByParent(Files fileInfo) throws Exception {
    int result = 0;
    List<Files> fileList = fileMapper.listByParent(fileInfo);

    for (Files file : fileList) {
        File deleteFile = new File(file.getFilePath());
        if( !deleteFile.exists() ) continue;
        if( !deleteFile.delete() ) continue;
        int deleted = fileMapper.delete(file.getNo());
        if( deleted > 0 ) result++;
    }
    log.info(result + "개의 파일을 삭제하였습니다.");
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


		@Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }


    
}
Java
복사

•

BoardServiceImpl.java

추가할 코드

@Override
@Transactional
public int delete(int no) throws Exception {
    int result = boardMapper.delete(no);
    String parentTable = "board";
    int parentNo = no;

    if( result > 0 ) {
        Files fileInfo = new Files();
        fileInfo.setParentTable(parentTable);
        fileInfo.setParentNo(parentNo);
        int fileResult = fileService.deleteByParent(fileInfo);
        result = fileResult;
    }

    return result;
}
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }



    @Override
    @Transactional
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        String parentTable = "board";
        int parentNo = no;

				// ✅(New) - 게시글에 종속된 파일 삭제
        if( result > 0 ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            int fileResult = fileService.deleteByParent(fileInfo);
            result = fileResult;
        }

        return result;
    }

}
Java
복사

선택 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

BoardServiceImpl.java

•

FileService.java

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;
    // 파일 삭제 - noList 기준
    public int deleteByNoList(List<Integer> noList) throws Exception;
    
}
Java
복사

•

FileServiceImpl.java

추가할 코드

@Override
public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
    int result = 0;
    if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
    for (Integer deleteFileNo : deleteFileNoList) {
        if( deleteFileNo == null ) continue;
        fileMapper.delete(deleteFileNo);
        log.info(deleteFileNo + "번 파일 삭제");
        result++;
    }
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }



    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

  

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    // 파일 목록 조회
    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }


		@Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        fis.close();
        sos.close();

        return 1;
    }


		@Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

		@Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }
    
}
Java
복사

•

BoardServiceImpl.java

추가할 코드

@Override
public int update(Board board) throws Exception {
    int result = boardMapper.update(board);

    // 파일 업로드 
    result += uploadFiles(board);

    // 개별 파일 삭제
    List<Integer> deleteFileNoList = board.getDeleteFileNoList();
    result += fileService.deleteByNoList(deleteFileNoList);

    return result;
}
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Board;
import com.joeun.server.dto.Files;
import com.joeun.server.mapper.BoardMapper;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class BoardServiceImpl implements BoardService {

    @Autowired
    private BoardMapper boardMapper;

    @Autowired
    private FileService fileService;


    @Override
    public List<Board> list() throws Exception {
        List<Board> boardList = boardMapper.list();
        return boardList;
    }

    @Override
    public Board select(int no) throws Exception {
        Board board = boardMapper.select(no);
        return board;
    }

    @Override
    @Transactional
    public int insert(Board board) throws Exception {
        int result = boardMapper.insert(board);         // 새로 생성된 데이터의 pk 가져옴
        int parentNo = boardMapper.maxPk();
        board.setNo(parentNo);

        result += uploadFiles(board);

        return result;
    }

    @Override
    public int update(Board board) throws Exception {
        int result = boardMapper.update(board);

        // 파일 업로드 
        result += uploadFiles(board);

        // ✅(New) 개별 파일 삭제
        List<Integer> deleteFileNoList = board.getDeleteFileNoList();
        result += fileService.deleteByNoList(deleteFileNoList);

        return result;
    }

    @Override
    public int updateViews(int count, int no) throws Exception {
        int result = boardMapper.updateViews(count, no);
        return result;
    }


    public int uploadFiles(Board board) throws Exception {
        String parentTable = "board";
        int parentNo = board.getNo();
        int result = 0;
        
        List<MultipartFile> fileList = board.getFiles();
        if( fileList != null && !fileList.isEmpty() ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            result = fileService.uploadFiles(fileInfo, fileList);
        }
        return result;
    }


    @Override
    @Transactional
    public int delete(int no) throws Exception {
        int result = boardMapper.delete(no);
        String parentTable = "board";
        int parentNo = no;

        if( result > 0 ) {
            Files fileInfo = new Files();
            fileInfo.setParentTable(parentTable);
            fileInfo.setParentNo(parentNo);
            int fileResult = fileService.deleteByParent(fileInfo);
            result = fileResult;
        }

        return result;
    }

}
Java
복사

개별 파일 삭제

•

FileService.java

•

FileServiceImpl.java

•

FileController.java

FileService.java

// 파일 삭제
public int delete(int no) throws Exception;
Java
복사

package com.joeun.server.service;

import java.util.List;

import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;

import jakarta.servlet.http.HttpServletResponse;

public interface FileService {

    // 파일 목록
    public List<Files> list() throws Exception;
    // 파일 조회
    public Files select(int no) throws Exception;
    // 파일 등록
    public int insert(Files file) throws Exception;
    // 파일 수정
    public int update(Files file) throws Exception;
    // 파일 삭제
    public int delete(int no) throws Exception;

    
    // 파일 업로드
    public int uploadFiles(Files file, List<MultipartFile> fileList) throws Exception;
    // 파일 업로드
    public int upload(Files file) throws Exception;
    
    
    // 파일 목록 - 부모 기준
    public List<Files> listByParent(Files file) throws Exception;

    // 파일 다운로드
    public int download(int no, HttpServletResponse response) throws Exception;

    
    // 파일 삭제 - 부모 기준
    public int deleteByParent(Files fileInfo) throws Exception;
    // 파일 삭제 - noList 기준
    public int deleteByNoList(List<Integer> noList) throws Exception;
    
}
Java
복사

FileServiceImpl.java

@Override
public int delete(int no) throws Exception {
    Files file = fileMapper.select(no);

    if( file == null ) return 0;

    String filePath = file.getFilePath();
    File deleteFile = new File(filePath);

    if( !deleteFile.exists() ) return 0;

    boolean deleted = deleteFile.delete();

    int result = 0;
    if( deleted ) {
        result = fileMapper.delete(no);
    }
    return result;
}
Java
복사

package com.joeun.server.service;

import java.io.File;
import java.io.FileInputStream;
import java.util.List;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

import com.joeun.server.dto.Files;
import com.joeun.server.mapper.FileMapper;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Autowired
    private FileMapper fileMapper;

    @Value("${upload.path}")            // application.properties 에 설정한 업로드 경로 속성명
    private String uploadPath;          // 업로드 경로

    @Override
    public List<Files> list() throws Exception {
        List<Files> fileList = fileMapper.list();
        return fileList;
    }

    @Override
    public Files select(int no) throws Exception {
        Files file = fileMapper.select(no);
        return file;
    }

    @Override
    public int insert(Files file) throws Exception {
        int result = fileMapper.insert(file);
        return result;
    }

    @Override
    public int update(Files file) throws Exception {
        int result = fileMapper.update(file);
        return result;
    }

    @Override
    public int delete(int no) throws Exception {
        Files file = fileMapper.select(no);

        if( file == null ) return 0;

        String filePath = file.getFilePath();
        File deleteFile = new File(filePath);

        if( !deleteFile.exists() ) return 0;

        boolean deleted = deleteFile.delete();

        int result = 0;
        if( deleted ) {
            result = fileMapper.delete(no);
        }
        return result;
    }

    @Override
    public List<Files> listByParent(Files file) throws Exception {
        List<Files> fileList = fileMapper.listByParent(file);
        return fileList;
    }

    @Override
    public int deleteByParent(Files fileInfo) throws Exception {
        int result = 0;
        List<Files> fileList = fileMapper.listByParent(fileInfo);

        for (Files file : fileList) {
            File deleteFile = new File(file.getFilePath());
            if( !deleteFile.exists() ) continue;
            if( !deleteFile.delete() ) continue;
            int deleted = fileMapper.delete(file.getNo());
            if( deleted > 0 ) result++;
        }
        log.info(result + "개의 파일을 삭제하였습니다.");
        return result;
    }

    @Override
    public int download(int fileNo, HttpServletResponse response) throws Exception {
        // result 
        // 0 : 파일 다운로드 처리 실패
        // 1 : 파일 다운로드 성공
        Files file = fileMapper.select(fileNo);

        if( file == null ) {
            // BAD_REQUEST : 400, 클라이언트의 요청이 잘못되었음을 알려주는 상태코드
            // response.setStatus(response.SC_BAD_REQUEST);
            return 0;
        }

        String filePath = file.getFilePath();       // 파일 경로
        String fileName = file.getFileName();       // 파일 이름

        // 다운로드 응답을 위한 헤더 세팅
        // - ContentType            : application/octet-stream
        // - Content-Disposition    : attachment, filename="파일명.확장자"
        response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");

        // 파일 다운로드
        // - 파일 입력
        File downloadFile = new File(filePath);
        FileInputStream fis = new FileInputStream(downloadFile);

        // - 파일 출력
        ServletOutputStream sos = response.getOutputStream();

        // 다운로드
        FileCopyUtils.copy(fis, sos);

        // byte[] buffer = new byte[1024];             // 1024bytes = 1KB 단위 버퍼
        // int data;
        // while( (data = fis.read(buffer)) != -1 ) {  // 1KB 씩 파일입력
        //     sos.write(buffer, 0, data);         // 1KB 씩 파일출력
        // }
        fis.close();
        sos.close();

        return 1;
    }

    @Override
    public int uploadFiles(Files fileInfo, List<MultipartFile> fileList) throws Exception {
        int result = 0;
        for (MultipartFile file : fileList) {
            result += uploadFile( fileInfo, file);
        }
        log.info(result + "개 파일을 업로드하였습니다.");
        return result;
    }

    @Override
    public int deleteByNoList(List<Integer> deleteFileNoList) throws Exception {
        int result = 0;
        if( deleteFileNoList != null && !deleteFileNoList.isEmpty() )
        for (Integer deleteFileNo : deleteFileNoList) {
            if( deleteFileNo == null ) continue;
            fileMapper.delete(deleteFileNo);
            log.info(deleteFileNo + "번 파일 삭제");
            result++;
        }
        return result;
    }

    @Override
    @Transactional
    public int upload(Files file) throws Exception {
        int result = uploadFile(file, file.getFile());
        if( result > 0 )
            result = fileMapper.maxPk();        
        return result;
    }


    public int uploadFile(Files fileInfo, MultipartFile file) throws Exception {
        int result = 0;
        if( file.isEmpty() ) return result;
            
        // 파일 정보 : 원본파일명, 파일 용량, 파일 데이터 
        String originName = file.getOriginalFilename();
        long fileSize = file.getSize();
        byte[] fileData = file.getBytes();
        
        // 업로드 경로
        // 파일명 중복 방지 방법(정책)
        // - 날짜_파일명.확장자
        // - UID_파일명.확장자

        // UID_강아지.png
        String fileName = UUID.randomUUID().toString() + "_" + originName;

        // c:/upload/UID_강아지.png
        String filePath = uploadPath + "/" + fileName;

        // - 서버 측, 파일 시스템에 파일 복사
        File uploadFile = new File(uploadPath, fileName);
        FileCopyUtils.copy(fileData, uploadFile);       // 파일 업로드
        
        // - DB 에 파일 정보 등록
        Files uploadedFile = new Files();
        uploadedFile.setParentTable(fileInfo.getParentTable());
        uploadedFile.setParentNo(fileInfo.getParentNo());
        uploadedFile.setFileName(fileName);
        uploadedFile.setFilePath(filePath);
        uploadedFile.setOriginName(originName);
        uploadedFile.setFileSize(fileSize);
        uploadedFile.setFileCode(0);

        result = fileMapper.insert(uploadedFile);

        return result;

    }

    
}
Java
복사

FileController.java

package com.joeun.server.controller;

import java.io.File;
import java.io.FileInputStream;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import com.joeun.server.dto.Files;
import com.joeun.server.service.FileService;
import com.joeun.server.utils.MediaUtil;

import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Controller
@RequestMapping("/file")
public class FileController {

  @Autowired
  private FileService fileService;

	@Autowired
	private ResourceLoader resourceLoader;



	/**
	 * 파일 다운로드
	 * @param fileNo
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/{no}")
	public void fileDownload(@PathVariable("no") int no
							,HttpServletResponse response) throws Exception {
		
		// 파일 조회
		Files file = fileService.select(no);
		
		// 파일이 존재하지 않으면,
		if( file == null ) {
			// 응답 상태코드 : 400, 클라이언트의 요청이 잘못되었음을 나타내는 상태코드
			response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
			return;
		}
		
		String fileName = file.getFileName();	// 파일 명
		String filePath = file.getFilePath();	// 파일 경로
		
		// 파일 다운로드를 위한 헤더 세팅
		// - ContentType 			: application/octet-straem
		// - Content-Disposition 	: attachment; fileanme="파일명.확장자"
		response.setContentType("application/octet-stream");
		response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
		
		
		// 파일 입력
		File downloadFile = new File(filePath);
		FileInputStream fis = new FileInputStream(downloadFile);
		ServletOutputStream sos = response.getOutputStream();

		// 다운로드
		FileCopyUtils.copy(fis, sos);
		
	}

	/**
	 * 이미지 썸네일 
	 * @param no
	 * @param response
	 * @throws Exception
	 */
	@GetMapping("/img/{no}")
	public void showImg(@PathVariable Integer no, HttpServletResponse response) throws Exception {

		Files file = fileService.select(no);
		String filePath = (file != null) ? file.getFilePath() : null;
		Resource resource = resourceLoader.getResource("classpath:static/img/no-image.png");

		File imgFile;

		if (filePath == null || !(imgFile = new File(filePath)).exists()) {
			// 파일이 존재하지 않거나 파일 경로가 null인 경우
			imgFile = resource.getFile();
		}

		String ext = filePath.substring(filePath.lastIndexOf(".") + 1);
		MediaType mType = MediaUtil.getMediaType(ext);

		if (mType == null) {
			// 이미지 타입이 아닐 경우
			response.setContentType(MediaType.IMAGE_PNG_VALUE); // 기본적으로 PNG로 설정
			imgFile = resource.getFile();
		} else {
			// 이미지 타입일 경우
			response.setContentType(mType.toString());
		}

		FileInputStream fis = new FileInputStream(imgFile);
		ServletOutputStream sos = response.getOutputStream();
		FileCopyUtils.copy(fis, sos);
	}
	

	
	 /**
     *  파일 삭제
     * @param file
     * @return
     * @throws Exception
     */
    @DeleteMapping("/{no}")
    public ResponseEntity<String> deleteFile(@PathVariable Integer no) throws Exception {
        log.info("[DELETE] - /file");
        int fileNo = no;
        log.info("fileNo : " + fileNo);
        if( fileNo == 0 )
            return new ResponseEntity<String>("FAIL", HttpStatus.BAD_REQUEST);       

        int result = fileService.delete(fileNo);

        if( result == 0 )
            return new ResponseEntity<String>("FAIL", HttpStatus.OK);    
        
        return new ResponseEntity<String>("SUCCESS", HttpStatus.OK);
    }

    
}
Java
복사

React (Front-End)

React 로 파일 업로드, 조회, 삭제 UI 및 API 를 구현합니다.

파일 업로드

파일 등록 UI 추가

BoardInsertForm.jsx

import React, { useState } from 'react'
import { Link } from 'react-router-dom'
import './BoardInsertForm.css'


const BoardInsertForm = ({ onInsert }) => {

    // state 설정
    const [title, setTitle] = useState('');
    const [writer, setWriter] = useState('');
    const [content, setContent] = useState('');
    const [files, setFiles] = useState(null);     // ✅ files state 추가

    const handleChangeTitle = (e) => {
        setTitle(e.target.value)
    }

    const handleChangeWriter = (e) => {
        setWriter(e.target.value)
    }

    const handleChangeContent = (e) => {
        setContent(e.target.value)
    }

    // ✅ 파일 핸들러 추가
    const handleFileChange = (e) => {
        setFiles(e.target.files);
    };

    const onSubmit = () => {
        const formData = new FormData();
        formData.append('title', title);
        formData.append('writer', writer);
        formData.append('content', content);

        const headers = {
            headers: {
                'Content-Type' : 'multipart/form-data',
            },
        };
        
        if (files) {
            for (let i = 0; i < files.length; i++) {
                formData.append(`files[${i}]`, files[i]);
            }
        }

        // onInsert(title, writer, content)
        // onInsert({title,writer,content,files}, headers)      // formData 사용 ❌
        onInsert(formData, headers)                             // formData 사용 ⭕
        
    }

    return (
        <div className='container'>
            <h1 className='title'>게시글 등록</h1>
            <table className='table'>
                <tbody>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input  type="text" 
                                    className='form-input'
                                    value={title} 
                                    onChange={handleChangeTitle} />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input  type="text" 
                                    className='form-input'
                                    value={writer} 
                                    onChange={handleChangeWriter} />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10"
                                        className='form-input'
                                        value={content}
                                        onChange={handleChangeContent}
                            ></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td>파일</td>
                        <td>
                        <input type='file' onChange={handleFileChange} multiple />
                        </td>
                    </tr>

                </tbody>
            </table>

            <div className='btn-box'>
                <Link to="/boards" className='btn'>목록</Link>
                <button onClick={ onSubmit } className='btn'>등록</button>
            </div>

        </div>
    )
}

export default BoardInsertForm
JavaScript
복사

파일 업로드 요청 API

files.js

import axios from 'axios';

// 업로드
export const upload = (formData, headers) => axios.post(`/file/upload`, formData, headers)
JavaScript
복사

︎ 파일 조회

파일 목록 조회 UI 및 API 추가

BoardReadContainer.jsx

import React, { useEffect, useState } from 'react';
import { useParams } from 'react-router-dom';
import * as boards from '../apis/boards';
import BoardRead from '../components/BoardRead/BoardRead';

// 👩‍💻 게시글 조회
const BoardReadContainer = () => {
    const { no } = useParams()

    const [board, setBoard] = useState({});
    const [fileList, setFileList] = useState([]);
    const [isLoading, setLoading] = useState(false);

    const getBoard = async () => {
        setLoading(true)
        try {
            const response = await boards.select(no);
            const data = response.data;
            console.log(data);

            const board = data.board;
            const fileList = data.fileList;
            setBoard(board);
            setFileList(fileList);
        }
        catch(e) {
            console.log(e);
        }
        setLoading(false)
    }


    useEffect( () => {
        getBoard()
    },[])

    return (<BoardRead  no={no}
                        board={board}
                        fileList={fileList}
                        isLoading={isLoading}
           />)
}

export default BoardReadContainer
JavaScript
복사

BoardRead.jsx

import React, { useEffect } from 'react';
import { Link } from 'react-router-dom';
import * as format from '../../apis/format';
import './BoardRead.css';

const BoardRead = ({ no, board, fileList, isLoading }) => {


    return (
        <div className='container'>
            <h1 className='title'>게시글 조회</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={format.formatDate( board.regDate )} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={board.title} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={board.writer} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={board.content} 
                                        readOnly></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>파일</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            { fileList.map( (file) => (
                                <div className='file-box' key={file.no}>
                                    <div className="item">
                                        <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                    </div>

                                    <div className="item">
                                       
                                    </div>

                                </div>
                            ))}
                        </td>
                    </tr>
                </tbody>
            </table>
            )}
            <hr />

            <div className="btn-box">
                <Link className='btn' to="/boards">목록</Link>
                <Link className='btn' to={`/boards/update/${no}`}>수정</Link>
            </div>
        </div>
    )
}

export default BoardRead
JavaScript
복사

다운로드 UI 및 API 추가

BoardRead.jsx

<button className="btn" onClick={() => handleDownload(file.no, file.originName)}>다운로드</button>
JavaScript
복사

import React, { useEffect } from 'react';
import { Link } from 'react-router-dom';
import * as format from '../../apis/format';
import './BoardRead.css';

const BoardRead = ({ no, board, fileList, isLoading }) => {


    return (
        <div className='container'>
            <h1 className='title'>게시글 조회</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={format.formatDate( board.regDate )} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={board.title} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={board.writer} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={board.content} 
                                        readOnly></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>파일</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            { fileList.map( (file) => (
                                <div className='file-box' key={file.no}>
                                    <div className="item">
                                        <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                    </div>

                                    <div className="item">
                                        <button className="btn" onClick={() => handleDownload(file.no, file.originName)}>다운로드</button>
                                    </div>

                                </div>
                            ))}
                        </td>
                    </tr>
                </tbody>
            </table>
            )}
            <hr />

            <div className="btn-box">
                <Link className='btn' to="/boards">목록</Link>
                <Link className='btn' to={`/boards/update/${no}`}>수정</Link>
            </div>
        </div>
    )
}

export default BoardRead
JavaScript
복사

files.js

import axios from 'axios';

// 업로드
export const upload = (formData, headers) => axios.post(`/file/upload`, formData, headers)

// 다운로드
export const download = (fileNo) => axios.get(`/file/${fileNo}`, {responseType: 'blob',} )
JavaScript
복사

썸네일 이미지 UI 추가

BoardRead.jsx

<img src={`/file/img/${file.no}`} alt={file.fileName} />
JavaScript
복사

import React, { useEffect } from 'react';
import { Link } from 'react-router-dom';
import * as format from '../../apis/format';
import './BoardRead.css';

const BoardRead = ({ no, board, fileList, isLoading }) => {


    return (
        <div className='container'>
            <h1 className='title'>게시글 조회</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={format.formatDate( board.regDate )} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={board.title} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={board.writer} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={board.content} 
                                        readOnly></textarea>
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>파일</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                            { fileList.map( (file) => (
                                <div className='file-box' key={file.no}>
                                    <div className="item">
																				<img src={`/file/img/${file.no}`} alt={file.fileName} />
                                        <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                    </div>

                                    <div className="item">
                                        <button className="btn" onClick={() => handleDownload(file.no, file.originName)}>다운로드</button>
                                    </div>

                                </div>
                            ))}
                        </td>
                    </tr>
                </tbody>
            </table>
            )}
            <hr />

            <div className="btn-box">
                <Link className='btn' to="/boards">목록</Link>
                <Link className='btn' to={`/boards/update/${no}`}>수정</Link>
            </div>
        </div>
    )
}

export default BoardRead
JavaScript
복사

파일 삭제

삭제할 파일 체크박스 UI 추가, 파일 삭제 버튼 UI 및 API 추가

import React, { useEffect, useState } from 'react'
import { Link } from 'react-router-dom'
import * as format from '../../apis/format'

const BoardUpdateForm = ({ no, board, fileList, onUpdate, onDelete, isLoading, onDownload, onDeleteFile  }) => {

    // state 설정
    const [title, setTitle] = useState('')
    const [writer, setWriter] = useState('')
    const [content, setContent] = useState('')
    const [files, setFiles] = useState(null);           // ✅ files state 추가
    const [fileNoList, setFileList] = useState([])      // ✅ 파일 선택 삭제 - deleteFileNoList

    const handleChangeTitle = (e) => {
        setTitle(e.target.value)
    }

    const handleChangeWriter = (e) => {
        setWriter(e.target.value)
    }

    const handleChangeContent = (e) => {
        setContent(e.target.value)
    }

    const onSubmit = () => {
        const formData = new FormData();
        formData.append('no', no);
        formData.append('title', title);
        formData.append('writer', writer);
        formData.append('content', content);

        console.log(`fileNoList --------------------------------------`);
        console.log(fileNoList);
        formData.append('deleteFileNoList', fileNoList);

        const headers = {
            headers: {
                'Content-Type' : 'multipart/form-data',
            },
        };
        
        if (files) {
            for (let i = 0; i < files.length; i++) {
                formData.append(`files[${i}]`, files[i]);
            }
        }

        // onUpdate(no, title, writer, content);
        // onUpdate({no, title, writer, content}, headers);
        onUpdate(formData, headers);
    }

    const handleDelete = () => {
        const check = window.confirm('정말로 삭제하시겠습니까?')
        if( check ) 
            onDelete(no)
    }

    const handleDownload = (fileNo, fileName) => {
        onDownload(fileNo, fileName)
    }

    const handleDeleteFile =(fileNo) => {

        const check = window.confirm('정말로 삭제하시겠습니까?')
        if( check )
            onDeleteFile(fileNo)
    }

    // ✅ 파일 핸들러 추가
    const handleFileChange = (e) => {
        setFiles(e.target.files);
    };


    // 파일 번호 체크
    const checkFileNo = (no) => {
        setFileList( [...fileNoList, no] )
    }


    useEffect( () => {
        if( board ) {
            setTitle(board.title);
            setWriter(board.writer)
            setContent(board.content)
        }
    }, [board])


    return (
        <div className='container'>
            <h1 className='title'>게시글 수정</h1>
            <h3>번호 : {no}</h3>
            <hr/>

            { isLoading && 
                <div>
                    <img src="/img/loading.webp" alt="loading" />
                </div> 
            }
            { !isLoading && board && (
            <table border={1} className='table'>
                <tbody>
                    <tr>
                        <td>번호</td>
                        <td>
                            <input type="text" className='form-input' value={board.no} readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>등록일자</td>
                        <td>
                            <input type="text" className='form-input' value={ format.formatDate(board.regDate) } readOnly />
                        </td>
                    </tr>
                    <tr>
                        <td>제목</td>
                        <td>
                            <input type="text" className='form-input' value={title} onChange={handleChangeTitle} />
                        </td>
                    </tr>
                    <tr>
                        <td>작성자</td>
                        <td>
                            <input type="text" className='form-input' value={writer} onChange={handleChangeWriter} />
                        </td>
                    </tr>
                    <tr>
                        <td colSpan={2}>내용</td>
                    </tr>
                    <tr>
                        <td colSpan={2}>
                      
                            <textarea   cols="40" rows="10" 
                                        className='form-input'
                                        value={content} 
                                        onChange={handleChangeContent}></textarea>
                    </td>

                    </tr>
                    <tr>
                        <td>파일 업로드</td>
                        <td>
                        <input type='file' onChange={handleFileChange} multiple />
                        </td>
                    </tr>
                    { fileList && fileList.length > 0 &&
                        <tr>
                            <td>삭제</td>
                            <td>파일</td>
                        </tr>
                    }
                    { fileList.length == 0 && 
                        <tr>
                            <td colSpan={2} align='center'>
                                업로드된 파일이 없습니다.
                            </td>
                        </tr>
                    }
                    { fileList.map( (file) => (
                    <tr>
                        <td>
                            <input type="checkbox" onChange={ () => checkFileNo(file.no) } />
                        </td>
                        <td>
                            <div className='file-box' key={file.no}>
                                <div className="item">
                                    <img src={`/file/img/${file.no}`} alt={file.fileName} />
                                    <span>{file.originName}({ format.byteToUnit(file.fileSize) })</span>
                                </div>

                                <div className="item">
                                    <button className="btn" onClick={() => handleDownload(file.no, file.originName)}>다운로드</button>
                                    <button className="btn" onClick={() => handleDeleteFile(file.no)}>삭제</button>
                                </div>

                            </div>
                        </td>
                    </tr>
                    ))}
                </tbody>
            </table>
            )}
            <hr />
            <div className="btn-box">
                <div className="item">
                    <Link to="/boards" className='btn'>목록</Link>
                </div>
                <div className="item">
                    <button className='btn' onClick={ handleDelete }>삭제</button>
                    <button className='btn' tton onClick={ onSubmit }>수정</button>
                </div>
            </div>
        </div>
    )

}

export default BoardUpdateForm
JavaScript
복사

Github (소스코드)

github.com

https://github.com/ALOHA-CLASS/React_TJE/tree/main/board-file