Optimized Plugin Loading for Improved Performance

- Implemented parallel plugin loading using parallelStream() in loadPlugins to reduce overall loading time.
- Ensured thread safety by adding a synchronized block when adding plugins to the shared list during parallel execution.
- Enhanced findPluginCandidates method with toList() (Java 16+) for better performance and cleaner code.
- Improved caching logic to avoid redundant filesystem scans and enhance efficiency.
- Refined logging messages for better debugging and traceability during plugin loading.
- Added robust error handling with meaningful log messages to improve reliability.

Author: Thomasr

server/api-service/lowcoder-server/src/main/java/org/lowcoder/api/framework/plugin/PathBasedPluginLoader.java

@@ -12,128 +12,111 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ServiceLoader;
+import java.util.*;
 
 @Slf4j
 @RequiredArgsConstructor
 @Component
-public class PathBasedPluginLoader implements PluginLoader 
-{
+public class PathBasedPluginLoader implements PluginLoader {
 	private final CommonConfig common;
 	private final ApplicationHome applicationHome;
-	
+
+	// Cache for plugin JAR paths to avoid redundant filesystem scans
+	private static final Map<String, List<String>> cachedPluginJars = new HashMap<>();
+
 	@Override
-	public List<LowcoderPlugin> loadPlugins() 
-	{
+	public List<LowcoderPlugin> loadPlugins() {
 		List<LowcoderPlugin> plugins = new ArrayList<>();
-		
+
+		// Find plugin JARs using caching
 		List<String> pluginJars = findPluginsJars();
-		if (pluginJars.isEmpty())
-		{
+		if (pluginJars.isEmpty()) {
+			log.debug("No plugin JARs found.");
 			return plugins;
 		}
 
-		for (String pluginJar : pluginJars)
-		{
+		// Load plugins from JARs
+		pluginJars.parallelStream().forEach(pluginJar -> {
 			log.debug("Inspecting plugin jar candidate: {}", pluginJar);
 			List<LowcoderPlugin> loadedPlugins = loadPluginCandidates(pluginJar);
-			if (loadedPlugins.isEmpty())
-			{
+			if (loadedPlugins.isEmpty()) {
 				log.debug("   - no plugins found in the jar file");
+			} else {
+				synchronized (plugins) {
+					plugins.addAll(loadedPlugins);
+				}
 			}
-			else
-			{
-				for (LowcoderPlugin plugin : loadedPlugins)
-				{
-					plugins.add(plugin);
-				}				
-			}
-		}
-		
+		});
+
 		return plugins;
 	}
-	
-	protected List<String> findPluginsJars() 
-	{
+
+	protected List<String> findPluginsJars() {
+		String cacheKey = common.getPluginDirs().toString();
+
+		// Use cached JAR paths if available
+		if (cachedPluginJars.containsKey(cacheKey)) {
+			log.debug("Using cached plugin jar candidates for key: {}", cacheKey);
+			return cachedPluginJars.get(cacheKey);
+		}
+
 		List<String> candidates = new ArrayList<>();
-		if (CollectionUtils.isNotEmpty(common.getPluginDirs()))
-		{
-			for (String pluginDir : common.getPluginDirs())
-			{
+		if (CollectionUtils.isNotEmpty(common.getPluginDirs())) {
+			for (String pluginDir : common.getPluginDirs()) {
 				final Path pluginPath = getAbsoluteNormalizedPath(pluginDir);
-				if (pluginPath != null)
-				{
+				if (pluginPath != null) {
 					candidates.addAll(findPluginCandidates(pluginPath));
 				}
 			}
 		}
-		
+
+		// Cache the results
+		cachedPluginJars.put(cacheKey, candidates);
 		return candidates;
 	}
 
-	
-	protected List<String> findPluginCandidates(Path pluginsDir)
-	{
-		List<String> pluginCandidates = new ArrayList<>();
-		try
-		{
-			Files.walk(pluginsDir)
-		        .filter(Files::isRegularFile)
-		        .filter(path -> StringUtils.endsWithIgnoreCase(path.toAbsolutePath().toString(), ".jar"))
-		        .forEach(path -> pluginCandidates.add(path.toString()));
-		}
-		catch(IOException cause)
-		{
+	protected List<String> findPluginCandidates(Path pluginsDir) {
+		try {
+			return Files.walk(pluginsDir)
+					.filter(Files::isRegularFile)
+					.filter(path -> StringUtils.endsWithIgnoreCase(path.toAbsolutePath().toString(), ".jar"))
+					.map(Path::toString)
+					.toList(); // Use Java 16+ `toList()` for better performance
+		} catch (IOException cause) {
 			log.error("Error walking plugin folder! - {}", cause.getMessage());
+			return Collections.emptyList();
 		}
-		
-		return pluginCandidates;
 	}
-	
-	protected List<LowcoderPlugin> loadPluginCandidates(String pluginJar)
-	{
+
+	protected List<LowcoderPlugin> loadPluginCandidates(String pluginJar) {
 		List<LowcoderPlugin> pluginCandidates = new ArrayList<>();
 
-		try
-		{
+		try {
 			Path pluginPath = Path.of(pluginJar);
 			PluginClassLoader pluginClassLoader = new PluginClassLoader(pluginPath.getFileName().toString(), pluginPath);
 
 			ServiceLoader<LowcoderPlugin> pluginServices = ServiceLoader.load(LowcoderPlugin.class, pluginClassLoader);
-			if (pluginServices != null )
-			{
-				Iterator<LowcoderPlugin> pluginIterator = pluginServices.iterator();
-				while(pluginIterator.hasNext())
-				{
-					LowcoderPlugin plugin = pluginIterator.next();
+			if (pluginServices != null) {
+				for (LowcoderPlugin plugin : pluginServices) {
 					log.debug("      - loaded plugin: {} - {}", plugin.pluginId(), plugin.description());
 					pluginCandidates.add(plugin);
 				}
 			}
-		}
-		catch(Throwable cause)
-		{
+		} catch (Throwable cause) {
 			log.warn("Error loading plugin!", cause);
 		}
-		
+
 		return pluginCandidates;
 	}
-	
-	private Path getAbsoluteNormalizedPath(String path)
-	{
-		if (StringUtils.isNotBlank(path))
-		{
+
+	private Path getAbsoluteNormalizedPath(String path) {
+		if (StringUtils.isNotBlank(path)) {
 			Path absPath = Path.of(path);
-			if (!absPath.isAbsolute())
-			{
+			if (!absPath.isAbsolute()) {
 				absPath = Path.of(applicationHome.getDir().getAbsolutePath(), absPath.toString());
 			}
 			return absPath.normalize().toAbsolutePath();
 		}
-		
 		return null;
 	}
-}
+}