protected OperationClient(AxisOperation axisOp,
    ServiceContext sc,
    Options options) 
{
        this.axisOp = axisOp;
        this.sc = sc;
        this.options = new Options(options);
        completed = false;
        oc = sc.createOperationContext(axisOp);
}

 abstract public  void addMessageContext(MessageContext messageContext) throws AxisFault
Add a message context to the client for processing. This method must not
process the message - it only records it in the operation client.
Processing only occurs when execute() is called.

 protected  void addReferenceParameters(MessageContext msgctx) 
{
        EndpointReference to = msgctx.getTo();
        if (options.isManageSession() || (options.getParent() != null &&
                options.getParent().isManageSession())) {
            EndpointReference tepr = sc.getTargetEPR();
            if (tepr != null) {
                Map< QName, OMElement > map = tepr.getAllReferenceParameters();
                if (map != null) {
                    Iterator< OMElement > valuse = map.values().iterator();
                    while (valuse.hasNext()) {
                        Object refparaelement = valuse.next();
                        if (refparaelement instanceof OMElement) {
                            to.addReferenceParameter((OMElement) refparaelement);
                        }
                    }
                }
            }
        }
}

 public  void complete(MessageContext msgCtxt) throws AxisFault 
{
        TransportOutDescription trsout = msgCtxt.getTransportOut();
        if (trsout != null) {
            trsout.getSender().cleanup(msgCtxt);
        }
}

To close the transport if necessary , can call this method. The main usage of this method is when client uses two tarnsports for sending and receiving , and we need to remove entries for waiting calls in the transport listener queue. Note : DO NOT call this method if you are not using two transports to send and receive

 public final  void execute(boolean block) throws AxisFault 
{
        sc.setLastOperationContext(oc);
        executeImpl(block);
}

Execute the MEP. This method is final and only serves to set (if appropriate) the lastOperationContext on the ServiceContext, and then it calls executeImpl(), which does the actual work.

 abstract public  void executeImpl(boolean block) throws AxisFault
Execute the MEP. What this does depends on the specific operation client.
The basic idea is to have the operation client execute and do something
with the messages that have been added to it so far. For example, if its
an Out-In MEP, then if the Out message has been set, then executing the
client asks it to send the message and get the In message, possibly using
a different thread.

 abstract public MessageContext getMessageContext(String messageLabel) throws AxisFault
Return a message from the client - will return null if the requested
message is not available.

 public OperationContext getOperationContext() 
{
        return oc;
}

To get the operation context of the operation client

 public Options getOptions() 
{
        return options;
}

Return the options used by this client. If you want to set a single option, then the right way is to do getOptions() and set specific options.

 protected  void prepareMessageContext(ConfigurationContext configurationContext,
    MessageContext mc) throws AxisFault 
{
        // set options on the message context
        if (mc.getSoapAction() == null || "".equals(mc.getSoapAction())) {
            mc.setSoapAction(options.getAction());
        }
        mc.setOptions(new Options(options));
        mc.setAxisMessage(axisOp.getMessage(WSDLConstants.MESSAGE_LABEL_OUT_VALUE));
        // do Target Resolution
        TargetResolver targetResolver =
                configurationContext.getAxisConfiguration().getTargetResolverChain();
        if (targetResolver != null) {
            targetResolver.resolveTarget(mc);
        }
        // if the transport to use for sending is not specified, try to find it
        // from the URL
        TransportOutDescription senderTransport = options.getTransportOut();
        if (senderTransport == null) {
            EndpointReference toEPR = (options.getTo() != null) ? options
                    .getTo() : mc.getTo();
            senderTransport = ClientUtils.inferOutTransport(configurationContext
                    .getAxisConfiguration(), toEPR, mc);
        }
        mc.setTransportOut(senderTransport);
        if (options.getParent() !=null && options.getParent().isManageSession()) {
            mc.getOptions().setManageSession(true);
        } else if (options.isManageSession()) {
            mc.getOptions().setManageSession(true);
        }
        addReferenceParameters(mc);
}

prepareMessageContext gets a fresh new MessageContext ready to be sent. It sets up the necessary properties, transport information, etc.

 public  void reset() throws AxisFault 
{
        if (!completed) {
            throw new AxisFault(Messages.getMessage("cannotreset"));
        }
        oc = null;
        completed = false;
}

Reset the operation client to a clean status after the MEP has completed. This is how you can reuse an operation client. NOTE: this does not reset the options; only the internal state so the client can be used again.

 abstract public  void setCallback(Callback callback)Deprecated! Please -  use the AxisCallback interface rather than Callback, which has been deprecated

Set the callback to be executed when a message comes into the MEP and the
operation client is executed. This is the way the operation client
provides notification that a message has been received by it. Exactly
when its executed and under what conditions is a function of the specific
operation client.

 public final  void setCallback(AxisCallback callback) 
{
        axisCallback = callback;
}

Set the callback to be executed when a message comes into the MEP and the operation client is executed. This is the way the operation client provides notification that a message has been received by it. Exactly when its executed and under what conditions is a function of the specific operation client.

 protected  void setMessageID(MessageContext mc) 
{
        // now its the time to put the parameters set by the user in to the
        // correct places and to the
        // if there is no message id still, set a new one.
        String messageId = options.getMessageId();
        if (messageId == null || "".equals(messageId)) {
            messageId = UUIDGenerator.getUUID();
        }
        mc.setMessageID(messageId);
}

Create a message ID for the given message context if needed. If user gives an option with MessageID then just copy that into MessageContext , and with that there can be multiple message with same MessageID unless user call setOption for each invocation.

If user want to give message ID then the better way is to set the message ID in the option and call setOption for each invocation then the right thing will happen.

If user does not give a message ID then the new one will be created and set that into Message Context.

 public  void setOptions(Options options) 
{
        this.options = options;
}

Sets the options that should be used for this particular client. This resets the entire set of options to use the new options - so you'd lose any option cascading that may have been set up.