implement suggested fixes from CR. fix some general nitpicks.

Author: Picazsoo

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultGenerator.java

@@ -31,6 +31,7 @@
 import org.apache.commons.io.IOCase;
 import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.Strings;
 import org.openapitools.codegen.api.*;
 import org.openapitools.codegen.config.GlobalSettings;
 import org.openapitools.codegen.ignore.CodegenIgnoreProcessor;
@@ -60,7 +61,6 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import static org.apache.commons.lang3.StringUtils.removeStart;
 import static org.openapitools.codegen.CodegenConstants.X_INTERNAL;
 import static org.openapitools.codegen.utils.OnceLogger.once;
 
@@ -86,16 +86,17 @@ public class DefaultGenerator implements Generator {
     private String basePath;
     private String basePathWithoutHost;
     private String contextPath;
-    private Map<String, String> generatorPropertyDefaults = new HashMap<>();
+    private final Map<String, String> generatorPropertyDefaults = new HashMap<>();
     /**
      * Retrieves an instance to the configured template processor, available after user-defined options are
      * applied via
      */
-    @Getter protected TemplateProcessor templateProcessor = null;
+    @Getter
+    protected TemplateProcessor templateProcessor = null;
 
     private List<TemplateDefinition> userDefinedTemplates = new ArrayList<>();
-    private String generatorCheck = "spring";
-    private String templateCheck = "apiController.mustache";
+    private final String generatorCheck = "spring";
+    private final String templateCheck = "apiController.mustache";
 
 
     public DefaultGenerator() {
@@ -266,8 +267,7 @@ void configureGeneratorProperties() {
                 openapiNormalizer.normalize();
             }
         } catch (Exception e) {
-            LOGGER.error("An exception occurred in OpenAPI Normalizer. Please report the issue via https://github.com/openapitools/openapi-generator/issues/new/: ");
-            e.printStackTrace();
+            LOGGER.error("An exception occurred in OpenAPI Normalizer. Please report the issue via https://github.com/openapitools/openapi-generator/issues/new/: ", e);
         }
 
         // resolve inline models
@@ -607,10 +607,10 @@ private void generateModelsForVariable(List<File> files, List<ModelMap> allModel
             if (!processedModels.contains(key) && allSchemas.containsKey(key)) {
                 generateModels(files, allModels, unusedModels, aliasModels, processedModels, () -> Set.of(key));
             } else {
-                LOGGER.info("Type " + variable.getComplexType() + " of variable " + variable.getName() + " could not be resolve because it is not declared as a model.");
+                LOGGER.info("Type {} of variable {} could not be resolve because it is not declared as a model.", variable.getComplexType(), variable.getName());
             }
         } else {
-            LOGGER.info("Type " + variable.getOpenApiType() + " of variable " + variable.getName() + " could not be resolve because it is not declared as a model.");
+            LOGGER.info("Type {} of variable {} could not be resolve because it is not declared as a model.", variable.getOpenApiType(), variable.getName());
         }
     }
 
@@ -639,8 +639,8 @@ private Set<String> getPropertyAsSet(String propertyName) {
         }
 
         return Arrays.stream(propertyRaw.split(","))
-            .map(String::trim)
-            .collect(Collectors.toSet());
+                .map(String::trim)
+                .collect(Collectors.toSet());
     }
 
     private Set<String> modelKeys() {
@@ -665,7 +665,6 @@ private Set<String> modelKeys() {
         return modelKeys;
     }
 
-    @SuppressWarnings("unchecked")
     void generateApis(List<File> files, List<OperationsMap> allOperations, List<ModelMap> allModels) {
         if (!generateApis) {
             // TODO: Process these anyway and present info via dryRun?
@@ -1006,7 +1005,7 @@ private void generateOpenapiGeneratorIgnoreFile() {
         File ignoreFile = new File(ignoreFileNameTarget);
         // use the entries provided by the users to pre-populate .openapi-generator-ignore
         try {
-            LOGGER.info("Writing file " + ignoreFileNameTarget + " (which is always overwritten when the option `openapiGeneratorIgnoreFile` is enabled.)");
+            LOGGER.info("Writing file {} (which is always overwritten when the option `openapiGeneratorIgnoreFile` is enabled.)", ignoreFileNameTarget);
             new File(config.outputFolder()).mkdirs();
             if (!ignoreFile.createNewFile()) {
                 // file may already exist, do nothing
@@ -1393,7 +1392,7 @@ private void processUserDefinedTemplates() {
                             // hack: destination filename in this scenario might be a suffix like Impl.java
                             templateExt = userDefinedTemplate.getDestinationFilename();
                         } else {
-                            templateExt = StringUtils.prependIfMissing(templateExt, ".");
+                            templateExt = Strings.CS.prependIfMissing(templateExt, ".");
                         }
                         String templateOutputFolder = userDefinedTemplate.getFolder();
                         if (!templateOutputFolder.isEmpty()) {
@@ -1430,7 +1429,9 @@ protected File processTemplateToFile(Map<String, Object> templateData, String te
         return processTemplateToFile(templateData, templateName, outputFilename, shouldGenerate, skippedByOption, this.config.getOutputDir());
     }
 
-    /** Stores lowercased absolute paths for O(1) case-insensitive duplicate detection. */
+    /**
+     * Stores lowercased absolute paths for O(1) case-insensitive duplicate detection.
+     */
     private final Set<String> seenFilesLower = new HashSet<>();
 
     private File processTemplateToFile(Map<String, Object> templateData, String templateName, String outputFilename, boolean shouldGenerate, String skippedByOption, String intendedOutputDir) throws IOException {
@@ -1993,7 +1994,7 @@ private void generateFilesMetadata(List<File> files) {
                     // Some implementations make the output ./c/d which seems to mix the logic
                     // as documented for symlinks. So we need to trim any / or ./ from the start,
                     // as nobody should be generating into system root and our expectation is no ./
-                    String relativePath = removeStart(removeStart(f.toString(), "." + File.separator), File.separator);
+                    String relativePath = Strings.CS.removeStart(Strings.CS.removeStart(f.toString(), "." + File.separator), File.separator);
                     if (File.separator.equals("\\")) {
                         // ensure that windows outputs same FILES format
                         relativePath = relativePath.replace(File.separator, "/");
@@ -2003,10 +2004,8 @@ private void generateFilesMetadata(List<File> files) {
                     }
                 });
 
-                Collections.sort(relativePaths, (a, b) -> IOCase.SENSITIVE.checkCompareTo(a, b));
-                relativePaths.forEach(relativePath -> {
-                    sb.append(relativePath).append(System.lineSeparator());
-                });
+                relativePaths.sort(IOCase.SENSITIVE::checkCompareTo);
+                relativePaths.forEach(relativePath -> sb.append(relativePath).append(System.lineSeparator()));
 
                 String targetFile = config.outputFolder() + File.separator + METADATA_DIR + File.separator + config.getFilesMetadataFilename();
 
@@ -2021,7 +2020,7 @@ private void generateFilesMetadata(List<File> files) {
     }
 
     private String removeTrailingSlash(String value) {
-        return StringUtils.removeEnd(value, "/");
+        return Strings.CS.removeEnd(value, "/");
     }
 
 }

modules/openapi-generator/src/main/java/org/openapitools/codegen/TemplateManager.java

@@ -94,15 +94,22 @@ public Path getFullTemplatePath(String name) {
         return Paths.get(getFullTemplateFile(name));
     }
 
+    /**
+     * Pre-compiled pattern for replacing the OS file separator with '/' in classpath resource paths.
+     * Only non-null on operating systems where {@link File#separator} is not already '/'.
+     */
+    private static final Pattern FILE_SEP_PATTERN =
+            "/".equals(File.separator) ? null : Pattern.compile(Pattern.quote(File.separator));
+
     /**
      * Gets a normalized classpath resource location according to OS-specific file separator
      *
      * @param name The name of the resource file/directory to find
      * @return A normalized string according to OS-specific file separator
      */
     public static String getCPResourcePath(final String name) {
-        if (!"/".equals(File.separator)) {
-            return name.replaceAll(Pattern.quote(File.separator), "/");
+        if (FILE_SEP_PATTERN != null) {
+            return FILE_SEP_PATTERN.matcher(name).replaceAll("/");
         }
         return name;
     }

modules/openapi-generator/src/main/java/org/openapitools/codegen/templating/GeneratorTemplateContentLocator.java

@@ -7,13 +7,22 @@
 
 import java.io.File;
 import java.nio.file.Paths;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Locates templates according to {@link CodegenConfig} settings.
  */
 public class GeneratorTemplateContentLocator implements TemplatePathLocator {
     private final CodegenConfig codegenConfig;
 
+    /**
+     * Cache of relativeTemplateFile -> resolved full path (or empty Optional when the template does not exist).
+     * The filesystem/classpath existence probes inside resolveFullTemplatePath are expensive on repeated calls
+     * for the same template name, so we memoize the result for the lifetime of this locator instance.
+     */
+    private final ConcurrentHashMap<String, Optional<String>> templatePathCache = new ConcurrentHashMap<>();
+
     /**
      * Constructs a new instance of {@link GeneratorTemplateContentLocator} for the provided {@link CodegenConfig}
      *
@@ -51,12 +60,25 @@ private boolean classpathTemplateExists(String name) {
      * 4) (embedded template dir)
      * <p>
      * Where "template dir" may be user defined and "embedded template dir" are the built-in templates for the given generator.
+     * <p>
+     * Results are cached per {@code relativeTemplateFile} name because the filesystem/classpath probes are expensive
+     * and the outcome is constant for the lifetime of this locator instance.
      *
      * @param relativeTemplateFile Template file
-     * @return String Full template file path
+     * @return String Full template file path, or {@code null} if the template does not exist in any location
      */
     @Override
     public String getFullTemplatePath(String relativeTemplateFile) {
+        return templatePathCache
+                .computeIfAbsent(relativeTemplateFile, key -> Optional.ofNullable(resolveFullTemplatePath(key)))
+                .orElse(null);
+    }
+
+    /**
+     * Performs the actual filesystem/classpath probes to find the full template path.
+     * Called at most once per unique {@code relativeTemplateFile} value; all subsequent lookups use the cache.
+     */
+    private String resolveFullTemplatePath(String relativeTemplateFile) {
         CodegenConfig config = this.codegenConfig;
 
         //check the supplied template library folder for the file

modules/openapi-generator/src/main/java/org/openapitools/codegen/templating/HandlebarsEngineAdapter.java

@@ -38,7 +38,6 @@
 
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -49,20 +48,24 @@ public class HandlebarsEngineAdapter extends AbstractTemplatingEngineAdapter {
     // We use this as a simple lookup for valid file name extensions. This adapter will inspect .mustache (built-in) and infer the relevant handlebars filename
     private final String[] canCompileFromExtensions = {".handlebars", ".hbs", ".mustache"};
     private boolean infiniteLoops = false;
-    @Setter private boolean prettyPrint = false;
+    @Setter
+    private boolean prettyPrint = false;
 
     /**
-     * Cache of (templateFile -> compiled Template). Compiled Handlebars templates are stateless after
-     * compilation and safe to reuse across multiple data-bundle invocations within the same run.
+     * Per-executor cache of fully-configured {@link Handlebars} engine instances.
+     * Each executor gets its own engine because the engine's {@link TemplateLoader} closes over the
+     * executor; sharing an engine across executors would silently resolve templates from the wrong source.
+     * {@link ConcurrentHashMap#computeIfAbsent} ensures the engine is built at most once per executor.
      */
-    private final Map<String, Template> compiledTemplateCache = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<TemplatingExecutor, Handlebars> engineCache = new ConcurrentHashMap<>();
 
     /**
-     * Cached Handlebars engine instance with all helpers pre-registered.
-     * Re-created lazily whenever the TemplatingExecutor changes (different template paths).
+     * Per-executor cache of compiled {@link Template} objects.
+     * Keying on the executor instance eliminates the non-atomic check-clear-update invalidation
+     * that the previous single-cache approach required; no state ever needs to be cleared.
      */
-    private volatile Handlebars cachedHandlebars;
-    private volatile TemplatingExecutor cachedExecutor;
+    private final ConcurrentHashMap<TemplatingExecutor, ConcurrentHashMap<String, Template>> templateCaches =
+            new ConcurrentHashMap<>();
 
     /**
      * Provides an identifier used to load the adapter. This could be a name, uuid, or any other string.
@@ -86,40 +89,44 @@ public String compileTemplate(TemplatingExecutor executor,
                         AccessAwareFieldValueResolver.INSTANCE)
                 .build();
 
-        // Reuse the Handlebars engine when the executor hasn't changed; rebuild otherwise.
-        if (cachedHandlebars == null || cachedExecutor != executor) {
-            TemplateLoader loader = new AbstractTemplateLoader() {
-                @Override
-                public TemplateSource sourceAt(String location) {
-                    return findTemplate(executor, location);
-                }
-            };
-            Handlebars handlebars = new Handlebars(loader);
-            handlebars.registerHelperMissing((obj, options) -> {
-                LOGGER.warn(String.format(Locale.ROOT, "Unregistered helper name '%s', processing template:%n%s", options.helperName, options.fn.text()));
-                return "";
-            });
-            handlebars.registerHelper("json", Jackson2Helper.INSTANCE);
-            StringHelpers.register(handlebars);
-            handlebars.registerHelpers(ConditionalHelpers.class);
-            handlebars.registerHelpers(org.openapitools.codegen.templating.handlebars.StringHelpers.class);
-            handlebars.setInfiniteLoops(infiniteLoops);
-            handlebars.setPrettyPrint(prettyPrint);
-            // Changing the executor means template content may differ; clear stale entries.
-            compiledTemplateCache.clear();
-            cachedHandlebars = handlebars;
-            cachedExecutor = executor;
-        }
+        // Each executor gets its own Handlebars engine (the loader closes over the executor) and its
+        // own compiled-template cache. computeIfAbsent is atomic, so concurrent calls with the same
+        // executor share one engine/cache rather than racing to create duplicates.
+        Handlebars handlebars = engineCache.computeIfAbsent(executor, this::buildHandlebars);
+        ConcurrentHashMap<String, Template> cache =
+                templateCaches.computeIfAbsent(executor, k -> new ConcurrentHashMap<>());
 
-        Template tmpl = compiledTemplateCache.get(templateFile);
+        // Manual get → compile → put so IOException propagates naturally.
+        Template tmpl = cache.get(templateFile);
         if (tmpl == null) {
-            // compile() declares throws IOException — propagate it directly without wrapping.
-            tmpl = cachedHandlebars.compile(templateFile);
-            compiledTemplateCache.put(templateFile, tmpl);
+            tmpl = handlebars.compile(templateFile);
+            cache.put(templateFile, tmpl);
         }
         return tmpl.apply(context);
     }
 
+    /** Constructs and fully configures a {@link Handlebars} engine for the given executor. */
+    private Handlebars buildHandlebars(TemplatingExecutor executor) {
+        TemplateLoader loader = new AbstractTemplateLoader() {
+            @Override
+            public TemplateSource sourceAt(String location) {
+                return findTemplate(executor, location);
+            }
+        };
+        Handlebars handlebars = new Handlebars(loader);
+        handlebars.registerHelperMissing((obj, options) -> {
+            LOGGER.warn("Unregistered helper name '{}', processing template:\n{}", options.helperName, options.fn.text());
+            return "";
+        });
+        handlebars.registerHelper("json", Jackson2Helper.INSTANCE);
+        StringHelpers.register(handlebars);
+        handlebars.registerHelpers(ConditionalHelpers.class);
+        handlebars.registerHelpers(org.openapitools.codegen.templating.handlebars.StringHelpers.class);
+        handlebars.setInfiniteLoops(infiniteLoops);
+        handlebars.setPrettyPrint(prettyPrint);
+        return handlebars;
+    }
+
     @SuppressWarnings("java:S108")
     public TemplateSource findTemplate(TemplatingExecutor generator, String templateFile) {
         String[] possibilities = getModifiedFileLocation(templateFile);