Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.arjuna.webservices11.wsaddr;
  
  
  import java.util.Map;
 
 import  org.jboss.ws.api.addressing.*;

The complete addressing context.

Author(s):
kevin
 
 public class AddressingHelper
 {
     protected AddressingHelper()
     {
     }
 
     public static MAP createOneWayResponseContext(final MAP mapfinal String messageID)
     {
         // create this each time so it uses the current thread classloader
         // this allows the builder class to be redefined via a property
         MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
         final MAP responseMap = builder.newMap();
         // ok just calling initializeAsDestination directly fails when the FaultTo/ReplyTo/From
         // contains reference parameter elements. these get installed into the target element extensions
         // list for insertion into the outgoing message. however, the insertion fails.
         // JBossWS decides they can be inserted as is without copying because they are SOAP
         // elements but this ignores the fact that they have a DOM node attached. when the
         // appendElement is called it barfs because the target and source belong to different
         // documents. we patch this by copying the FaultTo or ReplyTo or from here if need be.
         MAPEndpoint epref = map.getReplyTo();
         if (isNoneAddress(epref)) {
             epref = map.getFrom();
         }
         responseMap.initializeAsDestination(epref);
         responseMap.setMessageID(messageID) ;
 
         if (map.getMessageID() != null)
         {
             MAPRelatesTo relatesTo = builder.newRelatesTo(map.getMessageID(), );
             responseMap.setRelatesTo(relatesTo);
         }
 
         return responseMap ;
     }

    
Create an addressing context that represents an inline reply to the specified addressing context.

Parameters:
map The addressing context being replied to.
messageID The message id of the new message.
Returns:
The reply addressing context.
 
     public static MAP createResponseContext(final MAP mapfinal String messageID)
     {
         // create this each time so it uses the current thread classloader
         // this allows the builder class to be redefined via a property
         MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
         final MAP responseMap = builder.newMap();
         MAPEndpoint epref = map.getReplyTo();
         if (isNoneAddress(epref)) {
             epref = map.getFrom();
         }
         responseMap.initializeAsDestination(epref);
         responseMap.setMessageID(messageID) ;
 
         if (map.getMessageID() != null)
         {
             MAPRelatesTo relatesTo = builder.newRelatesTo(map.getMessageID(), );
             responseMap.setRelatesTo(relatesTo);
         }
 
         return responseMap ;
     }

    
Create an addressing context that represents a fault to the specified addressing context.

Parameters:
map The addressing context being replied to.
messageID The message id of the new message.
Returns:
The fault addressing context. N.B. Still need to do From, Action, ReplyTo, FaultTo if needed.
 
     public static MAP createFaultContext(final MAP mapfinal String messageID)
     {
         // create this each time so it uses the current thread classloader
         // this allows the builder class to be redefined via a property
         MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
         final MAP faultMap = builder.newMap();
         // ok just calling initializeAsDestination directly fails when the FaultTo/ReplyTo/From
         // contains reference parameter elements. these get installed into the target element extensions
         // list for insertion into the outgoing message. however, the insertion fails.
         // JBossWS decides they can be inserted as is without copying because they are SOAP
         // elements but this ignores the fact that they have a DOM node attached. when the
         // appendElement is called it barfs because the target and source belong to different
        // documents. we patch this by copying the FaultTo or ReplyTo or from here if need be.
        MAPEndpoint eprefmap.getFaultTo();
        if (isNoneAddress(epref)) {
            epref = map.getReplyTo();
            if (isNoneAddress(epref)) {
                epref = map.getFrom();
            }
        }
        faultMap.initializeAsDestination(epref);
        faultMap.setMessageID(messageID) ;
        if (map.getMessageID() != null)
        {
            MAPRelatesTo relatesTo = builder.newRelatesTo(map.getMessageID(), );
            faultMap.setRelatesTo(relatesTo);
        }
        return faultMap ;
    }

    
Create an addressing context that represents a request to the specified address.

Parameters:
address TheendpointReference target address.
messageID The message id of the new message.
Returns:
The addressing context. N.B. Still need to do From, Action, ReplyTo, FaultTo if needed.
    public static MAP createRequestContext(final String addressfinal String messageID)
    {
        // create this each time so it uses the current thread classloader
        // this allows the builder class to be redefined via a property
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        final MAP requestMap = builder.newMap();
        requestMap.setTo(address);
        if (messageID != null) {
            requestMap.setMessageID(messageID);
        } else {
            // client does not care about id but we have to set some id or WSA will complain
            final String dummyID = MessageId.getMessageId();
            requestMap.setMessageID(dummyID);
        }
        return requestMap;
    }

    
Create an addressing context that represents a request to the specified address.

Parameters:
address TheendpointReference target address.
messageID The message id of the new message.
action The action of the new message.
Returns:
The addressing context. N.B. Still need to do From, Action, ReplyTo, FaultTo if needed.
    public static MAP createRequestContext(final String addressfinal String actionfinal String messageID)
    {
        // create this each time so it uses the current thread classloader
        // this allows the builder class to be redefined via a property
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        final MAP requestMap = builder.newMap();
        requestMap.setTo(address);
        if (messageID != null) {
            requestMap.setMessageID(messageID);
        } else {
            // client does not care about id but we have to set some id or WSA will complain
            final String dummyID = MessageId.getMessageId();
            requestMap.setMessageID(dummyID);
        }
        requestMap.setAction(action);
        return requestMap;
    }

    
Create an addressing context that represents a notification to the specified context.

Parameters:
map The addressing properties used to derive the notification addressing context.
messageID The message id of the new message.
Returns:
The notification addressing context. N.B. Still need to do From, Action, ReplyTo, FaultTo if needed.
    public static MAP createRequestContext(final MAP mapfinal String messageID)
    {
        // create this each time so it uses the current thread classloader
        // this allows the builder class to be redefined via a property
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        final MAP requestMap = builder.newMap();
        // ok just calling initializeAsDestination directly fails when the FaultTo/ReplyTo/From
        // contains reference parameter elements. these get installed into the target element extensions
        // list for insertion into the outgoing message. however, the insertion fails.
        // JBossWS decides they can be inserted as is without copying because they are SOAP
        // elements but this ignores the fact that they have a DOM node attached. when the
        // appendElement is called it barfs because the target and source belong to different
        // documents. we patch this by copying the FaultTo or ReplyTo or from here if need be.
        MAPEndpoint epref = map.getReplyTo();
        if (isNoneAddress(epref)) {
            epref = map.getFrom();
        }
        requestMap.initializeAsDestination(epref);
        if (messageID != null)
        {
            requestMap.setMessageID (messageID);
        }
        if (map.getMessageID() != null)
        {
            MAPRelatesTo relatesTo = builder.newRelatesTo(map.getMessageID(), );
            requestMap.setRelatesTo(relatesTo);
        }
        return requestMap;
    }

    
Create an addressing context specifying only the message id for a notification.

Parameters:
messageID The message id of the new message.
Returns:
The notification addressing context.
    public static MAP createNotificationContext(final String messageID)
    {
        // create this each time so it uses the current thread classloader
        // this allows the builder class to be redefined via a property
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        final MAP requestMap = builder.newMap();
        requestMap.setMessageID (messageID);
        requestMap.setAction("");
        String noneURI = builder.newConstants().getNoneURI();
        requestMap.setReplyTo(builder.newEndpoint(noneURI));
        return requestMap;
    }
    public static void installActionMessageID(MAP mapfinal String actionfinal String messageID)
    {
        // requestProperties has been derived from an endpoint so To and ReferenceParameters will be set. we
        // need to install the action and messageID
        // create this each time so it uses the current thread classloader
        // this allows the builder class to be redefined via a property
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        map.setMessageID(messageID);
        map.setAction(action);
    }
    public static void installCallerProperties(MAP map, MAP requestMap)
    {
        // requestMap has been derived from an endpoint so To and ReferenceParameters will be set. we
        // need to install alll the other fields supplied in map
        String uri;
        MAPRelatesTo relatesTo;
        MAPEndpoint epr;
        uri = map.getAction();
        if (uri != null) {
            requestMap.setAction(uri);
        }
        uri = map.getMessageID();
        if (uri != null) {
            requestMap.setMessageID(uri);
        }
        epr = map.getFrom();
        if (epr != null) {
            requestMap.setFrom(epr);
        }
        epr = map.getFaultTo();
        if (epr != null) {
            requestMap.setFaultTo(epr);
        }
        epr = map.getReplyTo();
        if (epr != null) {
            requestMap.setReplyTo(epr);
        }
        relatesTo = map.getRelatesTo();
        if (relatesTo != null) {
            requestMap.setRelatesTo(relatesTo);
        }
    }
    
    public static void installFaultTo(MAP map, MAPEndpoint epReferenceInstanceIdentifier identifier)
    {
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        MAPEndpoint from = builder.newEndpoint(epReference.getAddress());
        InstanceIdentifier.setEndpointInstanceIdentifier(fromidentifier);
        map.setFaultTo(from);
    }
    public static void installFromFaultTo(MAP map, MAPEndpoint epReferenceInstanceIdentifier identifier)
    {
        MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
        MAPEndpoint from = builder.newEndpoint(epReference.getAddress());
        InstanceIdentifier.setEndpointInstanceIdentifier(fromidentifier);
        map.setFrom(from);
        MAPEndpoint faultTo = builder.newEndpoint(epReference.getAddress());
        InstanceIdentifier.setEndpointInstanceIdentifier(faultToidentifier);
        map.setFaultTo(faultTo);
    }
    public static boolean isNoneReplyTo(MAP map)
    {
        return isNoneAddress(map.getReplyTo());
    }
    public static boolean isNoneAddress(MAPEndpoint epref)
    {
        if (epref != null) {
            String noneAddress = getNoneAddress().getAddress();
            String eprefAddress = epref.getAddress();
            return noneAddress.equals(eprefAddress);
        } else {
            return true;
        }
    }
    public static void installNoneReplyTo(MAP map)
    {
        map.setReplyTo(getNoneAddress());
    }

    
JBossWS Native version to configure request context with MAP, to and action

Parameters:
requestContext
map
to
action
    public static void configureRequestContext(Map<StringObjectrequestContext, MAP mapString toString action)
    {
        configureRequestContext(requestContextmap);
        map.setAction(action);
        configureRequestContext(requestContexttoaction);
    }

    
JBossWS Native version to configure request context with MAP

Parameters:
requestContext
    public static void configureRequestContext(Map<StringObjectrequestContext, MAP map)
    {
        map.installOutboundMapOnClientSide(requestContextmap);
    }

    
JBossWS Native version to configure request context with to and action

Parameters:
requestContext
to
action
    public static void configureRequestContext(Map<StringObjectrequestContextString toString action) {
        if (to != null) {
            requestContext.put(.to);
        }
        if (action != null) {
            // need to set soap action header based upon what the client asks for
            requestContext.put(.action);
        }
    }
    
    
retrieve the inbound server message address properties attached to a message context

Parameters:
ctx the server message context
Returns:
    public static MAP inboundMap(MessageContext ctx)
    {
        return MAPBuilderFactory.getInstance().getBuilderInstance().inboundMap(ctx);
    }

    
retrieve the outbound client message address properties attached to a message request map

Parameters:
ctx the client request properties map
Returns:
    public static MAP outboundMap(Map<StringObject>  ctx) {
        return MAPBuilderFactory.getInstance().getBuilderInstance().outboundMap(ctx);
    }
    private static MAPEndpoint noneAddress = null;
    private static synchronized MAPEndpoint getNoneAddress()
    {
        if ( == null) {
            MAPBuilder builder = MAPBuilderFactory.getInstance().getBuilderInstance();
            MAPConstants mapConstants = builder.newConstants();
            String noneURI = mapConstants.getNoneURI();
             = builder.newEndpoint(noneURI);
        }
        return ;
    }
    private static String REPLY_RELATIONSHIP_TYPE_NS = "org.jboss.jbossts.xts";
    private static String REPLY_RELATIONSHIP_TYPE_STRING = "reply";
New to GrepCode? Check out our FAQ X