岑健浩 / SNManage

  package com.ectrip.demo.service.impl;

  
  import cn.hutool.core.codec.Base64;

  import com.ectrip.demo.dto.DeleteSNsDTO;
  import com.ectrip.demo.service.SNService;
  import com.ectrip.demo.dto.AddSNsDTO;
  import com.ectrip.demo.exception.SNRepetitiveException;

  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Logger;

  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.stereotype.Service;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.*;

  import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  import java.nio.file.Paths;

  import java.text.SimpleDateFormat;
  import java.util.Date;

  import java.util.HashSet;
  import java.util.Set;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  @Service
  public class SNServiceImpl implements SNService {
      /**
       *  多线程改写文件存在并发问题，需加锁操作
       */
      private static final Lock lock = new ReentrantLock();
  

      static Logger logger = LogManager.getLogger(SNServiceImpl.class);
  

      @Value("${SN.file.path}")
      String SNFilePath;
  
      @Value("${SN.file.temp.path}")
      String SNTempFilePath;
  
      @Override

      public void addSN(AddSNsDTO addSNsDTO) throws SNRepetitiveException, IOException {
  

          //加try，catch只为释放锁
          try {
              //加锁
              lock.lock();

              logger.info("-----------------------------开始添加SNs-----------------------------");
              StringBuilder SNs = new StringBuilder();
              SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
              String currTime = sdf.format(new Date());

              //读取文件，判断SN是否重复
              Set<String> set = new HashSet<>();

              Reader reader = new InputStreamReader(Files.newInputStream(Paths.get(SNFilePath)),StandardCharsets.UTF_8);
              BufferedReader bufferedReader = new BufferedReader(reader);

              String br;
              while ((br=bufferedReader.readLine()) != null) {
                  //截取SN

                  int index = br.indexOf("##");

                  String SN = br.substring(0,index == -1? 0 : index);
                  set.add(SN);
              }

              for (String SN : addSNsDTO.getSns()) {
                  if (set.contains(SN)) {
                      throw new SNRepetitiveException("SN：" + SN + " 已存在，请勿重复添加");
                  }
                  SNs.append(SN).append("##").append(addSNsDTO.getProjectName()).append("##").append(currTime);
                  SNs.append(System.lineSeparator());

              }
  

              //写入

              FileOutputStream fileOutputStream = new FileOutputStream(SNFilePath,true);
              fileOutputStream.write(SNs.toString().getBytes(StandardCharsets.UTF_8));
              fileOutputStream.flush();
              fileOutputStream.close();
              logger.info("成功写入SNs：{}",SNs);

          } finally { //释放锁
              lock.unlock();
          }
      }
  
      @Override
      public String getEncryptSNs() throws IOException {

          //读取文件

          Reader reader = new InputStreamReader(Files.newInputStream(Paths.get(SNFilePath)),StandardCharsets.UTF_8);
          char[] chars = new char[1000];
          StringBuilder builder = new StringBuilder();
          int len = reader.read(chars);
          while (len != -1) {
              builder.append(chars,0,len);
              len = reader.read(chars);
          }

          //加密
          return Base64.encode(builder.toString());

      }
  
      @Override

      public void deleteSN(DeleteSNsDTO deleteSNsDTO) throws Exception{

          try {
              lock.lock();

              logger.info("-----------------------------开始删除SNs-----------------------------");
  
              HashSet<String> deleteSNsSet = new HashSet<>(deleteSNsDTO.getSns());

  
              //读取文件，记录不用删除的数据

              Reader reader = new InputStreamReader(Files.newInputStream(new File(SNFilePath).toPath()), StandardCharsets.UTF_8);
              BufferedReader bufferedReader = new BufferedReader(reader);

              String br;
              StringBuilder stringBuilder = new StringBuilder();

              StringBuilder existSNs = new StringBuilder();
              //所要删除的SN是否存在

              boolean SNExist = false;
              while ((br=bufferedReader.readLine()) != null) {
                  //截取SN

                  int index = br.indexOf("##");

                  String str = br.substring(0,index == -1? 0 : index);

                  if (!deleteSNsSet.contains(str)) {

                      stringBuilder.append(br);
                      stringBuilder.append(System.lineSeparator());
                  } else {

                      existSNs.append(br).append(System.lineSeparator());

                      SNExist = true;
                  }
              }
              bufferedReader.close();
  

              //如果存在要删除的SN，先将数据备份，再将留存数据覆盖掉原SN文件。

              if (SNExist) {
                  //备份数据

                  FileOutputStream tempFileOutputStream = new FileOutputStream(SNTempFilePath);
                  tempFileOutputStream.write(stringBuilder.toString().getBytes(StandardCharsets.UTF_8));
                  tempFileOutputStream.flush();
                  tempFileOutputStream.close();

                  //覆盖掉原来的数据到SN文件中

                  FileOutputStream fileOutputStream = new FileOutputStream(SNFilePath);
                  fileOutputStream.write(stringBuilder.toString().getBytes(StandardCharsets.UTF_8));
                  fileOutputStream.flush();
                  fileOutputStream.close();
                  logger.warn("成功删除SNs：{}",existSNs);

              }

              logger.info("-----------------------------结束删除SNs-----------------------------");

  
  
          } finally {
              lock.unlock();
          }
      }
  
      @Override
      public void downloadSNFile(HttpServletRequest request, HttpServletResponse response) throws IOException {
          File file = new File(SNFilePath);
  
          response.setCharacterEncoding("UTF-8");
          response.setHeader("Content-type","application/octet-stream;charset=UTF-8");
          response.setHeader("Content-Disposition", "attachment;filename=" + java.net.URLEncoder.encode(file.getName().trim(), "UTF-8"));
          response.addHeader("Pargam", "no-cache");
          response.addHeader("Cache-Control", "no-cache");
  
          //读取文件
          byte[] SNsByteArr = new byte[(int) file.length()];
          FileInputStream fileInputStream = new FileInputStream(file);
          fileInputStream.read(SNsByteArr);
          //加密
          String encodeSNs = Base64.encode(SNsByteArr);
  
          //写入到输出流
          response.addHeader("Content-Length",String.valueOf(encodeSNs.getBytes().length));
          OutputStream outputStream = response.getOutputStream();
          outputStream.write(encodeSNs.getBytes());
          outputStream.flush();
          outputStream.close();
  
      }
  
  }