import org.apache.cxf.feature.Feature; //导入依赖的package包/类
@Bean(name="acaBulkRequestTransmitterService")
public BulkRequestTransmitterPortType request() {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setAddress(propertyResolver.getProperty("bulk.url"));
    factory.setServiceClass(BulkRequestTransmitterPortType.class);
    List<Feature> features = new ArrayList<>();
    features.add(new LoggingFeature());
    factory.setFeatures(features);
    Map<String, Object> properties = new HashMap<>();
    properties.put("schema-validation-enabled",
            propertyResolver.getProperty("bulk.properties.schema-validation-enabled", Boolean.class, true));
    properties.put("mtom-enabled",
            propertyResolver.getProperty("bulk.properties.mtom-enabled", Boolean.class, true));
    factory.setProperties(properties);
    BulkRequestTransmitterPortType client = (BulkRequestTransmitterPortType) factory.create();
    return client;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
@Bean(name="acaTransmitterStatusService")
public ACATransmitterStatusReqPortType status() {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setAddress(propertyResolver.getProperty("status.url"));
    factory.setServiceClass(ACATransmitterStatusReqPortType.class);
    List<Feature> features = new ArrayList<>();
    features.add(new LoggingFeature());
    factory.setFeatures(features);
    Map<String, Object> properties = new HashMap<>();
    properties.put("schema-validation-enabled",
            propertyResolver.getProperty("status.properties.schema-validation-enabled", Boolean.class, true));
    factory.setProperties(properties);
    ACATransmitterStatusReqPortType client = (ACATransmitterStatusReqPortType) factory.create();
    return client;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
/**
 * Creates the {@link IServerSync} client endpoint which this application can use to talk to the metasfresh server.
 *
 * @return
 */
@Bean
public IServerSync clientEndPoint()
{
	if (useMockedServer)
	{
		logger.warn("Using mocked implementation for {}", IServerSync.class);
		return new MockedServerSync();
	}

	//
	// Get server's URL
	logger.info("mfprocurement.sync.url: {}", serverUrl);
	if (Strings.isNullOrEmpty(serverUrl))
	{
		logger.warn("Using null implementation for {}", IServerSync.class);
		return new NullServerSync();
	}

	//
	// Get MediaType
	final MediaType mediaType = getMediaType();

	//
	// Create the server binding.
	final JacksonJaxbJsonProvider jacksonJaxbJsonProvider = new JacksonJaxbJsonProvider();

	final IServerSync serverSync = JAXRSClientFactory.create(
			serverUrl.trim(),
			IServerSync.class,
			Collections.singletonList(jacksonJaxbJsonProvider),
			Collections.singletonList((Feature)loggingFeature),
			null); // not providing a particular configLocation
	WebClient.client(serverSync)
			.type(mediaType)
			.accept(mediaType);
	return serverSync;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public static void addFeatures(InterceptorProvider interceptorProvider, Bus bus, Map<String, String> properties) {
   final String features = properties.get(Constants.CXF_FEATURES_PROP);
   if (features != null) {
      MapToBeanConverter converter = new MapToBeanConverter(properties);
      for (Feature f : createFeatures(features, converter)) {
         f.initialize(interceptorProvider, bus);
      }
   }
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private static List<Feature> createFeatures(String propValue, MapToBeanConverter converter) {
   List<Feature> list = new ArrayList<Feature>();
   StringTokenizer st = new StringTokenizer(propValue, ", ", false);
   
   while (st.hasMoreTokens()) {
      Feature feature = (Feature)newInstance(st.nextToken(), converter);
      if (feature != null) {
         list.add(feature);
      }
   }
   return list;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
@Bean(name = "bus")
Bus bus() {
    List<Feature> features = new ArrayList<Feature>();
    features.add(loggingFeature());
    cxf.setFeatures(features);

    return cxf;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private void addFeatures() {
    LoggingFeature loggingFeature = new LoggingFeature();
    loggingFeature.setPrettyLogging(true);

    List<Feature> features = new ArrayList<Feature>();
    features.add(loggingFeature);
    
    bus.setFeatures(features);
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private void addFeatures() {
    List<Feature> features = new ArrayList<Feature>();

    // create a loggingFeature that will log all received/sent messages
    LoggingFeature loggingFeature = new LoggingFeature();
    loggingFeature.setPrettyLogging(true);
    features.add(loggingFeature);

    // set the features on the CXF bus
    bus.setFeatures(features);
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private void addFeatures() {
    // create a loggingFeature that will log all received/sent messages
    LoggingFeature loggingFeature = new LoggingFeature();
    loggingFeature.setPrettyLogging(true);

    List<Feature> features = new ArrayList<Feature>();
    features.add(loggingFeature);

    // set the features on the CXF bus
    bus.setFeatures(features);
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
@Bean(name = "cxf", destroyMethod = "shutdown")
public SpringBus configureCxfBus() {
    final SpringBus bus = new SpringBus();
    List<Feature> features = new ArrayList<>();
    features.add(loggingFeature());
    bus.setFeatures(features);
    bus.setId("cxf");

    CamelTransportFactory camelTransportFactory = new CamelTransportFactory();
    camelTransportFactory.setCamelContext(camelContext);
    camelTransportFactory.setBus(bus);

    // bus.getExtension(CamelTransportFactory.class).setCamelContext(camelContext);
    return bus;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private static void checkAddressingEnabled(org.apache.cxf.endpoint.Endpoint e) {
    for (Feature feature : e.getActiveFeatures()) {
        if (feature instanceof WSAddressingFeature) {
             //TODO: remove this DecoupledFaultHandler once CXF is upgraded, see JBWS-3516
            e.getInInterceptors().add(new DecoupledFaultHandler());
            e.getOutInterceptors().add(new AddressingInterceptor());
            e.getOutFaultInterceptors().add(new AddressingInterceptor());
            break;
        }
    }
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
private static void checkAddressingEnabled(org.apache.cxf.endpoint.Endpoint e) {
    for (Feature feature : e.getActiveFeatures()) {
        if (feature instanceof WSAddressingFeature) {
             //TODO: remove this DecoupledFaultHandler once CXF is upgraded, see JBWS-3516
            e.getInInterceptors().add(new DecoupledFaultHandler());
            e.getOutInterceptors().add(new CXF3AddressingInterceptor());
            e.getOutFaultInterceptors().add(new CXF3AddressingInterceptor());
            break;
        }
    }
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public static List<Feature> createFeatures(final Collection<ServiceInfo> availableServices, final String featuresIds) {
    final List<?> features = ServiceInfos.resolve(availableServices, featuresIds.split(","));
    for (final Object instance : features) {
        if (!AbstractFeature.class.isInstance(instance)) {
            throw new OpenEJBRuntimeException("feature should inherit from " + AbstractFeature.class.getName());
        }
    }
    return (List<Feature>) features;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public JaxrsServiceDescriptor addFeature(Feature feature) {
    features.add(feature);
    return this;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
List<Feature> getFeatures() {
    return features;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public void setFeatures(List<Feature> f) {
    features = f;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public List<Feature> getFeatures() {
    return features;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
/**
 * Set the feature list to the CxfRs endpoint.
 */
public void setFeatures(List<Feature> features) {
    this.features = features;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
@Override
public <T extends ISingletonService> List<T> createClientEndpointsProgramatically(final CreateEndpointRequest<T> request)
{
	final String jmsURL = Services.get(IJMSService.class).getJmsURL(request.getCConnection());

	final JacksonJaxbJsonProvider jacksonJaxbJsonProvider = new JacksonJaxbJsonProvider();

	final String clientURL = StringUtils.formatMessage(CLIENT_ADDRESS_URL_ENCODED,
			request.getRequestQueue(),
			request.getResponseQueue(),
			jmsURL,
			Long.toString(request.getTimeOutMillis()));

	final List<T> result = new ArrayList<>();

	for (final Class<T> endPointclass : request.getEndpointClasses())
	{
		final List<Feature> features;
		if (loggingFeature == null)
		{
			logger.warn("No logging feature was wired for {}. Going without it", LoggingFeature.class);
			features = Collections.emptyList();
		}
		else
		{
			features = Collections.singletonList((Feature)loggingFeature);
		}

		final T client = JAXRSClientFactory.create(clientURL,
				endPointclass,
				Collections.singletonList(jacksonJaxbJsonProvider),
				features,
				null); // not providing a particular configLocation);

		WebClient.client(client)
				.type(MediaType.APPLICATION_JSON_TYPE)
				.accept(MediaType.APPLICATION_JSON_TYPE);

		result.add(client);
	}
	logger.info("Created client endpoints for {}", request);
	return result;
}
 

import org.apache.cxf.feature.Feature; //导入依赖的package包/类
public static void configureEndpoint(final AbstractEndpointFactory svrFactory, final ServiceConfiguration configuration, final String prefix) {
    final Properties beanConfig = configuration.getProperties();
    if (beanConfig == null || beanConfig.isEmpty()) {
        return;
    }

    final Collection<ServiceInfo> availableServices = configuration.getAvailableServices();

    // endpoint properties
    final Properties properties = ServiceInfos.serviceProperties(availableServices, beanConfig.getProperty(prefix + ENDPOINT_PROPERTIES));
    if (properties != null) {
        svrFactory.setProperties(PropertiesHelper.map(properties));
    }

    final String debugKey = prefix + DEBUG;
    if ("true".equalsIgnoreCase(beanConfig.getProperty(debugKey, SystemInstance.get().getOptions().get(debugKey, "false")))) {
        svrFactory.getProperties(true).put("faultStackTraceEnabled", "true");
    }

    // endpoint features
    final String featuresIds = beanConfig.getProperty(prefix + FEATURES);
    if (featuresIds != null) {
        final List<? extends Feature> features = createFeatures(availableServices, featuresIds);
        svrFactory.setFeatures(features);
    }

    configureInterceptors(svrFactory, prefix, availableServices, beanConfig);

    // databinding
    final String databinding = beanConfig.getProperty(prefix + DATABINDING);
    if (databinding != null && !databinding.trim().isEmpty()) {
        Object instance = ServiceInfos.resolve(availableServices, databinding);
        if (instance == null) {  // maybe id == classname
            try {
                instance = Thread.currentThread().getContextClassLoader().loadClass(databinding).newInstance();
            } catch (Exception e) {
                // ignore
            }
        }

        if (!DataBinding.class.isInstance(instance)) {
            throw new OpenEJBRuntimeException(instance + " is not a " + DataBinding.class.getName()
                    + ", please check configuration of service [id=" + databinding + "]");
        }
        svrFactory.setDataBinding((DataBinding) instance);
    }

    // address: easier than using openejb-jar.xml
    final String changedAddress = beanConfig.getProperty(prefix + ADDRESS);
    if (changedAddress != null && !changedAddress.trim().isEmpty()) {
        svrFactory.setAddress(changedAddress);
    }

    // published url
    final String publishedUrl = beanConfig.getProperty(prefix + PUBLISHED_URL);
    if (publishedUrl != null && !publishedUrl.trim().isEmpty()) {
        svrFactory.setPublishedEndpointUrl(publishedUrl);
    }
}