加载自定义插件

最新推荐文章于 2024-07-14 18:06:54 发布
转载 最新推荐文章于 2024-07-14 18:06:54 发布 · 789 阅读 · 1 

/**
 * 插件定义信息接口，包括以下信息：<br/>
 * <b>插件名称</b><br/>
 * <b>插件路径</b><br/>
 * <b>插件类型</b><br/>
 * <b>插件提供商</b><br/>
 * <b>插件激活器</b><br/>
 * <b>插件依赖的父插件定义集</b><br/>
 * <b>插件所有属性信息</b><br/>
 */
public interface IPluginDefinition extends Serializable{

    /**
     * 获取插件的唯一名称
     * @return 插件的唯一名称
     */
    public String getName();

    /**
     * 获取插件的URL路径
     * @return 插件的URL路径
     */
    public URL getPath();

    /**
     * 获取插件的提供商
     * @return 插件的提供商
     */
    public String getProvider();

    /**
     * 获取插件的激活器
     * @return 插件的激活器
     */
    public String getActivator();

    /**
     * 获取插件的类路径
     * @return 插件类路径
     */
    public IPluginClassPath getClassPath();

    /**
     * 获取插件配置文件中的所有属性信息
     * @return 插件配置文件中的所有属性信息
     */
    public Attributes getConfig();
}


public interface IPluginModule {
	/**
	 * 加载插件
	 * @param pluginPath
	 */
	public void load(File pluginPath);
	
	/**
	 * 卸载当前插件
	 */
	public void unload();
	
	/**
	 * 插件目录
	 * @return
	 */
	public File getPluginPath();
	
	/**
	 * 标识是否已经加载过
	 * @return
	 */
	public boolean isLoaded();
	
	/**
	 * 获取插件激活器
	 */
	public IPluginActivator getPluginActivator();
	
	/**
	 * 获取该插件的ClassLoader
	 * @return
	 */
	public ClassLoader getPluginLoader();

	/**
	 * 获取插件的名字
	 * @return
	 */
    public String getPluginName();
    
    /**
     * 获取该插件的监控节点配置以及服务
     * @return
     */
    public IPluginDefinition getPluginDefinition();
}



/**
 * 插件配置解析，生成PluginDefinition对象
 */
public class PluginResolver {
	private static final String PROTOCOL_FILE = "file";
	private static final String JAR = ".jar";
	private static final String LIB = "lib";
	private static final String CLASS_PATH = "classpath";
	private static final String AGENT_PLUGIN_XML = "datacenter-plugin.xml";
	
	public static PluginResolver INSTANCE = new PluginResolver();
	private Map<String, IPluginResolver> resolvers = new HashMap<String, IPluginResolver>(4);
	
	static {
        INSTANCE.resolvers.put(PROTOCOL_FILE, new FolderPathResolver());
    }
	
	static interface IPluginResolver {
        PluginDefinition resolvePlugin(XMLBuilder builder, URL url) throws Exception;
    }
	
	public PluginDefinition resolvePlugin(URL url) throws PluginResolveException {
        String protocol = url.getProtocol();
		IPluginResolver resolver = resolvers.get(protocol);
		if (resolver == null) {
			throw new PluginResolveException(String.format("Unsupport protocol [%s]", protocol));
		}
		try {
			Document document = DocumentDescriptor.INSTANCE.loadPluginXML(url);
			return resolver.resolvePlugin(XMLBuilder.createBuilder(document), url);
		} catch (Exception e) {
			throw new PluginResolveException("resolve config error!", e);
		}
    }
	
	private static class FolderPathResolver implements IPluginResolver {
		public PluginDefinition resolvePlugin(XMLBuilder builder, URL url) throws Exception {
			String pluginName     = loadPluginName(builder);
			String provider       = loadPluginProvider(builder);
			String activator      = loadPluginActivator(builder);
			Attributes attributes = loadAttribtes(builder.findNode("/plugin/attributes"));
			Assert.isNotNull(pluginName, "plugin Name must be not null");
			Assert.isNotNull(activator, "activator must be not null");
			IPluginClassPath classpath  = new PluginClassPath(url, attributes.getString(CLASS_PATH));
			
			return new PluginDefinition(pluginName, url, activator, provider, classpath , attributes);
		}
		
		private String loadPluginName(XMLBuilder builder) throws Exception {
			String pluginName = XMLBuilder.getAttribute(builder.findNode("/plugin"), "name");
			if(pluginName != null) {
				return pluginName.trim();
			}
			return null;
		}
		
		private String loadPluginProvider(XMLBuilder builder) throws Exception {
			String provider = XMLBuilder.getAttribute(builder.findNode("/plugin"), "provider");
			if(provider != null) {
				return provider.trim();
			}
			return null;
		}
		
		private String loadPluginActivator(XMLBuilder builder) throws Exception {
			String activator = XMLBuilder.getAttribute(builder.findNode("/plugin//controller"), "class");
			if(activator != null) {
				return activator.trim();
			}
			return null;
		}
		
		private static Attributes loadAttribtes(Node parent) throws Exception {
			Attributes attributes = new Attributes();
			NodeList attributeNodes = parent.getChildNodes();
			for (int i = 0; i < attributeNodes.getLength(); i++) {
				Node node = attributeNodes.item(i);
				if (node.getNodeType() == Node.ELEMENT_NODE && node.getNodeName().equals("attribute")) {
					// get attributes
					String name   = XMLBuilder.getAttribute(node, "name");
					String value  = XMLBuilder.getAttribute(node, "value");
					attributes.put(name, value);
				}
			}
			return attributes;
		}
	}
}



/**
 * 插件类路径信息定义实现类，包含对路径的解析和处理，包含目录和jar包两种
 * 形式。
 *
 * 目录形式：
 *   1. 该目录当作classpath
 *   2. 该目录直接子层的jar包也纳入classpath
 *
 * jar包形式：
 *   1. 直接将jar包的URL纳入classpath
 *   
 * 默认打入插件下面的lib包
 */
public class PluginClassPath implements IPluginClassPath {
	private static final String JAR = ".jar";
	private static final String LIB = "lib";
	
	private List<URL> pathURL = new ArrayList<URL>();

    PluginClassPath(URL pluginPath, String path) throws PluginResolveException {
    	resolve(pluginPath); //解析默认
    	resolve(pluginPath, path);
    }
    
    @SuppressWarnings("deprecation")
	protected void resolve(URL pluginPath) throws PluginResolveException {
    	File libPath = new File(pluginPath.getFile(), LIB);
		if (libPath.exists()) {
			File[] files = libPath.listFiles(new FileFilter() {
				public boolean accept(File file) {
					if (file.getName().endsWith(JAR)) {
						return true;
					}
					return false;
				}
			});
			for (File file : files) {
				try {
					pathURL.add(file.toURL());
				} catch (MalformedURLException e) {
					throw new PluginResolveException(e);
				}
			}
		}
    }

    /**
     * 解析类路径URL地址，首先基于“,”进行路径分割，分为两种类别处理：目录和jar包。
     *
     * 目录形式：
     *   1. 该目录当作classpath
     *   2. 该目录直接子层的jar包也纳入classpath
     *
     * jar包形式：
     *   1. 直接将jar包的URL纳入classpath
     *
     * @param pluginDir 插件路径
     * @param path classpath相对路径，以“,”分割
     * @throws PluginResolveException 解析错误时抛出该异常
     */
    protected void resolve(URL pluginDir, String path) throws PluginResolveException{
        if(StringUtil.isNullOrEmpty(path)) {
            //do nothing
        } else {
            String[] array = path.split(",");
            List<URL> list = new ArrayList<URL>(array.length);
            for(String p : array) {
                if(StringUtil.isNullOrEmpty(p)) {
                    continue;
                }
                p = p.trim();
                try {
                    URL pathURL = null;
                    File f = new File(pluginDir.getFile(), p);
                    if(f.exists()) {
                        if(f.isFile() && f.getName().endsWith(".jar")) {
                            pathURL = new URL(
                                pluginDir.getProtocol(), pluginDir.getHost(),
                                pluginDir.getPort(), pluginDir.getFile() + p);
                        } else {
                            pathURL = new URL(
                                pluginDir.getProtocol(), pluginDir.getHost(),
                                pluginDir.getPort(), pluginDir.getFile() + p + "/");
                            File[] jars = f.listFiles(new FilenameFilter() {
                                public boolean accept(File dir, String name) {
                                    return name.endsWith(".jar");
                                }
                            });
                            if(jars != null) {
                                for(File jar : jars) {
                                    list.add(FileUtil.getFileURL( jar ));
                                }
                            }
                        }
                        list.add(pathURL);
                    } else {
                        throw new PluginResolveException("Can not find classpath in directory " + f.getAbsolutePath());
                    }
                } catch (MalformedURLException e) {
                   throw new PluginResolveException(e);
                }
            }
            pathURL.addAll(list);
            //file:/F:/XX/datacenter/lib/gson-1.7.1.jar, file:/F:/xx/datacenter/lib/joe.jar, file:/F:/xxx/datacenter/lib/spring.jar, file:/F:/xxx/datacenter/bin/]
        }
    }

	public URL[] getPath() {
		return pathURL.toArray(new URL[0]);
	}
}

public class PluginManager {
	protected Logger logger = LoggerManager.getLogger(getClass());
	
    public static final String PLUGIN_LISTS_XML = "plugin-lists.xml";
    private static final String XML_PLUGIN = "/plugins//plugin";
    
    private File pluginsPath = new File(DataCenterConfig.getHome(), "plugins");
    private Map<String, IPluginModule> plugins = new ConcurrentHashMap<String, IPluginModule>();
    
    private static final List<IPluginActuator> startActuators = new LinkedList<IPluginActuator>();
	private static final List<IPluginActuator> stopActuators  = new LinkedList<IPluginActuator>();
	static {
        // 1. 创建执行器实例
        ExtensionActuator extension = new ExtensionActuator();
        ActivateActuator activate   = new ActivateActuator();
        
        // 2. 注册启动执行器
        startActuators.add(extension);
        startActuators.add(activate);
        
        // 3. 注册关闭执行器
        stopActuators.add(activate);
        stopActuators.add(extension);
    }
    
    /**
     * 初始化的时候安装所有的插件，插件可以被卸载
     */
    public void init() throws Exception {
    	installPlugins(new File(pluginsPath, PLUGIN_LISTS_XML));
    }
    
    public void start() throws Exception{
    	for (IPluginModule plugin : plugins.values()) {
            startPlugin(plugin);
        }
    }
    
    private void startPlugin(IPluginModule plugin) {
		IPluginActivator activator = plugin.getPluginActivator();
		if (activator == null) {
			return;
		}
		int state = activator.getState();
		if (state == IPluginActivator.RUNNING || state == IPluginActivator.STARTING) { // 只要插件的状态不是RESOLVER，
			return; // 则不能启动该插件，因为该插件可能正在停止或者正在启动过程中或者已经启动
		}
		try {
			for (IPluginActuator actuator : startActuators) {
				actuator.start(plugin);
			}
		} catch (RuntimeException e) {
			logger.log(Level.SEVERE, "Initialize plugin actuator fail", e);
			throw e;
		}
	}
    
    private void stopPlugin(IPluginModule plugin) {
        logger.info("stoping plugin:" + plugin.getPluginName());
        IPluginActivator activator = plugin.getPluginActivator();
		if (activator == null) {
			return;
		}
		int state = activator.getState();
		if (state == IPluginActivator.STOPPED || state == IPluginActivator.STOPPING) { // 只要插件的状态不是RESOLVER，
			return; // 则不能启动该插件，因为该插件可能正在停止或者正在启动过程中或者已经启动
		}
		try {
			for (IPluginActuator actuator : stopActuators) {
				actuator.stop(plugin);
			}
		} catch (RuntimeException e) {
			logger.log(Level.SEVERE, "stop plugin actuator fail", e);
			throw e;
		}
        logger.info("stoped plugin:" + plugin.getPluginName());
    }
    
    public void reloadPlugin(String pluginName) throws Exception {
    	IPluginModule plugin = plugins.get(pluginName);
    	if(plugin != null) {
    		reloadPlugin(plugin);
    	}
    }
    
    private void reloadPlugin(IPluginModule plugin) throws Exception {
    	String pluginName = plugin.getPluginName();
		logger.info("reload plugin " + pluginName);
		if (plugins.get(pluginName) != null) {
			unInstallPluin(pluginName);
			startPlugin(loadPlugin(plugin.getPluginPath()));
		}
    }

    
    public void destory() throws Exception {
    	for (IPluginModule plugin : getPlugins()) {
            stopPlugin(plugin);
            plugin.unload();
        }
        plugins.clear();
    }
    
    public void installPlugin(String folder) throws Exception {
        IPluginModule plugin = loadPlugin(folder, null);
		if (plugin != null) {
			plugins.put(plugin.getPluginName(), plugin);
			PluginContext.addPluginModule(plugin);
		}
    }
    
    public void unInstallPluin(String pluginName) throws Exception {
    	IPluginModule plugin = plugins.get(pluginName);
    	//先停止插件，然后卸载插件
    	stopPlugin(plugin);
    	if(plugin != null) {
    		plugin.unload();
    	}
    	plugins.remove(pluginName);
    }

    private void installPlugins(File path) throws Exception {
        XMLBuilder builder = XMLBuilder.createBuilder(path);
        NodeList pluginNodes = builder.findNodeList(XML_PLUGIN);
        for (int i = 0; i < pluginNodes.getLength(); i++) {
            Node node = pluginNodes.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                String folder   = XMLBuilder.getAttribute(node, "folder");
                String enable   = XMLBuilder.getAttribute(node, "enable");
                String filePath = XMLBuilder.getAttribute(node, "path");
                if (Boolean.valueOf(enable)) {
                    IPluginModule plugin = loadPlugin(folder, filePath);
                    if(plugin != null) {
                    	plugins.put(plugin.getPluginName(), plugin);
                        PluginContext.addPluginModule(plugin);
                    }
                }
            }
        }
    }

    private IPluginModule loadPlugin(String folder, String filePath) {
		if(StringUtil.isNullOrEmpty(filePath)) {
			File pluginFolder = new File(pluginsPath, folder);
			return loadPlugin(pluginFolder);
		} else {
			File pluginFolder = new File(filePath, folder);
			return loadPlugin(pluginFolder);
		}
	}
    
    private IPluginModule loadPlugin(File pluginFolder) {
    	logger.info("start load plugin:" + pluginFolder.getName());
    	if (pluginFolder.exists() && pluginFolder.isDirectory()) {
			IPluginModule plugin = new PluginModule();
			plugin.load(pluginFolder);
			logger.info("plugin loaded:" + pluginFolder.getName());
			return plugin;
		} else {
			logger.severe("plugin folder error:" + pluginFolder.getName());
			return null;
		}
    }

    public Collection<IPluginModule> getPlugins() {
        return Collections.unmodifiableCollection(plugins.values());
    }

    public File getPluginsPath() {
        return pluginsPath;
    }

    public void setPluginsPath(File pluginsPath) {
        this.pluginsPath = pluginsPath;
    }
}

public class PluginModule implements IPluginModule {
	private static Logger logger = LoggerManager.getLogger(PluginModule.class);
	private static final String JAR = ".jar";
	private static final String LIB = "lib";
	private static final String AGENT_PLUGIN_XML = "datacenter-plugin.xml";

	private IPluginActivator activator;
	private URLClassLoader pluginLoader;
	private String pluginName;
	private File pluginPath;
	private boolean isLoaded = false;
	private IPluginDefinition pluginDefinition;

	public void load(File pluginPath) {
		if (!isLoaded && pluginPath.isDirectory() && pluginPath.exists()) {
			this.pluginPath = pluginPath;
			loadPlugin(pluginPath);
		}
	}
	
	public void unload() {
		System.out.println(getPluginName() + ":stop");
		unloadNativeLibs(); //卸载本地代码
	}
	
	private void unloadNativeLibs() {
        ClassLoader loader = getPluginLoader();
        Field field;
        try {
            field = ClassLoader.class.getDeclaredField("nativeLibraries");
            field.setAccessible(true);
            Vector libs = (Vector) field.get(loader);
            Iterator it = libs.iterator();
            Object o;
            while (it.hasNext()) {
                o = it.next();
                Method finalize = o.getClass().getDeclaredMethod("finalize", new Class[0]);
                finalize.setAccessible(true);
                finalize.invoke(o, new Object[0]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

	@SuppressWarnings("deprecation")
	private void loadPlugin(File pluginPath) {
		try {
			pluginDefinition = PluginResolver.INSTANCE.resolvePlugin(pluginPath.toURL());
			if(pluginDefinition == null) {
				throw new PluginResolveException("resolve plugin config error!");
			}
			initClassLoader();
			//实例化插件启动器
			initPluginActivator();
			isLoaded = true;
		} catch (Exception e) {
			logger.log(Level.SEVERE, String.format("init plungin[%s] fail.", pluginPath.getPath()), e);
		}
	}

	private void initClassLoader() throws MalformedURLException {
		URL[] urls = pluginDefinition.getClassPath().getPath();  //[file:/F:/xx/demo/bin/]
		pluginLoader = new URLClassLoader(urls, ClassUtil.getClassLoader());
	}
	
	private void initPluginActivator() throws Exception {
		String cls = pluginDefinition.getActivator();
		Class clazz = pluginLoader.loadClass(cls);
		if (IPluginActivator.class.isAssignableFrom(clazz)) {
			activator  = (IPluginActivator)clazz.newInstance();
		}
//		throw new Exception(cls + " is not a subclass of:" + IPluginActivator.class);
	}

	public String getPluginName() {
		return pluginDefinition.getName();
	}

	public File getPluginPath() {
		return pluginPath;
	}

	public boolean isLoaded() {
		return isLoaded;
	}

	public ClassLoader getPluginLoader() {
		return pluginLoader;
	}

	public IPluginActivator getPluginActivator() {
		return activator;
	}

	public IPluginDefinition getPluginDefinition() {
		return pluginDefinition;
	}
}


4-异常-log4j配置日志滚动覆盖出现日志丢失问题
weixin_43873121的博客
06-16 1412
4-异常-log4j配置日志打印滚动覆盖出现日志丢失问题(附源码分析)
配置QtCreator能加载自定义插件的环境
肩上风骋的博客
04-12 1046
生成的自定义插件能在QtCreator的设计器中加载，需要满足当前使用的QtCreator的编译时所需的Qt库和编译器。本文旨在如何配置环境使其满足能在QtCreator的设计器中加载插件。
阿里one java agent的可插拔java agent运行
隐0士的博客
05-07 3601
基于one java agent的可插拔java agent方案 背景 第⼀阶段：⾃研微服务 阿⾥巴巴的微服务拆分实践进⾏的很早，从 2008 年就开始了，当时的单体应⽤已经⽆法承载业务迭代的速度，由五彩⽯项⽬开始了微服务化的改造，在这个改造过程中，也逐步诞⽣了服务框架，消息队列，数据库分库分表等三⼤中间件。在这个阶段的服务治理能⼒是通过 SDK⽅式直接依赖在框架⾥⾯的。每个中间件都有⾃⼰独⽴的 SDK 依赖，服务治理能⼒的升级需要借助框架 SDK 的升级来解决，升级成本是很⾼的。 第⼆阶段：Fat-SDK
Mysql密码策略
背锅浩的博客
08-16 8837
由于近期负责项目等报二级，涉及到“建议数据库设置密码复杂度和定期更换用户口令”这一项，在这里分享一下官方文档。 1.密码验证插件安装 要使服务器可以使用，插件库文件必须位于MySQL插件目录（plugin_dir系统变量指定的目录）中。如有必要，请设置plugin_dir服务器启动时的值， 以告知服务器插件目录位置。 插件库文件基本名称是 validate_password。文件名后缀因平台...
日志框架LOG4J2系列四——log4j2的plugins(插件)使用
SpringBoy的博客
09-17 7398
一、log4j2插件plugins简介 Log4j 1.x 允许对指定的大多数配置声明的类属性进行扩展，例如想要自定义模板匹配器需要通过代码来扩展PatternLayout类功能。而log4j2的目的是使这样的功能扩展变得更容易。在 Log4j 2 中，通过在类声明上添加@Plugin注解来声明一个自定义插件。在初始化期间，Configuration将调用PluginManager来加载内置的 Log4j 插件以及所有自定义插件。 PluginManager 会在以下的五个位置查找来找到插件： Class
Mysql数据库管理-plugin安装与配置总结
oradbm的博客
07-20 2711
包括CONNECTION_CONTROL 和 CONNECTION_CONTROL_FAILED_LOGIN_ATTEMPTS两个插件；该插件使管理员能设置当连续连接失败超过指定次数后，服务端根据配置值增加对连接的相应延迟。使用该插件能缓解MySQL用户的暴力破解；该插件默认未启用需要进行安装首先确认MySQL插件目录，plugin library文件需位于该路径下。在linux系统下plugin library文件名为connection_control.so 为了在MySQL进程启动时加载插件，需要使用
自定义eclipse插件
06-15
自定义Eclipse插件是扩展其功能、提高开发效率的重要方式。通过编写插件，开发者可以根据自己的需求定制工作环境，实现特定的任务自动化，如代码分析、调试辅助、版本控制集成等。 创建自定义Eclipse插件涉及以下几...
Qt-自定义插件
qq_36318563的博客
07-14 1170
1. Qt插件简介 2. 两种创建自定义插件和使用的方法
Kong网关自定义插件开发
LaurentNg的博客
07-05 1477
本文章旨在提供了一个简单的kong网关自定义插件开发的思路与步骤，并未涉及到更深层次的开发，如有需要，请参考kong网关插件开发官方文档。在进行开发之前，本文章默认读者是已经成功启动了本地kong网关服务并知道kong网关控制面板的基本操作。本文章的kong网关是在docker容器中运行的，版本为3.2.2.1。
ros+rviz+自定义消息+自定义插件
08-17
在这个项目中，“ros+rviz+自定义消息+自定义插件”意味着我们将深入探讨如何在ROS环境下利用RViz创建和使用自定义的消息类型以及开发自定义插件。 首先，我们来看自定义消息。在ROS中，消息是用来在节点之间传递...
《童虎学习笔记》9分钟学会向MySQL MGR集群中添加节点-方案1
tonghu_note的博客
04-09 1468
1
从插件/RCP中取得文件路径的方法
夕阳最温柔的专栏
04-06 777
 作者：hopeshared引用地址：http://www.blogjava.net/hopeshared/archive/2005/12/20/24798.html原文：引用地址：http://www.eclipseworld.org/bbs/read.php?tid=1345从插件中获得绝对路径：     AaaaPlugin.getDefault().getStateLocatio
Log4j2 Demos(基础/时间&大小回滚/定期删除/日志脱敏)
Be yourself.
07-30 5239
前言 本章主要介绍Log4j2的几个例子与使用场景。 Log4j2 Demos Log4j2 Demos(普通设置) &amp;amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot;?&amp;amp;gt; &amp;amp;lt;Configuration status=&amp;quot;debug&amp;quo
浅谈MYSQL之半同步复制(附带实验)
黑白一戒
11-30 457
浅谈MYSQL之半同步复制 半同步复制来源 默认情况下，MySQL的复制功能是异步的，异步复制可以提供最佳的性能，主库把binlog日志发送给从库即结束，并不验证从库是否接收完毕。 这意味着当主服务器或从服务器端发生故障时，有可能从服务器没有接收到主服务器发送过来的binlog日志，这就会造成主服务器和从服务器的数据不一致，甚至在恢复时造成数据的丢失 半同步复制概述 半同步复制是介于异步复...
变种Builder模式自动化生成Plugin的使用
八步赶蝉
04-08 850
1.在AS中下载插件，并重启AS2.写一个需要自动化生成Builder模式的类public class User { private final String name; private final String gender; private final String number; private final int age; }3.操作步骤如下：4.得到Bui...
Qt Plugin创建及调用
yizhou2010的专栏
10-17 8785
概述插件是一种遵循一定规范的应用程序接口编写出来的程序，定位于开发实现应用软件平台不具备的功能的程序。插件与宿主程序之间通过接口联系，就像硬件插卡一样，可以被随时删除，插入和修改，所以结构很灵活，容易修改，方便软件的升级和维护。Qt中的插件Qt提供了两种API用于创建插件： 一种是高阶API用于扩展Qt本身的功能：如自定义数据库驱动，图像格式，文本编码，自定义样式等等； 一种低阶API用于扩展Qt应
mysql 卸载插件_MySQL 插件安装或卸载(window validate_password 为例)
weixin_29623481的博客
01-27 1932
查看插件：mysql> show plugins;mysql> select plugin_name,plugin_status,plugin_type,load_option,plugin_library from information_schema.plugins;默认插件目录：mysql> show variables like 'plugin_dir';+-------...
【大话QT之四】ctkPlugin插件系统实现项目插件式开发
热门推荐
天道酬勤
04-16 1万+
插件式开发体会：         自开始写【大话QT】系列就开始接触渲染客户端的开发，说是开发不如更多的说是维护以及重构，在接手这块的东西之前自己还有点犹豫，因为之前我一直认为客户端嘛，没什么技术含量，总是想做比较有挑战性的，为了这周总还专门找我谈了谈，算是“安抚”民心吧。正式谈话过后，我才决定接手渲染客户端的开发。         渲染客户端的所有构成均是采用开源框架拼凑起来的整体，细分它的
1.IDEA Java开发必备插件
virgil
04-02 1万+
工欲善其事必先利其器。《论语·卫灵公》
在SharpDevelop中创建并加载自定义插件，以在IDE启动时添加自定义工具栏按钮的详细步骤是什么？
最新发布
11-10
要创建一个能在SharpDevelop启动时添加自定义工具栏按钮的插件，首先需要熟悉SharpDevelop的插件开发机制和ICsharpCode.Core插件库。ICsharpCode.Core提供了一个Addin系统，用于加载和管理插件。以下是一个详细的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值