Wie in der Anlegestelle Housekeeping zu tun?

Question

Wir lassen Benutzer einige Bilddateien auf unseren Webserver hochladen. Diese Dateien sind 10-15 Minuten nach dem Hochladen nutzlos. Gibt es eine Möglichkeit, diese Dateien automatisch zu löschen, z. alle Bilddateien, die 15 Minuten nach ihrer Erstellung in ihrem Namen "abgelaufen" sind?

Answer 1

ich im Grunde Setup Quarz-Scheduler in meinem Webserver mit einem cron-Trigger

und der Job sahen mehr oder ähnliche

public static void deleteFilesOlderThanNdays(int daysBack, String dirWay, org.apache.commons.logging.Log log) { 

    File directory = new File(dirWay); 
    if(directory.exists()){ 

     File[] listFiles = directory.listFiles();    
     long purgeTime = System.currentTimeMillis() - (daysBack * 24 * 60 * 60 * 1000); 
     for(File listFile : listFiles) { 
      if(listFile.lastModified() < purgeTime) { 
       if(!listFile.delete()) { 
        System.err.println("Unable to delete file: " + listFile); 
       } 
      } 
     } 
    } else { 
     log.warn("Files were not deleted, directory " + dirWay + " does'nt exist!"); 
    } 
} 

ref: http://www.coderanch.com/t/384581/java/java/Delete-Files-Older-days

Answer 2

Ich glaube nicht, Jetty hat eine eingebaute Funktion dafür. Sie könnten eine Art GarbageCollector Klasse erstellen und das Löschen einer Datei planen mit einem ScheduledExecutorService:

public class GarbageCollector { 
    private ScheduledExecutorService service = Executors.newScheduledThreadPool(1); 

    public void scheduleFileDeletion(Path path) { 
     service.schedule(() -> { 
      try { 
       Files.delete(path); 
      } catch (IOException ignored) { 
      } 
     }, 15, TimeUnit.MINUTES); 
    } 
} 

Answer 3

es so etwas in Anlegesteg, wie mlapeyre sagt. Schauen Sie sich Guavas cache an.

So etwas wird es tun, ich denke:

Cache<Key, Graph> graphs = CacheBuilder.newBuilder() 
     .maximumSize(1000) 
     .expireAfterWrite(10, TimeUnit.MINUTES) 
     .removalListener(DELETE_FILES_LISTENER) 
     .build(); 

Answer 4

Sie nur Ihre eigene Frage beantwortet - alle Dateien mit Wort bekommen „verfallen“ im Namen und modifizierte 15 Minuten vor aktuelle Zeit und löschen .

Hier ist Code. Es ist nicht effizient, aber einfach:

File dir=new File("."); 
String []expiredFiles=dir.list(new FilenameFilter() { 
    @Override 
    public boolean accept(File dir, String name) { 
     return (name.contains("expired")&& new File(dir,name).lastModified()<System.currentTimeMillis()-15*60*1000);     
    } 
}); 
for(String file:expiredFiles){ 
    new File(dir,file).delete(); 
} 

Sie können es alle 15 Minuten oder so ausführen. Oder, einfacher, führen Sie es aus, wenn jede Anfrage beantwortet und geschlossen wird, aber der Thread noch nicht gestoppt ist. Zum Beispiel unmittelbar nach dem Schließen des Ausgabestreams auf dem Antwortobjekt. Es braucht nicht viel Ressourcen, besonders wenn der Thread läuft und noch läuft.

Answer 5

Erstellen Sie eine Modellklasse zum Speichern von Informationen zum Hochladen von Bildern wie imagePath und uploadedTime.

class UploadedImage { 
    private Path imagePath; 
    private long uploadedTime; 
    public UploadedImage(Path imagePath, long uploadedTime) { 
     this.imagePath = imagePath; 
     this.uploadedTime = uploadedTime; 
    } 
    public Path getImagePath() { 
     return imagePath; 
    } 
    public long getUploadedTime() { 
     return uploadedTime; 
    } 
    @Override 
    public boolean equals(Object obj) { 
     if (obj == null) { 
      return false; 
     } 
     if (getClass() != obj.getClass()) { 
      return false; 
     } 
     final UploadedImage other = (UploadedImage) obj; 
     if (!Objects.equals(this.imagePath, other.imagePath)) { 
      return false; 
     } 
     if (this.uploadedTime != other.uploadedTime) { 
      return false; 
     } 
     return true; 
    } 
} 

erstellen UploadedImage Objekt für jedes Bild-Upload und speichern sie in einer globalen Arraylist.

//... 
ArrayList<UploadedImage> imageBucket = new ArrayList<>(); 
//... 

public synchronized void uploadingImage(Path imagePath, long uploadedTime){   
    imageBucket.add(new UploadeImage(imagePath, uploadedTime)); 
} 

Und bereiten Sie einen Thread zum Löschen der Dateien wie folgt vor.

boolean deletionOff = false; 
    new Thread(new Runnable() { 
    private final long IMAGE_LIFE_TIME = 1000 * 60 * 15;//fifteen minutes 
    @Override 
    public void run() { 
     while (!deletionOff) { 
      //this fore-each will retrieve objects from OLDEST to NEWEST 
      for (UploadedImage uploadedImage : imageBucket) { 
       //finds the elapsed time since the upload of this image 
       long timeElapsed = System.currentTimeMillis() - uploadedImage.getUploadedTime(); 
       if (timeElapsed >= IMAGE_LIFE_TIME) { 
        //following commands will execute only if the image is eligible to delete 
        try { 
         Files.delete(uploadedImage.getImagePath()); 
        } catch (IOException ex) { 
         // 
        } finally { 
         imageBucket.remove(uploadedImage); 
        } 
       } else { 
        //this block will execute when IMAGE_LIFE_TIME is 
        //bigger than the elapsed time which means the 
        //selected image only have 
        //(IMAGE_LIFE_TIME - timeElapsed) of time to stay alive 
        //NOTE : 
        //there is no need to check the next UploadedImage 
        //objects as they were added to the list after the 
        //currently considering UploadedImage object, 
        //which is still has some time to stay alive       
        try { 
         Thread.sleep(IMAGE_LIFE_TIME - timeElapsed); 
         break; 
        } catch (InterruptedException ex) { 
         // 
        } 
       } 
      } 
     } 
    } 
}).start();