<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<title>DescriptionFactory (Apache Axis2)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery/jquery-ui.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../jquery/jquery-3.3.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-migrate-3.0.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-ui.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="DescriptionFactory (Apache Axis2)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":9,"i1":9,"i2":9,"i3":9,"i4":9,"i5":9,"i6":9,"i7":9,"i8":9,"i9":9,"i10":9,"i11":9,"i12":9,"i13":9,"i14":9,"i15":9,"i16":9,"i17":9,"i18":9,"i19":9,"i20":9,"i21":9};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../";
var useModuleDirectories = true;
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<header role="banner">
<nav role="navigation">
<div class="fixedNav">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.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" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<ul class="navListSearch">
<li><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</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>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</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 id="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
</div>
<div class="navPadding">&nbsp;</div>
<script type="text/javascript"><!--
$('.navPadding').css('padding-top', $('.fixedNav').css("height"));
//-->
</script>
</nav>
</header>
<!-- ======== START OF CLASS DATA ======== -->
<main role="main">
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.apache.axis2.jaxws.description</a></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" class="externalLink">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>
<pre>public class <span class="typeNameLabel">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" class="externalLink">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 ======== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<table class="memberSummary">
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Class</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static class&nbsp;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a></span></code></th>
<td class="colLast">
<div class="block">The type of update being done for a particular Port.</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ========== METHOD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>static <a href="../../description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createAxisService(java.lang.Class)">createAxisService</a></span>&#8203;(<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="externalLink">Class</a>&nbsp;serviceImplClass)</code></th>
<td class="colLast">
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>static <a href="../../description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createAxisService(java.lang.Class,org.apache.axis2.context.ConfigurationContext)">createAxisService</a></span>&#8203;(<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="externalLink">Class</a>&nbsp;serviceImplClass,
                 <a href="../../context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</code></th>
<td class="colLast">
<div class="block">This provide very convenient way of creating an AxisService from an annotated java class.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>static <a href="../ClientConfigurationFactory.html" title="class in org.apache.axis2.jaxws">ClientConfigurationFactory</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createClientConfigurationFactory()">createClientConfigurationFactory</a></span>()</code></th>
<td class="colLast">
<div class="block">Creates Client ConfigurationFactory used to create AxisConfiguration.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>static <a href="ResolvedHandlersDescription.html" title="interface in org.apache.axis2.jaxws.description">ResolvedHandlersDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createResolvedHandlersDescription()">createResolvedHandlersDescription</a></span>()</code></th>
<td class="colLast">
<div class="block">Create a ResolvedHandlersDescription object, which describes attributes of handlers
 that have been resolved for a give port.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>static <a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescription(java.lang.Class)">createServiceDescription</a></span>&#8203;(<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="externalLink">Class</a>&nbsp;serviceImplClass)</code></th>
<td class="colLast">
<div class="block">Create a full ServiceDescription hierarchy on the SERVER side for a single service
 implementation class.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>static <a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)">createServiceDescription</a></span>&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net" class="externalLink">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" class="externalLink">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="externalLink">Class</a>&nbsp;serviceClass)</code></th>
<td class="colLast">
<div class="block">Create the initial ServiceDescription hierarchy on the CLIENT side.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>static <a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class,org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite,java.lang.Object)">createServiceDescription</a></span>&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net" class="externalLink">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" class="externalLink">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="externalLink">Class</a>&nbsp;serviceClass,
                        <a href="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" class="externalLink">Object</a>&nbsp;sparseCompositeKey)</code></th>
<td class="colLast">
<div class="block">Create the initial ServiceDescripton hierarchy on the CLIENT side.</div>
</td>
</tr>
<tr id="i7" 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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescriptionFromDBCMap(java.util.HashMap)">createServiceDescriptionFromDBCMap</a></span>&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap)</code></th>
<td class="colLast">
<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 id="i8" 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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescriptionFromDBCMap(java.util.HashMap,org.apache.axis2.context.ConfigurationContext)">createServiceDescriptionFromDBCMap</a></span>&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                  <a href="../../context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext)</code></th>
<td class="colLast">
<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 id="i9" 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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createServiceDescriptionFromDBCMap(java.util.HashMap,org.apache.axis2.context.ConfigurationContext,boolean)">createServiceDescriptionFromDBCMap</a></span>&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                  <a href="../../context/ConfigurationContext.html" title="class in org.apache.axis2.context">ConfigurationContext</a>&nbsp;configContext,
                                  boolean&nbsp;performVaidation)</code></th>
<td class="colLast">
<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 id="i10" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#updateEndpoint(org.apache.axis2.jaxws.description.ServiceDescription,java.lang.Class,javax.xml.namespace.QName,org.apache.axis2.jaxws.description.DescriptionFactory.UpdateType)">updateEndpoint</a></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="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" class="externalLink">Object</a>&nbsp;serviceDelegateKey)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="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" class="externalLink">Object</a>&nbsp;sparseCompositeKey)</code></th>
<td class="colLast">
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create an EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="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" class="externalLink">Object</a>&nbsp;serviceDelegateKey)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierarchy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create the EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="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" class="externalLink">Object</a>&nbsp;sparseCompositeKey)</code></th>
<td class="colLast">
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>static <a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#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></span>&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
              <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
              <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
              <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">String</a>&nbsp;endpointAddress)</code></th>
<td class="colLast">
<div class="block">Retrieve or create an EndpointDescription hierachy associated with an existing CLIENT side
 ServiceDescription for a particular port.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">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" class="externalLink">wait</a></code></li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a id="createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescription</h4>
<pre class="methodSignature">public static&nbsp;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net" class="externalLink">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" class="externalLink">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="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>A ServiceDescription instance for a CLIENT access to the service.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#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, ServiceDescription.UpdateType)</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/net/URL.html?is-external=true" title="class or interface in java.net" class="externalLink">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" class="externalLink">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="externalLink">Class</a>&nbsp;serviceClass,
                                                          <a href="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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                                 <a href="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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#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 id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                                 <a href="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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#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 id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">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" class="externalLink">QName</a>&nbsp;portQName,
                                                 <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                                 <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#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 id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An EndpointDescription corresponding to the port.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#createServiceDescription(java.net.URL,javax.xml.namespace.QName,java.lang.Class)"><code>createServiceDescription(URL, QName, Class)</code></a>, 
<a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description"><code>DescriptionFactory.UpdateType</code></a></dd>
</dl>
</li>
</ul>
<a id="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 class="methodSignature">public static&nbsp;<a href="EndpointDescription.html" title="interface in org.apache.axis2.jaxws.description">EndpointDescription</a>&nbsp;updateEndpoint&#8203;(<a href="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="externalLink">Class</a>&nbsp;sei,
                                                 <a href="../../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" class="externalLink">String</a>&nbsp;addressingNamespace,
                                                 <a href="DescriptionFactory.UpdateType.html" title="enum in org.apache.axis2.jaxws.description">DescriptionFactory.UpdateType</a>&nbsp;updateType,
                                                 <a href="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" class="externalLink">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" class="externalLink">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" class="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#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 id="createServiceDescriptionFromDBCMap(java.util.HashMap)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre class="methodSignature">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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd>
</dl>
</li>
</ul>
<a id="createServiceDescriptionFromDBCMap(java.util.HashMap,org.apache.axis2.context.ConfigurationContext)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre class="methodSignature">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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                                                          <a href="../../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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd>
</dl>
</li>
</ul>
<a id="createServiceDescriptionFromDBCMap(java.util.HashMap,org.apache.axis2.context.ConfigurationContext,boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescriptionFromDBCMap</h4>
<pre class="methodSignature">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" class="externalLink">List</a>&lt;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&gt;&nbsp;createServiceDescriptionFromDBCMap&#8203;(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html?is-external=true" title="class or interface in java.util" class="externalLink">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" class="externalLink">String</a>,&#8203;<a href="builder/DescriptionBuilderComposite.html" title="class in org.apache.axis2.jaxws.description.builder">DescriptionBuilderComposite</a>&gt;&nbsp;dbcMap,
                                                                          <a href="../../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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>A List of ServiceDescriptions with the associated SERVER side hierarchy created.</dd>
</dl>
</li>
</ul>
<a id="createServiceDescription(java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createServiceDescription</h4>
<pre class="methodSignature">public static&nbsp;<a href="ServiceDescription.html" title="interface in org.apache.axis2.jaxws.description">ServiceDescription</a>&nbsp;createServiceDescription&#8203;(<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="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>A ServiceDescription with the associated SERVER side hierarchy created.</dd>
</dl>
</li>
</ul>
<a id="createAxisService(java.lang.Class)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAxisService</h4>
<pre class="methodSignature">public static&nbsp;<a href="../../description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a>&nbsp;createAxisService&#8203;(<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="externalLink">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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An AxisService instance</dd>
</dl>
</li>
</ul>
<a id="createAxisService(java.lang.Class,org.apache.axis2.context.ConfigurationContext)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAxisService</h4>
<pre class="methodSignature">public static&nbsp;<a href="../../description/AxisService.html" title="class in org.apache.axis2.description">AxisService</a>&nbsp;createAxisService&#8203;(<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="externalLink">Class</a>&nbsp;serviceImplClass,
                                            <a href="../../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="paramLabel">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="returnLabel">Returns:</span></dt>
<dd>An AxisService instance</dd>
</dl>
</li>
</ul>
<a id="createClientConfigurationFactory()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createClientConfigurationFactory</h4>
<pre class="methodSignature">public static&nbsp;<a href="../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="returnLabel">Returns:</span></dt>
<dd>A Client Configuration Factory's new instance. ClinetConfigurationFactory is
         Singleton.</dd>
</dl>
</li>
</ul>
<a id="createResolvedHandlersDescription()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>createResolvedHandlersDescription</h4>
<pre class="methodSignature">public static&nbsp;<a href="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="returnLabel">Returns:</span></dt>
<dd>A new instance of a ResolfedHandlersDescription object.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
</div>
</main>
<!-- ========= END OF CLASS DATA ========= -->
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.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" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses.html">All&nbsp;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>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</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 id="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &copy; <a href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</small></p>
</footer>
</body>
</html>
