This section mainly explains the service discovery and routing of osmp. osmp publishes a cxf restful service through the osmp-http component. All requests accept the request through the restful interface, parse the request, and then call the osgi service to complete the request and return to the front end.
request->restful interface of osmp-http->parse request->osgi service discovery->service routing->call service->return-->assemble return parameters->return
osmp manages services in a unified manner through the osmp-service component. The main functions include service monitoring, bundle monitoring, service container management, and service registration to zookeeper.
In osgi, you can use the ServiceTracker service tracker to track the addition, modification, deletion and other operations of a certain type of interface service, and register the bundle listener ( BundleListener ) through BundlerContext.addBundleListener() to monitor the events of each bundle life cycle, such as bundle installation, uninstallation, update, start, stop and other events.
In order to facilitate the unified management of services, osmp requires that all services must implement the BaseDataService interface defined in osmp-intf-define . In this way, we can track the service addition, modification, deletion and other events of the BaseDataService interface through the service tracker!
For the specific code, please refer to the ServiceWatcher.java class in osmp-service
/*
* Project: OSMP
* FileName: ServiceWatcher.java
* version: V1.0
*/
package com.osmp.service.watch;
import java.util.Date;
import java.util.UUID;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleListener;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.osgi.context.BundleContextAware;
import org.springframework.util.Assert;
import com.osmp.intf.define.config.FrameConst;
import com.osmp.intf.define.interceptor.ServiceInterceptor;
import com.osmp.intf.define.service.BaseDataService;
import com.osmp.intf.define.service.ZookeeperService;
import com.osmp.service.bean.DataServiceInfo;
import com.osmp.service.bean.InterceptorInfo;
import com.osmp.service.factory.ServiceFactoryImpl;
import com.osmp.service.manager.ServiceStateManager;
import com.osmp.service.registration.ServiceContainer;
import com.osmp.service.util.ServiceUtil;
import com.osmp.utils.net.RequestInfoHelper;
/**
*
* Description: Service registration, cancellation, monitoring
* @author: wangkaiping
*@date: Aug 9, 2016 10:27:15AM 10:51:30AM
*/
public class ServiceWatcher implements BundleContextAware, InitializingBean, DisposableBean {
private Logger logger = LoggerFactory.getLogger(ServiceWatcher.class);
private ServiceTracker dataServiceTracker;
private ServiceTracker serviceInterceptorTracker;
private ServiceStateManager serviceStateManager;
private ServiceFactoryImpl serviceFactoryImpl;
private BundleContext context;
private ZookeeperService zookeeper;
private final static String NODE_CHANGE = "/osmp/nodechange";
@Override
public void setBundleContext(BundleContext context) {
this.context = context;
}
public void setServiceFactoryImpl(ServiceFactoryImpl serviceFactoryImpl) {
this.serviceFactoryImpl = serviceFactoryImpl;
}
public void setServiceStateManager(ServiceStateManager serviceStateManager) {
this.serviceStateManager = serviceStateManager;
}
public void setZookeeper(ZookeeperService zookeeper) {
this.zookeeper = zookeeper;
}
@Override
public void destroy() throws Exception {
if (dataServiceTracker != null) {
dataServiceTracker.close();
}
if (serviceInterceptorTracker != null) {
serviceInterceptorTracker.close();
}
logger.info("Service monitoring ended");
}
@Override
public void afterPropertiesSet() throws Exception {
Assert.notNull(context);
Assert.notNull(serviceStateManager);
Assert.notNull(serviceFactoryImpl);
dataServiceTracker = new ServiceTracker(context, BaseDataService.class.getName(),
new DataServiceTrackerCustomizer());
serviceInterceptorTracker = new ServiceTracker(context, ServiceInterceptor.class.getName(),
new ServiceInterceptorTrackerCustomizer());
dataServiceTracker.open(true);
serviceInterceptorTracker.open(true);
context.addBundleListener(new BundleListener() {
@Override
public void bundleChanged(BundleEvent event) {
if (event.getType() == BundleEvent.UNINSTALLED) {
String name = event.getBundle().getSymbolicName();
try {
logger.info("uninstall bundle " + name);
zookeeper.deleteNodeByBundle(name);
ServiceWatcher.this.nodeUpdate();
} catch (Exception e) {
logger.error(
"zookeeper delete service by bundle, bundle name : "
+ name, e);
}
}
}
});
logger.info("Service monitoring started");
}
// dataService listens
private class DataServiceTrackerCustomizer implements ServiceTrackerCustomizer {
@Override
public Object addingService(ServiceReference reference) {
BaseDataService bsService = (BaseDataService) context.getService(reference);
String bundleName = reference.getBundle().getSymbolicName();
String bundleVersion = reference.getBundle().getVersion().toString();
Object name = reference.getProperty(FrameConst.SERVICE_NAME);
if (name == null || "".equals(name)) {
logger.error("组件" + bundleName + "(" + bundleVersion
+ ") dataService service name is not set");
return bsService;
}
Object mark = reference.getProperty(FrameConst.SERVICE_MARK);
ServiceContainer.getInstance().putDataService(bundleName, bundleVersion, name.toString(), bsService);
DataServiceInfo info = new DataServiceInfo();
info.setBundle(bundleName);
info.setVersion(bundleVersion);
info.setName(name.toString());
info.setState(1);
info.setUpdateTime(new Date());
info.setMark(mark == null ? "" : mark.toString());
serviceStateManager.updateDataService(info);
String path = ZookeeperService.ROOT_PATH
+ ZookeeperService.SERVICE + "/"
+ RequestInfoHelper.getLocalIp() + "/";
logger.debug("register service path: " + path + " bundle : " + bundleName + " to zookeeper ");
ServiceWatcher.this.registerService(path, info);
return bsService;
}
@Override
public void modifiedService(ServiceReference reference, Object service) {
}
@Override
public void removedService(ServiceReference reference, Object service) {
String bundleName = reference.getBundle().getSymbolicName();
String bundleVersion = reference.getBundle().getVersion()
.toString();
Object name = reference.getProperty(FrameConst.SERVICE_NAME);
if (name == null || "".equals(name)) {
logger.error("组件" + bundleName + "(" + bundleVersion
+ ") dataService service name is not set");
return;
}
ServiceContainer.getInstance().removeDataService(bundleName, bundleVersion, name.toString());
Object mark = reference.getProperty(FrameConst.SERVICE_MARK);
DataServiceInfo info = new DataServiceInfo();
info.setBundle(bundleName);
info.setVersion(bundleVersion);
info.setName(name.toString());
info.setState(0);
info.setMark(mark == null ? "" : mark.toString());
info.setUpdateTime(new Date());
serviceStateManager.updateDataService(info);
System.out.println("===============remove service bundleName:"
+ bundleName + " name: " + name.toString() + " mark: "
+ mark.toString());
String path = ZookeeperService.ROOT_PATH
+ ZookeeperService.SERVICE + "/"
+ RequestInfoHelper.getLocalIp() + "/";
ServiceWatcher.this.unRegisterService(path, info);
}
}
// ServiceInterceptor listening
private class ServiceInterceptorTrackerCustomizer implements ServiceTrackerCustomizer {
@Override
public Object addingService(ServiceReference reference) {
ServiceInterceptor sicpt = (ServiceInterceptor) context.getService(reference);
String bundleName = reference.getBundle().getSymbolicName();
String bundleVersion = reference.getBundle().getVersion().toString();
Object name = reference.getProperty(FrameConst.SERVICE_NAME);
if (name == null || "".equals(name)) {
logger.error("组件" + bundleName + "(" + bundleVersion
+ ") serviceInterceptor service name is not set");
return sicpt;
}
Object mark = reference.getProperty(FrameConst.SERVICE_MARK);
ServiceContainer.getInstance (). PutInterceptor (
ServiceUtil.generateServiceName(bundleName, bundleVersion, name.toString()), sicpt);
InterceptorInfo info = new InterceptorInfo();
info.setBundle(bundleName);
info.setVersion(bundleVersion);
info.setName(name.toString());
info.setState(1);
info.setUpdateTime(new Date());
info.setMark(mark == null ? "" : mark.toString());
serviceStateManager.updateServiceInterceptor(info);
return sicpt;
}
@Override
public void modifiedService(ServiceReference reference, Object service) {
}
@Override
public void removedService(ServiceReference reference, Object service) {
String bundleName = reference.getBundle().getSymbolicName();
String bundleVersion = reference.getBundle().getVersion().toString();
Object name = reference.getProperty(FrameConst.SERVICE_NAME);
if (name == null || "".equals(name)) {
logger.error("组件" + bundleName + "(" + bundleVersion
+ ") serviceInterceptor service name is not set");
return;
}
Object mark = reference.getProperty(FrameConst.SERVICE_MARK);
ServiceContainer.getInstance().removeInterceptor(
ServiceUtil.generateServiceName(bundleName, bundleVersion, name.toString()));
InterceptorInfo info = new InterceptorInfo();
info.setBundle(bundleName);
info.setVersion(bundleVersion);
info.setName(name.toString());
info.setState(0);
info.setMark(mark == null ? "" : mark.toString());
info.setUpdateTime(new Date());
serviceStateManager.updateServiceInterceptor(info);
}
}
/**
* Register the service with zookeeper
*
* @param path
* @param ds
*/
public void registerService(String path, DataServiceInfo ds) {
String bundle = ds.getBundle();
String cname = ds.getMark();
String name = ds.getName();
String version = ds.getVersion();
String status = String.valueOf(ds.getState());
try {
if (!zookeeper.exists(path + name)) {
zookeeper.createNode(path + name);
}
if (!zookeeper.exists(path + name + "/bundle")) {
zookeeper.createNode(path + name + "/bundle", bundle);
} else {
zookeeper.setNodeData(path + name + "/bundle", bundle);
}
if (!zookeeper.exists(path + name + "/cname")) {
zookeeper.createNode(path + name + "/cname", cname);
} else {
zookeeper.setNodeData(path + name + "/cname", cname);
}
if (!zookeeper.exists(path + name + "/version")) {
zookeeper.createNode(path + name + "/version", version);
} else {
zookeeper.setNodeData(path + name + "/version", version);
}
if (!zookeeper.exists(path + name + "/status")) {
zookeeper.createNode(path + name + "/status", status);
} else {
zookeeper.setNodeData(path + name + "/status", status);
}
this.nodeUpdate();
} catch (Exception e) {
e.printStackTrace ();
logger.error("zookeeper register service fail, service name : "
+ name, e);
}
}
/**
* Uninstall service
*
* @param path
* @param ds
*/
public void unRegisterService(String path, DataServiceInfo ds) {
String name = ds.getName();
try {
if (zookeeper.exists(path + name + "/status")) {
zookeeper.setNodeData(path + name + "/status",
String.valueOf(ds.getState()));
this.nodeUpdate();
}
} catch (Exception e) {
e.printStackTrace ();
logger.error("zookeeper unRegister service fail, service name : "
+ name, e);
}
}
/**
* Update node state changes
*/
public void nodeUpdate(){
String data = UUID.randomUUID().toString();
try {
if(zookeeper.exists(NODE_CHANGE)){
zookeeper.setNodeData(NODE_CHANGE, data);
}else{
zookeeper.createNode(NODE_CHANGE);
zookeeper.setNodeData(NODE_CHANGE, data);
}
} catch (Exception e) {
logger.error("Update node change status error", e);
}
}
}
- ServiceWatcher implements the BundleContextAware interface and sets the BundleContext in it.
- When ServiceWatcher is initialized, two service trackers (ServiceTracker) are instantiated to track the services of BaseDataService and ServiceInterceptor interfaces respectively.
- When ServiceWatcher is initialized, add a Bunlde listener to the BundleContext to monitor the events of the bundle
- ServiceTracker needs to pass a ServiceTrackerCustomizer instance to specifically execute the monitored events. Here we use the DataServiceTrackerCustomizer to specifically execute the BaseDataService interface service tracking operation.
- When the BaseDataService service is published to the osgi container, the DataServiceTrackerCustomizer.addingService(ServiceReference reference) method will be called automatically. Through BundleContext.getService(ServiceReference reference), we can get the services currently published in the osgi container.
- By obtaining the bundleName, bundleVersion, and the tag label (name) defined when the service was published before, a unique key (bundleName+bundleVersion+name) is formed to obtain the service as the value. Save this to the service container (Map).
Note: Please ignore for the time being that the monitored services are saved in the database and registered to zookeeper in osmp-service, and will be explained in detail later in osmp registration.
Service discovery and routing:
After receiving the request, osmp-http parses the service name, and queries whether the service is bound with an interceptor through the service. If an interceptor is bound, the interceptor chain is executed first. If the interceptor fails to execute, it will return directly. If the interceptor executes If successful, the service is obtained through the service name. After the service is successfully obtained, the execute method of the service is directly executed, and the result is returned!
Here is a simple point. The specific osmp encapsulates a layer of proxy implementation. If you are interested, you can directly view the osmp-http source code.
So far, the service discovery and service invocation functions of osmp are here!