import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
private CouchbaseTemplate createTemplate() {
    try {
        return new CouchbaseTemplate(couchbaseConfiguration.couchbaseClusterInfo(), couchbaseConfiguration.couchbaseClient());
    } catch(Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
public Page<T> find(Parameters params, Pageable pageable, Class<T> clazz) {
    CouchbaseTemplate template = createTemplate();

    Statement query = createQueryStatement(params, pageable);
    N1qlQuery queryWithParameter = N1qlQuery.parameterized(query, params.toJsonObject());

    List<T> data = convertToDataList(template.findByN1QLProjection(queryWithParameter, LinkedHashMap.class), clazz);
    Integer count = count(params);

    return new PageImpl<>(data, pageable, count);
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
public Integer count(Parameters params) {
    CouchbaseTemplate template = createTemplate();

    Statement query = createCountStatement(params);
    N1qlQuery queryWithParams = N1qlQuery.parameterized(query, params.toJsonObject());
    LinkedHashMap countMap = ((LinkedHashMap) template.findByN1QLProjection(queryWithParams, Object.class).get(0));

    return ((Integer) countMap.get("count"));
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
public Integer sum(Parameters params, String field) {
    CouchbaseTemplate template = createTemplate();

    Statement query = createSumStatement(params, field);
    N1qlQuery queryWithParams = N1qlQuery.parameterized(query, params.toJsonObject());
    LinkedHashMap sumMap = ((LinkedHashMap) template.findByN1QLProjection(queryWithParams, Object.class).get(0));

    return ((Integer) sumMap.get("sum"));
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Test
public void customConfiguration() {
	load(CustomCouchbaseConfiguration.class);
	CouchbaseTemplate couchbaseTemplate = this.context
			.getBean(CouchbaseTemplate.class);
	assertThat(couchbaseTemplate.getDefaultConsistency())
			.isEqualTo(Consistency.STRONGLY_CONSISTENT);
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Autowired
PlaceService(Facebook facebook, CouchbaseTemplate couchbaseTemplate,
		PlaceRepository placeRepository) {
	this.facebook = facebook;
	this.couchbaseTemplate = couchbaseTemplate;
	this.placeRepository = placeRepository;
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Override
public CouchbaseTemplate couchbaseTemplate() throws Exception {
	CouchbaseTemplate template = super.couchbaseTemplate();
	template.setWriteResultChecking(WriteResultChecking.EXCEPTION);
	template.setDefaultConsistency(Consistency.READ_YOUR_OWN_WRITES);
	return template;
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
/**
 * Create couchbase template.
 *
 * @return the couchbase template
 * @throws Exception the exception
 */
public CouchbaseTemplate connect() throws Exception {
  environment = DefaultCouchbaseEnvironment.create();
  cluster = CouchbaseCluster.create(environment, bootstrapHosts);
  clusterInfo = cluster.clusterManager(bucketName, bucketPassword).info();
  return new CouchbaseTemplate(
      clusterInfo,
      cluster.openBucket(bucketName, bucketPassword));
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Override
@ConditionalOnMissingBean(name = BeanNames.COUCHBASE_TEMPLATE)
@Bean(name = BeanNames.COUCHBASE_TEMPLATE)
public CouchbaseTemplate couchbaseTemplate() throws Exception {
	return super.couchbaseTemplate();
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
public PersistentDao(CouchbaseProperties couchbase, SessionCouchbaseProperties sessionCouchbase, CouchbaseTemplate couchbaseTemplate, RetryTemplate retryTemplate) {
    bucket = couchbase.getBucket().getName();
    queryConsistency = sessionCouchbase.getPersistent().getQueryConsistency();
    this.couchbaseTemplate = couchbaseTemplate;
    this.retryTemplate = retryTemplate;
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public SessionDao sessionDao(CouchbaseTemplate couchbaseTemplate, @Qualifier("sessionCouchbaseRetryTemplate") RetryTemplate retryTemplate) {
    return new PersistentDao(couchbase, sessionCouchbase, couchbaseTemplate, retryTemplate);
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
public CouchbaseSessionRepository(CouchbaseTemplate couchbase) {
    Assert.notNull(couchbase);
    this.couchbase = couchbase;
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Bean
public CouchbaseSessionRepository couchbaseSessionRepository(CouchbaseTemplate couchbaseTemplate) {
    return new CouchbaseSessionRepository(couchbaseTemplate);
}
 

import org.springframework.data.couchbase.core.CouchbaseTemplate; //导入依赖的package包/类
@Override
public void create() {
    super.create();
    template = new CouchbaseTemplate(manager.info(), bucket);
}