<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>DescriptionFactory (Apache Axis2)</title>
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="DescriptionFactory (Apache Axis2)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/DescriptionFactory.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/axis2/jaxws/description/AttachmentType.html" title="enum in org.apache.axis2.jaxws.description"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/axis2/jaxws/description/DescriptionFactory.html" target="_top">Frames</a></li>
<li><a href="DescriptionFactory.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested_class_summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.axis2.jaxws.description</div>
<h2 title="Class DescriptionFactory" class="title">Class DescriptionFactory</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.axis2.jaxws.description.DescriptionFactory</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="strong">DescriptionFactory</span>
extends <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">Creates the JAX-WS metadata description hierarchy from some combinations of WSDL, Java class
 information including annotations, and (in the future) deployment descriptors.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested_class_summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Nested Class Summary table, listing nested classes, and an explanation">
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Class and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static class&nbsp;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a></strong></code>
<div class="block">The type of update being done for a particular Port.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createAxisService(java.lang.Class)">createAxisService</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass)</code>
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createAxisService(java.lang.Class, org.apache.axis2.context.ConfigurationContext)">createAxisService</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass,
                 <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</code>
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/ClientConfigurationFactory.html" title="class in org.apache.axis2.jaxws">ClientConfigurationFactory</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createClientConfigurationFactory()">createClientConfigurationFactory</a></strong>()</code>
<div class="block">Creates Client ConfigurationFactory used to create AxisConfiguration.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/ResolvedHandlersDescription.html" title="interface in org.apache.axis2.jaxws.description">ResolvedHandlersDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createResolvedHandlersDescription()">createResolvedHandlersDescription</a></strong>()</code>
<div class="block">Create a ResolvedHandlersDescription object, which describes attributes of handlers
 that have been resolved for a give port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.lang.Class)">createServiceDescription</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass)</code>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for a single service
 implementation class.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)">createServiceDescription</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net">URL</a>&nbsp;wsdlURL,
                        <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;serviceQName,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceClass)</code>
<div class="block">Create the initial ServiceDescription hierarchy on the CLIENT side.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">createServiceDescription</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net">URL</a>&nbsp;wsdlURL,
                        <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;serviceQName,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceClass,
                        <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;sparseComposite,
                        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</code>
<div class="block">Create the initial ServiceDescripton hierarchy on the CLIENT side.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescriptionFromDBCMap(java.util.HashMap)">createServiceDescriptionFromDBCMap</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap)</code>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescriptionFromDBCMap(java.util.HashMap, org.apache.axis2.context.ConfigurationContext)">createServiceDescriptionFromDBCMap</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                  <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</code>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescriptionFromDBCMap(java.util.HashMap, org.apache.axis2.context.ConfigurationContext, boolean)">createServiceDescriptionFromDBCMap</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                  <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext,
                                  boolean&nbsp;performVaidation)</code>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</code>
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</code>
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</code>
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<td class="colLast"><code><strong><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.String, java.lang.String)">updateEndpoint</a></strong>(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
              <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
              <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</code>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long, int)" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescription</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net">URL</a>&nbsp;wsdlURL,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;serviceQName,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceClass)</pre>
<div class="block">Create the initial ServiceDescription hierarchy on the CLIENT side.  This is intended to be
 called when the client creates a ServiceDelegate.  Note that it will only create the
 ServiceDescription at this point.  The EndpointDescription hierarchy under this
 ServiceDescription will be created by the updateEndpoint factory method, which will be called
 by the ServiceDelegate once the port is known (i.e. addPort, getPort, or createDispatch).</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>wsdlURL</code> - URL to the WSDL file to use; this may be null</dd><dd><code>serviceQName</code> - The ServiceQName for this service; may not be null</dd><dd><code>serviceClass</code> - The Service class; may not be null and must be assignable from
                     javax.xml.ws.Service</dd>
<dt><span class="strong">Returns:</span></dt><dd>A ServiceDescription instance for a CLIENT access to the service.</dd><dt><span class="strong">See Also:</span></dt><dd><code>#updateEndpoint(ServiceDescription, Class, QName, ServiceDescription.UpdateType)</code></dd></dl>
</li>
</ul>
<a name="createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescription</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net">URL</a>&nbsp;wsdlURL,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;serviceQName,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceClass,
                                          <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;sparseComposite,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</pre>
<div class="block">Create the initial ServiceDescripton hierarchy on the CLIENT side.  This allows a sparse DBC
 to be specified in addition to the service class.  The sparse DBC can be used to override
 the class annotation member values.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>wsdlURL</code> - </dd><dd><code>serviceQName</code> - </dd><dd><code>serviceClass</code> - </dd><dd><code>sparseComposite</code> - </dd><dd><code>sparseCompositeKey</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  If an EndpointDescritption already exists, it will
 be returned; if one does not already exist, it will be created.  Note that if the SEI is null
 then the EndpointDescription returned will be for a Dispatch client only and it will not have
 an EndpointInterfaceDescription hierarchy associated with it.  If, at a later point, the same
 port is requested and an SEI is provided, the existing EndpointDescription will be updated
 with a newly-created EndpointInterfaceDescription hierarchy.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>portQName</code> - The QName of the port.  If this is null, the runtime will attempt
                           to to select an appropriate port to use.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  This is identical to above, but this method has a 
 reference back to the ServiceDelegate (which invoked it) for purposes of properly caching 
 ServiceDescriptions that contain dynamic ports</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>portQName</code> - The QName of the port.  If this is null, the runtime will attempt
                           to to select an appropriate port to use.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd><dd><code>serviceDelegateKey</code> - A reference back to the ServiceDelegate that called it</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</pre>
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  Additional metadata may be specified in a sparse
 composite.  That metadata may come from a JSR-109 client deployment descriptor, for example,
 or from resource injection of an WebServiceRef or other Resource annotation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - </dd><dd><code>sei</code> - </dd><dd><code>portQName</code> - </dd><dd><code>updateType</code> - </dd><dd><code>composite</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)"><code>updateEndpoint(ServiceDescription, Class, QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</pre>
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.  If an EndpointDescritption already exists, it will
 be returned; if one does not already exist, it will be created.  Note that if the SEI is null
 then the EndpointDescription returned will be for a Dispatch client only and it will not have
 an EndpointInterfaceDescription hierachy associated with it.  If, at a later point, the same
 port is requested and an SEI is provided, the existing EndpointDescription will be updated
 with a newly-created EndpointInterfaceDescription hieracy.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                            null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                            creating a Dispatch; it can not be null when getting a port.</dd><dd><code>epr</code> - The endpoint reference to the target port.</dd><dd><code>addressingNamespace</code> - The addressing namespace of the endpoint reference.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                            getting an SEI-based port.</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  This is identical to above, but this method has a 
 reference back to the ServiceDelegate (which invoked it) for purposes of properly caching 
 ServiceDescriptions that contain dynamic ports</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>epr</code> - The endpoint reference to the target port.</dd><dd><code>addressingNamespace</code> - The addressing namespace of the endpoint reference.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd><dd><code>serviceDelegateKey</code> - A reference back to the ServiceDelegate that called it</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey)</pre>
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.  Additonal metdata may be specified in a sparse
 composite.  That metadata may come from a JSR-109 client deployment descriptor, for example,
 or from resource injection of an WebServiceRef or other Resource annotation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - </dd><dd><code>sei</code> - </dd><dd><code>portQName</code> - </dd><dd><code>updateType</code> - </dd><dd><code>composite</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)"><code>updateEndpoint(ServiceDescription, Class, QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  If an EndpointDescritption already exists, it will
 be returned; if one does not already exist, it will be created.  Note that if the SEI is null
 then the EndpointDescription returned will be for a Dispatch client only and it will not have
 an EndpointInterfaceDescription hierarchy associated with it.  If, at a later point, the same
 port is requested and an SEI is provided, the existing EndpointDescription will be updated
 with a newly-created EndpointInterfaceDescription hierarchy.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>portQName</code> - The QName of the port.  If this is null, the runtime will attempt
                           to to select an appropriate port to use.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  This is identical to above, but this method has a 
 reference back to the ServiceDelegate (which invoked it) for purposes of properly caching 
 ServiceDescriptions that contain dynamic ports</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>portQName</code> - The QName of the port.  If this is null, the runtime will attempt
                           to to select an appropriate port to use.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd><dd><code>serviceDelegateKey</code> - A reference back to the ServiceDelegate that called it</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/javax/xml/namespace/QName.html?is-external=true" title="class or interface in javax.xml.namespace">QName</a>&nbsp;portQName,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  Additional metadata may be specified in a sparse
 composite.  That metadata may come from a JSR-109 client deployment descriptor, for example,
 or from resource injection of an WebServiceRef or other Resource annotation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - </dd><dd><code>sei</code> - </dd><dd><code>portQName</code> - </dd><dd><code>updateType</code> - </dd><dd><code>composite</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)"><code>updateEndpoint(ServiceDescription, Class, QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.  If an EndpointDescritption already exists, it will
 be returned; if one does not already exist, it will be created.  Note that if the SEI is null
 then the EndpointDescription returned will be for a Dispatch client only and it will not have
 an EndpointInterfaceDescription hierachy associated with it.  If, at a later point, the same
 port is requested and an SEI is provided, the existing EndpointDescription will be updated
 with a newly-created EndpointInterfaceDescription hieracy.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                            null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                            creating a Dispatch; it can not be null when getting a port.</dd><dd><code>epr</code> - The endpoint reference to the target port.</dd><dd><code>addressingNamespace</code> - The addressing namespace of the endpoint reference.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                            getting an SEI-based port.</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, java.lang.Object, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;serviceDelegateKey,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.  This is identical to above, but this method has a 
 reference back to the ServiceDelegate (which invoked it) for purposes of properly caching 
 ServiceDescriptions that contain dynamic ports</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - An existing client-side ServiceDescription.  This must not be
                           null.</dd><dd><code>sei</code> - The ServiceInterface class.  This can be null for adding a port or
                           creating a Dispatch; it can not be null when getting a port.</dd><dd><code>epr</code> - The endpoint reference to the target port.</dd><dd><code>addressingNamespace</code> - The addressing namespace of the endpoint reference.</dd><dd><code>updateType</code> - The type of the update: adding a port, creating a dispatch, or
                           getting an SEI-based port.</dd><dd><code>serviceDelegateKey</code> - A reference back to the ServiceDelegate that called it</dd>
<dt><span class="strong">Returns:</span></dt><dd>An EndpointDescription corresponding to the port.</dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#createServiceDescription(java.net.URL, javax.xml.namespace.QName, java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd></dl>
</li>
</ul>
<a name="updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, org.apache.axis2.addressing.EndpointReference, java.lang.String, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType, org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite, java.lang.Object, java.lang.String, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateEndpoint</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint(<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;serviceDescription,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;sei,
                                 <a href="../../../../../org/apache/axis2/addressing/EndpointReference.html" title="class in org.apache.axis2.addressing">EndpointReference</a>&nbsp;epr,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;addressingNamespace,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                 <a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&nbsp;composite,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;sparseCompositeKey,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;bindingId,
                                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;endpointAddress)</pre>
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.  Additonal metdata may be specified in a sparse
 composite.  That metadata may come from a JSR-109 client deployment descriptor, for example,
 or from resource injection of an WebServiceRef or other Resource annotation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceDescription</code> - </dd><dd><code>sei</code> - </dd><dd><code>portQName</code> - </dd><dd><code>updateType</code> - </dd><dd><code>composite</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd></dd><dt><span class="strong">See Also:</span></dt><dd><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.html#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription, java.lang.Class, javax.xml.namespace.QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)"><code>updateEndpoint(ServiceDescription, Class, QName, org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)</code></a></dd></dl>
</li>
</ul>
<a name="createServiceDescriptionFromDBCMap(java.util.HashMap)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap)</pre>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.  Note that the associated SERVER side
 Axis description objects are also created.  To create a single ServiceDescription hierarchy
 for a single service implementation class, use the factory method that takes a single class
 and returns a single ServiceDescription.
 <p/>
 A service implementation DBC entry is one that: (1) Is a class and not an interface (2)
 Carries a WebService or WebServiceProvider annotation.
 <p/>
 A DBC represents the information found in the service implementation class.  There will be
 other DBC entries in the map for classes and interfaces associated with the service
 implementation, such as super classes, super interfaces, fault classes, and such.
 <p/>
 Note that map may contain > 1 service implementation DBC.  A full ServiceDescriptionhierarchy
 will be created for each service implementation DBC entry.
 <p/>
 Note that each ServiceDescription will have exactly one EndpointDescription corresponding to
 each service implementation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dbcMap</code> - A HashMap keyed on class name with a value for the DBC for that classname</dd>
<dt><span class="strong">Returns:</span></dt><dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd></dl>
</li>
</ul>
<a name="createServiceDescriptionFromDBCMap(java.util.HashMap, org.apache.axis2.context.ConfigurationContext)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                                          <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</pre>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.  Note that the associated SERVER side
 Axis description objects are also created.  To create a single ServiceDescription hierarchy
 for a single service implementation class, use the factory method that takes a single class
 and returns a single ServiceDescription.
 <p/>
 A service implementation DBC entry is one that: (1) Is a class and not an interface (2)
 Carries a WebService or WebServiceProvider annotation.
 <p/>
 A DBC represents the information found in the service implementation class.  There will be
 other DBC entries in the map for classes and interfaces associated with the service
 implementation, such as super classes, super interfaces, fault classes, and such.
 <p/>
 Note that map may contain > 1 service implementation DBC.  A full ServiceDescriptionhierarchy
 will be created for each service implementation DBC entry.
 <p/>
 Note that each ServiceDescription will have exactly one EndpointDescription corresponding to
 each service implementation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dbcMap</code> - A HashMap keyed on class name with a value for the DBC for that classname</dd><dd><code>configContext</code> - ConfigurationContext used to get WSDL Definition configuration parameters.</dd>
<dt><span class="strong">Returns:</span></dt><dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd></dl>
</li>
</ul>
<a name="createServiceDescriptionFromDBCMap(java.util.HashMap, org.apache.axis2.context.ConfigurationContext, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util">HashMap</a>&lt;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="../../../../../org/apache/axis2/jaxws/description/builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                                          <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext,
                                                          boolean&nbsp;performVaidation)</pre>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for EACH service implementation
 entry in the DescriptionBuilderComposite (DBC) map.  Note that the associated SERVER side
 Axis description objects are also created.  To create a single ServiceDescription hierarchy
 for a single service implementation class, use the factory method that takes a single class
 and returns a single ServiceDescription.
 <p/>
 A service implementation DBC entry is one that: (1) Is a class and not an interface (2)
 Carries a WebService or WebServiceProvider annotation.
 <p/>
 A DBC represents the information found in the service implementation class.  There will be
 other DBC entries in the map for classes and interfaces associated with the service
 implementation, such as super classes, super interfaces, fault classes, and such.
 <p/>
 Note that map may contain > 1 service implementation DBC.  A full ServiceDescriptionhierarchy
 will be created for each service implementation DBC entry.
 <p/>
 Note that each ServiceDescription will have exactly one EndpointDescription corresponding to
 each service implementation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>dbcMap</code> - A HashMap keyed on class name with a value for the DBC for that classname</dd><dd><code>configContext</code> - ConfigurationContext used to get WSDL Definition configuration parameters.</dd><dd><code>isValid</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd></dl>
</li>
</ul>
<a name="createServiceDescription(java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescription</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass)</pre>
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for a single service
 implementation class.  To create process more than one service implementation at one time or
 to process them without causing the service implementation classes to be loaded, use the
 factory method that takes a collection of DescriptionBuilderComposite objects and returns a
 collection of ServiceDescriptions.
 <p/>
 Note that the ServiceDescription will have exactly one EndpointDescription corresponding to
 the service implementation.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceImplClass</code> - A Web Service implementation class (i.e. one that carries an
                         WebService or WebServiceProvider annotation).</dd>
<dt><span class="strong">Returns:</span></dt><dd>A ServiceDescription with the associated SERVER side hierarchy created.</dd></dl>
</li>
</ul>
<a name="createAxisService(java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAxisService</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a>&nbsp;createAxisService(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass)</pre>
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceImplClass</code> - A Web Service implementation class (i.e. one that carries an
                         WebService or WebServiceProvider annotation).</dd>
<dt><span class="strong">Returns:</span></dt><dd>An AxisService instance</dd></dl>
</li>
</ul>
<a name="createAxisService(java.lang.Class, org.apache.axis2.context.ConfigurationContext)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAxisService</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a>&nbsp;createAxisService(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&nbsp;serviceImplClass,
                            <a href="../../../../../org/apache/axis2/context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</pre>
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>serviceImplClass</code> - A Web Service implementation class (i.e. one that carries an
                         WebService or WebServiceProvider annotation).</dd>
<dt><span class="strong">Returns:</span></dt><dd>An AxisService instance</dd></dl>
</li>
</ul>
<a name="createClientConfigurationFactory()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClientConfigurationFactory</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/ClientConfigurationFactory.html" title="class in org.apache.axis2.jaxws">ClientConfigurationFactory</a>&nbsp;createClientConfigurationFactory()</pre>
<div class="block">Creates Client ConfigurationFactory used to create AxisConfiguration.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>A Client Configuration Factory's new instance. ClinetConfigurationFactory is
         Singleton.</dd></dl>
</li>
</ul>
<a name="createResolvedHandlersDescription()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>createResolvedHandlersDescription</h4>
<pre>public static&nbsp;<a href="../../../../../org/apache/axis2/jaxws/description/ResolvedHandlersDescription.html" title="interface in org.apache.axis2.jaxws.description">ResolvedHandlersDescription</a>&nbsp;createResolvedHandlersDescription()</pre>
<div class="block">Create a ResolvedHandlersDescription object, which describes attributes of handlers
 that have been resolved for a give port.  This includes the handler classes and the roles.</div>
<dl><dt><span class="strong">Returns:</span></dt><dd>A new instance of a ResolfedHandlersDescription object.</dd></dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/DescriptionFactory.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../org/apache/axis2/jaxws/description/AttachmentType.html" title="enum in org.apache.axis2.jaxws.description"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../../org/apache/axis2/jaxws/description/DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/apache/axis2/jaxws/description/DescriptionFactory.html" target="_top">Frames</a></li>
<li><a href="DescriptionFactory.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested_class_summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &copy; <a href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</small></p>
</body>
</html>