#699 : PfAbstarctScannerImpl.java

Structure du code

Paquetage : org.projectforge.framework.persistence.hibernate

Classes : PfAbstarctScannerImpl, ArchiveDescriptorInfo, ArchiveContextImpl

Implémente : Scanner, ArchiveContext

Méthodes (5) : scan, buildArchiveDescriptor, validateReuse, isRootUrl, obtainArchiveEntryHandler

Champs (7) : archiveDescriptorFactory, archiveDescriptor, isRoot, isRootUrl, classEntryHandler, packageEntryHandler, fileEntryHandler

Importations : 8 paquetages

Code source (abrégé)

package org.projectforge.framework.persistence.hibernate;

import org.hibernate.boot.archive.internal.StandardArchiveDescriptorFactory;
import org.hibernate.boot.archive.scan.internal.ScanResultCollector;
import org.hibernate.boot.archive.scan.spi.*;
import org.hibernate.boot.archive.spi.*;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Florian Blumenstein
 * @deprecated voir JpaWithExtLibrariesScanner
 */
@Deprecated
public class PfAbstarctScannerImpl implements Scanner
{
  static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(PfAbstarctScannerImpl.class);

  private final ArchiveDescriptorFactory archiveDescriptorFactory;
  private final Map<String, ArchiveDescriptorInfo> archiveDescriptorCache = new HashMap<>();

  public PfAbstarctScannerImpl()
  {
    this(StandardArchiveDescriptorFactory.INSTANCE);
  }

  public PfAbstarctScannerImpl(ArchiveDescriptorFactory value)
  {
    this.archiveDescriptorFactory = value;
  }

  @Override
  public ScanResult scan(ScanEnvironment environment, ScanOptions options, ScanParameters parameters)
  {
    final ScanResultCollector collector = new ScanResultCollector(environment, options, parameters);

    if (environment.getNonRootUrls() != null) {
      final ArchiveContext context = new ArchiveContextImpl(false, collector);
      for (URL url : environment.getNonRootUrls()) {
        final ArchiveDescriptor descriptor = buildArchiveDescriptor(url, false);
        descriptor.visitArchive(context);
      }
    }

    if (environment.getRootUrl() != null) {
      final ArchiveContext context = new ArchiveContextImpl(true, collector);
      URL rootUrl = environment.getRootUrl();
      if (rootUrl.toString().contains("!")) {
        String customUrlStr = rootUrl.toString();
        customUrlStr = "jar:" + customUrlStr;
        log.info("URL personnalisée : " + customUrlStr);
        try {
          URL customUrl = new URL(customUrlStr);
          final ArchiveDescriptor descriptor = buildArchiveDescriptor(customUrl, true);
          descriptor.visitArchive(context);
        } catch (MalformedURLException e) {
          log.error("Erreur lors de l'obtention de l'URL personnalisée : " + customUrlStr);
        }
      } else {
        final ArchiveDescriptor descriptor = buildArchiveDescriptor(rootUrl, true);
        descriptor.visitArchive(context);
      }

    }

    return collector.toScanResult();
  }

  private ArchiveDescriptor buildArchiveDescriptor(URL url, boolean isRootUrl)
  {
    final ArchiveDescriptor descriptor;
    final ArchiveDescriptorInfo descriptorInfo = archiveDescriptorCache.get(url.toString());
    if (descriptorInfo == null) {
      descriptor = archiveDescriptorFactory.buildArchiveDescriptor(url);
      archiveDescriptorCache.put(
          url.toString(),
          new ArchiveDescriptorInfo(descriptor, isRootUrl));
    } else {
      validateReuse(descriptorInfo, isRootUrl);
      descriptor = descriptorInfo.archiveDescriptor;
    }
    return descriptor;
  }

  // Ceci doit être protégé et les attributs/constructeur visibles au cas où
  // un scanner personnalisé aurait besoin de surcharger validateReuse.
  protected static class ArchiveDescriptorInfo
  {
    public final ArchiveDescriptor archiveDescriptor;
    public final boolean isRoot;

    public ArchiveDescriptorInfo(ArchiveDescriptor archiveDescriptor, boolean isRoot)
    {
      this.archiveDescriptor = archiveDescriptor;
      this.isRoot = isRoot;
    }
  }

  @SuppressWarnings("UnusedParameters")
  protected void validateReuse(ArchiveDescriptorInfo descriptor, boolean root)
  {
    // est-il vraiment raisonnable qu'une seule URL soit traitée plusieurs fois ?
    // pour l'instant, lever une exception, principalement parce que je suis intéressé par les situations où cela pourrait arriver
    throw new IllegalStateException("ArchiveDescriptor réutilisé ; les URL peuvent-elles être traitées plusieurs fois ?");
  }

  public static class ArchiveContextImpl implements ArchiveContext
  {
    private final boolean isRootUrl;

    private final ClassFileArchiveEntryHandler classEntryHandler;
    private final PackageInfoArchiveEntryHandler packageEntryHandler;
    private final ArchiveEntryHandler fileEntryHandler;

    public ArchiveContextImpl(boolean isRootUrl, ScanResultCollector scanResultCollector)
    {
// ... (tronqué, total 148 lignes)

Historique Git

868d6abb7 2025 -> 2026
63081666f En-têtes de fichiers source : 2024 -> 2025.
b6092df09 Copyright 2023 -> 2024
ab45d51fa Copyright 2001-2022 -> 2001-2023.
5f7ef41b8 Copyright 2021 -> 2022