#699: PfAbstarctScannerImpl.java

Codestruktur

Paket: org.projectforge.framework.persistence.hibernate

Klassen: PfAbstarctScannerImpl, ArchiveDescriptorInfo, ArchiveContextImpl

Implementiert: Scanner, ArchiveContext

Methoden (5): scan, buildArchiveDescriptor, validateReuse, isRootUrl, obtainArchiveEntryHandler

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

Importe: 8 Pakete

Quellcode (gekürzt)

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 siehe 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("Benutzerdefinierte URL: " + customUrlStr);
        try {
          URL customUrl = new URL(customUrlStr);
          final ArchiveDescriptor descriptor = buildArchiveDescriptor(customUrl, true);
          descriptor.visitArchive(context);
        } catch (MalformedURLException e) {
          log.error("Fehler beim Abrufen der benutzerdefinierten URL: " + 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;
  }

  // Dies muss geschützt sein und Attribute/Konstruktor sichtbar, falls
  // ein benutzerdefinierter Scanner validateReuse überschreiben muss.
  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)
  {
    // Ist es wirklich sinnvoll, dass eine einzelne URL mehrfach verarbeitet wird?
    // vorerst eine Ausnahme werfen, hauptsächlich weil mich Situationen interessieren, in denen dies passieren könnte
    throw new IllegalStateException("ArchiveDescriptor wiederverwendet; können URLs mehrfach verarbeitet werden?");
  }

  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)
    {
// ... (gekürzt, insgesamt 148 Zeilen)

Git-Verlauf

868d6abb7 2025 -> 2026
63081666f Quellcode-Dateiköpfe: 2024 -> 2025.
b6092df09 Copyright 2023 -> 2024
ab45d51fa Copyright 2001-2022 -> 2001-2023.
5f7ef41b8 Copyright 2021 -> 2022