mirror of
https://github.com/plexusorg/Plex.git
synced 2025-07-03 08:26:42 +00:00
Move Plex to API-driven plugin and fix NoClassDefFoundError on startup
This commit is contained in:
Focusvity
152
server/src/main/java/dev/plex/module/ModuleManager.java
Normal file
152
server/src/main/java/dev/plex/module/ModuleManager.java
Normal file
@ -0,0 +1,152 @@
|
||||
package dev.plex.module;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import dev.plex.Plex;
|
||||
import dev.plex.module.exception.ModuleLoadException;
|
||||
import dev.plex.module.loader.LibraryLoader;
|
||||
import dev.plex.util.PlexLog;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import lombok.Getter;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.bukkit.configuration.file.YamlConfiguration;
|
||||
|
||||
@Getter
|
||||
public class ModuleManager
|
||||
{
|
||||
|
||||
private final List<PlexModule> modules = Lists.newArrayList();
|
||||
private final LibraryLoader libraryLoader;
|
||||
|
||||
public ModuleManager()
|
||||
{
|
||||
this.libraryLoader = new LibraryLoader(Plex.get().getLogger());
|
||||
}
|
||||
|
||||
public void loadAllModules()
|
||||
{
|
||||
this.modules.clear();
|
||||
PlexLog.debug(String.valueOf(Plex.get().getModulesFolder().listFiles().length));
|
||||
Arrays.stream(Plex.get().getModulesFolder().listFiles()).forEach(file ->
|
||||
{
|
||||
if (file.getName().endsWith(".jar"))
|
||||
{
|
||||
try
|
||||
{
|
||||
URLClassLoader loader = new URLClassLoader(
|
||||
new URL[]{file.toURI().toURL()},
|
||||
Plex.class.getClassLoader()
|
||||
);
|
||||
|
||||
InputStreamReader internalModuleFile = new InputStreamReader(loader.getResourceAsStream("module.yml"), StandardCharsets.UTF_8);
|
||||
YamlConfiguration internalModuleConfig = YamlConfiguration.loadConfiguration(internalModuleFile);
|
||||
|
||||
String name = internalModuleConfig.getString("name");
|
||||
if (name == null)
|
||||
{
|
||||
throw new ModuleLoadException("Plex module name can't be null!");
|
||||
}
|
||||
|
||||
String main = internalModuleConfig.getString("main");
|
||||
if (main == null)
|
||||
{
|
||||
throw new ModuleLoadException("Plex module main class can't be null!");
|
||||
}
|
||||
|
||||
String description = internalModuleConfig.getString("description", "A Plex module");
|
||||
String version = internalModuleConfig.getString("version", "1.0");
|
||||
List<String> libraries = internalModuleConfig.getStringList("libraries");
|
||||
|
||||
PlexModuleFile plexModuleFile = new PlexModuleFile(name, main, description, version);
|
||||
plexModuleFile.setLibraries(libraries);
|
||||
Class<? extends PlexModule> module = (Class<? extends PlexModule>)Class.forName(main, true, loader);
|
||||
|
||||
PlexModule plexModule = module.getConstructor().newInstance();
|
||||
plexModule.setPlex(Plex.get());
|
||||
plexModule.setPlexModuleFile(plexModuleFile);
|
||||
|
||||
plexModule.setDataFolder(new File(Plex.get().getModulesFolder() + File.separator + plexModuleFile.getName()));
|
||||
if (!plexModule.getDataFolder().exists())
|
||||
{
|
||||
plexModule.getDataFolder().mkdir();
|
||||
}
|
||||
|
||||
plexModule.setLogger(LogManager.getLogger(plexModuleFile.getName()));
|
||||
modules.add(plexModule);
|
||||
}
|
||||
catch (MalformedURLException | ClassNotFoundException | InvocationTargetException |
|
||||
InstantiationException | IllegalAccessException | NoSuchMethodException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void loadModules()
|
||||
{
|
||||
this.modules.forEach(module ->
|
||||
{
|
||||
PlexLog.log("Loading module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
|
||||
module.load();
|
||||
// this.libraryLoader.createLoader(module, module.getPlexModuleFile());
|
||||
});
|
||||
}
|
||||
|
||||
public void enableModules()
|
||||
{
|
||||
this.modules.forEach(module ->
|
||||
{
|
||||
PlexLog.log("Enabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
|
||||
module.enable();
|
||||
});
|
||||
}
|
||||
|
||||
public void disableModules()
|
||||
{
|
||||
this.modules.forEach(module ->
|
||||
{
|
||||
PlexLog.log("Disabling module " + module.getPlexModuleFile().getName() + " with version " + module.getPlexModuleFile().getVersion());
|
||||
module.getCommands().stream().toList().forEach(plexCommand ->
|
||||
{
|
||||
module.unregisterCommand(plexCommand);
|
||||
Plex.get().getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
|
||||
plexCommand.getAliases().forEach(alias -> Plex.get().getServer().getCommandMap().getKnownCommands().remove(alias));
|
||||
});
|
||||
module.getListeners().stream().toList().forEach(module::unregisterListener);
|
||||
module.disable();
|
||||
});
|
||||
}
|
||||
|
||||
public void unloadModules()
|
||||
{
|
||||
this.disableModules();
|
||||
this.modules.forEach(module ->
|
||||
{
|
||||
try
|
||||
{
|
||||
((URLClassLoader)module.getClass().getClassLoader()).close();
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void reloadModules()
|
||||
{
|
||||
unloadModules();
|
||||
loadAllModules();
|
||||
loadModules();
|
||||
enableModules();
|
||||
}
|
||||
}
|
||||
95
server/src/main/java/dev/plex/module/PlexModule.java
Normal file
95
server/src/main/java/dev/plex/module/PlexModule.java
Normal file
@ -0,0 +1,95 @@
|
||||
package dev.plex.module;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import dev.plex.Plex;
|
||||
import dev.plex.command.PlexCommand;
|
||||
import dev.plex.listener.PlexListener;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.URL;
|
||||
import java.net.URLConnection;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import lombok.AccessLevel;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.bukkit.event.HandlerList;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
@Getter
|
||||
@Setter(AccessLevel.MODULE)
|
||||
public abstract class PlexModule
|
||||
{
|
||||
@Getter(AccessLevel.MODULE)
|
||||
private final List<PlexCommand> commands = Lists.newArrayList();
|
||||
|
||||
@Getter(AccessLevel.MODULE)
|
||||
private final List<PlexListener> listeners = Lists.newArrayList();
|
||||
|
||||
private Plex plex;
|
||||
private PlexModuleFile plexModuleFile;
|
||||
private File dataFolder;
|
||||
private Logger logger;
|
||||
|
||||
public void load()
|
||||
{
|
||||
}
|
||||
|
||||
public void enable()
|
||||
{
|
||||
}
|
||||
|
||||
public void disable()
|
||||
{
|
||||
}
|
||||
|
||||
public void registerListener(PlexListener listener)
|
||||
{
|
||||
listeners.add(listener);
|
||||
}
|
||||
|
||||
public void unregisterListener(PlexListener listener)
|
||||
{
|
||||
listeners.remove(listener);
|
||||
HandlerList.unregisterAll(listener);
|
||||
}
|
||||
|
||||
public void registerCommand(PlexCommand command)
|
||||
{
|
||||
commands.add(command);
|
||||
}
|
||||
|
||||
public void unregisterCommand(PlexCommand command)
|
||||
{
|
||||
commands.remove(command);
|
||||
}
|
||||
|
||||
public PlexCommand getCommand(String name)
|
||||
{
|
||||
return commands.stream().filter(plexCommand -> plexCommand.getName().equalsIgnoreCase(name) || plexCommand.getAliases().stream().map(String::toLowerCase).toList().contains(name.toLowerCase(Locale.ROOT))).findFirst().orElse(null);
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public InputStream getResource(@NotNull String filename)
|
||||
{
|
||||
try
|
||||
{
|
||||
URL url = this.getClass().getClassLoader().getResource(filename);
|
||||
if (url == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
URLConnection connection = url.openConnection();
|
||||
connection.setUseCaches(false);
|
||||
return connection.getInputStream();
|
||||
}
|
||||
catch (IOException ex)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
17
server/src/main/java/dev/plex/module/PlexModuleFile.java
Normal file
17
server/src/main/java/dev/plex/module/PlexModuleFile.java
Normal file
@ -0,0 +1,17 @@
|
||||
package dev.plex.module;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import java.util.List;
|
||||
import lombok.Data;
|
||||
|
||||
@Data
|
||||
public class PlexModuleFile
|
||||
{
|
||||
private final String name;
|
||||
private final String main;
|
||||
private final String description;
|
||||
private final String version;
|
||||
|
||||
//TODO: does not work
|
||||
private List<String> libraries = ImmutableList.of();
|
||||
}
|
||||
@ -0,0 +1,10 @@
|
||||
package dev.plex.module.exception;
|
||||
|
||||
public class ModuleLoadException extends RuntimeException
|
||||
{
|
||||
public ModuleLoadException(String s)
|
||||
{
|
||||
super(s);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,70 @@
|
||||
package dev.plex.module.loader;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
|
||||
public class CustomClassLoader extends URLClassLoader
|
||||
{
|
||||
/*public CustomClassLoader(URL[] urls, ClassLoader parent) {
|
||||
super(urls, parent);
|
||||
for (URL url : urls) {
|
||||
super.addURL(url);
|
||||
}
|
||||
}*/
|
||||
|
||||
public CustomClassLoader(URL jarInJar, ClassLoader parent)
|
||||
{
|
||||
super(new URL[]{extractJar(jarInJar)}, parent);
|
||||
addURL(jarInJar);
|
||||
}
|
||||
|
||||
|
||||
static URL extractJar(URL jarInJar) throws RuntimeException
|
||||
{
|
||||
// get the jar-in-jar resource
|
||||
if (jarInJar == null)
|
||||
{
|
||||
throw new RuntimeException("Could not locate jar-in-jar");
|
||||
}
|
||||
|
||||
// create a temporary file
|
||||
// on posix systems by default this is only read/writable by the process owner
|
||||
Path path;
|
||||
try
|
||||
{
|
||||
path = Files.createTempFile("plex-jarinjar", ".jar.tmp");
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
throw new RuntimeException("Unable to create a temporary file", e);
|
||||
}
|
||||
|
||||
// mark that the file should be deleted on exit
|
||||
path.toFile().deleteOnExit();
|
||||
|
||||
// copy the jar-in-jar to the temporary file path
|
||||
try (InputStream in = jarInJar.openStream())
|
||||
{
|
||||
Files.copy(in, path, StandardCopyOption.REPLACE_EXISTING);
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
throw new RuntimeException("Unable to copy jar-in-jar to temporary path", e);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return path.toUri().toURL();
|
||||
}
|
||||
catch (MalformedURLException e)
|
||||
{
|
||||
throw new RuntimeException("Unable to get URL from path", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
265
server/src/main/java/dev/plex/module/loader/LibraryLoader.java
Normal file
265
server/src/main/java/dev/plex/module/loader/LibraryLoader.java
Normal file
@ -0,0 +1,265 @@
|
||||
package dev.plex.module.loader;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import dev.plex.Plex;
|
||||
import dev.plex.module.PlexModule;
|
||||
import dev.plex.module.PlexModuleFile;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.net.JarURLConnection;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Enumeration;
|
||||
import java.util.List;
|
||||
import java.util.jar.JarEntry;
|
||||
import java.util.jar.JarFile;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
|
||||
import org.eclipse.aether.DefaultRepositorySystemSession;
|
||||
import org.eclipse.aether.RepositorySystem;
|
||||
import org.eclipse.aether.artifact.Artifact;
|
||||
import org.eclipse.aether.artifact.DefaultArtifact;
|
||||
import org.eclipse.aether.collection.CollectRequest;
|
||||
import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
|
||||
import org.eclipse.aether.graph.Dependency;
|
||||
import org.eclipse.aether.impl.DefaultServiceLocator;
|
||||
import org.eclipse.aether.repository.LocalRepository;
|
||||
import org.eclipse.aether.repository.RemoteRepository;
|
||||
import org.eclipse.aether.repository.RepositoryPolicy;
|
||||
import org.eclipse.aether.resolution.ArtifactResult;
|
||||
import org.eclipse.aether.resolution.DependencyRequest;
|
||||
import org.eclipse.aether.resolution.DependencyResolutionException;
|
||||
import org.eclipse.aether.resolution.DependencyResult;
|
||||
import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
|
||||
import org.eclipse.aether.spi.connector.transport.TransporterFactory;
|
||||
import org.eclipse.aether.transfer.AbstractTransferListener;
|
||||
import org.eclipse.aether.transfer.TransferCancelledException;
|
||||
import org.eclipse.aether.transfer.TransferEvent;
|
||||
import org.eclipse.aether.transport.http.HttpTransporterFactory;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
//TODO: doesn't work
|
||||
|
||||
public class LibraryLoader
|
||||
{
|
||||
private final Logger logger;
|
||||
private final RepositorySystem repository;
|
||||
private final DefaultRepositorySystemSession session;
|
||||
private final List<RemoteRepository> repositories;
|
||||
|
||||
public LibraryLoader(@NotNull Logger logger)
|
||||
{
|
||||
this.logger = logger;
|
||||
|
||||
DefaultServiceLocator locator = MavenRepositorySystemUtils.newServiceLocator();
|
||||
locator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
|
||||
locator.addService(TransporterFactory.class, HttpTransporterFactory.class);
|
||||
|
||||
this.repository = locator.getService(RepositorySystem.class);
|
||||
this.session = MavenRepositorySystemUtils.newSession();
|
||||
|
||||
session.setChecksumPolicy(RepositoryPolicy.CHECKSUM_POLICY_FAIL);
|
||||
session.setLocalRepositoryManager(repository.newLocalRepositoryManager(session, new LocalRepository("libraries")));
|
||||
session.setTransferListener(new AbstractTransferListener()
|
||||
{
|
||||
@Override
|
||||
public void transferStarted(@NotNull TransferEvent event) throws TransferCancelledException
|
||||
{
|
||||
logger.log(Level.INFO, "Downloading {0}", event.getResource().getRepositoryUrl() + event.getResource().getResourceName());
|
||||
}
|
||||
});
|
||||
session.setReadOnly();
|
||||
|
||||
this.repositories = repository.newResolutionRepositories(session, Arrays.asList(new RemoteRepository.Builder("central", "default", "https://repo.maven.apache.org/maven2").build()));
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public ClassLoader createLoader(@NotNull PlexModule module, @NotNull PlexModuleFile moduleFile)
|
||||
{
|
||||
if (moduleFile.getLibraries().isEmpty())
|
||||
{
|
||||
return null;
|
||||
}
|
||||
logger.log(Level.INFO, "Loading libraries for {0}", new Object[]{moduleFile.getName()});
|
||||
logger.log(Level.INFO, "[{0}] Loading {1} libraries... please wait", new Object[]
|
||||
{
|
||||
moduleFile.getName(), moduleFile.getLibraries().size()
|
||||
});
|
||||
|
||||
List<Dependency> dependencies = new ArrayList<>();
|
||||
List<Class<?>> classes = Lists.newArrayList();
|
||||
List<File> files = Lists.newArrayList();
|
||||
for (String library : moduleFile.getLibraries())
|
||||
{
|
||||
Artifact artifact = new DefaultArtifact(library);
|
||||
Dependency dependency = new Dependency(artifact, null);
|
||||
|
||||
dependencies.add(dependency);
|
||||
}
|
||||
|
||||
DependencyResult result;
|
||||
try
|
||||
{
|
||||
result = repository.resolveDependencies(session, new DependencyRequest(new CollectRequest((Dependency)null, dependencies, repositories), null));
|
||||
}
|
||||
catch (DependencyResolutionException ex)
|
||||
{
|
||||
throw new RuntimeException("Error resolving libraries", ex);
|
||||
}
|
||||
|
||||
List<URL> jarFiles = new ArrayList<>();
|
||||
for (ArtifactResult artifact : result.getArtifactResults())
|
||||
{
|
||||
File file = artifact.getArtifact().getFile();
|
||||
files.add(file);
|
||||
URL url;
|
||||
try
|
||||
{
|
||||
url = file.toURI().toURL();
|
||||
}
|
||||
catch (MalformedURLException ex)
|
||||
{
|
||||
throw new AssertionError(ex);
|
||||
}
|
||||
|
||||
jarFiles.add(url);
|
||||
logger.log(Level.INFO, "[{0}] Loaded library {1}", new Object[]
|
||||
{
|
||||
moduleFile.getName(), file
|
||||
});
|
||||
}
|
||||
|
||||
/*List<URL> jarFiles = Lists.newArrayList();
|
||||
List<Artifact> artifacts = Lists.newArrayList();
|
||||
|
||||
|
||||
List<Class<?>> classes = new ArrayList<>();
|
||||
|
||||
for (String library : moduleFile.getLibraries()) {
|
||||
Artifact artifact = new DefaultArtifact(library);
|
||||
ArtifactRequest request = new ArtifactRequest();
|
||||
request.setArtifact(artifact);
|
||||
request.addRepository(this.repositories.get(0));
|
||||
try {
|
||||
ArtifactResult result = this.repository.resolveArtifact(this.session, request);
|
||||
artifact = result.getArtifact();
|
||||
jarFiles.add(artifact.getFile().toURI().toURL());
|
||||
logger.log(Level.INFO, "Loaded library {0} for {1}", new Object[]{
|
||||
artifact.getFile().toURI().toURL().toString(),
|
||||
moduleFile.getName()
|
||||
});
|
||||
artifacts.add(artifact);
|
||||
} catch (ArtifactResolutionException | MalformedURLException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
}*/
|
||||
logger.log(Level.INFO, "Loaded {0} libraries for {1}", new Object[]{jarFiles.size(), moduleFile.getName()});
|
||||
|
||||
// jarFiles.forEach(jar -> new CustomClassLoader(jar, Plex.class.getClassLoader()));
|
||||
// jarFiles.forEach(jar -> new CustomClassLoader(jar, Plex.class.getClassLoader()));
|
||||
|
||||
/*URLClassLoader loader = new URLClassLoader(jarFiles.toArray(URL[]::new), Plex.class.getClassLoader());
|
||||
|
||||
dependencies.forEach(artifact -> {
|
||||
ArrayList<String> classNames;
|
||||
try {
|
||||
classNames = getClassNamesFromJar(new JarFile(artifact.getArtifact().getFile()));
|
||||
for (String className : classNames) {
|
||||
Class<?> classToLoad = Class.forName(className, true, loader);
|
||||
classes.add(classToLoad);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
|
||||
classes.forEach(clazz -> logger.log(Level.INFO, "Loading class {0}", new Object[]{clazz.getName()}));*/
|
||||
jarFiles.forEach(url ->
|
||||
{
|
||||
JarURLConnection connection;
|
||||
try
|
||||
{
|
||||
URL url2 = new URL("jar:" + url.toString() + "!/");
|
||||
/*
|
||||
connection = (JarURLConnection) url2.openConnection();
|
||||
logger.log(Level.INFO, "Jar File: " + connection.getJarFileURL().toString());*/
|
||||
}
|
||||
catch (IOException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
return new URLClassLoader(files.stream().map(File::toURI).map(uri ->
|
||||
{
|
||||
try
|
||||
{
|
||||
return uri.toURL();
|
||||
}
|
||||
catch (MalformedURLException e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}).toList().toArray(URL[]::new)/*jarFiles.stream().map(url -> {
|
||||
try {
|
||||
return new URL("jar:" + url.toString() + "!/");
|
||||
} catch (MalformedURLException e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}).toList().toArray(URL[]::new)*/, Plex.class.getClassLoader())/*new CustomClassLoader(jarFiles.toArray(URL[]::new), Plex.class.getClassLoader())*/;
|
||||
}
|
||||
|
||||
/*public List<Class<?>> loadDependency(List<Path> paths) throws Exception {
|
||||
|
||||
List<Class<?>> classes = new ArrayList<>();
|
||||
|
||||
for (Path path : paths) {
|
||||
|
||||
URL url = path.toUri().toURL();
|
||||
URLClassLoader child = new URLClassLoader(new URL[]{url}, this.getClass().getClassLoader());
|
||||
|
||||
ArrayList<String> classNames = getClassNamesFromJar(path.toString());
|
||||
|
||||
for (String className : classNames) {
|
||||
Class classToLoad = Class.forName(className, true, child);
|
||||
classes.add(classToLoad);
|
||||
}
|
||||
}
|
||||
|
||||
return classes;
|
||||
}*/
|
||||
|
||||
|
||||
private ArrayList<String> getClassNamesFromJar(JarFile file) throws Exception
|
||||
{
|
||||
ArrayList<String> classNames = new ArrayList<>();
|
||||
try
|
||||
{
|
||||
//Iterate through the contents of the jar file
|
||||
Enumeration<JarEntry> entries = file.entries();
|
||||
while (entries.hasMoreElements())
|
||||
{
|
||||
JarEntry entry = entries.nextElement();
|
||||
//Pick file that has the extension of .class
|
||||
if ((entry.getName().endsWith(".class")))
|
||||
{
|
||||
String className = entry.getName().replaceAll("/", "\\.");
|
||||
String myClass = className.substring(0, className.lastIndexOf('.'));
|
||||
classNames.add(myClass);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new Exception("Error while getting class names from jar", e);
|
||||
}
|
||||
return classNames;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user