Node.js 정지점 전송 실현

방안 분석
슬라이스
  • 바로 동 영상 을 올 리 는 것 을 구분 하 는 것 이다.구체 적 인 체 조 는 다음 과 같다.
  • File.slice(start,end):새로운 blob 대상 으로 돌아 가기
  • blob 의 시작 바이트 복사
  • blob 의 끝 바이트 복사
  • 정지점 전송
  • 절편 이 업로드 되 기 전에 서버 인 터 페 이 스 를 요청 하여 같은 파일 의 업로드 절편 수
  • 를 읽 습 니 다.
  • 새 파일 을 업로드 하고 서버 는 0 을 되 돌려 줍 니 다.그렇지 않 으 면 업로드 한 절편 수 를 되 돌려 줍 니 다.
  • 구체 적 해결 절차
    이 demo 는 관건 적 인 사고방식 과 방법 을 제공 합 니 다.예 를 들 어 파일 제한,lastModified Date 검사 파일 중복 성,캐 시 파일 정기 제거 등 기능 확장 은 이 코드 를 바탕 으로 추가 할 수 있 습 니 다.
    html
    
    <input class="video" type="file" />
    <button type="submit" onclick="handleVideo(event, '.video', 'video')">
          
    </button>
    
    script
    
    let count = 0; //            
    const handleVideo = async (event, name, url) => {
    //            
    event.preventDefault();
    let currentSize = document.querySelector("h2");
    let files = document.querySelector(name).files;
    //       
    const sectionLength = 100;
    //       ,            
    // count 0       ,count  0         ,         
    count = await handleCancel(files[0]);
    
    //            
    let fileCurrent = [];
    //   file    
    for (const file of [...files]) {
      //          
      let itemSize = Math.ceil(file.size / sectionLength);
      //     size,  blob    
      let current = 0;
      for (current; current < file.size; current += itemSize) {
        fileCurrent.push({ file: file.slice(current, current + itemSize) });
      }
      // axios        
      const CancelToken = axios.CancelToken;
      const source = CancelToken.source();
      //       ,      ,               
      fileCurrent =
        count === 0 ? fileCurrent : fileCurrent.slice(count, sectionLength);
      //         
      for (const [index, item] of fileCurrent.entries()) {
        //        ||     
        if (index > 90) {
          source.cancel("    ");
        }
        //         
        // file   blob  
        // filename    
        // index      
        // total     
        let formData = new FormData();
        formData.append("file", item.file);
        formData.append("filename", file.name);
        formData.append("total", sectionLength);
        formData.append("index", index + count + 1);
    
        await axios({
          url: `http://localhost:8080/${url}`,
          method: "POST",
          data: formData,
          cancelToken: source.token,
        })
          .then((response) => {
            //         
            currentSize.innerHTML = `  ${response.data.size}%`;
          })
          .catch((err) => {
            console.log(err);
          });
      }
    }
    };
    
    //     ,          
    // count 0     ,count  0         
    const handleCancel = (file) => {
    return axios({
      method: "post",
      url: "http://localhost:8080/getSize",
      headers: { "Content-Type": "application/json; charset = utf-8" },
      data: {
        fileName: file.name,
      },
    })
      .then((res) => {
        return res.data.count;
      })
      .catch((err) => {
        console.log(err);
      });
    };
    
    노드 서버
    
    //   express     api
    const express = require("express");
    //           
    const upload = require("./upload_file");
    //       ,    
    app.all("*", (req, res, next) => {
      res.header("Access-Control-Allow-Origin", "*");
      res.header("Access-Control-Allow-Headers", "X-Requested-With");
      res.header("Access-Control-Allow-Methods", "PUT,POST,GET,DELETE,OPTIONS");
      res.header("Access-Control-Allow-Headers", "Content-Type, X-Requested-With ");
      res.header("X-Powered-By", " 3.2.1");
      res.header("Content-Type", "application/json;charset=utf-8");
      next();
    });
    const app = express();
    
    app.use(bodyParser.json({ type: "application/*+json" }));
    //     (       )
    app.post("/getSize", upload.getSize);
    //       
    app.post("/video", upload.video);
    
    //         
    app.listen(8080);
    
    upload_file
    
    //       
    const formidable = require("formidable");
    //       
    const fs = require("fs");
    //       
    const path = require("path");
    
    //        
    const handleStream = (item, writeStream) => {
      //         buffer
      const readFile = fs.readFileSync(item);
      //     buffer || chunk   stream 
      writeStream.write(readFile);
      //     ,         
      fs.unlink(item, () => {});
    };
    
    //     (  )
    module.exports.video = (req, res) => {
      //       
      const form = new formidable.IncomingForm();
      //           
      let dirPath = path.join(__dirname, "video");
      form.uploadDir = dirPath;
      //            
      form.keepExtensions = true;
      // err                  
      // fields           formData key-value  
      // file             
      form.parse(req, async (err, fields, file) => {
        //       blob  
        let files = file.file;
        //       index
        let index = fields.index;
        //       
        let total = fields.total;
        //      
        let filename = fields.filename;
        //        ,      
        let url =
          dirPath +
          "/" +
          filename.split(".")[0] +
          `_${index}.` +
          filename.split(".")[1];
        try {
          //          
          fs.renameSync(files.path, url);
          console.log(url);
          //     
          setTimeout(() => {
            //                ,        
            if (index === total) {
              //        ,        
              let newDir = __dirname + `/uploadFiles/${Date.now()}`;
              //     
              fs.mkdirSync(newDir);
              //      ,      
              let writeStream = fs.createWriteStream(newDir + `/${filename}`);
              let fsList = [];
              //         ,    
              for (let i = 0; i < total; i++) {
                const fsUrl =
                  dirPath +
                  "/" +
                  filename.split(".")[0] +
                  `_${i + 1}.` +
                  filename.split(".")[1];
                fsList.push(fsUrl);
              }
              //         ,  stream    
              for (let item of fsList) {
                handleStream(item, writeStream);
              }
              //     ,  stream   
              writeStream.end();
            }
          }, 100);
        } catch (e) {
          console.log(e);
        }
        res.send({
          code: 0,
          msg: "    ",
          size: index,
        });
      });
    };
    
    //        
    module.exports.getSize = (req, res) => {
      let count = 0;
      req.setEncoding("utf8");
      req.on("data", function (data) {
        let name = JSON.parse(data);
        let dirPath = path.join(__dirname, "video");
        //             
        let files = fs.readdirSync(dirPath);
        files.forEach((item, index) => {
          let url =
            name.fileName.split(".")[0] +
            `_${index + 1}.` +
            name.fileName.split(".")[1];
          if (files.includes(url)) {
            ++count;
          }
        });
        res.send({
          code: 0,
          msg: "     ",
          count,
        });
      });
    };
    
    논리 분석
    전단
  • 먼저 파일 이 처음 업로드 되 었 거나 해당 하 는 슬라이드 가 존재 하 는 지 조회 파일 을 업로드 해 달라 고 요청 합 니 다.
  • 파일 이 처음 올 라 오 면 슬라이스 는 0 부터
  • 파일 에 해당 하 는 절편 이 존재 하면 절편 수 부터 업로드 요청
  • 순환 절편 배열 로 각 절편 파일 을 업로드 합 니 다.
  • 그 중에서 아 날로 그 수 동 정지 요청 을 사 용 했 는데 절편 수가 90 보다 많 으 면 취소 요청 을 사용 합 니 다.
  • 서버
  • 조회 파일 filename 을 받 고 임시 저 장 된 파일 주 소 를 찾 아 업로드 파일 이 있 는 지 판단 합 니 다.
  • 이 파일 을 업로드 한 적 이 없 으 면 0 으로 돌아 가 고 절편 수 는 0 으로 시작 합 니 다
  • 파일 을 올 렸 으 면 해당 절편 수
  • 를 되 돌려 줍 니 다.
  • 업로드 파일 절편 을 받 고 임시 저장 디 렉 터 리 에 파일 을 저장 합 니 다.
  • count 와 total 을 통 해 절편 업로드 완료 여 부 를 판단 합 니 다
  • 업로드 완료,파일 저장 디 렉 터 리 를 만 들 고 쓰기 가능 한 스 트림 을 만 들 고 쓰기 작업
  • 해당 임시 파일 을 추출 하여 배열 에 넣 고 파일 디 렉 터 리 배열 을 순환 하 며 파일 버퍼 를 순서대로 읽 고 기록 합 니 다
  • 기록 이 완료 되 었 습 니 다.스 트림 을 닫 습 니 다.
  • 작은 매듭
    상기 코드 는 구체 적 인 업무 절차 와 관련 되 어 변경 되 거나 편차 가 있 을 수 있 는데 이것 은 그 중의 구체 적 인 실현 방식 일 뿐이다.
    이 글 이 여러분 에 게 도움 이 되 기 를 바 랍 니 다.잘못 쓴 부분 이 있 으 면 하나,둘 을 가르쳐 주시 기 바 랍 니 다.
    이상 코드 주소:github.com/Surprise-li…
    이상 은 Node.js 가 정지점 속전 을 실현 하 는 상세 한 내용 입 니 다.Node.js 정지점 속전 에 관 한 자 료 는 저희 의 다른 관련 글 을 주목 해 주 십시오!

    좋은 웹페이지 즐겨찾기