Динамическая загрузка JAR файлов: 5 методов для Java-разработчиков

import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class JarLoader {
public static void main(String[] args) {
try {
// Путь к JAR-файлу
File file = new File("path/to/external-module.jar");

// Создаем URL из файла
URL jarUrl = file.toURI().toURL();

// Создаем новый URLClassLoader
URLClassLoader classLoader = new URLClassLoader(new URL[]{jarUrl}, JarLoader.class.getClassLoader());

// Загружаем класс из JAR
Class<?> loadedClass = classLoader.loadClass("com.example.ExternalService");

// Создаем экземпляр загруженного класса
Object instance = loadedClass.getDeclaredConstructor().newInstance();

// Находим метод в загруженном классе
Method method = loadedClass.getMethod("processData", String.class);

// Вызываем метод
String result = (String) method.invoke(instance, "Test input data");

System.out.println("Result: " + result);

// Закрываем ClassLoader, когда он больше не нужен
classLoader.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashMap;
import java.util.Map;

public class HotSwappableClassLoader extends URLClassLoader {

// Идентификатор модуля
private final String moduleId;

// Версия модуля
private final String version;

public HotSwappableClassLoader(String moduleId, String version, URL[] urls, ClassLoader parent) {
super(urls, parent);
this.moduleId = moduleId;
this.version = version;
}

public String getModuleId() {
return moduleId;
}

public String getVersion() {
return version;
}
}

class ModuleManager {
// Хранилище загруженных модулей: moduleId -> ClassLoader
private Map<String, HotSwappableClassLoader> modules = new HashMap<>();

// Загрузить или обновить модуль
public void loadModule(String moduleId, String version, File jarFile) throws Exception {
URL jarUrl = jarFile.toURI().toURL();

// Создаем новый ClassLoader для модуля
HotSwappableClassLoader newLoader = new HotSwappableClassLoader(
moduleId, 
version, 
new URL[] { jarUrl }, 
this.getClass().getClassLoader()
);

// Если у нас уже есть такой модуль, закрываем его ClassLoader
HotSwappableClassLoader oldLoader = modules.get(moduleId);
if (oldLoader != null) {
try {
oldLoader.close(); // Закрываем старый ClassLoader, освобождая ресурсы
} catch (Exception e) {
System.err.println("Error closing old class loader: " + e.getMessage());
}
}

// Сохраняем новый ClassLoader в хранилище
modules.put(moduleId, newLoader);
System.out.println("Module " + moduleId + " version " + version + " loaded successfully");
}

// Получить экземпляр класса из модуля
public Object getModuleInstance(String moduleId, String className) throws Exception {
HotSwappableClassLoader loader = modules.get(moduleId);
if (loader == null) {
throw new IllegalStateException("Module " + moduleId + " is not loaded");
}

Class<?> clazz = loader.loadClass(className);
return clazz.getDeclaredConstructor().newInstance();
}

// Выгрузить модуль
public void unloadModule(String moduleId) {
HotSwappableClassLoader loader = modules.remove(moduleId);
if (loader != null) {
try {
loader.close();
System.out.println("Module " + moduleId + " unloaded successfully");
} catch (Exception e) {
System.err.println("Error unloading module " + moduleId + ": " + e.getMessage());
}
}
}
}

public class HotSwapDemo {
public static void main(String[] args) {
try {
ModuleManager manager = new ModuleManager();

// Загружаем первую версию модуля
manager.loadModule("reporting", "1.0", new File("path/to/reporting-v1.jar"));

// Используем модуль
Object reportGenerator = manager.getModuleInstance("reporting", "com.example.ReportGenerator");
// Работаем с загруженным модулем...

// Обнаружено обновление, загружаем новую версию
manager.loadModule("reporting", "1.1", new File("path/to/reporting-v1.1.jar"));

// Получаем новую версию модуля
Object updatedGenerator = manager.getModuleInstance("reporting", "com.example.ReportGenerator");
// Работаем с обновленной версией...

// По окончании работы выгружаем модуль
manager.unloadModule("reporting");

} catch (Exception e) {
e.printStackTrace();
}
}
}

import java.io.File;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

// Аннотация для маркировки плагинов
@Retention(RetentionPolicy.RUNTIME)
@interface Plugin {
String name();
String version();
String[] dependencies() default {};
}

// Интерфейс для всех плагинов
interface PluginService {
void initialize(Map<String, Object> context);
void execute();
void shutdown();
}

public class PluginManager {
private final Map<String, Class<?>> pluginClasses = new HashMap<>();
private final Map<String, Object> pluginInstances = new HashMap<>();
private final Map<String, Object> sharedContext = new HashMap<>();

// Сканирует директорию на наличие JAR-файлов и загружает плагины
public void scanAndLoadPlugins(String directory) throws Exception {
File pluginDir = new File(directory);
if (!pluginDir.exists() || !pluginDir.isDirectory()) {
throw new IllegalArgumentException("Invalid plugins directory: " + directory);
}

File[] jarFiles = pluginDir.listFiles((dir, name) -> name.endsWith(".jar"));
if (jarFiles == null) {
return;
}

for (File jarFile : jarFiles) {
loadPluginsFromJar(jarFile);
}
}

// Загружает плагины из JAR-файла
private void loadPluginsFromJar(File jarFile) throws Exception {
URL jarUrl = jarFile.toURI().toURL();
URLClassLoader classLoader = new URLClassLoader(new URL[]{jarUrl}, getClass().getClassLoader());

try (JarFile jar = new JarFile(jarFile)) {
// Ищем классы с аннотацией @Plugin
jar.stream()
.filter(entry -> !entry.isDirectory() && entry.getName().endsWith(".class"))
.forEach(entry -> {
try {
String className = entry.getName()
.replace('/', '.')
.replace(".class", "");

Class<?> loadedClass = classLoader.loadClass(className);

if (loadedClass.isAnnotationPresent(Plugin.class) && 
PluginService.class.isAssignableFrom(loadedClass)) {

Plugin pluginAnnotation = loadedClass.getAnnotation(Plugin.class);
String pluginName = pluginAnnotation.name();

System.out.println("Found plugin: " + pluginName + " v" + pluginAnnotation.version());
pluginClasses.put(pluginName, loadedClass);
}
} catch (Exception e) {
System.err.println("Error processing entry " + entry.getName() + ": " + e.getMessage());
}
});
}
}

// Инициализирует плагины, учитывая зависимости
public void initializePlugins() {
// Сначала определяем порядок загрузки с учетом зависимостей
List<String> loadOrder = determineLoadOrder();

// Инициализируем плагины в правильном порядке
for (String pluginName : loadOrder) {
try {
Class<?> pluginClass = pluginClasses.get(pluginName);
Object instance = pluginClass.getDeclaredConstructor().newInstance();

// Сохраняем экземпляр плагина
pluginInstances.put(pluginName, instance);

// Вызываем метод инициализации
Method initMethod = pluginClass.getMethod("initialize", Map.class);
initMethod.invoke(instance, sharedContext);

System.out.println("Initialized plugin: " + pluginName);
} catch (Exception e) {
System.err.println("Failed to initialize plugin " + pluginName + ": " + e.getMessage());
}
}
}

// Определяет порядок загрузки плагинов с учетом зависимостей
private List<String> determineLoadOrder() {
// Здесь должен быть алгоритм топологической сортировки
// для простоты вернем список всех плагинов
return new ArrayList<>(pluginClasses.keySet());
}

// Выполняет все загруженные плагины
public void executePlugins() {
for (Map.Entry<String, Object> entry : pluginInstances.entrySet()) {
String pluginName = entry.getKey();
Object instance = entry.getValue();

try {
Method executeMethod = instance.getClass().getMethod("execute");
executeMethod.invoke(instance);
System.out.println("Executed plugin: " + pluginName);
} catch (Exception e) {
System.err.println("Error executing plugin " + pluginName + ": " + e.getMessage());
}
}
}

// Корректно останавливает все плагины
public void shutdownPlugins() {
// Останавливаем в обратном порядке
List<String> loadOrder = determineLoadOrder();
for (int i = loadOrder.size() – 1; i >= 0; i--) {
String pluginName = loadOrder.get(i);
Object instance = pluginInstances.get(pluginName);

try {
Method shutdownMethod = instance.getClass().getMethod("shutdown");
shutdownMethod.invoke(instance);
System.out.println("Shutdown plugin: " + pluginName);
} catch (Exception e) {
System.err.println("Error shutting down plugin " + pluginName + ": " + e.getMessage());
}
}
pluginInstances.clear();
}
}

public class PluginSystemDemo {
public static void main(String[] args) {
try {
PluginManager manager = new PluginManager();

// Загружаем плагины из директории
manager.scanAndLoadPlugins("./plugins");

// Инициализируем плагины
manager.initializePlugins();

// Выполняем плагины
manager.executePlugins();

// При завершении работы приложения
manager.shutdownPlugins();

} catch (Exception e) {
e.printStackTrace();
}
}
}

@Plugin(name = "DataProcessor", version = "1.2", dependencies = {"Logger"})
public class DataProcessorPlugin implements PluginService {
private Map<String, Object> context;

@Override
public void initialize(Map<String, Object> context) {
this.context = context;
// Регистрируем свои сервисы в контексте
context.put("dataProcessor", this);
System.out.println("DataProcessor plugin initialized");
}

@Override
public void execute() {
// Используем зависимости из контекста
System.out.println("Processing data...");
}

@Override
public void shutdown() {
// Освобождаем ресурсы
System.out.println("DataProcessor plugin shutdown");
}

// Специфичные методы плагина
public void processData(byte[] data) {
// Логика обработки данных
}
}

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

// API плагина (должен быть доступен как плагинам, так и основному приложению)
interface Plugin {
String getId();
String getVersion();
void start();
void stop();
}

// Менеджер плагинов — центральный компонент архитектуры
public class IsolatedPluginManager {
private final Map<String, PluginInfo> loadedPlugins = new ConcurrentHashMap<>();
private final File pluginsDirectory;
private final ClassLoader parentClassLoader;

// Класс для хранения информации о загруженном плагине
private static class PluginInfo {
final String id;
final String version;
final IsolatedClassLoader classLoader;
final Plugin instance;
final Set<String> dependencies;
boolean started;

PluginInfo(String id, String version, IsolatedClassLoader classLoader, 
Plugin instance, Set<String> dependencies) {
this.id = id;
this.version = version;
this.classLoader = classLoader;
this.instance = instance;
this.dependencies = dependencies;
this.started = false;
}
}

// Собственный ClassLoader с изоляцией
private static class IsolatedClassLoader extends URLClassLoader {
private final Set<String> exportedPackages;
private final ClassLoader parent;

public IsolatedClassLoader(URL[] urls, ClassLoader parent, Set<String> exportedPackages) {
super(urls, null); // parent = null для полной изоляции
this.parent = parent;
this.exportedPackages = exportedPackages;
}

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
// Проверяем, не находится ли класс в пакетах, которые должны быть загружены родительским загрузчиком
for (String exportedPackage : exportedPackages) {
if (name.startsWith(exportedPackage)) {
return parent.loadClass(name);
}
}

// Пытаемся загрузить класс самостоятельно
try {
// Сначала проверяем, не загружен ли класс уже
Class<?> loadedClass = findLoadedClass(name);
if (loadedClass != null) {
return loadedClass;
}

// Пытаемся загрузить класс из нашего JAR
return findClass(name);
} catch (ClassNotFoundException e) {
// Если класс не найден в нашем JAR, и это системный класс,
// делегируем загрузку родительскому загрузчику
if (name.startsWith("java.") || name.startsWith("javax.")) {
return parent.loadClass(name);
}
throw e;
}
}
}

public IsolatedPluginManager(File pluginsDirectory, ClassLoader parentClassLoader) {
this.pluginsDirectory = pluginsDirectory;
this.parentClassLoader = parentClassLoader;

// Убеждаемся, что директория существует
if (!pluginsDirectory.exists()) {
pluginsDirectory.mkdirs();
}
}

// Загружает все плагины из директории
public void loadPlugins() {
File[] jarFiles = pluginsDirectory.listFiles((dir, name) -> name.endsWith(".jar"));
if (jarFiles == null) {
return;
}

for (File jarFile : jarFiles) {
try {
loadPlugin(jarFile);
} catch (Exception e) {
System.err.println("Failed to load plugin from " + jarFile.getName() + ": " + e.getMessage());
}
}
}

// Загружает один плагин из JAR-файла
private void loadPlugin(File jarFile) throws Exception {
// Читаем манифест для получения метаданных плагина
JarFile jar = new JarFile(jarFile);
Manifest manifest = jar.getManifest();
Attributes attributes = manifest.getMainAttributes();

String pluginId = attributes.getValue("Plugin-Id");
String pluginVersion = attributes.getValue("Plugin-Version");
String pluginClass = attributes.getValue("Plugin-Class");
String dependenciesStr = attributes.getValue("Plugin-Dependencies");
String exportedPackagesStr = attributes.getValue("Exported-Packages");

if (pluginId == null || pluginClass == null) {
jar.close();
throw new IllegalArgumentException("Invalid plugin manifest");
}

// Парсим зависимости
Set<String> dependencies = new HashSet<>();
if (dependenciesStr != null && !dependenciesStr.isEmpty()) {
String[] deps = dependenciesStr.split(",");
for (String dep : deps) {
dependencies.add(dep.trim());
}
}

// Парсим экспортируемые пакеты
Set<String> exportedPackages = new HashSet<>();
exportedPackages.add("java.");
exportedPackages.add("javax.");
exportedPackages.add("com.example.pluginapi."); // Пакет с API для плагинов

if (exportedPackagesStr != null && !exportedPackagesStr.isEmpty()) {
String[] exports = exportedPackagesStr.split(",");
for (String export : exports) {
exportedPackages.add(export.trim());
}
}

// Создаем изолированный ClassLoader
URL jarUrl = jarFile.toURI().toURL();
IsolatedClassLoader classLoader = new IsolatedClassLoader(
new URL[] { jarUrl },
parentClassLoader,
exportedPackages
);

// Загружаем и инстанцируем главный класс плагина
Class<?> pluginClazz = classLoader.loadClass(pluginClass);
Plugin pluginInstance = (Plugin) pluginClazz.getDeclaredConstructor().newInstance();

// Проверяем совпадение ID из манифеста и из экземпляра
if (!pluginId.equals(pluginInstance.getId())) {
jar.close();
throw new IllegalStateException("Plugin ID mismatch");
}

// Сохраняем информацию о плагине
PluginInfo info = new PluginInfo(
pluginId,
pluginVersion,
classLoader,
pluginInstance,
dependencies
);

loadedPlugins.put(pluginId, info);
jar.close();

System.out.println("Loaded plugin: " + pluginId + " v" + pluginVersion);
}

// Запускает плагин и его зависимости
public void startPlugin(String pluginId) {
PluginInfo info = loadedPlugins.get(pluginId);
if (info == null) {
throw new IllegalArgumentException("Plugin not found: " + pluginId);
}

if (info.started) {
return; // Уже запущен
}

// Сначала запускаем зависимости
for (String dependencyId : info.dependencies) {
startPlugin(dependencyId);
}

// Запускаем сам плагин
try {
info.instance.start();
info.started = true;
System.out.println("Started plugin: " + pluginId);
} catch (Exception e) {
System.err.println("Failed to start plugin " + pluginId + ": " + e.getMessage());
}
}

// Останавливает плагин
public void stopPlugin(String pluginId) {
PluginInfo info = loadedPlugins.get(pluginId);
if (info == null || !info.started) {
return;
}

// Проверяем, не зависит ли какой-то запущенный плагин от этого
for (PluginInfo otherInfo : loadedPlugins.values()) {
if (otherInfo.started && otherInfo.dependencies.contains(pluginId)) {
stopPlugin(otherInfo.id); // Сначала останавливаем зависящий плагин
}
}

try {
info.instance.stop();
info.started = false;
System.out.println("Stopped plugin: " + pluginId);
} catch (Exception e) {
System.err.println("Failed to stop plugin " + pluginId + ": " + e.getMessage());
}
}

// Выгружает плагин полностью
public void unloadPlugin(String pluginId) {
PluginInfo info = loadedPlugins.get(pluginId);
if (info == null) {
return;
}

// Сначала останавливаем, если запущен
if (info.started) {
stopPlugin(pluginId);
}

try {
// Закрываем ClassLoader, освобождая ресурсы
info.classLoader.close();
loadedPlugins.remove(pluginId);
System.out.println("Unloaded plugin: " + pluginId);
} catch (Exception e) {
System.err.println("Failed to unload plugin " + pluginId + ": " + e.getMessage());
}
}

// Запускает все плагины в правильном порядке с учетом зависимостей
public void startAllPlugins() {
// Используем топологическую сортировку для определения порядка запуска
List<String> startOrder = getPluginStartOrder();
for (String pluginId : startOrder) {
startPlugin(pluginId);
}
}

// Определяет порядок запуска плагинов с учетом зависимостей
private List<String> getPluginStartOrder() {
// Упрощенная реализация топологической сортировки
Map<String, Boolean> visited = new HashMap<>();
List<String> startOrder = new ArrayList<>();

for (String pluginId : loadedPlugins.keySet()) {
if (!visited.getOrDefault(pluginId, false)) {
dfsTopologicalSort(pluginId, visited, startOrder);
}
}

Collections.reverse(startOrder);
return startOrder;
}

private void dfsTopologicalSort(String pluginId, Map<String, Boolean> visited, List<String> result) {
visited.put(pluginId, true);
PluginInfo info = loadedPlugins.get(pluginId);

if (info != null) {
for (String depId : info.dependencies) {
if (!visited.getOrDefault(depId, false)) {
dfsTopologicalSort(depId, visited, result);
}
}
}

result.add(pluginId);
}

// Останавливает и выгружает все плагины
public void shutdownAll() {
List<String> pluginIds = new ArrayList<>(loadedPlugins.keySet());
for (String pluginId : pluginIds) {
unloadPlugin(pluginId);
}
}
}

public class PluginSystemDemo {
public static void main(String[] args) {
try {
// Создаем менеджер плагинов
IsolatedPluginManager manager = new IsolatedPluginManager(
new File("./plugins"),
PluginSystemDemo.class.getClassLoader()
);

// Загружаем все плагины из директории
manager.loadPlugins();

// Запускаем все плагины в правильном порядке
manager.startAllPlugins();

// Здесь основная логика приложения
System.out.println("Application is running with plugins...");

// При необходимости можно выгрузить/загрузить отдельный плагин без остановки приложения
// manager.unloadPlugin("some-plugin-id");
// manager.loadPlugin(new File("./plugins/new-plugin.jar"));

// При завершении работы приложения
manager.shutdownAll();

} catch (Exception e) {
e.printStackTrace();
}
}
}

Manifest-Version: 1.0
Plugin-Id: data-processor
Plugin-Version: 1.0.0
Plugin-Class: com.example.plugins.DataProcessorPlugin
Plugin-Dependencies: logger,database-connector
Exported-Packages: com.example.plugins.dataprocessor.api