java组件中的热插拔（osgi)

最新推荐文章于 2024-05-24 09:55:13 发布
最新推荐文章于 2024-05-24 09:55:13 发布
阅读量9.4k 收藏 8
点赞数
分类专栏： osgi 文章标签： osgi java eclipse servlet exception interface

 关键字: java 开发 osgi 组件 热插拔

大部分的开发这都是直接使用IDE，很少用人愿意去探究Eclipse内部的情况，而Eclipse本身就是有一大堆的Plug-in组成，同时提供一个OSGi的环境供众多的Plug-in使用。Eclipse与OSGI联姻的行为是从Eclipse 基金在Eclipse 3.0 发布的时候开始的，此后，Eclipse 逐步迁移到OSGi 框架中，并自己实现了一个OSGi 开源框架，取名为Equinox，该框架随着每次Eclipse 的发布也会相应的更新。Eclipse 之所以这么做，其一是因为Eclipse 的插件体系与OSGi 的设计思想不谋而合，其二也是因为OSGi 更为规范，其对插件体系的定义也更为完整一些。事实证明Eclipse 在采用OSGi 架构后，无论从性能、可扩展性这两个方面来讲还是从二次开发的角度来定义，都取得巨大的成功。

从此以后，开发人员不仅能够从网络中获得俯拾皆是的Eclipse Plug-in，并在开发中发挥作用，同时也有很多的团体和个人也参与到了Plug-in的开发过程中。Eclipse Plug-in的最大特点就是热插拔，当然这个特点的源泉便是OSGi。估计很多人都接触过路由器，大部分的路由器都支持模块的热插拔，这就意味着可以在路由器运行的状况下给它动态的增加新的功能或者卸载不需要的功能，硬件界的这种热插拔技术一直就是软件界所追求的，而OSGI则使得热插拔技术在软件界成为现实。基于OSGI的系统，可通过安装新的Bundle、更新或停止现有的Bundle来实现系统功能的插拔。

在这份文档中，我将围绕着OSGi的热插拔技术展开话题。与此同时会介绍OSGi同接口多Bundle服务的使用以及Servlet在OSGi中的使用。同样，为了能够给大家一个感性的认识，我决定还是提供一个小的工程实例来说明我要阐述的问题。这个工程将由一个接口定义Bundle、两个接口实现Bundle以及一个客户端调用Bundle。


1.实现接口定义Bundle

a. 编写代码
 Activator.java

Java代码 复制代码
  1. package org.danlley.osgi.ds.common;   
  2.   
  3. import org.osgi.framework.BundleActivator;   
  4. import org.osgi.framework.BundleContext;   
  5.   
  6. public class Activator implements BundleActivator {   
  7.   
  8.     public void start(BundleContext context) throws Exception {   
  9.     }   
  10.   
  11.     public void stop(BundleContext context) throws Exception {   
  12.     }   
  13.   
  14. }  
package org.danlley.osgi.ds.common;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

public class Activator implements BundleActivator {

	public void start(BundleContext context) throws Exception {
	}

	public void stop(BundleContext context) throws Exception {
	}

}

 

 Item.java

Java代码 复制代码
  1. package org.danlley.osgi.ds.services;   
  2.   
  3. public class Item {   
  4.     String name;   
  5.     String id;   
  6.   
  7.     public Item(String name, String id) {   
  8.         super();   
  9.         this.name = name;   
  10.         this.id = id;   
  11.     }   
  12.   
  13.     public Item() {   
  14.         super();   
  15.     }   
  16.   
  17.     public String getName() {   
  18.         return name;   
  19.     }   
  20.   
  21.     public void setName(String name) {   
  22.         this.name = name;   
  23.     }   
  24.   
  25.     public String getId() {   
  26.         return id;   
  27.     }   
  28.   
  29.     public void setId(String id) {   
  30.         this.id = id;   
  31.     }   
  32. }  
package org.danlley.osgi.ds.services;

public class Item {
	String name;
	String id;

	public Item(String name, String id) {
		super();
		this.name = name;
		this.id = id;
	}

	public Item() {
		super();
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
}

 

 MySampleListContributor.java 

 

 

Java代码 复制代码
  1. package org.danlley.osgi.ds.services;   
  2.   
  3. import java.util.List;   
  4.   
  5. public interface MySampleListContributor {   
  6.     public List<Item> getItems();   
  7. }  
package org.danlley.osgi.ds.services;

import java.util.List;

public interface MySampleListContributor {
	public List<Item> getItems();
}

 

 

b. 修改配置文件，发布包路径
 
 修改MANIFEST.MF配置文件的内容，添加内容：Export-Package: org.danlley.osgi.ds.services，为后面的两个Bundle实现提供接口，修改后MANIFEST.MF配置文件的内容如下：
  -------------------------------------------------------
  Manifest-Version: 1.0
  Bundle-ManifestVersion: 2
  Bundle-Name: Osgi_ds_interface Plug-in
  Bundle-SymbolicName: osgi_ds_interface
  Bundle-Version: 1.0.0
  Bundle-ClassPath: target/classes/
  Bundle-Activator: org.danlley.osgi.ds.common.Activator
  Bundle-Vendor: some vendor
  Import-Package: org.osgi.framework;version="1.3.0"
  Export-Package: org.danlley.osgi.ds.services
  -------------------------------------------------------
 修改后build.properties配置文件的内容
  ----------------------------------------
  source.target/classes/ = src/main/java/
  output.target/classes/ = target/classes/
  bin.includes = META-INF/,/
          target/classes/
  ----------------------------------------

 

 

2.定义Bundle接口实现

 a. 实现Bunble：osgi_ds_implements_a
  1). 定义类：MySampleListContributor

Java代码 复制代码
  1. package org.danlley.osgi.ds.impl;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5. import org.danlley.osgi.ds.services.Item;   
  6. import org.danlley.osgi.ds.services.MySampleListContributor;   
  7.   
  8. public class ContributeA implements MySampleListContributor{   
  9.     public List<Item> getItems(){   
  10.         List<Item> list=new ArrayList<Item>();   
  11.         list.add(new Item("ContributeA","1"));   
  12.         list.add(new Item("ContributeA","2"));   
  13.         list.add(new Item("ContributeA","3"));   
  14.         list.add(new Item("ContributeA","4"));   
  15.         return list;   
  16.     }   
  17. }  
package org.danlley.osgi.ds.impl;

import java.util.ArrayList;
import java.util.List;
import org.danlley.osgi.ds.services.Item;
import org.danlley.osgi.ds.services.MySampleListContributor;

public class ContributeA implements MySampleListContributor{
	public List<Item> getItems(){
		List<Item> list=new ArrayList<Item>();
		list.add(new Item("ContributeA","1"));
		list.add(new Item("ContributeA","2"));
		list.add(new Item("ContributeA","3"));
		list.add(new Item("ContributeA","4"));
		return list;
	}
}

 

  2). 定义一个新目录OSGI-INF用来存放接口实现的相关配置
  3). 在OSGI-INF目录下定义文件component.xml
   内容如下：

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <component name="services">  
  3.     <implementation  
  4.         class="org.danlley.osgi.ds.impl.ContributeA" />  
  5.     <service>  
  6.         <provide  
  7.             interface="org.danlley.osgi.ds.services.MySampleListContributor" />  
  8.     </service>  
  9. </component>  

 

 

   说明：关于OSGi接口与实现的绑定事实上是有两种实现的方式，一种便是利用这里的配置文件的声明来实现其绑定的任务，另外还有一种方式是在程序中直接绑定。我们可以使用OSGi为我们提供的一个工具类org.osgi.framework.BundleContext为我们提供的方法registerService(String className,Object _instance, Dictionary arg)来完成这项工作，具体代码示例如下：

Java代码 复制代码
  1. private ServiceRegistration sr = null;   
  2. public void start(BundleContext context) throws Exception {   
  3.     Hashtable props = new Hashtable();   
  4.     props.put("description", "This an long value");   
  5.     sr = context.registerService(SomeClass.class.getName(),SomeClassImpl, props);   
  6. }  
private ServiceRegistration sr = null;
public void start(BundleContext context) throws Exception {
	Hashtable props = new Hashtable();
	props.put("description", "This an long value");
	sr = context.registerService(SomeClass.class.getName(),SomeClassImpl, props);
}

 

  4). 声明OSGI-INF/component.xml

   -----------------------------------------------------
   Manifest-Version: 1.0
   Bundle-ManifestVersion: 2
   Bundle-Name: Osgi_ds_implements_a Plug-in
   Bundle-SymbolicName: osgi_ds_implements_a
   Bundle-Version: 1.0.0
   Bundle-ClassPath: target/classes/
   Bundle-Activator: org.danlley.osgi.ds.common.Activator
   Import-Package: org.osgi.framework;version="1.3.0"
   Require-Bundle: osgi_ds_interface
   Service-Component: OSGI-INF/component.xml
   -----------------------------------------------------

 

 b. 实现Bundle：osgi_ds_implement_b
  1). 定义类：MySampleListContributor

Java代码 复制代码
  1. package org.danlley.osgi.ds.impl;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5.   
  6. import org.danlley.osgi.ds.services.Item;   
  7. import org.danlley.osgi.ds.services.MySampleListContributor;   
  8.   
  9. public class ContributeB implements MySampleListContributor{   
  10.     public List<Item> getItems(){   
  11.         List<Item> list=new ArrayList<Item>();   
  12.         list.add(new Item("ContributeB","[1]"));   
  13.         list.add(new Item("ContributeB","[2]"));   
  14.         return list;   
  15.     }   
  16. }  
package org.danlley.osgi.ds.impl;

import java.util.ArrayList;
import java.util.List;

import org.danlley.osgi.ds.services.Item;
import org.danlley.osgi.ds.services.MySampleListContributor;

public class ContributeB implements MySampleListContributor{
	public List<Item> getItems(){
		List<Item> list=new ArrayList<Item>();
		list.add(new Item("ContributeB","[1]"));
		list.add(new Item("ContributeB","[2]"));
		return list;
	}
}

 

  2). 定义一个新目录OSGI-INF用来存放接口实现的相关配置
  3). 在OSGI-INF目录下定义文件component.xml
   内容如下：

Java代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <component name="services">   
  3.     <implementation   
  4.         class="org.danlley.osgi.ds.impl.ContributeB" />   
  5.     <service>   
  6.         <provide   
  7.             interface="org.danlley.osgi.ds.services.MySampleListContributor" />   
  8.     </service>   
  9. </component>  
<?xml version="1.0" encoding="UTF-8"?>
<component name="services">
	<implementation
		class="org.danlley.osgi.ds.impl.ContributeB" />
	<service>
		<provide
			interface="org.danlley.osgi.ds.services.MySampleListContributor" />
	</service>
</component>

 

  4). 声明OSGI-INF/component.xml

   -----------------------------------------------------
   Manifest-Version: 1.0
   Bundle-ManifestVersion: 2
   Bundle-Name: Osgi_ds_implement_b Plug-in
   Bundle-SymbolicName: osgi_ds_implement_b
   Bundle-Version: 1.0.0
   Bundle-ClassPath: target/classes/
   Bundle-Activator: org.danlley.osgi.ds.common.Activator
   Bundle-Vendor: some vendor
   Import-Package: org.osgi.framework;version="1.3.0"
   Require-Bundle: osgi_ds_interface
   Service-Component: OSGI-INF/component.xml
   -----------------------------------------------------

 

3. 定义客户端Bundle：osgi_ds_client
 说明：在osgi_ds_client中，我们需要处理两件事情
  i.  分别从两个实现接口的Bundle中获取数据
  ii. 注册一个Servlet用来在浏览器中展现获取的数据
 为此，我们需要设计一个工具类MenuHelper来获取数据，并由ClientServlet来进行数据展现。
 a. 编写代码
  MenuHelper.java

Java代码 复制代码
  1. package org.danlley.osgi.ds.client;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5. import org.danlley.osgi.ds.services.MySampleListContributor;   
  6. import org.osgi.service.component.ComponentContext;   
  7.   
  8. public class MenuHelper {   
  9.   
  10.     static MenuHelper instance;   
  11.   
  12.     List<MySampleListContributor> menuContributors = new ArrayList<MySampleListContributor>();   
  13.   
  14.     protected void activate(ComponentContext context) {   
  15.         System.out.println("Calling activate");   
  16.         Object obj = null;   
  17.         try {   
  18.             obj = context.locateService("menuHelper");   
  19.         } catch (Exception e) {   
  20.             e.printStackTrace();   
  21.         }   
  22.         System.out.println(obj);   
  23.         instance = this;   
  24.     }   
  25.   
  26.     protected void deactivate(ComponentContext context) throws Exception {   
  27.         System.out.println("Calling deactivate");   
  28.     }   
  29.   
  30.     public static MenuHelper getInstance() {   
  31.         return instance;   
  32.     }   
  33.   
  34.     public List<MySampleListContributor> getMenuContributors() {   
  35.         return menuContributors;   
  36.     }   
  37.   
  38.     public void addMenuContributor(MySampleListContributor menuContributor) {   
  39.         System.out.println("Calling addMenuContributor");   
  40.         menuContributors.add(menuContributor);   
  41.     }   
  42.   
  43.     public void removeMenuContributor(MySampleListContributor menuContributor) {   
  44.         System.out.println("Calling removeMenuContributor");   
  45.         menuContributors.remove(menuContributor);   
  46.     }   
  47. }  
package org.danlley.osgi.ds.client;

import java.util.ArrayList;
import java.util.List;
import org.danlley.osgi.ds.services.MySampleListContributor;
import org.osgi.service.component.ComponentContext;

public class MenuHelper {

	static MenuHelper instance;

	List<MySampleListContributor> menuContributors = new ArrayList<MySampleListContributor>();

	protected void activate(ComponentContext context) {
		System.out.println("Calling activate");
		Object obj = null;
		try {
			obj = context.locateService("menuHelper");
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(obj);
		instance = this;
	}

	protected void deactivate(ComponentContext context) throws Exception {
		System.out.println("Calling deactivate");
	}

	public static MenuHelper getInstance() {
		return instance;
	}

	public List<MySampleListContributor> getMenuContributors() {
		return menuContributors;
	}

	public void addMenuContributor(MySampleListContributor menuContributor) {
		System.out.println("Calling addMenuContributor");
		menuContributors.add(menuContributor);
	}

	public void removeMenuContributor(MySampleListContributor menuContributor) {
		System.out.println("Calling removeMenuContributor");
		menuContributors.remove(menuContributor);
	}
}

 

  ClientServlet.java

 

Java代码 复制代码
  1. package org.danlley.osgi.ds.client.servlet;   
  2.   
  3. import java.io.IOException;   
  4. import javax.servlet.http.HttpServlet;   
  5. import javax.servlet.http.HttpServletRequest;   
  6. import javax.servlet.http.HttpServletResponse;   
  7. import org.danlley.osgi.ds.client.MenuHelper;   
  8. import org.danlley.osgi.ds.services.Item;   
  9. import org.danlley.osgi.ds.services.MySampleListContributor;   
  10.   
  11. public class ClientServlet extends HttpServlet {   
  12.     /**  
  13.      * serialVersionUID  
  14.      */  
  15.     private static final long serialVersionUID = -2631550134006854279L;   
  16.   
  17.     public void doPost(HttpServletRequest servlet, HttpServletResponse response) throws IOException {   
  18.         doGet(servlet, response);   
  19.     }   
  20.   
  21.     public void doGet(HttpServletRequest servlet, HttpServletResponse response) throws IOException {   
  22.         response.setContentType("text/html");   
  23.         response.getWriter().write("Hello  
  24. ");   
  25.         response.getWriter().write("<ul>");   
  26.         for (MySampleListContributor mycontribute : MenuHelper.getInstance().getMenuContributors()) {   
  27.             for (Item mItem : mycontribute.getItems()) {   
  28.                 response.getWriter().write(   
  29.                     "<li><a href=/"" + mItem.getId() + "/">" + mItem.getName() + "[" +    
  30.                     mItem.getId() + "]" + "</a></li>");   
  31.             }   
  32.         }   
  33.         response.getWriter().write("</ul>");   
  34.     }   
  35.   
  36. }  
package org.danlley.osgi.ds.client.servlet;

import java.io.IOException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.danlley.osgi.ds.client.MenuHelper;
import org.danlley.osgi.ds.services.Item;
import org.danlley.osgi.ds.services.MySampleListContributor;

public class ClientServlet extends HttpServlet {
	/**
	 * serialVersionUID
	 */
	private static final long serialVersionUID = -2631550134006854279L;

	public void doPost(HttpServletRequest servlet, HttpServletResponse response) throws IOException {
		doGet(servlet, response);
	}

	public void doGet(HttpServletRequest servlet, HttpServletResponse response) throws IOException {
		response.setContentType("text/html");
		response.getWriter().write("Hello<br/>");
		response.getWriter().write("<ul>");
		for (MySampleListContributor mycontribute : MenuHelper.getInstance().getMenuContributors()) {
			for (Item mItem : mycontribute.getItems()) {
				response.getWriter().write(
					"<li><a href=/"" + mItem.getId() + "/">" + mItem.getName() + "[" + 
					mItem.getId() + "]" + "</a></li>");
			}
		}
		response.getWriter().write("</ul>");
	}

}

 

 b.注册Servlet
  在工程根目录定义文件plugin.xml，同时也可以采用在Eclipse提供的可视化界面进行操作。

Xml代码 复制代码
  1. <plugin>  
  2.   <extension point="org.eclipse.equinox.http.registry.resources">  
  3.     <resource  
  4.       alias="/web"  
  5.       base-name="/page"/>  
  6.   </extension>  
  7.      
  8.     <extension point="org.eclipse.equinox.http.registry.servlets">  
  9.         <servlet  
  10.           alias="/exampleServlet"  
  11.           class="org.danlley.osgi.ds.client.servlet.ClientServlet"/>  
  12.     </extension>  
  13. </plugin>  

 

 c. 定义文件目录OSGI-INF
 d. 在OSGI-INF中增加文件component.xml

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <component name="menuHelper">  
  3.     <implementation     
  4.         class="org.danlley.osgi.ds.client.MenuHelper"/>      
  5.     <reference name="menuHelper"  
  6.         interface="org.danlley.osgi.ds.services.MySampleListContributor"  
  7.         cardinality="0..n"  
  8.         policy="dynamic"  
  9.         bind="addMenuContributor"  
  10.         unbind="removeMenuContributor"  
  11.     />  
  12. </component>  

 

  这样，在系统初始化过程中，我们定义在MenuHelper中的activate方法首先会被执行，然后，locateService()查找系统中是否有可用的"menuHelper"，接着查找MySampleListContributor实例，并由addMenuContributor方法完成合并工作。另外，当我们停掉客户端调用Bundle时，deactivate方法会在整个Bundle被Stop之前被调用来执行一些清理工作。
 e. 修改配置文件

  ------------------------------------------------------
  Manifest-Version: 1.0
  Bundle-ManifestVersion: 2
  Bundle-Name: Osgi_ds_client Plug-in
  Bundle-SymbolicName: osgi_ds_client;singleton:=true
  Bundle-Version: 1.0.0
  Bundle-ClassPath: target/classes/
  Bundle-Activator: org.danlleyo.osgi.ds.common.Activator
  Import-Package: org.osgi.framework;version="1.3.0"
  Service-Component: OSGI-INF/component.xml
  Require-Bundle: osgi_ds_interface,
   org.eclipse.osgi,
   org.eclipse.osgi.services,
   org.eclipse.equinox.http.registry,
   org.eclipse.equinox.common,
   org.eclipse.equinox.launcher,
   org.eclipse.equinox.http.servlet,
   org.eclipse.equinox.ds,
   org.eclipse.equinox.http.helper,
   org.eclipse.equinox.http.jetty,
   org.eclipse.core.jobs,
   org.apache.commons.logging,
   javax.servlet,
   org.mortbay.jetty,
   osgi_ds_implement_b,
   osgi_ds_implements_a
  ------------------------------------------------------

 

4. 系统运行
 a. 启动服务：
  运行结果如下，说明服务成功启动。
  ---------------------------------------------------------------
  osgi> Jul 23, 2008 2:08:58 PM org.mortbay.http.HttpServer doStart
  INFO: Version Jetty/5.1.x
  Jul 23, 2008 2:08:58 PM org.mortbay.util.Container start
  INFO: Started org.mortbay.jetty.servlet.ServletHandler@1081d2e
  Jul 23, 2008 2:08:58 PM org.mortbay.util.Container start
  INFO: Started HttpContext[/,/]
  Jul 23, 2008 2:08:58 PM org.mortbay.http.SocketListener start
  INFO: Started SocketListener on 0.0.0.0:80
  Jul 23, 2008 2:08:58 PM org.mortbay.util.Container start
  INFO: Started org.mortbay.http.HttpServer@e0b6f5
  Calling addMenuContributor
  Calling addMenuContributor
  Calling activate
  org.danlley.osgi.ds.impl.ContributeA@c44b88
  ---------------------------------------------------------------
 b. 访问服务
  访问地址：http://localhost/exampleServlet 如果出现6条数据(4条ContributeA的数据和2条ContributeB的数据)，则说明系统运行正常。
 c. 热插拔Bundle
  查看当前系统中所有运行Bundle的运行状态及ID，结果如下：
  ------------------------------------------------------------------------------
  ss

  Framework is launched.

  id State       Bundle
  0 ACTIVE      org.eclipse.osgi_3.3.2.R33x_v20080105
  1879 ACTIVE      org.eclipse.osgi.services_3.1.200.v20070605
  2304 ACTIVE      javax.servlet_2.4.0.v200706111738
  3059 ACTIVE      org.eclipse.equinox.launcher_1.0.1.R33x_v20080118
  3060 ACTIVE      org.apache.commons.logging_1.0.4
  3065 ACTIVE      org.eclipse.equinox.http.registry_1.0.1.R33x_v20071231
  3066 ACTIVE      org.eclipse.equinox.registry_3.3.1.R33x_v20070802
  3067 ACTIVE      org.eclipse.equinox.common_3.3.0.v20070426
  3074 ACTIVE      org.apache.commons.logging_1.0.4.v200706111724
  3087 ACTIVE      org.eclipse.equinox.http.jetty_1.0.1.R33x_v20070816
  3095 ACTIVE      osgi_ds_interface_1.0.0
  3096 ACTIVE      org.eclipse.equinox.ds_1.0.0.qualifier
  3102 ACTIVE      org.eclipse.equinox.http.helper_1.0.0.qualifier
  3103 ACTIVE      osgi_ds_implement_b_1.0.0
  3104 ACTIVE      osgi_ds_implements_a_1.0.0
  3106 ACTIVE      org.eclipse.core.jobs_3.3.1.R33x_v20070709
  3109 ACTIVE      org.mortbay.jetty_5.1.11.v200706111724
  3112 ACTIVE      org.eclipse.equinox.http.servlet_1.0.1.R33x_v20070816
  3125 ACTIVE      osgi_ds_client_1.0.0
  ------------------------------------------------------------------------------

  执行stop 3104，运行结果如下：
   -----------------------------
   osgi> stop 3104
   Calling removeMenuContributor
   -----------------------------
  此时如果刷新页面，页面上会仅剩两天数据。说明osgi_ds_implements_a已被成功卸载。
  继续执行stop 3103，运行结果如下：
   ------------------------------
   osgi> stop 3103
   Calling removeMenuContributor
   ------------------------------
  此时，刷新页面刚才展示的数据就会全部消失。
  继续执行stop 3125，运行结果如下：
   --------------------
   osgi> stop 3125
   Calling deactivate
   ---------------------
  可见客户端Bundle在停止之前，确实会执行deactivate方法来做一些清理工作。

 

 

 QQ群：9896150 【Java终结者】


 结束！

 

 

参考资料： http://www.springframework.org/

javierhui111
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java模块热插拔/热加载原理
meser88的博客
02-20 163
Java类的加载是由虚拟机来完成的,虚拟机把描述类的Class文件加载到内存,并对数据进行校验,解析和初始化,最终形成能被Java虚拟机直接使用的Java类型,这就是虚拟机的类加载机制.JVM中用来完成上述功能的具体实现就是类加载器.类加载器读取.class字节码文件将其转换成java.lang.Class类的一个实例.每个实例用来表示一个java类.通过该实例的newInstance()方法可以创建出一个该类的对象.对于Java应用程序来说，热部署就是在运行时更新Java类文件。
JPlugman:一个简单的Java插件管理器，具有热重载功能
03-28
鲁格曼 JPlugman是一个插件管理器，可以在模块化Java项目中使用。 其主要特点是： 热插拔：可以在应用程序运行时添加/删除/更新插件。 依赖管理：插件提供的需求可以由主应用程序使用，也可以由其他插件使用。 简单包装：插件是zip文件。 该模块是根据MIT许可发布的。 成分 插件：这是所有插件的主界面。 插件被加载到它们自己的 应用程序：插件将插入的主要应用程序 PluginManager ：用于加载和卸载插件。 它照顾插件之间的依赖性以及与应用程序的兼容性 如何使用 首先通过实现Application接口创建您的应用程序： public interface Application { /** * @param pluginServiceType the type of the versionedService provided by the plugi
EXP：打造灵活高效的Java插件化热插拔框架
最新发布
gitblog_00050的博客
05-24 322
EXP：打造灵活高效的Java插件化热插拔框架 项目地址:https://gitcode.com/stateIs0/exp 在这个快速迭代的时代，软件系统的可扩展性和灵活性至关重要。【EXP】是一个专为Java开发者设计的强大的插件化热插拔框架，它允许你在无需重启应用程序的情况下，轻松地添加、修改或移除功能。由钉钉开源社区推出，EXP旨在简化B端大客户的定制需求，提高开发效率，并提供一种全新的模块...
Solon2 开发之插件，四、插件热插拔管理机制（H-Spi）
向往自由的少年！（我是一个少年！！！）
02-13 419
插件热插拔管理机制，简称：H-Spi。是框架提供的生产时用的另一种高级扩展方案。相对E-Spi，H-Spi 更侧重隔离、热插热拔、及管理性。应用时，是以一个业务模块为单位进行开发，且封装为一个独立插件包。
关于OSGI中的Felix热插拔技术
dongyanze0726的博客
03-06 684
关于OSGI中的Felix热插拔技术 OSGI介绍 OSGI的全称是Open Service Gateway Initiative，即开放服务网关。OSGI是基于模块（Bundle）驱动的，每个模块都有属于自己的classpath和类加载器，模块之间通过包暴露和引入进行关联，每个模块有着自己独立的生命周期，我们可以动态地对模块进行加载、卸载、更新。如此看来，OSGI可以用一句话描述，就是一个为Java提供的动态模块化的系统。 Idea创建OSGI工程（简单整理一下） File -> New -&g
EXP 一款 Java 插件化热插拔框架
爱码一生的博客简介
08-12 206
EXP Java 扩展点 插件化 系统，本地化软件定制需求解决方案。
Mybatis源码解析：从基础到源码统统帮你搞定，使用指南
m0_56037919的博客
03-16 315
个人背景 如标题所示，我的个人背景非常简单，Java开发经验1年半，学历普通，2本本科毕业，毕业后出来就一直在Crud，在公司每天重复的工作对我的技术提升并没有什么帮助，但小镇出来的我也深知自我努力的重要性，想要改变“命运”，没有背景没有资本的人，只能通过勤奋获得。 幸运女神往往会眷顾努力的人，所以当好运降临到我头上，我并不诧异，目前拿到了美团30K的offer，下文也不说废话，主要分享我这次“美团面试经历”和“个人学习方法”，希望能帮助到你们。 什么是数据库 数据库就是存储数据的地方，好比家里的冰箱用来
基于OSGi的热插拔观察者模式
12-27
OSGi（Open Service Gateway Initiative）框架提供了一种强大的模块化系统，它允许可动态部署、更新和卸载服务，使得应用程序能够在运行时进行热插拔。本文将深入探讨如何利用OSGi的特性实现一个基于观察者模式的热...
OSGI.zip_osgi_osgi原理
09-14
它的核心理念是将Java应用程序分解为独立的、可热插拔的组件，这些组件被称为服务单元（Bundles）。OSGI使得开发人员可以独立地升级、安装、启动或停止这些服务单元，而不会影响到其他部分的正常运行。 OSGI的基本...
OSGI.rar_osgi_practice
09-22
它提供了一种动态、可热插拔的框架，使得开发者可以构建、部署和管理软件组件。在"OSGI in practice"中，我们将深入探讨OSGI的实际应用与开发技术。 1. **模块化系统**：OSGI的核心理念是将Java应用程序划分为独立...
Osgi的简单实现
04-19
Osgi（Open Services Gateway Initiative）是一种Java模块化系统，它允许开发者将应用程序分解为独立的、可热插拔的组件，这些组件被称为服务或bundle。在Eclipse这样的集成开发环境中，Osgi框架被广泛用于构建模块...
深入探索Java热部署
12-22
简介 　　在 Java 开发领域，热部署一直是一个难以解决的问题，目前的 Java 虚拟机只能实现方法体的修改热部署，对于整个类的结构修改，仍然需要重启虚拟机，对类重新加载才能完成更新操作。对于某些大型的应用来说，每次的重启都需 要花费大量的时间成本。虽然 osgi 架构的出现，让模块重启成为可能，但是如果模块之间有调用关系的话，这样的操作依然会让应用出现短暂的功能性休克。本文将探索如何在不破坏 Java 虚拟机现有行为的前提下，实现某个单一类的热部署，让系统无需重启完成某个类的更新。 　　类加载的探索 　　首先谈一下何为热部署（hotswap），热部署是在不重启 Java 虚拟机的前提
基于Eclipse开发OSGI的简单实例
10-12
1. **插件可热插拔**：OSGI允许在系统运行时动态安装、更新和卸载Bundle，实现软件的无缝升级。 2. **代码维护性**：Bundle之间的依赖关系仅存在于接口层面，有助于提高代码的可维护性。 3. **系统稳定性**：采用微...
OSGi规范与原理（杂）
CanftIn's blog
10-24 662
使用OSGI优缺点使用OSGI构建Java应用优点比较明显，主要体现在以下几个方面：1、基于OSGI的应用程序可动态更改运行状态和行为。在OSGI框架中，每一个Bundle实际上都是可热插拔的，因此，对一个特定的Bundle进行修改不会影响到容器中的所有应用，运行的大部分应用还是可以照常工作。当你将修改后的Bundle再部署上去的时候，容器从来没有重新启过。这种可动态更改状态的特性在一些及时性很强的
java模块化热插拔，讲的太透彻了
m0_57473261的博客
06-24 983
Part 1消息队列 介绍消息队列技术的背景，包括使用场景和消息队列的功能特点，并设计了一个简单的消息队列。 1.1 系统间通信技术介绍 1.2 为何要用消息队列 1.3 消息队列的功能特点 1.4 设计一个简单的消息队列 Part 2消息协议 介绍消息队列中常用的消息协议，包括每个消息协议的历史背景、主要概念和基于该协议的消息通信过程。本章所介绍的协议也是接下来理解各种消息中间件产品的基础。 2.1 AMQP 2.2 MQTT 2.3 STOMP 2.4 XMPP 2.5 JMS
热插拔式组件定制-论Spring-boot-starter实现
langfeiyes的博客
04-09 1820
热插拔式组件定制，手把手教你定制自己的Spring-boot-starter启动器~
OSGI（面向Java的动态模型系统）2
Truong的专栏
04-17 2701
OSGi(Open Service Gateway Initiative)技术是面向Java的动态模型系统。OSGi服务平台向Java提供服务，这些服务使Java成为软件集成和软件开发的首选环境。Java提供在多个平台支持产品的可移植性。OSGi技术提供允许应用程序使用精炼、可重用和可协作的组件构建的标准化原语。这些组件能够组装进一个应用和部署中。 目录 1基本简介
OSGi实战 笔记
weixin_43941593的博客
03-18 1364
目标：弥补java模块化的不足 架构：框架（运行环境）+标准服务（常见任务） 一、OSGi框架：三层 模块层 生命周期层 服务层 创建应用程序方法： 设计：服务接口+客户端 实现服务提供者和客户端组件 服务提供者和客户端组件打包为独立的jar文件，加上OSGi元数据 启动OSGi框架 安装启动jar文件 模块层 OSGi模块指bundle（含元数据的jar文件） 用META-INF/MANIFEST.MF文件添加元数据信息，声明导入包、导出包 Bundle-Description: One-Ping-O
java osgi 自动化运维,OSGI组件自动化测试的一种方案
weixin_33230433的博客
03-11 304
1. 背景介绍OSGi称做Java语言的动态模块系统，它为模块化应用的开发定义了一个基础架构。在产品设计中，OSGI是一种规范或者是一种基础结构，以OSGI的形式设计出产品的工作单元。在企业实际的应用中，也会采用spring DM框架来开发OSGI程序，通过maven管理OSGI组件的结构，并且也有多样的设计模式。本文在介绍OSGI，maven，spring DM的基础上，引入pax-exam对组...
java 9 osgi
12-13
Java 9 OSGi是指在Java 9平台上使用OSGi（开放服务网关接口）规范来构建和管理模块化的应用程序。OSGi是一种用于构建模块化、可扩展和动态更新的Java应用程序的标准。Java 9引入了模块系统，使得开发人员可以更轻松地创建和管理模块化的应用程序。 在Java 9中，OSGi框架可以与新的模块系统进行集成，使得开发人员能够更灵活地管理应用程序的依赖关系。通过使用Java 9的模块系统，开发人员可以将应用程序拆分为更小的模块，以便更好地管理依赖关系和提高可维护性。 另外，Java 9还引入了Jigsaw项目，用于实现Java平台的模块化。这使得Java 9的模块系统可以更好地与OSGi框架集成，并提供更强大的模块化功能。开发人员可以使用OSGi规范和Java 9的模块系统来构建灵活、可扩展的应用程序，从而更好地满足业务需求。 总之，Java 9 OSGi为开发人员提供了更强大、灵活的工具，使他们能够更轻松地构建和管理模块化的应用程序。通过将Java 9的模块系统与OSGi框架集成，开发人员可以更好地实现应用程序的模块化，提高可维护性和可扩展性。 Java 9 OSGi为Java平台的模块化带来了新的可能性，有助于提高应用程序的质量和性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值