目前对这个文件的操作，我觉得得有专门的一个自己很熟练的工具来使用，目前为止，我觉得应该集多家的文件处理Util所长为自己所用
    apache.common 里面的工具，还有就是spring中的工具，还有就是自己本身的一些工具
    所有的这些工具都给自己

    1. <dependency>
    2.   <groupId>org.quartz-scheduler</groupId>
    3.   <artifactId>quartz</artifactId>
    4.   <version>2.3.1</version>
    5. </dependency>

    1.创建文件
    2.文件内容添加
    3.文件迭代创建
    4.本机的文件加锁

    其中本机的文件锁其实必要性不是很大，因为通常情况下就直接采用分布式锁就可以了

    场景：
    1.单机多进程，竞争同一个资源

    1. import com.alibaba.fastjson.JSON;
    2. import com.alibaba.fastjson.JSONObject;
    3. import com.isyscore.isc.neo.NeoMap;
    4. import lombok.experimental.UtilityClass;
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.apache.commons.lang3.StringUtils;
    7. import org.apache.commons.lang3.time.DateUtils;
    8. import org.quartz.*;
    10. import java.io.*;
    11. import java.lang.management.ManagementFactory;
    12. import java.net.HttpURLConnection;
    13. import java.net.URL;
    14. import java.nio.charset.Charset;
    15. import java.nio.charset.StandardCharsets;
    16. import java.nio.file.Files;
    17. import java.util.ArrayList;
    18. import java.util.Date;
    19. import java.util.List;
    20. import java.util.Objects;
    21. import java.util.stream.Stream;
    23. /**
    24.  * @author shizi
    25.  * @since 2019/12/3 11:48 上午
    26.  */
    27. @Slf4j
    28. @UtilityClass
    29. public class FileUtil {
    31.     private Charset CRYPTO_CHARSET = StandardCharsets.UTF_8;
    32.     private static SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory();
    33.     private static Scheduler scheduler;
    35.     static {
    36.         try {
    37.             scheduler = schedulerFactory.getScheduler();
    38.             scheduler.start();
    39.         } catch (SchedulerException e) {
    40.             e.printStackTrace();
    41.         }
    42.     }
    44.     /**
    45.      * 获取文件
    46.      */
    47.     public File getFile(String fileName) throws IOException {
    48.         File file = new File(fileName);
    49.         if (!file.getParentFile().exists()) {
    50.             file.getParentFile().mkdirs();
    51.         }
    52.         if (!file.exists()) {
    53.             file.createNewFile();
    54.         }
    55.         file.setReadable(true);
    56.         file.setWritable(true);
    57.         return file;
    58.     }
    60.     /**
    61.      * 获取文件夹类型的文件
    62.      */
    63.     public File getDirectFile(String fileName) {
    64.         File file = new File(fileName);
    65.         if (!file.getParentFile().exists()) {
    66.             file.getParentFile().mkdirs();
    67.         }
    68.         if (!file.exists()) {
    69.             file.mkdir();
    70.         }
    71.         file.setReadable(true);
    72.         file.setWritable(true);
    73.         return file;
    74.     }
    76.     @SuppressWarnings("all")
    77.     public Boolean createFile(String fileName) throws IOException {
    78.         File file = new File(fileName);
    79.         if (!file.getParentFile().exists()) {
    80.             file.getParentFile().mkdirs();
    81.         }
    82.         if (!file.exists() && file.createNewFile()) {
    83.             return file.setReadable(true) && file.setWritable(true);
    84.         }
    85.         return false;
    86.     }
    88.     public Boolean exist(String fileFullPath){
    89.         File file = new File(fileFullPath);
    90.         return file.exists();
    91.     }
    93.     /**
    94.      * 向文件中写入对应的文件
    95.      */
    96.     public void writeFile(File file, String content) throws IOException {
    97.         try (FileOutputStream outputStream = new FileOutputStream(file)) {
    98.             outputStream.write(content.getBytes(CRYPTO_CHARSET));
    99.             outputStream.flush();
    100.         }
    101.     }
    103.     public void writeFile(String file, String content) throws IOException {
    104.         try (FileOutputStream outputStream = new FileOutputStream(new File(file))) {
    105.             outputStream.write(content.getBytes(CRYPTO_CHARSET));
    106.             outputStream.flush();
    107.         }
    108.     }
    110.     public BufferedReader readFile(File file) throws IOException {
    111.         return Files.newBufferedReader(file.toPath(), CRYPTO_CHARSET);
    112.     }
    114.     public String readFromFile(File file) throws IOException {
    115.         StringBuilder stringBuilder = new StringBuilder();
    116.         try (BufferedReader bufferedReader = readFile(file)) {
    117.             String line;
    118.             while ((line = bufferedReader.readLine()) != null) {
    119.                 stringBuilder.append(line).append("\n");
    120.             }
    121.         }
    122.         return stringBuilder.toString();
    123.     }
    125.     /**
    126.      * 读取资源文件中的内容
    127.      * @param cls 类所在的位置
    128.      * @param resourceFileName 资源文件中的位置比如：/script/base.groovy，其中前面一定要有"/"
    129.      * @return 文件的字符数据
    130.      */
    131.     public String readFromResource(Class cls, String resourceFileName) throws IOException {
    132.         StringBuilder stringBuilder = new StringBuilder();
    133.         InputStream inputStream = cls.getResourceAsStream(resourceFileName);
    134.         BufferedReader bufferedReader = null;
    135.         try {
    136.             bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    137.             String line;
    138.             while ((line = bufferedReader.readLine()) != null) {
    139.                 stringBuilder.append(line).append("\n");
    140.             }
    141.         } finally {
    142.             inputStream.close();
    143.             assert bufferedReader != null;
    144.             bufferedReader.close();
    145.         }
    146.         return stringBuilder.toString();
    147.     }
    149.     /**
    150.      * 通过文件的绝对路径读取文件信息
    151.      */
    152.     public String read(String filePath) throws IOException {
    153.         FileReader fileReader;
    154.         StringBuilder stringBuilder = new StringBuilder();
    155.         fileReader = new FileReader(filePath);
    156.         char[] cbuf = new char[32];
    157.         int hasRead = 0;
    158.         while ((hasRead = fileReader.read(cbuf)) > 0) {
    159.             stringBuilder.append(cbuf, 0, hasRead);
    160.         }
    161.         return stringBuilder.toString();
    162.     }
    164.     public FileInputStream readToStream(String filePath) throws IOException {
    165.         File file = new File(filePath);
    166.         if (file.exists()) {
    167.             return new FileInputStream(file);
    168.         }
    169.         return null;
    170.     }
    172.     /**
    173.      * 向绝对路径中的文件写入对应的数据信息
    174.      */
    175.     public void write(String filePath, String content) throws IOException {
    176.         writeFile(getFile(filePath), content);
    177.     }
    179.     public  String readUrl(String FileName) throws IOException {
    180.         String read;
    181.         StringBuilder stringBuilder = new StringBuilder();
    182.         try {
    183.             URL url = new URL(FileName);
    184.             HttpURLConnection urlCon = (HttpURLConnection) url.openConnection();
    185.             urlCon.setConnectTimeout(5000);
    186.             urlCon.setReadTimeout(5000);
    187.             BufferedReader br = new BufferedReader(new InputStreamReader(urlCon.getInputStream()));
    188.             while ((read = br.readLine()) != null) {
    189.                 stringBuilder.append(read);
    190.             }
    191.             br.close();
    192.         } catch (IOException e) {
    194.         }
    195.         return stringBuilder.toString();
    196.     }
    199.     public void appendFile(String filePath, List<String> content) {
    200.         FileWriter fw = null;
    201.         if (content == null || content.isEmpty()) {
    202.             return;
    203.         }
    204.         try {
    205.             //如果文件存在，则追加内容；如果文件不存在，则创建文件
    206.             File file = getFile(filePath);
    207.             if ((!file.exists()) &&
    208.                     (!file.createNewFile())) {
    209.                 throw new IOException("create file '" + filePath +
    210.                         "' failure.");
    211.             }
    212.             fw = new FileWriter(file, true);
    213.             PrintWriter pw = new PrintWriter(fw);
    214.             for (String str : content) {
    215.                 if(str != null && !"".equals(str)) {
    216.                     pw.println(str);
    217.                 }
    218.             }
    219.             pw.flush();
    220.             fw.flush();
    221.             pw.close();
    222.             fw.close();
    223.         } catch (IOException e) {
    224.             e.printStackTrace();
    225.         }
    226.     }
    228.     public void appendFile(String filePath, String content) {
    229.         List<String> contents = new ArrayList<>();
    230.         contents.add(content);
    231.         appendFile(filePath, contents);
    232.     }
    234.     public boolean delete(String filePath) {
    235.         return delete(new File(filePath));
    236.     }
    238.     public boolean delete(File file) {
    239.         if (null == file || !file.exists()) {
    240.             return false;
    241.         }
    243.         if (file.isFile()) {
    244.             return file.delete();
    245.         } else {
    246.             File[] childFile = file.listFiles();
    247.             if (null == childFile) {
    248.                 return false;
    249.             }
    250.             for (File fileMeta : childFile) {
    251.                 delete(fileMeta);
    252.             }
    253.         }
    255.         return file.delete();
    256.     }
    258.     /**
    259.      * 文件加锁
    260.      * <p>
    261.      *     <ul>
    262.      *         <li>1.可重入</li>
    263.      *         <li>2.锁有过期时间</li>
    264.      *         <li>3.自动延长过期时间</li>
    265.      *     </ul>
    266.      *
    267.      * @param lockFile 加锁对应的文件的路径
    268.      * @return true：加锁成功，false：加锁失败
    269.      */
    270.     public boolean lock(String lockFile) {
    271.         try {
    272.             File compressLock = new File(lockFile);
    273.             if (compressLock.isDirectory()) {
    274.                 return false;
    275.             }
    277.             String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
    278.             String tid = String.valueOf(Thread.currentThread().getId());
    279.             if (!compressLock.exists() && null != getFile(lockFile)) {
    280.                 NeoMap dataMap = NeoMap.of();
    281.                 dataMap.put("time", DateUtils.addMinutes(new Date(), -1).getTime());
    282.                 dataMap.put("pid", pid);
    283.                 dataMap.put("tid", tid);
    284.                 writeFile(compressLock, JSON.toJSONString(dataMap));
    285.                 startDelayThread(lockFile);
    286.                 return true;
    287.             } else {
    288.                 String lockData = readFromFile(compressLock);
    289.                 JSONObject dataMap = JSONObject.parseObject(lockData);
    290.                 if (null == dataMap) {
    291.                     return false;
    292.                 }
    294.                 // 锁可重入
    295.                 if (dataMap.containsKey("pid") && dataMap.containsKey("tid")) {
    296.                     String pidCache = dataMap.getString("pid");
    297.                     String tidCache = dataMap.getString("tid");
    298.                     if (!StringUtils.isEmpty(pidCache) && pidCache.equals(pid) && !StringUtils.isEmpty(tidCache) && tidCache.equals(tid)) {
    299.                         // 重入后，顺便更新下下次时间
    300.                         dataMap.put("time", getNextTime());
    301.                         writeFile(compressLock, JSON.toJSONString(dataMap));
    302.                         return true;
    303.                     }
    304.                 }
    306.                 if (dataMap.containsKey("time")) {
    307.                     Long timeLong = dataMap.getLong("time");
    308.                     if (timeLong < System.currentTimeMillis()) {
    309.                         // 锁过期，则重新占有
    310.                         if (createFile(lockFile + "_lock")) {
    311.                             dataMap.put("time", getNextTime());
    312.                             dataMap.put("pid", pid);
    313.                             dataMap.put("tid", tid);
    314.                             writeFile(compressLock, JSON.toJSONString(dataMap));
    315.                             delete(lockFile + "_lock");
    316.                             return true;
    317.                         }
    318.                         return false;
    319.                     }
    320.                 }
    321.             }
    322.         } catch (IOException e) {
    323.             log.error("lock exception", e);
    324.             return false;
    325.         }
    326.         return false;
    327.     }
    329.     /**
    330.      * 启动延期保护线程，20秒执行一次，每次向后默认延长1分钟
    331.      */
    332.     private void startDelayThread(String filePath) {
    333.         try {
    334.             JobDetail job = JobBuilder.newJob(InnerJob.class).withIdentity(new JobKey(filePath)).usingJobData("filePath", filePath).build();
    335.             Trigger trigger = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(30)).build();
    337.             scheduler.scheduleJob(job, trigger);
    338.         } catch (SchedulerException e) {
    339.             e.printStackTrace();
    340.         }
    341.     }
    343.     /**
    344.      * 关闭延期保护线程
    345.      */
    346.     private void closeDelayThread(String filePath) {
    347.         try {
    348.             scheduler.deleteJob(new JobKey(filePath));
    349.         } catch (SchedulerException e) {
    350.             e.printStackTrace();
    351.         }
    352.     }
    354.     private Long getNextTime() {
    355.         return DateUtils.addMinutes(new Date(), 1).getTime();
    356.     }
    358.     public boolean unlock(String lockFile) {
    359.         File compressLock = new File(lockFile);
    360.         if (compressLock.isDirectory()) {
    361.             return false;
    362.         }
    364.         String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
    365.         String tid = String.valueOf(Thread.currentThread().getId());
    366.         try {
    367.             String lockData = readFromFile(compressLock);
    368.             JSONObject dataMap = JSONObject.parseObject(lockData);
    369.             if (null == dataMap) {
    370.                 return false;
    371.             }
    372.             if (dataMap.containsKey("pid") && dataMap.containsKey("tid")) {
    373.                 String pidCache = dataMap.getString("pid");
    374.                 String tidCache = dataMap.getString("tid");
    375.                 // 保证删除的是自己的
    376.                 if (!StringUtils.isEmpty(pidCache) && pidCache.equals(pid) && !StringUtils.isEmpty(tidCache) && tidCache.equals(tid)) {
    377.                     closeDelayThread(lockFile);
    378.                     return compressLock.delete();
    379.                 }
    380.             }
    381.         } catch (IOException e) {
    382.             e.printStackTrace();
    383.         }
    384.         return false;
    385.     }
    387.     public class InnerJob implements Job {
    389.         public InnerJob() {}
    391.         @Override
    392.         public void execute(JobExecutionContext context) {
    393.             String filePath = context.getJobDetail().getJobDataMap().getString("filePath");
    394.             try {
    395.                 if (!exist(filePath)) {
    396.                     return;
    397.                 }
    398.                 String content = read(filePath);
    400.                 JSONObject contentObject = JSONObject.parseObject(content);
    401.                 // 默认向后延长1分钟
    402.                 contentObject.put("time", getNextTime());
    403.                 write(filePath, contentObject.toJSONString());
    404.             } catch (IOException e) {
    405.                 e.printStackTrace();
    406.             }
    407.         }
    408.     }
    409. }