Beispiel #1
0
  @Test
  public void testServerFactoryBean() throws Exception {
    ServerFactoryBean svrBean = new ServerFactoryBean();
    svrBean.setAddress("http://localhost/Hello");
    svrBean.setTransportId("http://schemas.xmlsoap.org/soap/http");
    svrBean.setServiceBean(new HelloServiceImpl());
    svrBean.setServiceClass(HelloService.class);
    svrBean.setBus(getBus());

    svrBean.create();

    ClientProxyFactoryBean proxyFactory = new ClientProxyFactoryBean();
    ClientFactoryBean clientBean = proxyFactory.getClientFactoryBean();
    clientBean.setAddress("http://localhost/Hello");
    clientBean.setTransportId("http://schemas.xmlsoap.org/soap/http");
    clientBean.setServiceClass(HelloService.class);
    clientBean.setBus(getBus());
    clientBean.getInInterceptors().add(new LoggingInInterceptor());

    HelloService client = (HelloService) proxyFactory.create();

    ClientImpl c = (ClientImpl) ClientProxy.getClient(client);
    c.getOutInterceptors().add(new LoggingOutInterceptor());
    c.getInInterceptors().add(new LoggingInInterceptor());

    assertEquals("hello", client.sayHello());
    assertEquals("hello", client.echo("hello"));
  }
Beispiel #2
0
 private CreditAgencyWS getProxy() {
   // Here we use JaxWs front end to create the proxy
   JaxWsProxyFactoryBean proxyFactory = new JaxWsProxyFactoryBean();
   ClientFactoryBean clientBean = proxyFactory.getClientFactoryBean();
   clientBean.setAddress(creditAgencyAddress);
   clientBean.setServiceClass(CreditAgencyWS.class);
   clientBean.setBus(BusFactory.getDefaultBus());
   return (CreditAgencyWS) proxyFactory.create();
 }
  @Test
  public void testInvokingServiceFromCXFClient() throws Exception {
    ClientProxyFactoryBean proxyFactory = new ClientProxyFactoryBean();
    ClientFactoryBean clientBean = proxyFactory.getClientFactoryBean();
    clientBean.setAddress(simpleEndpointAddress);
    clientBean.setServiceClass(HelloService.class);
    clientBean.setBus(BusFactory.getDefaultBus());

    HelloService client = (HelloService) proxyFactory.create();
    assertNotNull(client);

    String result = client.echo(TEST_MESSAGE);
    assertEquals(
        "We should get the echo string result from router", result, "echo " + TEST_MESSAGE);

    Boolean bool = client.echoBoolean(Boolean.TRUE);
    assertNotNull("The result should not be null", bool);
    assertEquals("We should get the echo boolean result from router ", bool.toString(), "true");

    int beforeCallingPing = pingCounter;
    client.ping();
    int afterCallingPing = pingCounter;
    assertTrue("The ping operation doesn't be called", afterCallingPing - beforeCallingPing == 1);
  }
  RuntimeESBConsumer(
      final QName serviceName,
      final QName portName,
      final QName operationName,
      String publishedEndpointUrl,
      String wsdlURL,
      final boolean useServiceLocator,
      final Map<String, String> locatorProps,
      final EventFeature samFeature,
      boolean useServiceRegistry,
      final SecurityArguments securityArguments,
      Bus bus,
      boolean logging,
      final List<Header> soapHeaders,
      boolean enhancedResponse,
      Object correlationIDCallbackHandler) {
    this.operationName = operationName;
    this.samFeature = samFeature;
    this.soapHeaders = soapHeaders;
    this.enhancedResponse = enhancedResponse;

    clientFactory = new ClientFactoryBean();
    clientFactory.setServiceClass(GenericServiceClass.class);
    clientFactory
        .getServiceFactory()
        .getServiceConfigurations()
        .add(
            0,
            new AbstractServiceConfiguration() {
              @Override
              public Boolean isOperation(Method method) {
                return "invoke".equals(method.getName());
              }

              @Override
              public QName getOperationName(InterfaceInfo service, Method method) {
                return operationName;
              }

              @Override
              public Boolean isWrapped() {
                return Boolean.FALSE;
              }
            });

    clientFactory.setServiceName(serviceName);
    clientFactory.setEndpointName(portName);
    if (!useServiceRegistry) {
      String endpointUrl =
          (useServiceLocator) ? "locator://" + serviceName.getLocalPart() : publishedEndpointUrl;
      clientFactory.setAddress(endpointUrl);
    }
    if (!useServiceRegistry && null != wsdlURL) {
      clientFactory.setWsdlURL(wsdlURL);
    }
    clientFactory.setDataBinding(new SourceDataBinding());

    clientFactory.setBus(bus);

    final List<Feature> features = new ArrayList<Feature>();
    if (useServiceLocator) {
      features.add(new LocatorFeature());
    }
    if (samFeature != null) {
      features.add(samFeature);
    }
    if (correlationIDCallbackHandler != null && (!useServiceRegistry)) {
      features.add(new CorrelationIDFeature());
    }
    if (null != securityArguments.getPolicy()) {
      features.add(new WSPolicyFeature(securityArguments.getPolicy()));
    }
    if (logging) {
      features.add(new org.apache.cxf.feature.LoggingFeature());
    }
    clientFactory.setFeatures(features);

    authorizationPolicy = securityArguments.buildAuthorizationPolicy();

    Map<String, Object> clientProps =
        securityArguments.buildClientConfig(bus, useServiceRegistry, serviceName.toString());

    clientProps.put("soap.no.validate.parts", Boolean.TRUE);

    clientProps.put(
        ESBEndpointConstants.USE_SERVICE_REGISTRY_PROP, Boolean.toString(useServiceRegistry));

    if ((useServiceLocator || useServiceRegistry)
        && null != locatorProps
        && !locatorProps.isEmpty()) {
      clientProps.put(LocatorFeature.LOCATOR_PROPERTIES, locatorProps);
    }

    if (correlationIDCallbackHandler != null) {
      clientProps.put(
          CorrelationIDFeature.CORRELATION_ID_CALLBACK_HANDLER, correlationIDCallbackHandler);
    }

    clientFactory.setProperties(clientProps);
  }
  public RuntimeESBConsumer(
      final QName serviceName,
      final QName portName,
      String operationName,
      String publishedEndpointUrl,
      boolean isRequestResponse,
      final LocatorFeature slFeature,
      final EventFeature samFeature,
      final SecurityArguments securityArguments,
      final Bus bus,
      boolean logging) {
    this.operationName = operationName;
    this.isRequestResponse = isRequestResponse;
    this.samFeature = samFeature;

    clientFactory =
        new JaxWsClientFactoryBean() {
          @Override
          protected Endpoint createEndpoint() throws BusException, EndpointException {
            final Endpoint endpoint = super.createEndpoint();
            // set portType = serviceName
            InterfaceInfo ii = endpoint.getService().getServiceInfos().get(0).getInterface();
            ii.setName(serviceName);
            return endpoint;
          }
        };
    clientFactory.setServiceName(serviceName);
    clientFactory.setEndpointName(portName);
    final String endpointUrl =
        (slFeature == null) ? publishedEndpointUrl : "locator://" + serviceName.getLocalPart();
    clientFactory.setAddress(endpointUrl);
    clientFactory.setServiceClass(this.getClass());
    clientFactory.setBus(bus);
    final List<AbstractFeature> features = new ArrayList<AbstractFeature>();
    if (slFeature != null) {
      features.add(slFeature);
    }
    if (samFeature != null) {
      features.add(samFeature);
    }
    if (null != securityArguments.getPolicy()) {
      features.add(new WSPolicyFeature(securityArguments.getPolicy()));
    }
    if (logging) {
      features.add(new org.apache.cxf.feature.LoggingFeature());
    }

    clientFactory.setFeatures(features);

    if (EsbSecurity.TOKEN == securityArguments.getEsbSecurity()) {
      Map<String, Object> properties = new HashMap<String, Object>(2);
      properties.put(SecurityConstants.USERNAME, securityArguments.getUsername());
      properties.put(SecurityConstants.PASSWORD, securityArguments.getPassword());
      clientFactory.setProperties(properties);
    } else if (EsbSecurity.SAML == securityArguments.getEsbSecurity()) {
      final Map<String, String> stsPropsDef = securityArguments.getStsProperties();

      final STSClient stsClient = new STSClient(bus);
      stsClient.setWsdlLocation(stsPropsDef.get(STS_WSDL_LOCATION));
      stsClient.setServiceQName(
          new QName(stsPropsDef.get(STS_NAMESPACE), stsPropsDef.get(STS_SERVICE_NAME)));
      stsClient.setEndpointQName(
          new QName(stsPropsDef.get(STS_NAMESPACE), stsPropsDef.get(STS_ENDPOINT_NAME)));

      Map<String, Object> stsProps = new HashMap<String, Object>();

      for (Map.Entry<String, String> entry : stsPropsDef.entrySet()) {
        if (SecurityConstants.ALL_PROPERTIES.contains(entry.getKey())) {
          stsProps.put(entry.getKey(), entry.getValue());
        }
      }

      stsProps.put(SecurityConstants.USERNAME, securityArguments.getUsername());
      stsProps.put(SecurityConstants.PASSWORD, securityArguments.getPassword());
      stsClient.setProperties(stsProps);

      Map<String, Object> clientProps = new HashMap<String, Object>();
      clientProps.put(SecurityConstants.STS_CLIENT, stsClient);

      Map<String, String> clientPropsDef = securityArguments.getClientProperties();

      for (Map.Entry<String, String> entry : clientPropsDef.entrySet()) {
        if (SecurityConstants.ALL_PROPERTIES.contains(entry.getKey())) {
          clientProps.put(entry.getKey(), entry.getValue());
        }
      }
      clientProps.put(
          SecurityConstants.CALLBACK_HANDLER,
          new WSPasswordCallbackHandler(
              clientPropsDef.get(SecurityConstants.SIGNATURE_USERNAME),
              clientPropsDef.get(CONSUMER_SIGNATURE_PASSWORD)));

      clientFactory.setProperties(clientProps);
    }
  }