Java ServiceConnectorConfig类代码示例

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
/**
 * Creates an {@link S3Connector} instance  with embedded {@link AmazonS3 Amazon Web Services S3 SDK Client} from
 * {@link S3ServiceInfo}.
 * @param serviceInfo S3ServiceInfo provided by {@link org.springframework.cloud.cloudfoundry.CloudFoundryServiceInfoCreator}
 *                    implementation included within the application.
 * @param serviceConnectorConfig
 * @return
 */
@Override
public S3Connector create(S3ServiceInfo serviceInfo, ServiceConnectorConfig serviceConnectorConfig) {
    AWSCredentials credentials = new BasicAWSCredentials(serviceInfo.getAccessKey(), serviceInfo.getSecretKey());
    AWSCredentialsProvider credentialsProvider = new AWSStaticCredentialsProvider(credentials);
    AwsClientBuilder.EndpointConfiguration endpointConfig = new AwsClientBuilder.EndpointConfiguration(
            serviceInfo.getEndpoint(), Region.getRegion(Regions.DEFAULT_REGION).getName());
    AmazonS3 amazonS3 = AmazonS3ClientBuilder
            .standard()
            .withEndpointConfiguration(endpointConfig)
            .withCredentials(credentialsProvider)
            .enablePathStyleAccess()
            .build();
    if (serviceInfo.getBucket() != null) {
        log.debug("Creating connector addressing ECS bucket: " + serviceInfo.getBucket());
        return new S3Connector(amazonS3, serviceInfo.getEndpoint(), serviceInfo.getBucket());
    } else {
        log.debug("Creating connector addressing ECS namespace.");
        return new S3Connector(amazonS3, serviceInfo.getEndpoint());
    }
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public ClientCache create(GemfireServiceInfo serviceInfo, ServiceConnectorConfig serviceConnectorConfig) {
	for (URI locator : serviceInfo.getLocators()) {
		factory.addPoolLocator(locator.getHost(), locator.getPort());
	}
	if (serviceInfo.getUsername() != null) {
		factory.set("security-client-auth-init", "io.pivotal.spring.cloud.service.gemfire.UserAuthInitialize.create");
		factory.set("security-username", serviceInfo.getUsername());
	}
	if (serviceInfo.getPassword() != null) {
		factory.set("security-password", serviceInfo.getPassword());
	}
	if (serviceConnectorConfig != null && serviceConnectorConfig.getClass().isAssignableFrom(GemfireServiceConnectorConfig.class)) {
		apply((GemfireServiceConnectorConfig) serviceConnectorConfig);
	}
	return factory.create();
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Test
public void testCreate() {
    final CloudantServiceInfo badUrlServiceInfo = new CloudantServiceInfo(
            "id",
            "username",
            "password",
            "hostname",
            443,
            "url"
    );
    assertNull(creator.create(badUrlServiceInfo, new ServiceConnectorConfig() {
    }));

    final CloudantServiceInfo serviceInfo = new CloudantServiceInfo(
            "testId",
            "username",
            "password",
            "username.cloudant.com",
            443,
            "https://username:[email protected]"
    );
    assertTrue(creator.create(serviceInfo, new ServiceConnectorConfig() {
    }) instanceof CouchDbInstance);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Test
public void testCreate() {
    final String test1_hostname = "example.com";
    final String test1_username = "username";
    final String test1_password = "password";
    final String test1_database = "database";

    final List<ServerAddress> servers = ImmutableList.of(
            new ServerAddress(test1_hostname)
    );
    final List<MongoCredential> credentials = ImmutableList.of(
            MongoCredential.createCredential(test1_username, test1_database, test1_password.toCharArray())
    );
    final MongoClientOptions options = new MongoClientOptions.Builder().build();

    final ComposeForMongoDBServiceInfo serviceInfo
            = new ComposeForMongoDBServiceInfo("id", servers, credentials, options);

    assertTrue(creator.create(serviceInfo, new ServiceConnectorConfig() {
    }) instanceof MongoClient);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
private Collection<PooledDataSourceCreator<SI>> filterPooledDataSourceCreators(ServiceConnectorConfig serviceConnectorConfig) {
	if (serviceConnectorConfig != null) {
		List<String> pooledDataSourceNames = ((DataSourceConfig) serviceConnectorConfig).getPooledDataSourceNames();
		if (pooledDataSourceNames != null) {
			List<PooledDataSourceCreator<SI>> filtered = new ArrayList<PooledDataSourceCreator<SI>>();

			for (String name : pooledDataSourceNames) {
				for (String key : pooledDataSourceCreators.keySet()) {
					if (key.contains(name)) {
						filtered.add(pooledDataSourceCreators.get(key));
					}
				}
			}

			return filtered;
		}
	}
	return pooledDataSourceCreators.values();
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
protected void setBasicDataSourceProperties(DataSource basicDataSource, RelationalServiceInfo serviceInfo,
										   ServiceConnectorConfig serviceConnectorConfig,
 											   String driverClassName, String validationQuery) {
	BeanWrapper target = new BeanWrapperImpl(basicDataSource);
	target.setPropertyValue("driverClassName", driverClassName);
	target.setPropertyValue("url", serviceInfo.getJdbcUrl());
	if (validationQuery != null) {
		target.setPropertyValue("validationQuery", validationQuery);
		target.setPropertyValue("testOnBorrow", true);
	}

	if (serviceConnectorConfig == null) {
		// choose sensible values so that we set max connection pool size to what
		// free tier services on Cloud Foundry and Heroku allow
		serviceConnectorConfig = new DataSourceConfig(new PoolConfig(4, 30000), null);
	}
	configurer.configure(basicDataSource, (DataSourceConfig)serviceConnectorConfig);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
private CachingConnectionFactory createSpringConnectionFactory(AmqpServiceInfo serviceInfo,
															   ServiceConnectorConfig serviceConnectorConfiguration,
															   com.rabbitmq.client.ConnectionFactory connectionFactory) {
	CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(connectionFactory);

	if (serviceInfo.getUris() != null) {
		cachingConnectionFactory.setAddresses(getAddresses(serviceInfo));
	}

	if (serviceConnectorConfiguration != null) {
		Integer channelCacheSize = ((RabbitConnectionFactoryConfig) serviceConnectorConfiguration).getChannelCacheSize();
		if (channelCacheSize != null) {
			cachingConnectionFactory.setChannelCacheSize(channelCacheSize);
		}
	}

	return cachingConnectionFactory;
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	try {
		Constructor<?> ctor = serviceConnectorFactoryType.getConstructor(String.class, ServiceConnectorConfig.class);
		AbstractCloudServiceConnectorFactory<?> serviceFactory = (AbstractCloudServiceConnectorFactory<?>)ctor.newInstance(serviceId, serviceConnectorConfig);
		serviceFactory.setServiceConnectorType((Class)serviceConnectorType);
		serviceFactory.setBeanFactory(beanFactory);
		serviceFactory.afterPropertiesSet();
		// id is the beanId if specified, otherwise the serviceId
		if (StringUtils.hasText(beanId)) {
			beanFactory.registerSingleton(beanId, serviceFactory);
		} else {
			beanFactory.registerSingleton(serviceFactory.getServiceId(), serviceFactory);
		}
	} catch (Exception ex) {
		throw new BeanCreationException("Error registering service factory", ex);
	}
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public VaultTemplate create(VaultServiceInfo serviceInfo,
		ServiceConnectorConfig serviceConnectorConfig) {

	TokenAuthentication tokenAuthentication = new TokenAuthentication(new String(
			serviceInfo.getToken()));
	SimpleSessionManager sessionManager = new SimpleSessionManager(
			tokenAuthentication);

	// early pre-init
	assert sessionManager.getSessionToken() != null;

	ClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();

	if (serviceConnectorConfig != null
			&& serviceConnectorConfig instanceof VaultServiceConnectorConfig) {

		VaultServiceConnectorConfig config = (VaultServiceConnectorConfig) serviceConnectorConfig;

		requestFactory = config.getClientHttpRequestFactory();
	}

	VaultEndpoint endpoint = VaultEndpoint.from(URI.create(serviceInfo.getUri()));

	return new VaultTemplate(endpoint, requestFactory, sessionManager);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
/**
 * Creates a {@link FeatureFlagsService} by given
 * {@link FeatureFlagsServiceInfo} and {@link ServiceConnectorConfig}.
 */

@Override
public FeatureFlagsService create(FeatureFlagsServiceInfo serviceInfo,
		ServiceConnectorConfig serviceConnectorConfig) {
	URI baseUri = createBaseUri(serviceInfo.getUri());
	RestOperations restOperations = createRestOperations(serviceInfo.getUserName(), serviceInfo.getPassword());

	return new FeatureFlagsService(baseUri, restOperations);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
public ServiceConnectorConfig createGemfireConnectorConfig() {
  // Create a custom service connector config object which sets specific properties
  // for the ClientCache as exposed by the GemfireServiceConnectorConfig.
  GemfireServiceConnectorConfig gemfireConfig = new GemfireServiceConnectorConfig();
  gemfireConfig.setPoolIdleTimeout(7777L);

  return gemfireConfig;
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public CouchDbInstance create(CloudantServiceInfo serviceInfo,
        ServiceConnectorConfig serviceConnectorConfig) {
    HttpClient httpClient;
    try {
        httpClient = new StdHttpClient.Builder()
                .url(serviceInfo.getUrl())
                .build();
        return new StdCouchDbInstance(httpClient);
    } catch (MalformedURLException e) {
        LOG.logp(Level.WARNING, CloudantInstanceCreator.class.getName(), "create", "Error parsing URL", e);
        return null;
    }
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public KafkaConsumer create(
        final MessageHubServiceInfo serviceInfo,
        final ServiceConnectorConfig serviceConnectorConfig) {
    // Producer Configuration
    final Map<String, Object> consumerConfiguration = new HashMap<>();
    consumerConfiguration.put("bootstrap.servers", Joiner.on(',').join(serviceInfo.getBrokers()));
    consumerConfiguration.put("security.protocol", "SASL_SSL");
    consumerConfiguration.put("sasl.mechanism", "PLAIN");
    consumerConfiguration.put("ssl.protocol", "TLSv1.2");
    consumerConfiguration.put("ssl.enabled.protocols", "TLSv1.2");
    consumerConfiguration.put("ssl.truststore.location", System.getProperty("java.home") + "/lib/security/cacerts");
    consumerConfiguration.put("ssl.truststore.password", "changeit");
    consumerConfiguration.put("ssl.truststore.type", "jks");

    if (serviceConnectorConfig != null && serviceConnectorConfig instanceof MessageHubFactoryConfig) {
        consumerConfiguration.putAll((MessageHubFactoryConfig) serviceConnectorConfig);
    }

    // JAAS Login Module Configuration
    final Map<String, Object> loginModuleConfiguration = new HashMap<>();
    loginModuleConfiguration.put("serviceName", "kafka");
    loginModuleConfiguration.put("username", serviceInfo.getUsername());
    loginModuleConfiguration.put("password", serviceInfo.getPassword());
    MemoryConfiguration.use().addConfigurationEntry("KafkaClient",
            "kafka", REQUIRED, loginModuleConfiguration
    );

    return new KafkaConsumer(consumerConfiguration);
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public Discovery create(
        final WatsonDiscoveryServiceInfo serviceInfo,
        final ServiceConnectorConfig serviceConnectorConfig) {
    final Discovery service = new Discovery("2016-12-01");
    service.setEndPoint(serviceInfo.getUrl());
    service.setUsernameAndPassword(serviceInfo.getUsername(), serviceInfo.getPassword());
    return service;
}
 

import org.springframework.cloud.service.ServiceConnectorConfig; //导入依赖的package包/类
@Override
public NaturalLanguageClassifier create(
        final WatsonNaturalLanguageClassifierServiceInfo serviceInfo,
        final ServiceConnectorConfig serviceConnectorConfig) {
    final NaturalLanguageClassifier service = new NaturalLanguageClassifier();
    service.setEndPoint(serviceInfo.getUrl());
    service.setUsernameAndPassword(serviceInfo.getUsername(), serviceInfo.getPassword());
    return service;
}