Java CommandCallback类代码示例

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
/**
 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
 */
  
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("text/html");
    String itemId=request.getParameter("id");
    Integer quantity=Integer.parseInt(request.getParameter("quantity"));
    AddItemCommand addItemCommand=new AddItemCommand(itemId);
    addItemCommand.setQuantity(quantity);
    
    logger.debug("quantity:" + quantity);
    logger.debug("id:" + itemId);
    //asynchronous call - callback registered
    CommandCallback commandCallback = new CommandCallback<Object>() {
        @Override
        public void onSuccess(Object result) {
        	logger.debug("Expected this command to fail");
        }

        @Override
        public void onFailure(Throwable cause) {
        	logger.debug("command exception", cause.getMessage());
        }
    };
    commandGateway.send(addItemCommand, commandCallback);
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void onHzCommandReply(final HzCommandReply reply) {
    m_logger.debug("Got HzCommandReply from <{}>",reply.getNodeName());

    CommandCallback cbk = m_agent.getCallback(reply.getCommandId());

    if(cbk != null) {
        if(reply.isSuccess()) {
            cbk.onSuccess(reply.getReturnValue());
        } else {
            cbk.onFailure(reply.getError());
        }
    } else {
        m_logger.warn("No callback registered for <{}>",reply.getCommandId());
    }
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
public CommandProcessor(AxonMessageSerializer serializer, CommandBus localCommandBus,
                        CommandCallback<Object, Object> commandCallback,
                        ConsumerService consumerService, String name, int threads) {
    this.serializer = serializer;
    this.localCommandBus = localCommandBus;
    this.commandCallback = commandCallback;
    this.consumerService = consumerService;
    this.name = name;
    this.threads = threads;
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public <R> void send(String routingKey, CommandMessage<?> command, CommandCallback<R> callback) throws Exception {
    String destination = getCommandDestination(routingKey, command);
    m_logger.debug("Send command <{}> to <{}>",command.getIdentifier(),destination);

    if(StringUtils.isNotBlank(destination)) {
        try {
            m_hzInstance.getQueue(destination)
                .put(new HzCommand(m_agent.getNodeName(), command, true));

            if(callback != null) {
                m_agent.registerCallback(command,new HzCommandCallback(callback));
            } else {
                m_agent.registerCallback(command,new HzCommandCallback(
                    true,
                    new CommandCallback<Object>() {
                        @Override
                        public void onSuccess(Object result) {
                            m_logger.debug("onSuccess : <{}>",result);
                        }

                        @Override
                        public void onFailure(Throwable cause) {
                            m_logger.warn("onFailure", cause);
                        }
                    }
                ));
            }
        } catch(Exception e) {
            m_agent.removeCallback(command);
            m_logger.warn("Exception,e");
            throw e;
        }
    }
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <R> void send(String routingKey, CommandMessage<?> command, CommandCallback<R> callback) throws Exception {
    try {
        // put a key as placeholder
        m_hzInstance.getMap(HzConstants.REG_AGGREGATES).put(
            routingKey,
            m_hzInstance.getName());

        Future<HzCommandReply> fr = m_executor.submitToKeyOwner(
            new HzCommandTask(new HzCommand(m_nodeName,command,true)),
            routingKey);

        HzCommandReply reply = fr.get();

        if(callback != null) {
            if(reply.isSuccess()) {
                LOGGER.debug("HzCommandReply.CommandId {}",reply.getCommandId());
                LOGGER.debug("HzCommandReply.NodeName  {}",reply.getNodeName());
                callback.onSuccess((R)reply.getReturnValue());
            } else {
                LOGGER.debug("HzCommandReply.CommandId {}",reply.getCommandId());
                LOGGER.debug("HzCommandReply.NodeName  {}",reply.getNodeName());
                callback.onFailure(reply.getError());
            }
        }
    } catch(Exception e) {
        m_logger.warn("Exception",e);
        throw e;
    }
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
public <R> void send(Object command, CommandCallback<R> callback) {
    m_commandGateway.send(command,callback);
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
public <R> void send(Object command, CommandCallback<R> callback) {
    m_cmdGw.send(command,callback);
}
 

import org.axonframework.commandhandling.CommandCallback; //导入依赖的package包/类
/**
 * c-tor
 *
 * @param callback the callback
 */
public HzCommandCallback(CommandCallback<T> callback) {
    this(false, callback);
}