在从消息存储中检索元素之后和序列执行之前，执行的WSO2 ESB消息处理器方法是什么？

我是WSO2 ESB的新手，尝试创建扩展WSO2采样处理器类的自定义消息处理器时遇到以下问题

SamplingProcessor类扩展了ScheduledMessageProcessor抽象类，该类反过来实现了MessageProcessor接口（因此我认为它应该包含消息处理器可以实现的所有方法的列表）

因此，为了实现我的定制消息处理器，我使用这个pom.xml文件创建了一个Maven项目（它应该符合构建定制消息处理器的要求）：

4.0.0
com.mycompany.toolkit
采样处理器头错误模拟
0.0.1-快照
捆
采样处理器头速率限制
使用响应头实现速率限制的自定义采样处理器
org.apache.maven.plugins
maven编译器插件
2
1.7
1.7
org.apache.felix
maven捆绑插件
2.3.4
真的
com.mycompany.toolkit.messageprocessor
com.mycompany.toolkit.messageprocessor
com.mycompany.toolkit*
*
${buildNumber}
${project.scm.connection}
每日的
忽视
wso2连接
http://maven.wso2.org/nexus/content/groups/wso2-public/
每日的
忽视
wso2连接
http://maven.wso2.org/nexus/content/groups/wso2-public/
org.apache.synapse
突触核
2.1.7-wso2v3
公用记录
公用记录
1.1.1
lib/突触/介体

然后，我创建了这个SamplingProcessorHeaderRatelSimulation，这是我的自定义消息处理器实现，它扩展了SamplingProcessor WSO2消息处理器类：

package com.mycompany.toolkit.messageprocessor;

import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.SynapseException;
import org.apache.synapse.core.SynapseEnvironment;
import org.apache.synapse.message.processor.impl.ScheduledMessageProcessor;
import org.apache.synapse.message.processor.impl.sampler.SamplingProcessor;
import org.apache.synapse.message.processor.impl.sampler.SamplingProcessorView;

public class SamplingProcessorHeaderRateLimitation extends SamplingProcessor {

    private static final Log logger = LogFactory.getLog(ScheduledMessageProcessor.class.getName());
    private SamplingProcessorView view;

    @Override
    public void init(SynapseEnvironment se) {
        super.init(se);

        logger.info("init() START");
        System.out.println("init() START");

        try {
            view = new SamplingProcessorView(this);
        } catch (Exception e) {
            throw new SynapseException(e);
        }

        // register MBean
        org.apache.synapse.commons.jmx.MBeanRegistrar.getInstance().registerMBean(view,
                "Message Sampling Processor view", getName());

        logger.info("init() END");
        System.out.println("init() END");
    }

    @Override
    public void setParameters(Map<String, Object> parameters) {
        logger.info("setParameters() START");
        System.out.println("setParameters() START");
        // TODO Auto-generated method stub
        super.setParameters(parameters);

        logger.info("setParameters() END");
        System.out.println("setParameters() END");
    }
}

package com.mycompany.toolkit.messageprocessor；
导入java.util.Map；
导入org.apache.commons.logging.Log；
导入org.apache.commons.logging.LogFactory；
导入org.apache.synapse.SynapseException；
导入org.apache.synapse.core.SynapseEnvironment；
导入org.apache.synapse.message.processor.impl.ScheduledMessageProcessor；
导入org.apache.synapse.message.processor.impl.sampler.SamplingProcessor；
导入org.apache.synapse.message.processor.impl.sampler.SamplingProcessorView；
公共类SamplingProcessor HeaderRatelSimulation扩展了SamplingProcessor{
私有静态最终日志记录器=LogFactory.getLog（ScheduledMessageProcessor.class.getName（））；
私有采样处理器视图；
@凌驾
公共无效初始（SynapseEnvironment se）{
超级初始化（se）；
info（“init（）START”）；
System.out.println（“init（）START”）；
试一试{
视图=新采样处理器视图（此）；
}捕获（例外e）{
抛出新的突触异常（e）；
}
//寄存器MBean
org.apache.synapse.commons.jmx.mbeanregister.getInstance（）.registerMBean（视图，
“消息采样处理器视图”，getName（））；
logger.info（“init（）END”）；
System.out.println（“init（）END”）；
}
@凌驾
公共void setParameters（映射参数）{
info（“setParameters（）START”）；
System.out.println（“setParameters（）START”）；
//TODO自动生成的方法存根
super.setParameters（参数）；
logger.info（“setParameters（）END”）；
System.out.println（“setParameters（）END”）；
}
}

最后，我在ESB消息处理器定义中使用自定义的采样处理器HeaderRatelSimulation类（而不是标准的采样处理器）：

转移处理器序列
1000
真的
1.

此消息处理器为从transferFromMessageStore消息存储检索到的每个元素执行transferProcessorSequence.xml序列

它工作正常，但正如您所看到的，我将一些logger.info（）放入了自定义实现的init（）和setParameters（）方法中。它工作正常，但这些方法仅在消息处理器初始化时执行一次

我需要知道每次从transferFromMessageStore消息存储检索元素时执行的方法是什么，因为这里我必须实现一个自定义操作

那么，在从与消息处理器相关的消息存储中检索元素之后，在执行相关序列之前，执行什么方法？（对我来说，了解检索元素之后和序列执行之前的方法非常重要）

使用Luke

重点是：

boolean setMessageConsumer(MessageConsumer messageConsumer);
List<MessageConsumer> getMessageConsumer();

---

由于存储和使用存储中的消息是相反的操作，因此所有这些java类都应该彼此相邻。您所需要的一切都必须在同一个文件夹中。

为了在每次消息使用和发送到序列之间进行自定义实现，需要扩展类SamplingService。

org.apache.synapse.message.processor.impl.sampler.SamplingService.java

B

<?xml version="1.0" encoding="UTF-8"?>
<!---<messageProcessor class="org.apache.synapse.message.processor.impl.sampler.SamplingProcessor" messageStore="transferFromMessageStore" name="transferFromMessageProcessor" xmlns="http://ws.apache.org/ns/synapse">-->
<messageProcessor class="com.mycompany.toolkit.messageprocessor.SamplingProcessorHeaderRateLimitation" messageStore="transferFromMessageStore" name="transferFromMessageProcessor" xmlns="http://ws.apache.org/ns/synapse">
    <parameter name="sequence">transferProcessorSequence</parameter>
    <parameter name="interval">1000</parameter>
    <parameter name="is.active">true</parameter>
    <parameter name="concurrency">1</parameter>
</messageProcessor>

boolean setMessageConsumer(MessageConsumer messageConsumer);
List<MessageConsumer> getMessageConsumer();

/**
 * This method is used to set the message consumer of message processor. Consumer is the one who is
 * responsible for retrieving messages from a store.
 * @param messageConsumer is the name of the associated message consumer
 * @return is true if the message if the message consumer is returned successfully. Otherwise false.
 */

public MessageContext fetch(MessageConsumer msgConsumer) {
MessageContext newMsg = super.fetch(msgConsumer);
// custom code here
return newMsg;
}