Question

人。我是AEM的新手，有问题。我需要从我自己执行com.day.cq.dam.core.process.UnarchiverProcess进程（继承自AbstractAssetWorkflowProcess）。所以我需要这样的东西（下面的代码显然不起作用）：

import com.day.cq.dam.core.process.UnarchiverProcess;
public class FirstProcess extends AbstractAssetWorkflowProcess {
       public final void execute(final WorkItem item, final WorkflowSession wfSession, final MetaDataMap args)
                throws WorkflowException {
    UnarchiverProcess unarchiverProcess = new UnarchiverProcess();
    unarchiverProcess.execute(item,wfSession,args);
    return;
}

有什么办法吗？谢谢！

Answer 1

UnarchiverProcess是一个独立的流程，有理由创建一个自定义步骤来调用UnarchiverProcess。您只需在工作流模型中添加另一个流程步骤，然后为UnarchiverProcess配置它。

如果你想这样做（我不推荐这个，除非你有充分理由这样做），有两种可能性 -

首先：

仅使用UnarchiverProcess

工作流模型

在您的流程步骤中，使用WorkflowSession获取上述工作流程的WorkflowModel（WorkflowSession.getModel(....)），并致电WorkflowSession.startWorkflow(....)以调用流程步骤。

当您从工作流程过程调用另一个工作流程时，这不是一种有效的方法。工作流是消耗资源的任务，因此如果在高负载下调用此工作流将导致实例运行速度变慢。

第二次：

每个工作流程都被重新作为OSGi服务，因此可以注入其他OSGi服务。
您可以在自定义流程中注入UnarchiverProcess。但挑战在于所有工作流程都是通过其界面注册的，因此所有流程都注册为WorkflowProcess，因此您需要一种方法来过滤掉您需要的唯一实施，即UnarchiverProcess

@Reference（target =＆＃34;（component.name = com.day.cq.dam.core.process.UnarchiverProcess）＆＃34;） WorkflowProcess workflowProcess;

有关详细信息，请参阅文章here。

在这种方法中，您不是要调用另一个进程，而是注入服务引用并调用其方法。

我仍然建议在此流程的工作流程中添加另一个步骤，因为它更简洁，您不需要为此维护代码。

更新：

如果服务过滤不起作用，你可以去OSGI Bundle上下文路由（添加缺少的导入） -

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Service;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.component.ComponentFactory;
import org.osgi.service.component.ComponentInstance;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by ameesh.trikha on 2/24/16.
 */

@Service
@Component
public class YourWorkflowClass implements WorkflowProcess {

    private BundleContext bundleContext;
    private Map<String, ServiceReference> serviceReferenceMap = new ConcurrentHashMap<>();
    private Map<String, ComponentInstance> componentInstanceMap = new ConcurrentHashMap();

    @Activate
    protected void activate(ComponentContext context) {
        this.bundleContext = context.getBundleContext();
    }

    @Deactivate
    protected void deactivate(ComponentContext context) {

        synchronized (this.serviceReferenceMap) {
            for(Map.Entry<String,ComponentInstance> componentInstance : this.componentInstanceMap.entrySet()) {
                componentInstance.getValue().dispose();
            }

            for(Map.Entry<String, ServiceReference> serviceReference : this.serviceReferenceMap.entrySet()) {
                this.bundleContext.ungetService(serviceReference.getValue());
            }
        }
        this.componentInstanceMap.clear();
        this.serviceReferenceMap.clear();
        this.bundleContext = null;
    }


    public UnarchiverProcess getUnarchiverProcess() {

        ServiceReference [] serviceReferences;

        String serviceIdentifier = "component.name="+UnarchiverProcess.class.getName();
        if (this.componentInstanceMap.containsKey(serviceIdentifier)) {
            final ComponentInstance componentInstance = this.componentInstanceMap.get(serviceIdentifier);
            return (UnarchiverProcess) componentInstance.getInstance();
        }

        try {
            serviceReferences = this.bundleContext.getServiceReferences(ComponentFactory.class.getName(), serviceIdentifier);
        } catch (InvalidSyntaxException ise) {

            LOGGER.error("Could'nt get Service reference for {}", serviceIdentifier, ise);
            return null;
        }

        if (null != serviceReferences && serviceReferences.length > 0) {
            final ServiceReference serviceReference = serviceReferences[0];
            final ComponentFactory componentFactory = (ComponentFactory) this.bundleContext.getService(serviceReference);
            final ComponentInstance componentInstance = componentFactory.newInstance(null);
            final UnarchiverProcess unarchiverProcess = (UnarchiverProcess) componentInstance.getInstance();
            if (unarchiverProcess == null) {
                LOGGER.error("Unable to get " + serviceIdentifier);
                componentInstance.dispose();
                this.bundleContext.ungetService(serviceReference);
            } else {
                synchronized (this.serviceReferenceMap) {
                    this.serviceReferenceMap.put(serviceIdentifier, serviceReference);
                    this.componentInstanceMap.put(serviceIdentifier, componentInstance);
                }
            }

            return unarchiverProcess;
        }

        return null;
    }

}

从其他工作流程运行工作流程

1 个答案: