import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Override
public void removeAccessTokenUsingRefreshToken(OAuth2RefreshToken refreshToken) {
  String tokenValue = refreshToken.getValue();
  // Lookup RefreshTokenToAccessToken table for locating access token
  RefreshTokenToAccessToken refreshTokenToAccessToken = refreshTokenToAccessTokenRepository.findOne(tokenValue);
  if (refreshTokenToAccessToken != null) {
    String accessTokenKey = refreshTokenToAccessToken.getAccessTokenKey();
    AccessToken accessToken = accessTokenRepository.findOne(accessTokenKey);
    String jsonOAuth2AccessToken = accessToken.getoAuth2AccessToken();
    OAuth2AccessToken oAuth2AccessToken = OAuthUtil.deserializeOAuth2AccessToken(jsonOAuth2AccessToken);
    // Delete access token from all related tables
    List<RegularStatement> statementList = prepareRemoveAccessTokenStatements(oAuth2AccessToken);
    // Delete from RefreshTokenToAccessToken table
    Delete refreshTokenToAccessTokenDelete = CassandraTemplate.createDeleteQuery(RefreshTokenToAccessToken.TABLE, refreshTokenToAccessToken, null, cassandraTemplate.getConverter());
    statementList.add(refreshTokenToAccessTokenDelete);
    Batch batch = QueryBuilder.batch(statementList.toArray(new RegularStatement[statementList.size()]));
    cassandraTemplate.execute(batch);
  }
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Override
public void storeRefreshToken(OAuth2RefreshToken refreshToken, OAuth2Authentication authentication) {
  List<RegularStatement> statementList = new ArrayList<RegularStatement>();

  byte[] serializedRefreshToken = SerializationUtils.serialize(refreshToken);
  ByteBuffer bufferedRefreshToken = ByteBuffer.wrap(serializedRefreshToken);

  byte[] serializedAuthentication = SerializationUtils.serialize(authentication);
  ByteBuffer bufferedAuthentication = ByteBuffer.wrap(serializedAuthentication);

  WriteOptions refreshWriteOptions = new WriteOptions();
  if (refreshToken instanceof ExpiringOAuth2RefreshToken) {
    ExpiringOAuth2RefreshToken expiringRefreshToken = (ExpiringOAuth2RefreshToken) refreshToken;
    Date expiration = expiringRefreshToken.getExpiration();
    if (expiration != null) {
      int seconds = Long.valueOf((expiration.getTime() - System.currentTimeMillis()) / 1000L).intValue();
      refreshWriteOptions.setTtl(seconds);
    }
  }

  // Insert into RefreshToken table
  Insert accessInsert = CassandraTemplate.createInsertQuery(RefreshToken.TABLE, new RefreshToken(refreshToken.getValue(), bufferedRefreshToken), refreshWriteOptions, cassandraTemplate.getConverter());
  statementList.add(accessInsert);

  // Insert into RefreshTokenAuthentication table
  Insert authInsert = CassandraTemplate.createInsertQuery(RefreshTokenAuthentication.TABLE, new RefreshTokenAuthentication(refreshToken.getValue(), bufferedAuthentication), refreshWriteOptions, cassandraTemplate.getConverter());
  statementList.add(authInsert);

  Batch batch = QueryBuilder.batch(statementList.toArray(new RegularStatement[statementList.size()]));
  cassandraTemplate.execute(batch);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Test
public void templateExists() {
	this.context = new AnnotationConfigApplicationContext();
	this.context.register(TestExcludeConfiguration.class, TestConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class,
			CassandraAutoConfiguration.class, CassandraDataAutoConfiguration.class);
	this.context.refresh();
	assertThat(this.context.getBeanNamesForType(CassandraTemplate.class).length)
			.isEqualTo(1);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
/**
 * Create an {@link EventStore} that persists and retrieves {@link Event}s using Cassandra.
 * @param cassandraTemplate The {@link CassandraTemplate} to use to perform queries against Cassandra.
 * @param objectMapper the {@link ObjectMapper} to use to serialise and deserialise event data.
 * @return The constructed {@link EventStore}
 */
public static EventStore create(CassandraTemplate cassandraTemplate, ObjectMapper objectMapper) {
    return ComposedEventStore.create(
            CassandraEventPersister.create(cassandraTemplate, objectMapper),
            CassandraEventRetriever.create(cassandraTemplate, objectMapper)
    );
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
/**
 * Create a new {@link AggregateCatalogue} that uses Cassandra for persistence.
 * @param cassandraTemplate The {@link CassandraTemplate} to use to execute Cassandra queries.
 * @param bucketCount The number of buckets to use to distribute the catalogue data over multiple rows.
 * @return The constructed {@link AggregateCatalogue}.
 */
public static AggregateCatalogue create(CassandraTemplate cassandraTemplate, int bucketCount) {
    PreparedStatement insertStatement = cassandraTemplate.getSession().prepare(
            "INSERT INTO Catalogue (aggregateType, bucket, aggregateId) VALUES (?, ?, ?)");
    PreparedStatement deleteStatement = cassandraTemplate.getSession().prepare(
            "DELETE FROM Catalogue WHERE aggregateType = ? AND bucket = ? AND aggregateId = ?");
    return new CassandraAggregateCatalogue(bucketCount, cassandraTemplate, insertStatement, deleteStatement);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
@Primary
public AggregateCatalogue aggregateCatalogue(Cluster cluster) {
    return CassandraAggregateCatalogue.create(
            new CassandraTemplate(cluster.connect(configuration.getKeyspace())),
            configuration.getCatalogueBucketCount());
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Test
public void templateExists() {
	this.context = new AnnotationConfigApplicationContext();
	this.context.register(TestExcludeConfiguration.class, TestConfiguration.class,
			PropertyPlaceholderAutoConfiguration.class,
			CassandraAutoConfiguration.class, CassandraDataAutoConfiguration.class);
	this.context.refresh();
	assertEquals(1, this.context.getBeanNamesForType(CassandraTemplate.class).length);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Before
public void setUp() throws Exception {

    final Cluster cluster = Cluster.builder()
            .addContactPoints(InetAddress.getLoopbackAddress())
            .withPort(9142)
            .build();
    cassandraTemplate = new CassandraTemplate(cluster.connect("zuul"));

    instance = new CassandraZuulRouteStore(cassandraTemplate);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
public CassandraTemplate cassandraTemplate(Session session) {
	return new CassandraTemplate(session);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
private List<RegularStatement> prepareRemoveAccessTokenStatements(OAuth2AccessToken token) {
  //String tokenId = token.getValue();
  String tokenValue = token.getValue();
  String jsonOAuth2AccessToken = OAuthUtil.serializeOAuth2AccessToken(token);
  List<RegularStatement> statementList = new ArrayList<RegularStatement>();
  
  // Delete from AccessToken table
  RegularStatement accessTokenDelete = prepareDeleteByPrimaryKeyRegularStatement(AccessToken.class, tokenValue);
  statementList.add(accessTokenDelete);

  // Lookup Authentication table for further deleting from AuthenticationToAccessToken table
  Authentication authentication = authenticationRepository.findOne(tokenValue);
  if (authentication != null) {
    ByteBuffer bufferedOAuth2Authentication = authentication.getoAuth2Authentication();
    byte[] serializedOAuth2Authentication = new byte[bufferedOAuth2Authentication.remaining()];
    bufferedOAuth2Authentication.get(serializedOAuth2Authentication);
    OAuth2Authentication oAuth2Authentication = SerializationUtils.deserialize(serializedOAuth2Authentication);
    String clientId = oAuth2Authentication.getOAuth2Request().getClientId();

    // Delete from Authentication table
    RegularStatement authenticationDelete = prepareDeleteByPrimaryKeyRegularStatement(Authentication.class, tokenValue);
    statementList.add(authenticationDelete);

    // Delete from AuthenticationToAccessToken table
    RegularStatement authToAccessDelete = prepareDeleteByPrimaryKeyRegularStatement(AuthenticationToAccessToken.class, authenticationKeyGenerator.extractKey(oAuth2Authentication));
    statementList.add(authToAccessDelete);

    // Delete from UsernameToAccessToken table
    Optional<UsernameToAccessToken> optionalUsernameToAccessToken = usernameToAccessTokenRepository.findByKeyAndOAuth2AccessToken(OAuthUtil.getApprovalKey(clientId, oAuth2Authentication.getName()), jsonOAuth2AccessToken);
    optionalUsernameToAccessToken.ifPresent(usernameToAccessToken -> {
      Delete usernameToAccessDelete = CassandraTemplate.createDeleteQuery(UsernameToAccessToken.TABLE, usernameToAccessToken, null, cassandraTemplate.getConverter());
      statementList.add(usernameToAccessDelete);
    });

    // Delete from ClientIdToAccessToken table
    Optional<ClientIdToAccessToken> optionalClientIdToAccessToken = clientIdToAccessTokenRepository.findByKeyAndOAuth2AccessToken(clientId, jsonOAuth2AccessToken);
    optionalClientIdToAccessToken.ifPresent(clientIdToAccessToken -> {
      Delete clientIdToAccessDelete = CassandraTemplate.createDeleteQuery(ClientIdToAccessToken.TABLE, clientIdToAccessToken, null, cassandraTemplate.getConverter());
      statementList.add(clientIdToAccessDelete);
    });
  }

  return statementList;
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
public CassandraTemplate cassandraTemplate() throws Exception {
    return new CassandraTemplate(session().getObject());
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public CassandraTemplate cassandraTemplate(Session session,
		CassandraConverter converter) throws Exception {
	return new CassandraTemplate(session, converter);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
private CassandraEventRetriever(CassandraTemplate cassandraTemplate, BiFunction<String, Type, Object> deserialiser) {
    this.cassandraTemplate = cassandraTemplate;
    this.deserialiser = deserialiser;
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
private CassandraAggregateCatalogue(int bucketCount, CassandraTemplate cassandraTemplate, PreparedStatement insertStatement, PreparedStatement deleteStatement) {
    this.bucketCount = bucketCount;
    this.cassandraTemplate = cassandraTemplate;
    this.insertStatement = insertStatement;
    this.deleteStatement = deleteStatement;
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
private CassandraEventPersister(CassandraTemplate cassandraTemplate, PreparedStatement preparedStatement, Function<Object, String> serialiser) {
    this.cassandraTemplate = cassandraTemplate;
    this.preparedStatement = preparedStatement;
    this.serialiser = serialiser;
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
@Primary
public EventStore eventStore(Cluster cluster, ObjectMapper objectMapper) {
    return CassandraEventStore.create(new CassandraTemplate(cluster.connect(configuration.getKeyspace())), objectMapper);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
public CassandraOperations cassandraTemplate(Cluster cluster) {
    return new CassandraTemplate(cluster.connect("zuul"));
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
private CassandraOperations ops() {
    return new CassandraTemplate(session);
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
@Bean
public CassandraOperations operations() throws Exception {
    return new CassandraTemplate(session().getObject(), new MappingCassandraConverter(new BasicCassandraMappingContext()));
}
 

import org.springframework.data.cassandra.core.CassandraTemplate; //导入依赖的package包/类
/**
 * Construct an {@link EventRetriever} that retrieves events from Cassandra using the supplied
 * {@link CassandraTemplate} and {@link ObjectMapper}
 * @param cassandraTemplate The {@link CassandraTemplate} to use to execute Cassandra queries.
 * @param objectMapper The {@link ObjectMapper} to use to deserialise Event data.
 * @return The constructed {@link EventRetriever}.
 */
public static EventRetriever create(CassandraTemplate cassandraTemplate, ObjectMapper objectMapper) {
    return create(cassandraTemplate, JsonDeserialiser.using(objectMapper));
}