import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
protected WSService importService(ServiceInfo service) {
    String name = service.getName().getLocalPart();
    String location = "";

    for (EndpointInfo endpoint : service.getEndpoints()) {
        location = endpoint.getAddress();
    }

    WSService wsService = new WSService(this.namespace + name, location, this.wsdlLocation);
    for (OperationInfo operation : service.getInterface().getOperations()) {
        WSOperation wsOperation = this.importOperation(operation, wsService);
        wsService.addOperation(wsOperation);

        this.wsOperations.put(this.namespace + operation.getName().getLocalPart(), wsOperation);
    }
    return wsService;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private boolean isExistsPolicy(ServiceInfo service, String uri)
{
   Object exts[] = service.getDescription().getExtensors().get();
   exts = exts == null ? new Object[0] : exts;
   for (Object o : exts)
   {
      if (o instanceof UnknownExtensibilityElement)
      {
         UnknownExtensibilityElement uee = (UnknownExtensibilityElement) o;
         String uri2 = getPolicyId(uee.getElement());
         if (uri.equals(uri2))
         {
            return true;
         }
      }
   }
   return false;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
/**
 * For both code-first and wsdl-first scenarios, reset the endpoint address
 * so that it is written to the generated wsdl file.
 */
private void updateSoapAddress() {
   final SOAPAddressRewriteMetadata metadata = getSOAPAddressRewriteMetadata();
   if (metadata.isModifySOAPAddress()) {
      //- code-first handling
      List<ServiceInfo> sevInfos = getServer().getEndpoint().getService().getServiceInfos();
      for (ServiceInfo si: sevInfos){
         Collection<EndpointInfo > epInfos = si.getEndpoints();
         for(EndpointInfo ei: epInfos){
            String publishedEndpointUrl = (String)ei.getProperty(WSDLGetUtils.PUBLISHED_ENDPOINT_URL);
            if (publishedEndpointUrl != null){
               ei.setAddress(publishedEndpointUrl);
            } else {
               //- wsdl-first handling
               if (ei.getAddress().contains(ServerConfig.UNDEFINED_HOSTNAME)) {
                  String epurl = SoapAddressRewriteHelper.getRewrittenPublishedEndpointUrl(ei.getAddress(), metadata);
                  ei.setAddress(epurl);
               }
            }
         }
      }
   }
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public void importFrom(String url) {
  this.wsServices.clear();
  this.wsOperations.clear();
  this.structures.clear();

  this.wsdlLocation = url;

  try {
    Bus bus = BusFactory.getDefaultBus();
    WSDLManager wsdlManager = bus.getExtension(WSDLManager.class);
    Definition def = wsdlManager.getDefinition(url);
    WSDLServiceBuilder builder = new WSDLServiceBuilder(bus);
    List<ServiceInfo> services = builder.buildServices(def);
    
    for (ServiceInfo service : services) {
      WSService wsService = this.importService(service);
      this.wsServices.put(this.namespace + wsService.getName(), wsService);
    }
    
    this.importTypes(def.getTypes());
  } catch (WSDLException e) {
    e.printStackTrace();
  }
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private WSService importService(ServiceInfo service) {
  String name = service.getName().getLocalPart();
  String location = "";
  
  for (EndpointInfo endpoint : service.getEndpoints()) {
    location = endpoint.getAddress();
  }
  
  WSService wsService = new WSService(this.namespace + name, location, this.wsdlLocation);
  for (OperationInfo operation : service.getInterface().getOperations()) {
    WSOperation wsOperation = this.importOperation(operation, wsService);
    wsService.addOperation(wsOperation);

    this.wsOperations.put(this.namespace + operation.getName().getLocalPart(), wsOperation);
  }
  return wsService;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public void importFrom(String url) {
  this.wsServices.clear();
  this.wsOperations.clear();
  this.structures.clear();

  this.wsdlLocation = url;

  try {
    Bus bus = BusFactory.getDefaultBus();
    WSDLManager wsdlManager = bus.getExtension(WSDLManager.class);
    Definition def = wsdlManager.getDefinition(url);
    
    WSDLServiceBuilder builder = new WSDLServiceBuilder(bus);
    List<ServiceInfo> services = builder.buildServices(def);
    
    for (ServiceInfo service : services) {
      WSService wsService = this.importService(service);
      this.wsServices.put(this.namespace + wsService.getName(), wsService);
    }
    
    this.importTypes(def.getTypes());
  } catch (WSDLException e) {
    e.printStackTrace();
  }
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private EndPoint createEndpoint(Class<?> clz) {
    List<PhpService> services;ServiceBuilder builder = getServiceBuilder(clz);
    ServiceInfo serviceInfo = builder.createService();

    NameManager nameManager = NameManager.newNameManager(serviceInfo, null);
    NamespacePrefixAccumulator prefixManager = new NamespacePrefixAccumulator(serviceInfo.getXmlSchemaCollection());
    Collection<SchemaInfo> schemata = serviceInfo.getSchemas();


    TypesPHPBuilder jsBuilder = new TypesPHPBuilder(serviceInfo.getXmlSchemaCollection(), prefixManager, nameManager);

    List<PhpType> phpTypes = new ArrayList<>();
    for (SchemaInfo schema : schemata) {
        phpTypes.addAll(jsBuilder.gatherTypes(schema.getSchema()));
    }

    ServicePHPBuilder serviceBuilder = new ServicePHPBuilder(serviceInfo, prefixManager, nameManager);
    serviceBuilder.walk();

    services = serviceBuilder.getServices();
    return new EndPoint(services, phpTypes);
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
@Override
public void begin(ServiceInfo service) {
    BindingInfo xml = null;
    for (BindingInfo bindingInfo : service.getBindings()) {
        if (SoapBindingConstants.SOAP11_BINDING_ID.equals(bindingInfo.getBindingId())
                || SoapBindingConstants.SOAP12_BINDING_ID.equals(bindingInfo.getBindingId())
                || SoapBindingFactory.SOAP_11_BINDING.equals(bindingInfo.getBindingId())
                || SoapBindingFactory.SOAP_12_BINDING.equals(bindingInfo.getBindingId())
                ) {
            SoapBindingInfo sbi = (SoapBindingInfo) bindingInfo;
            if (WSDLConstants.NS_SOAP11_HTTP_TRANSPORT.equals(sbi.getTransportURI())
                    || WSDLConstants.NS_SOAP12_HTTP_BINDING.equals(sbi.getTransportURI())
                    || "http://cxf.apache.org/transports/local".equals(sbi.getTransportURI())) {
                soapBindingInfo = sbi;
                break;
            }
        } else if (WSDLConstants.NS_BINDING_XML.equals(bindingInfo.getBindingId())) {
            xml = bindingInfo;
        }
    }

    // For now, we use soap if its available, and XML if it isn't.\
    if (soapBindingInfo == null && xml == null) {
        throw new UnsupportedConstruct("NO_USABLE_BINDING");
    }
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
protected void setExchangeProperties(Exchange exchange, Endpoint ep) {
    if (ep != null) {
        exchange.put(Endpoint.class, ep);
        exchange.put(Service.class, ep.getService());
        if (ep.getEndpointInfo().getService() != null) {
            exchange.put(ServiceInfo.class, ep.getEndpointInfo()
                    .getService());
            exchange.put(InterfaceInfo.class, ep.getEndpointInfo()
                    .getService().getInterface());
        }
        exchange.put(Binding.class, ep.getBinding());
        exchange.put(BindingInfo.class, ep.getEndpointInfo().getBinding());
    }

    exchange.put(MessageObserver.class, this);
    exchange.put(Bus.class, getBus());
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private void addPolicy(AbstractPropertiesHolder place, ServiceInfo service, PolicyAttachment pa, Class<?> cls, String defName)
{
   Element el = addPolicy(service, pa, cls, defName);
   UnknownExtensibilityElement uee = new UnknownExtensibilityElement();
   uee.setElement(el);
   uee.setRequired(true);
   uee.setElementType(DOMUtils.getElementQName(el));
   place.addExtensor(uee);
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private MessageInfo setMessage(Message message, BindingOperationInfo operation,
                               boolean requestor, ServiceInfo si) {
    MessageInfo msgInfo = getMessageInfo(message, operation, requestor);
    message.put(MessageInfo.class, msgInfo);

    Exchange ex = message.getExchange();
    ex.put(BindingOperationInfo.class, operation);
    ex.put(OperationInfo.class, operation.getOperationInfo());
    ex.setOneWay(operation.getOperationInfo().isOneWay());

    //Set standard MessageContext properties required by JAX_WS, but not specific to JAX_WS.
    message.put(Message.WSDL_OPERATION, operation.getName());

    QName serviceQName = si.getName();
    message.put(Message.WSDL_SERVICE, serviceQName);

    QName interfaceQName = si.getInterface().getName();
    message.put(Message.WSDL_INTERFACE, interfaceQName);

    EndpointInfo endpointInfo = ex.get(Endpoint.class).getEndpointInfo();
    QName portQName = endpointInfo.getName();
    message.put(Message.WSDL_PORT, portQName);

    
    URI wsdlDescription = endpointInfo.getProperty("URI", URI.class);
    if (wsdlDescription == null) {
        String address = endpointInfo.getAddress();
        try {
            wsdlDescription = new URI(address + "?wsdl");
        } catch (URISyntaxException e) {
            //do nothing
        }
        endpointInfo.setProperty("URI", wsdlDescription);
    }
    message.put(Message.WSDL_DESCRIPTION, wsdlDescription);

    return msgInfo;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public JAXBContextInitializer(ServiceInfo serviceInfo,
                              Set<Type> classes,
                              Collection<Object> typeReferences) {
    super(serviceInfo);
    this.classes = classes;
    this.typeReferences = typeReferences;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public JAXBSchemaInitializer(ServiceInfo serviceInfo,
                             SchemaCollection col,
                             JAXBContext context,
                             boolean q) {
    super(serviceInfo);
    schemas = col;
    this.context = ReflectionInvokationHandler.createProxyWrapper(context, JAXBContextProxy.class);
    this.qualifiedSchemas = q;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
private Set<Class<?>> generatedWrapperBeanClass() {
    DataBinding b = getDataBinding();
    if (b.getClass().getName().endsWith("JAXBDataBinding")
        && schemaLocations == null) {
        ServiceInfo serviceInfo = getService().getServiceInfos().get(0);
        PlusWrapperClassGenerator wrapperGen = new PlusWrapperClassGenerator(this,
                                                                     serviceInfo.getInterface(),
                                                                     getQualifyWrapperSchema());
        return wrapperGen.generate();
    }
    return Collections.emptySet();
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public AegisSchemaValidationInInterceptor(Bus bus, ServiceInfo service) {
    super(Phase.READ);
    this.bus = bus;
    this.service = service;
    addBefore(StartBodyInterceptor.class.getName());
    addAfter(ReadHeadersInterceptor.class.getName());
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public static Service createServiceModel() {
    ServiceInfo serviceInfo = new ServiceInfo();
    // does not make sense for protobuf services
    serviceInfo.setName(new QName("", "protobuf_service_"
            + System.identityHashCode(serviceInfo)));

    InterfaceInfo interfaceInfo = new InterfaceInfo(serviceInfo,
            serviceInfo.getName());
    serviceInfo.setInterface(interfaceInfo);

    Service service = new ServiceImpl(serviceInfo);

    return service;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public static EndpointInfo createEndpointInfo(Bus bus, ServiceInfo serviceInfo,
                                              BindingInfo bindingInfo, String address) {
    String transportURI = getTransportId(bus, address);
    EndpointInfo endpointInfo = new EndpointInfo(serviceInfo, transportURI);

    if (address != null) {
        endpointInfo.setName(new QName(address));
        endpointInfo.setAddress(address);
    }

    System.out.println("seting binding info:" + bindingInfo);
    endpointInfo.setBinding(bindingInfo);

    return endpointInfo;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
public BindingInfo createBindingInfo(Service service, String namespace,
                                     Object obj) {

    ServiceInfo si = new ServiceInfo();
    si.setTargetNamespace(ProtobufBindingFactory.PROTOBUF_BINDING_ID);

    BindingInfo info = new BindingInfo(si,
            ProtobufBindingFactory.PROTOBUF_BINDING_ID);

    return info;
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
/** Publish the deployed wsdl file to the data directory
 */
public void publishWsdlFiles(QName serviceName, String wsdlLocation, Bus bus, List<ServiceInfo> serviceInfos) throws IOException
{
   String deploymentName = dep.getCanonicalName();
   File wsdlFile = getPublishLocation(serviceName.getLocalPart(), deploymentName, wsdlLocation);
   if (wsdlFile == null) return;
   createParentDir(wsdlFile);
   try
   {
      // Write the wsdl def to file
      ServiceWSDLBuilder builder = new ServiceWSDLBuilder(bus, serviceInfos);
      Definition def = builder.build();

      Document doc = getWsdlDocument(bus, def);
      writeDocument(doc, wsdlFile);

      URL wsdlPublishURL = new URL(URLDecoder.decode(wsdlFile.toURI().toURL().toExternalForm(), "UTF-8"));
      Loggers.DEPLOYMENT_LOGGER.wsdlFilePublished(wsdlPublishURL);

      // Process the wsdl imports
      if (def != null)
      {
         List<String> published = new LinkedList<String>();
         String expLocation = getExpLocation(wsdlLocation);
         publishWsdlImports(wsdlPublishURL, def, published, expLocation);

         // Publish XMLSchema imports
         publishSchemaImports(wsdlPublishURL, doc.getDocumentElement(), published, expLocation);

         dep.addAttachment(WSDLFilePublisher.class, this);
      }
      else
      {
         throw Messages.MESSAGES.wsdl20NotSupported();
      }
   }
   catch (RuntimeException rte)
   {
      throw rte;
   }
   catch (Exception e)
   {
      throw Messages.MESSAGES.cannotPublishWSDLTo(serviceName, wsdlFile, e);
   }
}
 

import org.apache.cxf.service.model.ServiceInfo; //导入依赖的package包/类
/**
 * @param service
 * @param endpoint
 * @return
 */
public static NameManager newNameManager(ServiceInfo service, Endpoint endpoint) {
    NameManager nameManager = new NameManager();
    nameManager.initialize(service);
    return nameManager;
}