docs: static List<InjectionBinding<WebServiceRef>> buildJaxWsWebServiceRefBindings(List<ServiceRef> jaxwsServiceRefs, ComponentNameSpaceConfiguration cnsConfig) throws InjectionException {
  
          if (jaxwsServiceRefs.size() == 0) {
              return Collections.emptyList();
          }
  
          ClassLoader classLoader = cnsConfig.getClassLoader();
  
          List<InjectionBinding<WebServiceRef>> bindingList = new ArrayList<InjectionBinding<WebServiceRef>>(jaxwsServiceRefs.size());
  
          try {
              // For each service ref, we will build a binding and a WebServiceRefInfo object to hold the service-ref's metadata.
              for (ServiceRef serviceRef : jaxwsServiceRefs) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Building WebServiceRefInfo for service-ref: " + serviceRef.getName());
                  }
  
                  WebServiceRefInfo wsrInfo = WebServiceRefInfoBuilder.buildWebServiceRefInfo(serviceRef, classLoader);
                  wsrInfo.setClientMetaData(JaxWsMetaDataManager.getJaxWsClientMetaData(cnsConfig.getModuleMetaData()));
  
                  Class<?> srvInterfaceClass = wsrInfo.getAnnotationValue().value();
                  Class<?> srvRefTypeClass = wsrInfo.getAnnotationValue().type();
  
                  // Use portComponentLink to find the wsdl location if not specified in <wsdl-file> explicitly
                  if (wsrInfo.getWsdlLocation() == null || wsrInfo.getWsdlLocation().isEmpty()) {
  
                      String pcLinkValue = null;
                      String srvRefTypeClassName = wsrInfo.getServiceRefTypeClassName();
  
                      // loop through until we find a port-component-ref whose
                      // service-endpoint-interface value matches the service-ref-type in the service-ref
                      for (Entry<String, PortComponentRefInfo> entry : wsrInfo.getPortComponentRefInfoMap().entrySet()) {
                          String seiName = entry.getKey();
                          PortComponentRefInfo pcRefInfo = entry.getValue();
  
                          if (!seiName.equals(srvRefTypeClassName)) {
                              continue;
                          }
  
                          pcLinkValue = pcRefInfo.getPortComponentLink();
                          break;
                      }
  
                      // if we found a non-null port-component-link value, we need to look for the wsdl location 
                      // from the port component of the same module
                      if (pcLinkValue != null) {
                          // the service metadata has processed before the client metadata processing
                          JaxWsModuleMetaData jaxwsModuleMetaData = JaxWsMetaDataManager.getJaxWsModuleMetaData(cnsConfig.getModuleMetaData());
                          Container moduleContainer = jaxwsModuleMetaData.getModuleContainer();
  
                          NonPersistentCache overlayCache = moduleContainer.adapt(NonPersistentCache.class);
                          JaxWsModuleInfo jaxWsModuleInfo = (JaxWsModuleInfo) overlayCache.getFromCache(JaxWsModuleInfo.class);
  
                          if (jaxWsModuleInfo != null) {
                              for (EndpointInfo endpointInfo : jaxWsModuleInfo.getEndpointInfos()) {
                                  if (pcLinkValue.equals(endpointInfo.getPortComponentName())) {
                                      String wsdlLocation = endpointInfo.getWsdlLocation();
                                      if (wsdlLocation != null && !wsdlLocation.isEmpty()) {
                                          wsrInfo.setWsdlLocation(wsdlLocation);
                                      }
                                      break;
                                  }
                              }
                          }
                      }
                  }
  
                  // Create the injection binding for this service ref.
                  WebServiceRefBinding binding = new WebServiceRefBinding(wsrInfo, cnsConfig);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Created WebServiceRefBinding: " + binding.toString());
                  }
  
                  // Add injection targets which defined in injection-targets element
                  // Note that injection targets will be empty for java:global/java:app/java:module.
                  List<InjectionTarget> injectionTargets = serviceRef.getInjectionTargets();
                  if (injectionTargets != null && !injectionTargets.isEmpty()) {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "Adding injection targets specified in service-ref element");
                      }
                      // get the injection type from service-interface and service-ref-type element
                      Class<?> injectionType = srvInterfaceClass;
                      if (srvRefTypeClass != null && !srvRefTypeClass.getName().equals(Object.class.getName())) {
                          injectionType = srvRefTypeClass;
                      }
  
                      for (InjectionTarget target : injectionTargets) {
                          if (target.getInjectionTargetClassName() != null && target.getInjectionTargetName() != null) {
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                  Tr.debug(tc, "Adding injection target from XML, type= " + injectionType.getName()
                                               + ", target class= " + target.getInjectionTargetClassName()
                                               + ", target member= " + target.getInjectionTargetName());
                              }
                              binding.addInjectionTarget(injectionType, target.getInjectionTargetName(), target.getInjectionTargetClassName());
                          }
                      }
                  }
  
                  // Add the new binding to the list to be returned to the caller.
                  bindingList.add(binding);
              }
          } catch (InjectionException e) {
              throw e;
          } catch (Throwable t) {
              throw new InjectionException(t);
          }
  
          return bindingList;
      }