OFBiz业务方法里面,当执行一个 service 的时候,通常采用如下的方式:
LocalDispatcher 是本地调度器,实现服务的同步异步调度和定时任务的调度。与服务调度相关的类图如下:
LocalDispatcher 是一个接口,实例化的都是 GenericDispatcher 类,ContextFilter 实现了ServletFilter,会初始化一个 GenericDispatcher ,并将其存放在 ServletContext 中,以备整个应用使用。
在请求处理过程中,如果遇到 service 的 event ,那么 EventHandler 会使用 LocalDispatcher 执行 service 。
实际上 GenericDispatcher 只是一个 Proxy ,自己并不处理相关的调度工作,真正最苦最累的调度工作是由 ServiceDispatcher 完成的。下面具体研究一下 Dispatcher 同步和异步调用方法的实现代码:
通过 dispatcher 调用 runSync 方法,也即是调用 GenericDispatcher 的 runSync 方法:
但最终调用 service 的是 GenericEngine 。
Java 的 StandardJavaEnignerunSync 方法采用的是反射来执行相应的方法,如下:
对于Job的执行,可以看另一篇文章OFBiz中Job的运行机制。
LocalDispatcher dispatcher = dctx.getDispatcher();
Map<String, Object> result = dispatcher.runSync(getServiceName(), getContext());
LocalDispatcher 是本地调度器,实现服务的同步异步调度和定时任务的调度。与服务调度相关的类图如下:
LocalDispatcher 是一个接口,实例化的都是 GenericDispatcher 类,ContextFilter 实现了ServletFilter,会初始化一个 GenericDispatcher ,并将其存放在 ServletContext 中,以备整个应用使用。
在请求处理过程中,如果遇到 service 的 event ,那么 EventHandler 会使用 LocalDispatcher 执行 service 。
实际上 GenericDispatcher 只是一个 Proxy ,自己并不处理相关的调度工作,真正最苦最累的调度工作是由 ServiceDispatcher 完成的。下面具体研究一下 Dispatcher 同步和异步调用方法的实现代码:
1.同步调用
通过 dispatcher 调用 runSync 方法,也即是调用 GenericDispatcher 的 runSync 方法:
/**
* @see org.ofbiz.service.LocalDispatcher#runSync(java.lang.String, java.util.Map)
*/
public Map<String, Object> runSync(String serviceName, Map<String, ? extends Object> context)
throws ServiceValidationException, GenericServiceException{
ModelService service = ctx.getModelService(serviceName);
return dispatcher.runSync(this.name, service, context);
}
dispatcher 实际是 ServiceDispatcher 对象。ServiceDispatcher 的 runSync 方法有三百多行,比较复杂,
但最终调用 service 的是 GenericEngine 。
GenericEngine engine = this.getGenericEngine(modelService.engineName);
……
Map<String, Object> invokeResult = engine.runSync(localName, modelService, context);
GenericEngine 是其工厂类 GenericEngineFactory 获取的,这个 Factory 类非常简单:
public class GenericEngineFactory {
protected ServiceDispatcher dispatcher = null;
protected Map<String, GenericEngine> engines = null;
public GenericEngineFactory(ServiceDispatcher dispatcher) {
this.dispatcher = dispatcher;
engines = FastMap.newInstance();
}
/**
* Gets the GenericEngine instance that corresponds to given the name
*@param engineName Name of the engine
*@return GenericEngine that corresponds to the engineName
*/
public GenericEngine getGenericEngine(String engineName) throws GenericServiceException {
Element rootElement = null;
try {
rootElement = ServiceConfigUtil.getXmlRootElement();
} catch (GenericConfigException e) {
throw new GenericServiceException("Error getting Service Engine XML root element", e);
}
Element engineElement = UtilXml.firstChildElement(rootElement, "engine", "name", engineName);
if (engineElement == null) {
throw new GenericServiceException("Cannot find a service engine definition for the engine name [" + engineName + "] in the serviceengine.xml file");
}
String className = engineElement.getAttribute("class");
GenericEngine engine = engines.get(engineName);
if (engine == null) {
synchronized (GenericEngineFactory.class) {
engine = engines.get(engineName);
if (engine == null) {
try {
ClassLoader loader = Thread.currentThread().getContextClassLoader();
Class<?> c = loader.loadClass(className);
Constructor cn = c.getConstructor(ServiceDispatcher.class);
engine = (GenericEngine) cn.newInstance(dispatcher);
} catch (Exception e) {
throw new GenericServiceException(e.getMessage(), e);
}
if (engine != null) {
engines.put(engineName, engine);
}
}
}
}
return engine;
}
}
从配置文件 serviceengine.xml 文件中获取相应的 engine 子类,
如 java的是 org.ofbiz.service.engine.StandardJavaEngine
bsh的是 org.ofbiz.service.engine.BeanShellEngineJava 的 StandardJavaEnignerunSync 方法采用的是反射来执行相应的方法,如下:
Class<?> c = cl.loadClass(this.getLocation(modelService));
Method m = c.getMethod(modelService.invoke, DispatchContext.class, Map.class);
result = m.invoke(null, dctx, context);
不同的Engine实现的方式不一样。
异步调用怎么实现的呢?
实现异步的原理就是启动一个线程来执行相应的业务逻辑,原方法直接返回,从而实现异步。
具体实现的时候可以根据实际情况而定,比如将业务逻辑封装成一个任务,将此任务放到一个任务链中,线程池采用先进先出的方式来选择任务进行执行。
OFBiz中怎么实现呢?具体查看GenericAsyncEngine的runAsync方法发现是通过一个生成一个Job来实现的:
job = new GenericServiceJob(dctx, jobId, name, modelService.name, context, requester);
try {
dispatcher.getJobManager().runJob(job);
} catch (JobManagerException jse) {
throw new GenericServiceException("Cannot run job.", jse);
}
对于Job的执行,可以看另一篇文章OFBiz中Job的运行机制。