public class EfluidPersistenceUnitInfo implements PersistenceUnitInfo {

    @Override
    public List<URL> getJarFileUrls() {
      return ClasspathJarEfluid.getInstance().getURLs();
    }
  }

package com.efluid.hibernate.core.scanner;

...

/**
 * Permet de wrapper {@link ScanResult} avec {@link EfluidScanResult}
 * et de récupérer la liste des package-info.java scannés.
 */
public class EfluidScanner extends StandardScanner {

  private static final Logger LOG = LoggerFactory.getLogger(EfluidScanner.class);
  private static final String FICHIER = "EfluidScanResult.ser";

  @Override
  public ScanResult scan(ScanEnvironment environment, ScanOptions options, ScanParameters parameters) {
    long startTime = currentTimeMillis();
    ScanResult scan = new EfluidSerialise<ScanResult>().get(FICHIER, ClasspathJarEfluid.getInstance().getChecksum(), () -> super.scan(environment, options, parameters));
    LOG.debug("[TIME] Temps d'exécution du scan de l'environnement : {} ms", (currentTimeMillis() - startTime));
    return new EfluidScanResult(scan);
  }
}

package com.efluid.hibernate.core.sessionfactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.function.Supplier;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.imrglobal.framework.error.GenericException;

/**
 * Permet de récupérer un objet sérialisé ou bien de le sérialiser s'il n'y est pas déjà.
 * Une valeur checksum, permet de savoir si l'objet sérialisé et celui à sérialiser est identique.
 * Si ce n'est pas le cas, alors on écrase l'objet sérialisé par celui à sérialiser.
 * Sinon on récupère l'instance désérialiser.
 */
public final class EfluidSerialise<T> {

  private static final Logger LOG = LoggerFactory.getLogger(EfluidSerialise.class);

  public T get(String nomFichier, long checksum, Supplier<T> supplierObject) {
    WrapperObjetSerialise<T> deserialise = deserialise(nomFichier);

    if (deserialise == null || deserialise.getChecksum() != checksum) {
      LOG.debug("Sérialisation du fichier {}", nomFichier);
      return serialise(supplierObject.get(), nomFichier, checksum);
    }
    LOG.debug("Désérialisation du fichier {}", nomFichier);
    return deserialise.getObjetSerialise();
  }

  private WrapperObjetSerialise<T> deserialise(String nom) {
    if (new File(nom).exists()) {
      try (var fileInput = new FileInputStream(nom);
          var objectInput = new ObjectInputStream(fileInput)) {
        return (WrapperObjetSerialise<T>) objectInput.readObject();
      } catch (IOException | ClassNotFoundException e) {
        throw new GenericException("Erreur lors de la dé-sérialisation du fichier " + nom, e);
      }
    }
    return null;
  }

  private T serialise(T objetASerialise, String nom, long checksum) {
    try (var fout = new FileOutputStream(nom);
        var oos = new ObjectOutputStream(fout)) {
      oos.writeObject(new WrapperObjetSerialise(objetASerialise, checksum));
    } catch (IOException e) {
      throw new GenericException("Erreur lors de la sérialisation du fichier " + nom, e);
    }
    return objetASerialise;
  }

  /**
   * Permet de stocker la valeur qui permet de déterminer un changement entre l'objet sérialisé et celui à sérialiser.
   */
  private static class WrapperObjetSerialise<T> implements Serializable {

    private T objetASerialise;
    private long checksum;

    public WrapperObjetSerialise(T objetASerialise, long checksum) {
      this.objetASerialise = objetASerialise;
      this.checksum = checksum;
    }

    public long getChecksum() {
      return this.checksum;
    }

    public T getObjetSerialise() {
      return objetASerialise;
    }
  }
}

package com.efluid.hibernate.core.sessionfactory;

...

/**
 * Parcours tous les fichiers d'une arborescence et concatène les dates de modification des fichiers.
 * <p>
 * Exemple de répertoire scanné : "D:/java/workspaces/developpement_dev/archi/app/target"
 */
public class CheckSumDateModification {

  private static final Logger LOG = LoggerFactory.getLogger(CheckSumDateModification.class);

  /**
   * Parcours la liste des URLs pour calculer le checksum basé sur la date de modification du fichier.
   */
  public static long checksum(List<URL> urls) {
    return urls.stream().mapToLong(url -> {
      try {
        return checksum(Paths.get(url.toURI()));
      } catch (Throwable e) {
        LOG.error("Erreur lors de la récupération des répertoires classes du classpath.", e);
        return 0;
      }
    }).sum();
  }

  /**
   * Parcours tous les fichiers d'une arborescence et concatène la date de modification des fichiers.
   */
  public static long checksum(Path repertoire) {
    long start = System.currentTimeMillis();
    long check = 0;
    try {
      check = Files.walk(repertoire)
                   .filter(Files::isRegularFile)
                   .mapToLong(getDateModification()).sum();
    } catch (IOException e) {
      LOG.error("Erreur lors du calcul de la modification du répertoire : " + repertoire, e);
    }
    LOG.debug("Check date modification : {}", check);
    LOG.debug("Temps d'exécution : {} ms, path {}", (System.currentTimeMillis() - start), repertoire);
    return check;
  }

  private static ToLongFunction<Path> getDateModification() {
    return file -> {
      try {
        return Files.readAttributes(file.toAbsolutePath(), BasicFileAttributes.class)
                    .lastModifiedTime()
                    .toMillis();
      } catch (Throwable e) {
        return 0;
      }
    };
  }
}