feat: use custom classloader instead of plugin classloader

Author: linyimin0812

src/main/java/io/github/linyimin/plugin/compile/MybatisPojoCompile.java

@@ -1,21 +1,19 @@
 package io.github.linyimin.plugin.compile;
 
 import com.intellij.compiler.impl.ProjectCompileScope;
-import com.intellij.ide.plugins.cl.PluginClassLoader;
 import com.intellij.openapi.compiler.CompilerManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.OrderEnumerator;
 import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.lang.UrlClassLoader;
-import io.github.linyimin.plugin.dom.Constant;
 import io.github.linyimin.plugin.utils.JavaUtils;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 
 import java.io.File;
-import java.lang.reflect.Field;
+import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.*;
@@ -31,7 +29,7 @@ public class MybatisPojoCompile {
 
     // TODO: 需要优化成只编译Mybatis需要的类
 
-    public static UrlClassLoader classLoader;
+    public static ProjectLoader classLoader;
     public static List<String> preDependencies;
 
     public static void compile(Project project) {
@@ -47,15 +45,7 @@ public static void setClassLoader(Project project) {
 
         List<String> dependencies = getProjectDependencies(project);
 
-        List<URL> urls = new ArrayList<>();
-        for (String path : dependencies) {
-            try {
-                urls.add(new File(FileUtil.toSystemIndependentName(path)).toURI().toURL());
-            }
-            catch (MalformedURLException e) {
-                Messages.showErrorDialog(e.getMessage(), "MalformedURLException");
-            }
-        }
+        List<URL> urls = pathToURL(dependencies);
 
         if (Objects.nonNull(classLoader)) {
             changeLoaderUrls(preDependencies, dependencies);
@@ -65,6 +55,30 @@ public static void setClassLoader(Project project) {
         preDependencies = dependencies;
     }
 
+    private static List<URL> pathToURL(List<String> paths) {
+        List<URL> urls = new ArrayList<>();
+
+        try {
+            for (String path : paths) {
+                urls.add(new File(FileUtil.toSystemIndependentName(path)).toURI().toURL());
+            }
+
+            // 添加本地获取消息类
+            URL url = MybatisPojoCompile.class.getClassLoader().getResource("io/github/linyimin/plugin/utils/MybatisSqlUtils.class");
+            if (Objects.nonNull(url)) {
+                String fileName = MybatisPojoCompile.class.getClassLoader().getResource("io/github/linyimin/plugin/utils/MybatisSqlUtils.class").getFile();
+
+                fileName = StringUtils.substring(fileName, 0, fileName.indexOf("jar!") + 3);
+
+                urls.add(new URL(fileName));
+            }
+
+        } catch (MalformedURLException e) {
+            Messages.showErrorDialog(e.getMessage(), "MalformedURLException");
+        }
+
+        return urls;
+    }
     private static List<String> getProjectDependencies(Project project) {
 
         Set<String> mapperDependencies = JavaUtils.getAllDependenciesRecursive(project);
@@ -75,13 +89,7 @@ private static List<String> getProjectDependencies(Project project) {
                 .runtimeOnly()
                 .withoutSdk()
                 .getPathsList()
-                .getPathList()
-                .stream()
-                .filter(path -> path.contains(Constant.MYBATIS_LOGGING_LOG4J)
-                        || path.contains(Constant.MYBATIS_LOGGING_SLF4J)
-                        || isProjectModule(project, path))
-                .collect(Collectors.toList());
-
+                .getPathList();
 
         list.addAll(mapperDependencies);
 
@@ -99,49 +107,10 @@ private static boolean isProjectModule(Project project, String path) {
     }
 
     private static void createProjectLoader(List<URL> urls) {
-        classLoader = UrlClassLoader.build().urls(urls).parent(ClassLoader.getSystemClassLoader()).get();
-        attachPluginParentLoader(classLoader);
-    }
 
-    private static void attachPluginParentLoader(UrlClassLoader classLoader) {
-        PluginClassLoader pluginClassLoader = (PluginClassLoader) MybatisPojoCompile.class.getClassLoader();
-
-        Class<? extends PluginClassLoader> pluginClassLoaderClass = pluginClassLoader.getClass();
-
-        Field field = null;
-
-        try {
-            field = pluginClassLoaderClass.getDeclaredField(Constant.PLUGIN_CLASS_LOADER_PARENTS);
-        } catch (NoSuchFieldException ignored) {
-        }
-
-        try {
-            field = pluginClassLoaderClass.getDeclaredField(Constant.PLUGIN_CLASS_LOADER_MY_PARENTS);
-        } catch (NoSuchFieldException ignored) {
-        }
-
-        if (Objects.isNull(field)) {
-            Messages.showInfoMessage("Unsupported this version", Constant.APPLICATION_NAME);
-            return;
-        }
-
-        try {
-            field.setAccessible(true);
-
-            ClassLoader[] parents = (ClassLoader[]) field.get(pluginClassLoader);
-            if (Objects.isNull(parents)) {
-                parents = new ClassLoader[] {classLoader};
-                field.set(pluginClassLoader, parents);
-            } else {
-                ClassLoader[] newParents = new ClassLoader[parents.length + 1];
-                newParents[parents.length] = classLoader;
-                System.arraycopy(parents, 0, newParents, 0, parents.length);
-                field.set(pluginClassLoader, newParents);
-            }
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
+        URL[] urlArr = urls.toArray(new URL[0]);
 
+        classLoader = new ProjectLoader(urlArr, MybatisPojoCompile.class.getClassLoader());
     }
 
     private static void changeLoaderUrls(List<String> preDependencies, List<String> dependencies) {
@@ -156,15 +125,15 @@ private static void changeLoaderUrls(List<String> preDependencies, List<String>
             return;
         }
 
-        for (String path : list) {
-            try {
-                URL url = new File(FileUtil.toSystemIndependentName(path)).toURI().toURL();
-                classLoader.addURL(url);
-            }
-            catch (MalformedURLException e) {
-                Messages.showErrorDialog(e.getMessage(), "MalformedURLException");
-            }
+        try {
+            classLoader.close();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
         }
+
+        List<URL> urls = pathToURL(dependencies);
+        classLoader = new ProjectLoader(urls.toArray(new URL[0]), MybatisPojoCompile.class.getClassLoader());
+
     }
 
 }

src/main/java/io/github/linyimin/plugin/compile/ProjectLoader.java

@@ -0,0 +1,57 @@
+package io.github.linyimin.plugin.compile;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @author banzhe
+ * @date 2022/07/27 16:12
+ **/
+public class ProjectLoader extends URLClassLoader {
+
+
+    private final Map<String /* class qualifier */, Class<?> /*loaded class*/> loadedClassMap = new ConcurrentHashMap<>();
+
+
+    public ProjectLoader(URL[] urls, ClassLoader parent) {
+        super(urls, parent);
+    }
+
+    private Class<?> findLoadedClass0(String name) {
+        return loadedClassMap.get(name);
+    }
+
+    @Override
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+
+        Class<?> clazz = findLoadedClass0(name);
+
+        if (Objects.nonNull(clazz)) {
+            return clazz;
+        }
+
+        clazz = findLoadedClass(name);
+
+        if (Objects.nonNull(clazz)) {
+            return clazz;
+        }
+
+        try {
+            clazz = findClass(name);
+            if (Objects.nonNull(clazz)) {
+                if (resolve) {
+                    resolveClass(clazz);
+                }
+                loadedClassMap.put(name, clazz);
+                return clazz;
+            }
+        } catch (ClassNotFoundException | SecurityException ignored) {
+
+        }
+
+        return super.loadClass(name, resolve);
+    }
+}

src/main/java/io/github/linyimin/plugin/service/SqlParamGenerateService.java

@@ -18,10 +18,12 @@
 import io.github.linyimin.plugin.service.model.MybatisSqlConfiguration;
 import io.github.linyimin.plugin.utils.JavaUtils;
 import io.github.linyimin.plugin.utils.MapperDomUtils;
-import io.github.linyimin.plugin.utils.MybatisSqlUtils;
 import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang3.StringUtils;
+
+import java.lang.reflect.Method;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @author yiminlin
@@ -42,59 +44,65 @@ public String generateSql(Project project, String methodQualifiedName, String pa
             return StringUtils.EMPTY;
         }
 
-        String mybatisConfig = getMybatisConfiguration(project, psiMethods.get(0));
+        List<String> mybatisConfigs = getMybatisConfigurations(project, psiMethods.get(0));
 
-        boolean isNeedCompile = checkNeedCompile(mybatisConfig, methodQualifiedName, params);
+        boolean isNeedCompile = checkNeedCompile(mybatisConfigs, methodQualifiedName, params);
 
         if (isNeedCompile) {
             MybatisPojoCompile.compile(project);
         }
 
-        return MybatisSqlUtils.getSql(mybatisConfig, methodQualifiedName, params, false);
+        return getSql(mybatisConfigs, methodQualifiedName, params);
 
     }
 
-    private boolean checkNeedCompile(String mybatisConfig, String methodQualifiedName, String params) {
+    private boolean checkNeedCompile(List<String> mybatisConfigs, String methodQualifiedName, String params) {
         if (Objects.isNull(MybatisPojoCompile.classLoader)) {
-            return true;
+            return  true;
         }
 
         try {
-            MybatisSqlUtils.getSql(mybatisConfig, methodQualifiedName, params, true);
-        } catch (Exception | NoClassDefFoundError e) {
+            getSql(mybatisConfigs, methodQualifiedName, params);
+        } catch (Throwable e) {
             return true;
         }
 
         return false;
     }
 
-    private String getMybatisConfiguration(Project project, PsiMethod psiMethod) {
+    private List<String> getMybatisConfigurations(Project project, PsiMethod psiMethod) {
 
-        MybatisConfiguration mybatisConfiguration = MapperDomUtils.findConfiguration(project, psiMethod);
-        if (Objects.isNull(mybatisConfiguration)) {
+        List<MybatisConfiguration> mybatisConfigurations = MapperDomUtils.findConfiguration(project, psiMethod);
+        if (org.apache.commons.collections.CollectionUtils.isEmpty(mybatisConfigurations)) {
             Messages.showInfoMessage("Mybatis配置文件不存在", Constant.APPLICATION_NAME);
-            return StringUtils.EMPTY;
+            return Collections.emptyList();
         }
 
-        if (Objects.isNull(mybatisConfiguration.getParent().getXmlElement())) {
+        mybatisConfigurations = mybatisConfigurations.stream().filter(mybatisConfiguration -> Objects.nonNull(mybatisConfiguration.getParent().getXmlElement())).collect(Collectors.toList());
+
+        if (org.apache.commons.collections.CollectionUtils.isEmpty(mybatisConfigurations)) {
             Messages.showInfoMessage("Mybatis配置文件错误", Constant.APPLICATION_NAME);
-            return StringUtils.EMPTY;
+            return Collections.emptyList();
         }
 
-        String mybatisConfig = mybatisConfiguration.getParent().getXmlElement().getText();
+        return mybatisConfigurations.stream().map(mybatisConfiguration -> {
+            String mybatisConfig = mybatisConfiguration.getParent().getXmlElement().getText();
 
-        // 不处理plugins
-        XmlElement xmlElement = mybatisConfiguration.getXmlElement();
+            // 不处理plugins
+            XmlElement xmlElement = mybatisConfiguration.getXmlElement();
 
-        if (Objects.nonNull(xmlElement) && xmlElement instanceof XmlTag) {
-            XmlTag[] tags = ((XmlTag) xmlElement).findSubTags("plugins");
-            if (tags.length > 0) {
-                String plugins = tags[0].getText();
-                mybatisConfig = mybatisConfig.replace(plugins, StringUtils.EMPTY);
+            if (Objects.nonNull(xmlElement) && xmlElement instanceof XmlTag) {
+                XmlTag[] tags = ((XmlTag) xmlElement).findSubTags("plugins");
+                if (tags.length > 0) {
+                    String plugins = tags[0].getText();
+                    mybatisConfig = mybatisConfig.replace(plugins, StringUtils.EMPTY);
+                }
             }
-        }
 
-        return mybatisConfig;
+            return mybatisConfig;
+        }).collect(Collectors.toList());
+
+
     }
 
 
@@ -179,7 +187,7 @@ private String parseParamNameTypeList(List<ParamNameType> paramNameTypes) {
 
             // 数组或者列表
             if (isArray(type)) {
-               param.put(name, Lists.newArrayList(param.get(name)));
+                param.put(name, Lists.newArrayList(param.get(name)));
             }
 
             params.putAll(param);
@@ -369,4 +377,32 @@ public ParamNameType(String name, PsiClass psiClass, PsiType psiType, boolean is
         }
     }
 
+    private String getSql(List<String> mybatisConfigurations, String qualifiedMethod, String params) {
+
+        ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader();
+
+        try {
+            Thread.currentThread().setContextClassLoader(MybatisPojoCompile.classLoader);
+            Class<?> clazz = MybatisPojoCompile.classLoader.loadClass("io.github.linyimin.plugin.utils.MybatisSqlUtils");
+            Object object = clazz.newInstance();
+            Method method = clazz.getDeclaredMethod("getSql", String.class, String.class, String.class);
+
+            int length = mybatisConfigurations.size();
+            for (int i = 0; i < length - 1; i++) {
+                try {
+                    return (String) method.invoke(object, mybatisConfigurations.get(i), qualifiedMethod, params);
+                } catch (Throwable ignored) {
+
+                }
+            }
+
+            return (String) method.invoke(object, mybatisConfigurations.get(length - 1), qualifiedMethod, params);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            Thread.currentThread().setContextClassLoader(currentClassLoader);
+        }
+
+    }
+
 }

src/main/java/io/github/linyimin/plugin/utils/JavaUtils.java

@@ -153,6 +153,7 @@ public static Set<String> getAllDependenciesRecursive(Project project) {
         List<PsiClass> psiClassList = namespaces
                 .stream()
                 .map(namespace -> JavaUtils.findClazz(project, namespace))
+                .filter(Objects::nonNull)
                 .collect(Collectors.toList());
 
         Set<PsiClass> allDependencies = new HashSet<>();