| Method from org.apache.axis2.description.AxisService Detail: |
|---|
 public void addDataLocatorClassNames(String dialect,
String dataLocatorClassName) {
dataLocatorClassNames.put(dialect, dataLocatorClassName);
}
Save data Locator configured at service level for this Axis Service |
public void addEndpoint(String key,
AxisEndpoint axisEndpoint) {
this.endpointMap.put(key, axisEndpoint);
} |
public void addExposedTransport(String transport) {
enableAllTransports = false;
if (!this.exposedTransports.contains(transport)) {
this.exposedTransports.add(transport);
try {
eprs = calculateEPRs();
} catch (Exception e) {
eprs = null;
}
}
} |
public void addHttpLocationDispatcherString(String string,
AxisOperation axisOperation) {
httpLocationDispatcherMap.put(string, axisOperation);
} Maps an constant string in the whttp:location to the given operation.
This is used by RequestURIOperationDispatcher based dispatching to figure
out which operation it is that a given message is for. |
public void addMessageContextListener(MessageContextListener scl) {
messageContextListeners.add(scl);
} Add a ServiceContextListener |
public void addMessageElementQNameToOperationMapping(QName messageElementQName,
AxisOperation operation) {
// when setting an operation we have to set it only if the
// messegeElementQName does not
// exists in the map.
// does exists means there are two or more operations which has the same
// input element (in doc/literal
// this is possible. In this case better to set it as null without
// giving
// a random operation.
if (messageElementQNameToOperationMap.containsKey(messageElementQName)
&& messageElementQNameToOperationMap.get(messageElementQName) != operation) {
messageElementQNameToOperationMap.put(messageElementQName, null);
} else {
messageElementQNameToOperationMap.put(messageElementQName,
operation);
}
} Add an entry to the map between element QNames in WSDL messages and
AxisOperations for this service. |
public void addMessageReceiver(String mepURI,
MessageReceiver messageReceiver) {
if (WSDL2Constants.MEP_URI_IN_ONLY.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_ONLY
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_ONLY
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_IN_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_ONLY,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_OUT_ONLY.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_ONLY
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_ONLY
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_OUT_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_ONLY,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_IN_OUT.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OUT
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OUT
.equals(mepURI)) {
messageReceivers
.put(WSDL2Constants.MEP_URI_IN_OUT, messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OUT,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OUT,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_IN_OPTIONAL_OUT.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OPTIONAL_OUT
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OPTIONAL_OUT
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_IN_OPTIONAL_OUT,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_IN_OPTIONAL_OUT,
messageReceiver);
messageReceivers
.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_IN_OPTIONAL_OUT,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_OUT_IN.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_IN
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_IN
.equals(mepURI)) {
messageReceivers
.put(WSDL2Constants.MEP_URI_OUT_IN, messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_IN,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_IN,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_OUT_OPTIONAL_IN.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_OPTIONAL_IN
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_OPTIONAL_IN
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_OUT_OPTIONAL_IN,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_OUT_OPTIONAL_IN,
messageReceiver);
messageReceivers
.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_OUT_OPTIONAL_IN,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_ROBUST_OUT_ONLY.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_OUT_ONLY
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_OUT_ONLY
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_ROBUST_OUT_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_OUT_ONLY,
messageReceiver);
messageReceivers
.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_OUT_ONLY,
messageReceiver);
} else if (WSDL2Constants.MEP_URI_ROBUST_IN_ONLY.equals(mepURI)
|| WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_IN_ONLY
.equals(mepURI)
|| WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_IN_ONLY
.equals(mepURI)) {
messageReceivers.put(WSDL2Constants.MEP_URI_ROBUST_IN_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2006Constants.MEP_URI_ROBUST_IN_ONLY,
messageReceiver);
messageReceivers.put(
WSDLConstants.WSDL20_2004_Constants.MEP_URI_ROBUST_IN_ONLY,
messageReceiver);
} else {
messageReceivers.put(mepURI, messageReceiver);
}
} |
public void addModuleConfig(ModuleConfiguration moduleConfiguration) {
moduleConfigmap.put(moduleConfiguration.getModuleName(),
moduleConfiguration);
} Adds module configuration , if there is moduleConfig tag in service. |
void addModuleOperations(AxisModule module) throws AxisFault {
HashMap< QName, AxisOperation > map = module.getOperations();
Collection< AxisOperation > col = map.values();
PhaseResolver phaseResolver = new PhaseResolver(getAxisConfiguration());
for (Iterator< AxisOperation > iterator = col.iterator(); iterator.hasNext();) {
AxisOperation axisOperation = copyOperation((AxisOperation) iterator
.next());
if (this.getOperation(axisOperation.getName()) == null) {
ArrayList< String > wsamappings = axisOperation.getWSAMappingList();
if (wsamappings != null) {
for (int j = 0, size = wsamappings.size(); j < size; j++) {
String mapping = (String) wsamappings.get(j);
mapActionToOperation(mapping, axisOperation);
}
}
// If we've set the "expose" parameter for this operation, it's
// normal (non-
// control) and therefore it will appear in generated WSDL. If
// we haven't,
// it's a control operation and will be ignored at WSDL-gen
// time.
if (axisOperation
.isParameterTrue(DeploymentConstants.TAG_EXPOSE)) {
axisOperation.setControlOperation(false);
} else {
axisOperation.setControlOperation(true);
}
phaseResolver.engageModuleToOperation(axisOperation, module);
this.addOperation(axisOperation);
}
}
} Add any control operations defined by a Module to this service. |
public void addModuleref(String moduleref) {
moduleRefs.add(moduleref);
} |
public void addOperation(AxisOperation axisOperation) {
axisOperation.setParent(this);
if (log.isDebugEnabled()) {
if (axisOperation.getName().equals(ServiceClient.ANON_OUT_ONLY_OP)
|| (axisOperation.getName().equals(ServiceClient.ANON_OUT_ONLY_OP))
|| (axisOperation.getName().equals(ServiceClient.ANON_OUT_ONLY_OP))) {
log.debug("Client-defined operation name matches default operation name. "
+ "this may cause interoperability issues. Name is: " + axisOperation.getName().toString());
}
}
Iterator< AxisModule > modules = getEngagedModules().iterator();
while (modules.hasNext()) {
AxisModule module = (AxisModule) modules.next();
try {
axisOperation.engageModule(module);
} catch (AxisFault axisFault) {
log.info(Messages.getMessage("modulealredyengagetoservice",
module.getName()));
}
}
if (axisOperation.getMessageReceiver() == null) {
axisOperation.setMessageReceiver(loadDefaultMessageReceiver(
axisOperation.getMessageExchangePattern(), this));
}
if (axisOperation.getInputAction() == null) {
axisOperation.setSoapAction("urn:"
+ axisOperation.getName().getLocalPart());
}
if (axisOperation.getOutputAction() == null) {
axisOperation.setOutputAction("urn:"
+ axisOperation.getName().getLocalPart()
+ Java2WSDLConstants.RESPONSE);
}
addChild(axisOperation);
String operationName = axisOperation.getName().getLocalPart();
/*
* Some times name of the operation can be different from the name of
* the first child of the SOAPBody. This will put the correct mapping
* associating that name with the operation. This will be useful
* especially for the SOAPBodyBasedDispatcher
*/
Iterator axisMessageIter = axisOperation.getChildren();
while (axisMessageIter.hasNext()) {
AxisMessage axisMessage = (AxisMessage) axisMessageIter.next();
String messageName = axisMessage.getName();
if (messageName != null && !messageName.equals(operationName)) {
mapActionToOperation(messageName, axisOperation);
}
}
mapActionToOperation(operationName, axisOperation);
String action = axisOperation.getInputAction();
if (action.length() > 0) {
mapActionToOperation(action, axisOperation);
}
ArrayList< String > wsamappings = axisOperation.getWSAMappingList();
if (wsamappings != null) {
for (int j = 0, size = wsamappings.size(); j < size; j++) {
String mapping = (String) wsamappings.get(j);
mapActionToOperation(mapping, axisOperation);
}
}
if (axisOperation.getMessageReceiver() == null) {
axisOperation.setMessageReceiver(loadDefaultMessageReceiver(
axisOperation.getMessageExchangePattern(), this));
}
} |
public void addSchema(XmlSchema schema) {
if (schema != null) {
schemaList.add(schema);
if (schema.getTargetNamespace() != null) {
addSchemaNameSpace(schema);
}
}
} |
public void addSchema(Collection schemas) {
Iterator< XmlSchema > iterator = schemas.iterator();
while (iterator.hasNext()) {
XmlSchema schema = (XmlSchema) iterator.next();
schemaList.add(schema);
addSchemaNameSpace(schema);
}
} |
public void attachEnvelopeEvent(MessageContext mc) {
for (int i=0; i< messageContextListeners.size(); i++) {
messageContextListeners.get(i).attachEnvelopeEvent(mc);
}
} Signal an Attach Envelope Event |
public void attachServiceContextEvent(ServiceContext sc,
MessageContext mc) {
for (int i=0; i< messageContextListeners.size(); i++) {
messageContextListeners.get(i).attachServiceContextEvent(sc, mc);
}
} Signal an Attach ServiceContext Event |
public static AxisService createClientSideAxisService(URL wsdlURL,
QName wsdlServiceName,
String portName,
Options options) throws AxisFault {
try {
InputStream in = wsdlURL.openConnection().getInputStream();
Document doc = XMLUtils.newDocument(in);
WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();
reader.setFeature("javax.wsdl.importDocuments", true);
Definition wsdlDefinition = reader.readWSDL(getBaseURI(wsdlURL
.toString()), doc);
if (wsdlDefinition != null) {
wsdlDefinition.setDocumentBaseURI(getDocumentURI(wsdlURL
.toString()));
}
return createClientSideAxisService(wsdlDefinition, wsdlServiceName,
portName, options);
} catch (IOException e) {
log.error(e.getMessage(), e);
throw AxisFault.makeFault(e);
} catch (ParserConfigurationException e) {
log.error(e.getMessage(), e);
throw AxisFault.makeFault(e);
} catch (SAXException e) {
log.error(e.getMessage(), e);
throw AxisFault.makeFault(e);
} catch (WSDLException e) {
log.error(e.getMessage(), e);
throw AxisFault.makeFault(e);
}
} To create a AxisService for a given WSDL and the created client is most
suitable for client side invocation not for server side invocation. Since
all the soap action and wsa action is added to operations |
public static AxisService createClientSideAxisService(Definition wsdlDefinition,
QName wsdlServiceName,
String portName,
Options options) throws AxisFault {
WSDL11ToAxisServiceBuilder serviceBuilder = new WSDL11ToAxisServiceBuilder(
wsdlDefinition, wsdlServiceName, portName);
serviceBuilder.setServerSide(false);
AxisService axisService = serviceBuilder.populateService();
AxisEndpoint axisEndpoint = (AxisEndpoint) axisService.getEndpoints()
.get(axisService.getEndpointName());
options.setTo(new EndpointReference(axisEndpoint.getEndpointURL()));
if (axisEndpoint != null) {
options.setSoapVersionURI((String) axisEndpoint.getBinding()
.getProperty(WSDL2Constants.ATTR_WSOAP_VERSION));
}
return axisService;
} |
public static AxisService createService(String implClass,
AxisConfiguration axisConfig) throws AxisFault {
try {
HashMap< String, MessageReceiver > messageReciverMap = new HashMap< String, MessageReceiver >();
Class inOnlyMessageReceiver = Loader
.loadClass("org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver");
MessageReceiver messageReceiver = (MessageReceiver) inOnlyMessageReceiver
.newInstance();
messageReciverMap.put(WSDL2Constants.MEP_URI_IN_ONLY,
messageReceiver);
Class inoutMessageReceiver = Loader
.loadClass("org.apache.axis2.rpc.receivers.RPCMessageReceiver");
MessageReceiver inOutmessageReceiver = (MessageReceiver) inoutMessageReceiver
.newInstance();
messageReciverMap.put(WSDL2Constants.MEP_URI_IN_OUT,
inOutmessageReceiver);
messageReciverMap.put(WSDL2Constants.MEP_URI_ROBUST_IN_ONLY,
inOutmessageReceiver);
return createService(implClass, axisConfig, messageReciverMap,
null, null, axisConfig.getSystemClassLoader());
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
} To create an AxisService using given service impl class name first
generate schema corresponding to the given java class , next for each
methods AxisOperation will be created. If the method is in-out it will
uses RPCMessageReceiver else RPCInOnlyMessageReceiver Note : Inorder
to work this properly RPCMessageReceiver should be available in the class
path otherewise operation can not continue |
public static AxisService createService(String implClass,
AxisConfiguration axisConfiguration,
Map messageReceiverClassMap,
String targetNamespace,
String schemaNamespace,
ClassLoader loader) throws AxisFault {
int index = implClass.lastIndexOf(".");
String serviceName;
if (index > 0) {
serviceName = implClass.substring(index + 1, implClass.length());
} else {
serviceName = implClass;
}
SchemaGenerator schemaGenerator;
ArrayList excludeOpeartion = new ArrayList();
AxisService service = new AxisService();
service.setParent(axisConfiguration);
service.setName(serviceName);
try {
Parameter generateBare = service
.getParameter(Java2WSDLConstants.DOC_LIT_BARE_PARAMETER);
if (generateBare != null && "true".equals(generateBare.getValue())) {
schemaGenerator = new DocLitBareSchemaGenerator(loader,
implClass, schemaNamespace,
Java2WSDLConstants.SCHEMA_NAMESPACE_PRFIX, service);
} else {
schemaGenerator = new DefaultSchemaGenerator(loader, implClass,
schemaNamespace,
Java2WSDLConstants.SCHEMA_NAMESPACE_PRFIX, service);
}
schemaGenerator
.setElementFormDefault(Java2WSDLConstants.FORM_DEFAULT_UNQUALIFIED);
Utils.addExcludeMethods(excludeOpeartion);
schemaGenerator.setExcludeMethods(excludeOpeartion);
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
return createService(implClass, serviceName, axisConfiguration,
messageReceiverClassMap, targetNamespace, loader,
schemaGenerator, service);
} messageReceiverClassMap will hold the MessageReceivers for given meps.
Key will be the mep and value will be the instance of the MessageReceiver
class. Ex: Map mrMap = new HashMap();
mrMap.put("http://www.w3.org/2004/08/wsdl/in-only",
RPCInOnlyMessageReceiver.class.newInstance());
mrMap.put("http://www.w3.org/2004/08/wsdl/in-out",
RPCMessageReceiver.class.newInstance()); |
public static AxisService createService(String implClass,
String serviceName,
AxisConfiguration axisConfiguration,
Map messageReceiverClassMap,
String targetNamespace,
ClassLoader loader,
SchemaGenerator schemaGenerator,
AxisService axisService) throws AxisFault {
Parameter parameter = new Parameter(Constants.SERVICE_CLASS, implClass);
OMElement paraElement = Utils.getParameter(Constants.SERVICE_CLASS,
implClass, false);
parameter.setParameterElement(paraElement);
axisService.setUseDefaultChains(false);
axisService.addParameter(parameter);
axisService.setName(serviceName);
axisService.setClassLoader(loader);
NamespaceMap map = new NamespaceMap();
map.put(Java2WSDLConstants.AXIS2_NAMESPACE_PREFIX,
Java2WSDLConstants.AXIS2_XSD);
map.put(Java2WSDLConstants.DEFAULT_SCHEMA_NAMESPACE_PREFIX,
Java2WSDLConstants.URI_2001_SCHEMA_XSD);
axisService.setNamespaceMap(map);
Utils.processBeanPropertyExclude(axisService);
axisService.setElementFormDefault(false);
try {
axisService.addSchema(schemaGenerator.generateSchema());
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
axisService.setSchemaTargetNamespace(schemaGenerator
.getSchemaTargetNameSpace());
axisService.setTypeTable(schemaGenerator.getTypeTable());
if (targetNamespace == null) {
targetNamespace = schemaGenerator.getSchemaTargetNameSpace();
}
if (targetNamespace != null && !"".equals(targetNamespace)) {
axisService.setTargetNamespace(targetNamespace);
}
Method[] method = schemaGenerator.getMethods();
PhasesInfo pinfo = axisConfiguration.getPhasesInfo();
for (int i = 0; i < method.length; i++) {
Method jmethod = method[i];
AxisOperation operation = axisService.getOperation(new QName(
jmethod.getName()));
String mep = operation.getMessageExchangePattern();
MessageReceiver mr;
if (messageReceiverClassMap != null) {
if (messageReceiverClassMap.get(mep) != null) {
Object obj = messageReceiverClassMap.get(mep);
if (obj instanceof MessageReceiver) {
mr = (MessageReceiver) obj;
operation.setMessageReceiver(mr);
} else {
log
.error("Object is not an instance of MessageReceiver, thus, default MessageReceiver has been set");
mr = axisConfiguration.getMessageReceiver(operation
.getMessageExchangePattern());
operation.setMessageReceiver(mr);
}
} else {
log
.error("Required MessageReceiver couldn't be found, thus, default MessageReceiver has been used");
mr = axisConfiguration.getMessageReceiver(operation
.getMessageExchangePattern());
operation.setMessageReceiver(mr);
}
} else {
log
.error("MessageRecevierClassMap couldn't be found, thus, default MessageReceiver has been used");
mr = axisConfiguration.getMessageReceiver(operation
.getMessageExchangePattern());
operation.setMessageReceiver(mr);
}
pinfo.setOperationPhases(operation);
axisService.addOperation(operation);
}
String endpointName = axisService.getEndpointName();
if ((endpointName == null || endpointName.length() == 0)
&& axisService.getAxisConfiguration() != null) {
Utils.addEndpointsToService(axisService, axisService.getAxisConfiguration());
}
return axisService;
} messageReceiverClassMap will hold the MessageReceivers for given meps.
Key will be the mep and value will be the instance of the MessageReceiver
class. Ex: Map mrMap = new HashMap();
mrMap.put("http://www.w3.org/2004/08/wsdl/in-only",
RPCInOnlyMessageReceiver.class.newInstance());
mrMap.put("http://www.w3.org/2004/08/wsdl/in-out",
RPCMessageReceiver.class.newInstance()); |
public AxisServiceGroup getAxisServiceGroup() {
return (AxisServiceGroup) parent;
} |
public String getBindingName() {
return bindingName;
} |
public ClassLoader getClassLoader() {
return this.serviceClassLoader;
} |
public ArrayList getControlOperations() {
Iterator< AxisOperation > op_itr = getOperations();
ArrayList< AxisOperation > operationList = new ArrayList< AxisOperation >();
while (op_itr.hasNext()) {
AxisOperation operation = (AxisOperation) op_itr.next();
if (operation.isControlOperation()) {
operationList.add(operation);
}
}
return operationList;
} Gets the control operation which are added by module like RM. |
public String getCustomSchemaNamePrefix() {
return customSchemaNamePrefix;
} |
public String getCustomSchemaNameSuffix() {
return customSchemaNameSuffix;
} |
public Data[] getData(DataRetrievalRequest request,
MessageContext msgContext) throws AxisFault {
Data[] data;
String dialect = request.getDialect();
AxisDataLocator dataLocator = null;
int nextDataLocatorIndex = 0;
int totalLocators = availableDataLocatorTypes.length;
for (int i = 0; i < totalLocators; i++) {
dataLocator = getDataLocator(availableDataLocatorTypes[i], dialect);
if (dataLocator != null) {
nextDataLocatorIndex = i + 1;
break;
}
}
if (dataLocator == null) {
return null;
}
data = dataLocator.getData(request, msgContext);
// Null means Data Locator not understood request. Automatically find
// Data Locator in the hierarchy to process the request.
if (data == null) {
if (nextDataLocatorIndex < totalLocators) {
data = bubbleupDataLocators(nextDataLocatorIndex, request,
msgContext);
}
}
return data;
} Find a data locator from the available data locators (both configured and
default ones) to retrieve Metadata or data specified in the request. |
public AxisDataLocator getDataLocator(LocatorType locatorType,
String dialect) throws AxisFault {
AxisDataLocator locator;
if (locatorType == LocatorType.SERVICE_DIALECT) {
locator = getServiceDataLocator(dialect);
} else if (locatorType == LocatorType.SERVICE_LEVEL) {
locator = getServiceDataLocator(DRConstants.SERVICE_LEVEL);
} else if (locatorType == LocatorType.GLOBAL_DIALECT) {
locator = getGlobalDataLocator(dialect);
} else if (locatorType == LocatorType.GLOBAL_LEVEL) {
locator = getGlobalDataLocator(DRConstants.GLOBAL_LEVEL);
} else if (locatorType == LocatorType.DEFAULT_AXIS) {
locator = getDefaultDataLocator();
} else {
locator = getDefaultDataLocator();
}
return locator;
} |
public String[] getEPRs() {
if (eprs != null && eprs.length != 0) {
return eprs;
}
eprs = calculateEPRs();
return eprs;
} |
public AxisEndpoint getEndpoint(String key) {
return (AxisEndpoint) endpointMap.get(key);
} |
public String getEndpointName() {
return endpointName;
} |
public String getEndpointURL() {
return endpointURL;
} |
public Map getEndpoints() {
return endpointMap;
} |
public ExcludeInfo getExcludeInfo() {
return excludeInfo;
} |
public List getExposedTransports() {
return this.exposedTransports;
} |
public URL getFileName() {
return fileName;
} |
public AxisDataLocator getGlobalDataLocator(String dialect) throws AxisFault {
AxisConfiguration axisConfig = getAxisConfiguration();
AxisDataLocator locator = null;
if (axisConfig != null) {
locator = axisConfig.getDataLocator(dialect);
if (locator == null) {
String className = axisConfig.getDataLocatorClassName(dialect);
if (className != null) {
locator = loadDataLocator(className);
axisConfig.addDataLocator(dialect, locator);
}
}
}
return locator;
} |
public List getImportedNamespaces() {
return importedNamespaces;
} Get the namespaces associated with imported WSDLs |
public Object getKey() {
return this.name;
} |
public long getLastUpdate() {
return lastupdate;
} |
public long getLastupdate() {
return lastupdate;
} Deprecated! please - use getLastUpdate
|
public MessageReceiver getMessageReceiver(String mepURL) {
return (MessageReceiver) messageReceivers.get(mepURL);
} |
public ModuleConfiguration getModuleConfig(String moduleName) {
return (ModuleConfiguration) moduleConfigmap.get(moduleName);
} |
public ArrayList getModules() {
return moduleRefs;
} |
public String getName() {
return name;
} |
public Map getNameSpacesMap() {
return namespaceMap;
} Deprecated! please - use getNamespaceMap()
Get the namespace map for this service. |
public Map getNamespaceMap() {
return namespaceMap;
} Get the namespace map for this service. |
public ObjectSupplier getObjectSupplier() {
return objectSupplier;
} |
public AxisOperation getOperation(QName operationName) {
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled())
log.debug("Get operation for " + operationName);
AxisOperation axisOperation = (AxisOperation) getChild(operationName);
if (axisOperation == null) {
axisOperation = (AxisOperation) getChild(new QName(
getTargetNamespace(), operationName.getLocalPart()));
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled())
log.debug("Target namespace: " + getTargetNamespace());
}
if (axisOperation == null) {
axisOperation = (AxisOperation) operationsAliasesMap
.get(operationName.getLocalPart());
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled())
log.debug("Operations aliases map: " + operationsAliasesMap);
}
//The operation may be associated with a namespace other than the
//target namespace, e.g. if the operation is from an imported wsdl.
if (axisOperation == null) {
List namespaces = getImportedNamespaces();
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled())
log.debug("Imported namespaces: " + namespaces);
if (namespaces != null) {
Iterator iterator = namespaces.iterator();
while (iterator.hasNext()) {
String namespace = (String) iterator.next();
axisOperation = (AxisOperation) getChild(new QName(
namespace, operationName.getLocalPart()));
if (axisOperation != null)
break;
}
}
}
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled())
log.debug("Found axis operation: " + axisOperation);
return axisOperation;
} |
public AxisOperation getOperationByAction(String action) {
return (AxisOperation) operationsAliasesMap.get(action);
} Returns the AxisOperation which has been mapped to the given alias. |
public AxisOperation getOperationByMessageElementQName(QName messageElementQName) {
return (AxisOperation) messageElementQNameToOperationMap
.get(messageElementQName);
} Look up an AxisOperation for this service based off of an element QName
from a WSDL message element. |
public AxisOperation getOperationBySOAPAction(String soapAction) {
// Check for illegal soapActions
if ((soapAction == null) || soapAction.length() == 0) {
if (log.isDebugEnabled()) {
log.debug("getOperationBySOAPAction: " + soapAction
+ " is null or ''. Returning null.");
}
return null;
}
// If the action maps to an alais that is not unique, then it can't be
// used to map to
// an operation.
if (invalidOperationsAliases.contains(soapAction)) {
if (log.isDebugEnabled()) {
log.debug("getOperationBySOAPAction: " + soapAction
+ " is an invalid operation alias. Returning null.");
}
return null;
}
// Get the operation from the action- >operation map
AxisOperation operation = (AxisOperation) operationsAliasesMap
.get(soapAction);
if (operation != null) {
if (log.isDebugEnabled()) {
log.debug("getOperationBySOAPAction: Operation (" + operation
+ "," + operation.getName() + ") for soapAction: "
+ soapAction + " found in action map.");
}
return operation;
}
// The final fallback is to check the operations for a matching name.
Iterator children = getChildren();
// I could not find any spec statement that explicitly forbids using a
// short name in the SOAPAction header or wsa:Action element,
// so I believe this to be valid. There may be customers using the
// shortname as the SOAPAction in their client code that would
// also require this support.
while (children.hasNext() && (operation == null)) {
AxisOperation op = (AxisOperation) children.next();
if (op.getName().getLocalPart().equals(soapAction)) {
operation = op;
}
}
if (operation != null) {
if (log.isDebugEnabled()) {
log.debug("getOperationBySOAPAction: Operation (" + operation
+ "," + operation.getName() + ") for soapAction: "
+ soapAction + " found as child.");
}
}
return operation;
} Returns the operation given a SOAP Action. This method should be called
if only one Endpoint is defined for this Service. If more than one
Endpoint exists, one of them will be picked. If more than one Operation
is found with the given SOAP Action; null will be returned. If no
particular Operation is found with the given SOAP Action; null will be
returned. If the action is in the list of invaliad aliases, which means
it did not uniquely identify an operation, a null will be returned. |
public Iterator getOperations() {
return (Iterator< AxisOperation >) getChildren();
} |
public List getOperationsNameList() {
return operationsNameList;
} |
public Map getP2nMap() {
return p2nMap;
} |
public String getPortTypeName() {
return endpointName;
} Deprecated! use - AxisService#getEndpointName() instead.
|
public ArrayList getPublishedOperations() {
Iterator< AxisOperation > op_itr = getOperations();
ArrayList< AxisOperation > operationList = new ArrayList< AxisOperation >();
while (op_itr.hasNext()) {
AxisOperation operation = (AxisOperation) op_itr.next();
if (!operation.isControlOperation()) {
operationList.add(operation);
}
}
return operationList;
} Gets only the published operations. |
public ArrayList getSchema() {
return schemaList;
} |
public XmlSchema getSchema(int index) {
return addNameSpaces(index);
} |
public XmlSchemaElement getSchemaElement(QName elementQName) {
XmlSchemaElement element;
for (int i = 0; i < schemaList.size(); i++) {
XmlSchema schema = (XmlSchema) schemaList.get(i);
if (schema != null) {
element = schema.getElementByName(elementQName);
if (element != null) {
return element;
}
}
}
return null;
} |
public Map getSchemaMappingTable() {
return schemaMappingTable;
} |
public String getSchemaTargetNamespace() {
return schematargetNamespace;
} |
public String getSchemaTargetNamespacePrefix() {
return schematargetNamespacePrefix;
} |
public String getSchematargetNamespace() {
return schematargetNamespace;
} Deprecated! please - use getSchemaTargetNamespace
|
public String getScope() {
return scope;
} |
public String getServiceDescription() {
return getDocumentation();
} Deprecated! Use - getDocumentation() instead
Gets the description about the service which is specified in
services.xml. |
public ServiceLifeCycle getServiceLifeCycle() {
return serviceLifeCycle;
} |
public String getSoapNsUri() {
return soapNsUri;
} |
public String getTargetNamespace() {
return targetNamespace;
} |
public String getTargetNamespacePrefix() {
return targetNamespacePrefix;
} |
public TypeTable getTypeTable() {
return typeTable;
} |
public String getWSAddressingFlag() {
return AddressingHelper.getAddressingRequirementParemeterValue(this);
} Deprecated! Use - AddressingHelper.getAddressingRequirementParemeterValue
|
public boolean hasMessageContextListener(Class cls) {
for (int i=0; i< messageContextListeners.size(); i++) {
if (messageContextListeners.get(i).getClass() == cls) {
return true;
}
}
return false;
} |
public boolean isActive() {
return active;
} |
public boolean isClientSide() {
return clientSide;
} |
public boolean isCustomWsdl() {
return customWsdl;
} |
public boolean isElementFormDefault() {
return elementFormDefault;
} |
public boolean isEnableAllTransports() {
return enableAllTransports;
} |
public boolean isExposedTransport(String transport) {
return exposedTransports.contains(transport);
} |
public boolean isModifyUserWSDLPortAddress() {
Parameter parameter = getParameter("modifyUserWSDLPortAddress");
if (parameter != null) {
String value = (String) parameter.getValue();
if ("false".equals(value)) {
return false;
}
}
return true;
} By default the port address in user WSDLs is modified, set the following
parameter to override this behaviour false |
public boolean isSchemaLocationsAdjusted() {
return schemaLocationsAdjusted;
} |
public boolean isUseDefaultChains() {
return useDefaultChains;
} |
public boolean isUseUserWSDL() {
Parameter parameter = getParameter("useOriginalwsdl");
if (parameter != null) {
String value = (String) parameter.getValue();
if ("true".equals(value)) {
return true;
}
}
return false;
} User can set a parameter in services.xml saying he want to show the
original wsdl that he put into META-INF once someone ask for ?wsdl so if
you want to use your own wsdl then add following parameter into
services.xml true |
public boolean isWsdlFound() {
return wsdlFound;
} |
protected AxisDataLocator loadDataLocator(String className) throws AxisFault {
AxisDataLocator locator;
try {
Class dataLocator;
dataLocator = Class.forName(className, true, serviceClassLoader);
locator = (AxisDataLocator) dataLocator.newInstance();
} catch (ClassNotFoundException e) {
throw AxisFault.makeFault(e);
} catch (IllegalAccessException e) {
throw AxisFault.makeFault(e);
} catch (InstantiationException e) {
throw AxisFault.makeFault(e);
}
return locator;
} |
public Policy lookupPolicy(String key) {
return (Policy) policyMap.get(key);
} |
public void mapActionToOperation(String action,
AxisOperation axisOperation) {
if (action == null || "".equals(action)) {
if (log.isDebugEnabled()) {
log
.debug("mapActionToOperation: A null or empty action cannot be used to map to an operation.");
}
return;
}
if (log.isDebugEnabled()) {
log
.debug("mapActionToOperation: Mapping Action to Operation: action: "
+ action
+ "; operation: "
+ axisOperation
+ "named: " + axisOperation.getName());
}
// First check if this action has already been flagged as invalid
// because it is a duplicate.
if (invalidOperationsAliases.contains(action)) {
// This SOAPAction has already been determined to be invalid; log a
// message
// and do not add it to the operation alias map.
if (log.isDebugEnabled()) {
log
.debug("mapActionToOperation: The action: "
+ action
+ " can not be used for operation: "
+ axisOperation
+ " with operation name: "
+ axisOperation.getName()
+ " because that SOAPAction is not unique for this service.");
}
return;
}
// Check if the action is currently mapping to an operation.
AxisOperation currentlyMappedOperation = getOperationByAction(action);
if (currentlyMappedOperation != null) {
if (currentlyMappedOperation == axisOperation) {
// This maps to the same operation, then it is already in the
// alias table, so
// just silently ignore this mapping request.
if (log.isDebugEnabled()) {
log
.debug("mapActionToOperation: This operation is already mapped to this action: "
+ action
+ "; AxisOperation: "
+ currentlyMappedOperation
+ " named: "
+ currentlyMappedOperation.getName());
}
} else {
// This action is already mapped, but it is to a different
// operation. Remove
// the action mapping from the alias table and add it to the
// list of invalid mappings
operationsAliasesMap.remove(action);
invalidOperationsAliases.add(action);
if (log.isDebugEnabled()) {
log
.debug("mapActionToOperation: The action is already mapped to a different "
+ "operation. The mapping of the action to any operations will be "
+ "removed. Action: "
+ action
+ "; original operation: "
+ currentlyMappedOperation
+ " named "
+ currentlyMappedOperation.getName()
+ "; new operation: "
+ axisOperation
+ " named " + axisOperation.getName());
}
}
} else {
operationsAliasesMap.put(action, axisOperation);
// Adding operation name to the mapping table
// operationsAliasesMap.put(axisOperation.getName().getLocalPart(),
// axisOperation);
}
} Maps an alias (such as a SOAPAction, WSA action, or an operation name) to
the given AxisOperation. This is used by dispatching (both SOAPAction-
and WSAddressing- based dispatching) to figure out which operation a
given message is for. Some notes on restrictions of "action" - A null or
empty action will be ignored - An action that is a duplicate and
references an idential operation is allowed - An acton that is a
duplicate and references a different operation is NOT allowed. In this
case, the action for the original operation is removed from the alias
table, thus removing the ability to route based on this action. This is
necessary to prevent mis-directing incoming message to the wrong
operation based on SOAPAction.
Note that an alias could be a SOAPAction, WS-Addressing Action, the
operation name, or some other alias. |
public void onDisengage(AxisModule module) throws AxisFault {
removeModuleOperations(module);
for (Iterator operations = getChildren(); operations.hasNext();) {
AxisOperation axisOperation = (AxisOperation) operations.next();
axisOperation.disengageModule(module);
}
AxisConfiguration config = getAxisConfiguration();
if (!config.isEngaged(module.getName())) {
PhaseResolver phaseResolver = new PhaseResolver(config);
phaseResolver.disengageModuleFromGlobalChains(module);
}
} |
public void onEngage(AxisModule axisModule,
AxisDescription engager) throws AxisFault {
// adding module operations
addModuleOperations(axisModule);
Iterator< AxisOperation > operations = getOperations();
while (operations.hasNext()) {
AxisOperation axisOperation = (AxisOperation) operations.next();
axisOperation.engageModule(axisModule, engager);
}
} Engages a module. It is required to use this method. |
public Map populateSchemaMappings() {
// when calling from other than codegen. i.e from deployment
// engine we don't have to override the absolute http locations.
return populateSchemaMappings(false);
} |
public Map populateSchemaMappings(boolean overrideAbsoluteAddress) {
// populate the axis service with the necessary schema references
ArrayList schema = this.schemaList;
Map changedSchemaLocations = null;
if (!this.schemaLocationsAdjusted) {
Hashtable nameTable = new Hashtable();
Hashtable sourceURIToNewLocationMap = new Hashtable();
// calculate unique names for the schemas
calculateSchemaNames(schema, nameTable, sourceURIToNewLocationMap,
overrideAbsoluteAddress);
// adjust the schema locations as per the calculated names
changedSchemaLocations = adjustSchemaNames(schema, nameTable,
sourceURIToNewLocationMap);
// reverse the nametable so that there is a mapping from the
// name to the schemaObject
setSchemaMappingTable(swapMappingTable(nameTable));
setSchemaLocationsAdjusted(true);
}
return changedSchemaLocations;
} runs the schema mappings if it has not been run previously it is best
that this logic be in the axis service since one can call the axis
service to populate the schema mappings |
public void printSchema(OutputStream out) throws AxisFault {
for (int i = 0; i < schemaList.size(); i++) {
XmlSchema schema = addNameSpaces(i);
schema.write(out);
}
} |
public void printUserWSDL(OutputStream out,
String wsdlName) throws AxisFault {
Definition definition = null;
// first find the correct wsdl definition
Parameter wsdlParameter = getParameter(WSDLConstants.WSDL_4_J_DEFINITION);
if (wsdlParameter != null) {
definition = (Definition) wsdlParameter.getValue();
}
if (definition != null) {
try {
printDefinitionObject(getWSDLDefinition(definition, wsdlName),
out, null);
} catch (WSDLException e) {
throw AxisFault.makeFault(e);
}
} else {
printWSDLError(out);
}
} |
public void printWSDL(OutputStream out) throws AxisFault {
printWSDL(out, null);
} Print the WSDL with a default URL. This will be called only during
codegen time. |
public void printWSDL(OutputStream out,
String requestIP) throws AxisFault {
// If we're looking for pre-existing WSDL, use that.
if (isUseUserWSDL()) {
printUserWSDL(out, null);
return;
}
// If we find a WSDLSupplier, use that
WSDLSupplier supplier = (WSDLSupplier) getParameterValue("WSDLSupplier");
if (supplier != null) {
try {
Definition definition = supplier.getWSDL(this);
if (definition != null) {
changeImportAndIncludeLocations(definition);
printDefinitionObject(getWSDLDefinition(definition, null),
out, requestIP);
}
} catch (Exception e) {
printWSDLError(out, e);
}
return;
}
// Otherwise, generate WSDL ourselves
String[] eprArray = requestIP == null ? new String[] { this.endpointName }
: calculateEPRs(requestIP);
getWSDL(out, eprArray);
} Produces a WSDL for this AxisService and prints it to the specified
OutputStream. |
public void printWSDL2(OutputStream out) throws AxisFault {
printWSDL2(out, null);
} Print the WSDL2.0 with a default URL. This will be called only during
codegen time. |
public void printWSDL2(OutputStream out,
String requestIP) throws AxisFault {
AxisService2WSDL20 axisService2WSDL2 = new AxisService2WSDL20(this);
try {
if (requestIP != null) {
axisService2WSDL2.setEPRs(calculateEPRs(requestIP));
}
OMElement wsdlElement = axisService2WSDL2.generateOM();
wsdlElement.serialize(out);
out.flush();
out.close();
} catch (Exception e) {
throw AxisFault.makeFault(e);
}
} |
public int printWSDL2(OutputStream out,
String requestIP,
String wsdl) throws IOException, AxisFault {
// a name is present - try to pump the requested wsdl file
if (!"".equals(wsdl)) {
// make sure we are only serving .wsdl files and ignore requests with
// ".." in the name.
if (wsdl.endsWith(".wsdl") && wsdl.indexOf("..") == -1) {
InputStream in = getClassLoader().getResourceAsStream(
DeploymentConstants.META_INF + "/" + wsdl);
if (in != null) {
IOUtils.copy(in, out, true);
} else {
// can't find the wsdl
return -1;
}
} else {
// bad wsdl2 request
return -1;
}
} else {
printWSDL2(out, requestIP);
}
return 1;
} Produces a WSDL2 for this AxisService and prints it to the specified
OutputStream. |
public int printXSD(OutputStream out,
String xsd) throws IOException {
// If we find a SchemaSupplier, use that
SchemaSupplier supplier = (SchemaSupplier) getParameterValue("SchemaSupplier");
if (supplier != null) {
XmlSchema schema = supplier.getSchema(this, xsd);
if (schema != null) {
updateSchemaLocation(schema);
schema.write(new OutputStreamWriter(out, "UTF8"));
out.flush();
out.close();
return 1;
}
}
// call the populator
populateSchemaMappings();
Map schemaMappingtable = getSchemaMappingTable();
ArrayList< XmlSchema > schemas = getSchema();
// a name is present - try to pump the requested schema
if (!"".equals(xsd)) {
XmlSchema schema = (XmlSchema) schemaMappingtable.get(xsd);
if (schema == null) {
int dotIndex = xsd.indexOf('.");
if (dotIndex > 0) {
String schemaKey = xsd.substring(0, dotIndex);
schema = (XmlSchema) schemaMappingtable.get(schemaKey);
}
}
if (schema != null) {
// schema is there - pump it outs
schema.write(new OutputStreamWriter(out, "UTF8"));
out.flush();
out.close();
} else {
// make sure we are only serving .xsd files and ignore requests with
// ".." in the name.
if (xsd.endsWith(".xsd") && xsd.indexOf("..") == -1) {
InputStream in = getClassLoader().getResourceAsStream(
DeploymentConstants.META_INF + "/" + xsd);
if (in != null) {
IOUtils.copy(in, out, true);
} else {
// Can't find the schema
return -1;
}
} else {
// bad schema request
return -1;
}
}
} else if (schemas.size() > 1) {
// multiple schemas are present and the user specified
// no name - in this case we cannot possibly pump a schema
// so redirect to the service root
return 0;
} else {
// user specified no name and there is only one schema
// so pump that out
ArrayList< XmlSchema > list = getSchema();
if (list.size() > 0) {
XmlSchema schema = getSchema(0);
if (schema != null) {
schema.write(new OutputStreamWriter(out, "UTF8"));
out.flush();
out.close();
}
} else {
String xsdNotFound = "< error >"
+ "< description >Unable to access schema for this service< /description >"
+ "< /error >";
out.write(xsdNotFound.getBytes());
out.flush();
out.close();
}
}
return 1;
} Produces a XSD for this AxisService and prints it to the specified
OutputStream. |
public void registerPolicy(String key,
Policy policy) {
policyMap.put(key, policy);
} |
public void releaseSchemaList() {
if (schemaList != null) {
// release the schema list
schemaList.clear();
}
if (log.isDebugEnabled()) {
log.debug("releaseSchemaList: schema list has been released.");
}
} Release the list of schema objects. In some environments, this can
provide significant relief of memory consumption in the java heap, as
long as the need for the schema list has completed. |
public void removeExposedTransport(String transport) {
enableAllTransports = false;
this.exposedTransports.remove(transport);
try {
eprs = calculateEPRs();
} catch (Exception e) {
eprs = null;
}
} |
public void removeMessageContextListener(MessageContextListener scl) {
messageContextListeners.remove(scl);
} Remove a ServiceContextListener |
public void removeOperation(QName opName) {
AxisOperation operation = getOperation(opName);
if (operation != null) {
removeChild(opName);
ArrayList< String > mappingList = operation.getWSAMappingList();
if (mappingList != null) {
for (int i = 0; i < mappingList.size(); i++) {
String actionMapping = (String) mappingList.get(i);
operationsAliasesMap.remove(actionMapping);
}
}
operationsAliasesMap.remove(operation.getName().getLocalPart());
}
} |
public void setActive(boolean active) {
this.active = active;
} |
public void setBindingName(String bindingName) {
this.bindingName = bindingName;
} |
public void setClassLoader(ClassLoader classLoader) {
this.serviceClassLoader = classLoader;
} |
public void setClientSide(boolean clientSide) {
this.clientSide = clientSide;
} |
public void setCustomSchemaNamePrefix(String customSchemaNamePrefix) {
this.customSchemaNamePrefix = customSchemaNamePrefix;
} |
public void setCustomSchemaNameSuffix(String customSchemaNameSuffix) {
this.customSchemaNameSuffix = customSchemaNameSuffix;
} |
public void setCustomWsdl(boolean customWsdl) {
this.customWsdl = customWsdl;
} |
public void setEPRs(String[] eprs) {
this.eprs = eprs;
} |
public void setElementFormDefault(boolean elementFormDefault) {
this.elementFormDefault = elementFormDefault;
} |
public void setEnableAllTransports(boolean enableAllTransports) {
this.enableAllTransports = enableAllTransports;
eprs = calculateEPRs();
} To eneble service to be expose in all the transport |
public void setEndpointName(String endpoint) {
this.endpointName = endpoint;
} |
public void setEndpointURL(String endpointURL) {
this.endpointURL = endpointURL;
} |
public void setExcludeInfo(ExcludeInfo excludeInfo) {
this.excludeInfo = excludeInfo;
} |
public void setExposedTransports(List transports) {
enableAllTransports = false;
this.exposedTransports = transports;
eprs = null; // Do not remove this. We need to force EPR
// recalculation.
} |
public void setFileName(URL fileName) {
this.fileName = fileName;
} |
public void setImportedNamespaces(List importedNamespaces) {
this.importedNamespaces = importedNamespaces;
} Set the namespaces associated with imported WSDLs |
public void setLastUpdate() {
lastupdate = new Date().getTime();
} Sets the current time as last update time of the service. |
public void setLastupdate() {
lastupdate = new Date().getTime();
} Deprecated! please - use setLastUpdate
Sets the current time as last update time of the service. |
public void setMessageElementQNameToOperationMap(Map messageElementQNameToOperationMap) {
this.messageElementQNameToOperationMap = messageElementQNameToOperationMap;
} Set the map of WSDL message element QNames to AxisOperations for this
service. This map is used during SOAP Body-based routing for
document/literal bare services to match the first child element of the
SOAP Body element to an operation. (Routing for RPC and document/literal
wrapped services occurs via the operationsAliasesMap.) From section
4.7.6 of the WS-I BP 1.1: the "operation signature" is "the fully
qualified name of the child element of SOAP body of the SOAP input
message described by an operation in a WSDL binding," and thus this map
must be from a QName to an operation. |
public void setName(String name) {
this.name = name;
} |
public void setNameSpacesMap(NamespaceMap nameSpacesMap) {
this.namespaceMap = nameSpacesMap;
} Deprecated! please - use setNamespaceMap
|
public void setNamespaceMap(NamespaceMap namespaceMap) {
this.namespaceMap = namespaceMap;
} |
public void setObjectSupplier(ObjectSupplier objectSupplier) {
this.objectSupplier = objectSupplier;
} |
public void setOperationsNameList(List operationsNameList) {
this.operationsNameList = operationsNameList;
} |
public void setP2nMap(Map p2nMap) {
this.p2nMap = p2nMap;
} |
public void setParent(AxisServiceGroup parent) {
this.parent = parent;
} |
public void setPortTypeName(String portTypeName) {
this.endpointName = portTypeName;
} Deprecated! use - AxisService#setEndpointName() instead
|
public void setSchemaLocationsAdjusted(boolean schemaLocationsAdjusted) {
this.schemaLocationsAdjusted = schemaLocationsAdjusted;
} |
public void setSchemaMappingTable(Map schemaMappingTable) {
this.schemaMappingTable = schemaMappingTable;
} |
public void setSchemaTargetNamespace(String schematargetNamespace) {
this.schematargetNamespace = schematargetNamespace;
} |
public void setSchemaTargetNamespacePrefix(String schematargetNamespacePrefix) {
this.schematargetNamespacePrefix = schematargetNamespacePrefix;
} |
public void setSchematargetNamespacePrefix(String schematargetNamespacePrefix) {
this.schematargetNamespacePrefix = schematargetNamespacePrefix;
} Deprecated! please - use setSchemaTargetNamespacePrefix
|
public void setScope(String scope) {
if (Constants.SCOPE_APPLICATION.equals(scope)
|| Constants.SCOPE_TRANSPORT_SESSION.equals(scope)
|| Constants.SCOPE_SOAP_SESSION.equals(scope)
|| Constants.SCOPE_REQUEST.equals(scope)) {
this.scope = scope;
}
} |
public void setServiceDescription(String documentation) {
setDocumentation(documentation);
} Deprecated! Use - setDocumentation() instead
Sets the description about the service which is specified in services.xml |
public void setServiceLifeCycle(ServiceLifeCycle serviceLifeCycle) {
this.serviceLifeCycle = serviceLifeCycle;
} |
public void setSoapNsUri(String soapNsUri) {
this.soapNsUri = soapNsUri;
} |
public void setTargetNamespace(String targetNamespace) {
this.targetNamespace = targetNamespace;
} |
public void setTargetNamespacePrefix(String targetNamespacePrefix) {
this.targetNamespacePrefix = targetNamespacePrefix;
} |
public void setTypeTable(TypeTable typeTable) {
this.typeTable = typeTable;
} |
public void setUseDefaultChains(boolean useDefaultChains) {
this.useDefaultChains = useDefaultChains;
} |
public void setWSAddressingFlag(String ar) {
AddressingHelper.setAddressingRequirementParemeterValue(this, ar);
} Deprecated! Use - AddressingHelper.setAddressingRequirementParemeterValue
|
public void setWsdlFound(boolean wsdlFound) {
this.wsdlFound = wsdlFound;
} |
public String toString() {
return getName();
} |
org.apache.axis2.description.AxisDescription