couchbase笔记

最新推荐文章于 2024-01-23 02:21:29 发布
最新推荐文章于 2024-01-23 02:21:29 发布
阅读量3.8k 收藏 2
点赞数 2
分类专栏： java日常学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hao_kkkkk/article/details/51198611
版权

最近在做一个项目，用到了couchbase，正好项目组里也有个大牛，他自己先把couchbase搞的差不多，我就拿个现成的，理解消化一下，然后再融会贯通，算是入门吧。

再有就是好记性不如烂笔头，还是要记录一下，免得将来忘记。


1、couchbase连接

couchbase连接摸索出来了两种方式，各有不同的用法，下面来一一说明。


第一种是创建Cluster连接，然后通过Cluster来创建bucket，具体代码如下。

    Cluster cluster = CouchbaseCluster.create(path);//path指具体的couchbase服务路径
    cluster.openBucket(bucketName,30,TimeUnit.SECONDS);//30是指打开couchbase桶的超时时间，TimeUnit.SECONDS指超时时间的单位，在此为秒
    cluster.openbucket(bucketName,password,30,TimeUnit.SECONDS);//此处多了一个password，这个password是桶密码，couchbase可以为桶设置密码


第二种是创建CouchbaseClient，这种方法目前网上技术文档比较多

    List<URI> uris = new LinkedList<URI>();
    uris.add(URI.create(path));//path值具体的couchbase服务路径
    CouchbaseClient client = client = new CouchbaseClient(uris, bucketName, password);


这些只是最基础的连接代码，如果真要在项目中用，这些代码还需要改造，在这里就贴出来改造过后的代码

改造过后的代码仍然有两种方式，第一种创建Cluster连接

public class CouchBaseUtils {

    private static String couchBasePath;
    private static Cluster cluster;
    private static List<String> couchBasePathList = new ArrayList<String>();
    private static Map<String,Bucket> bucketMap = new HashMap<String, Bucket>();
    static{
        couchBasePath = APPPropertisUtils.getProperty("couchBase.Server.path");
    }

    //初始化化缓存相关配置，外部必须显示调用此方法
    public static void init() {
        cluster = CouchbaseCluster.create(getCouchBasePathList(couchBasePath));
        bucketMap.put(getBucketName(APPPropertisUtils.getProperty("couchBase.website_product")),openBucket(getBucketName(APPPropertisUtils.getProperty("couchBase.website_product")),getBucketPwd(APPPropertisUtils.getProperty("couchBase.website_product"))));
        bucketMap.put(getBucketName(APPPropertisUtils.getProperty("couchBase.website_company")),openBucket(getBucketName(APPPropertisUtils.getProperty("couchBase.website_company")),getBucketPwd(APPPropertisUtils.getProperty("couchBase.website_company"))));
        bucketMap.put(getBucketName(APPPropertisUtils.getProperty("couchBase.website_product_group")),openBucket(getBucketName(APPPropertisUtils.getProperty("couchBase.website_product_group")),getBucketPwd(APPPropertisUtils.getProperty("couchBase.website_product_group"))));
        bucketMap.put(getBucketName(APPPropertisUtils.getProperty("couchBase.website_fundmanager")),openBucket(getBucketName(APPPropertisUtils.getProperty("couchBase.website_fundmanager")),getBucketPwd(APPPropertisUtils.getProperty("couchBase.website_fundmanager"))));
        AppLogUtils.info("缓存服务器连接成功...");
    }

    /**
     *  打开桶
     * @param bucketName 桶名
     * @param password 密码
     * @return
     */
    private static Bucket openBucket(String bucketName,String password) {
        if(StringUtils.isEmpty(password)) {
            return cluster.openBucket(bucketName,30,TimeUnit.SECONDS);
        } else {
            return cluster.openBucket(bucketName,password,30,TimeUnit.SECONDS);
        }
    }

    public static List<String> getCouchBasePathList(String path){
        if(path.contains(",")){
            String[] arrayOne = path.split("\\,");
            for(int i = 0;i < arrayOne.length;i++){
                couchBasePathList.add(arrayOne[i]);
            }
        }else{
            couchBasePathList.add(path);
        }
        return couchBasePathList;
    }


    public static List<Map<String,Object>> queryCouchBase(String sqlKey,String bucketName){
        Bucket bucket = null;
        try {
            if(bucketName.contains(",")){
                String[] arrayTwo = bucketName.split("\\,");
                if(arrayTwo.length != 2){
                    AppLogUtils.error("配置文件有误！");
                    throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
                }
                bucket = bucketMap.get(arrayTwo[0]);
            }else{
                bucket = bucketMap.get(bucketName);
            }
                List<Map<String,Object>> mapList = getMapList(sqlKey,bucket);
                return mapList;
        } catch (Exception e) {
            AppLogUtils.error("连接Couchbase异常！", e.getMessage());
            throw new AppException(ErrorCodes.UNKNOWN, "连接Couchbase异常！");
        }

    }
    public static String getBucketName(String temp){
        if(temp.contains(",")){
            String[] arrayTwo = temp.split("\\,");
            if(arrayTwo.length != 2){
                AppLogUtils.error("配置文件有误！");
                throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
            }
            return arrayTwo[0];
        }else{
            return temp;
        }
    }

    public static String getBucketPwd(String temp){
        if(temp.contains(",")){
            String[] arrayTwo = temp.split("\\,");
            if(arrayTwo.length != 2){
                AppLogUtils.error("配置文件有误！");
                throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
            }
            return arrayTwo[1];
        }else{
            return temp;
        }
    }

    //下边这段代码是根据sql语句从桶中查询信息，并转换成mapList返回。
    public static List<Map<String,Object>> getMapList(String sqlKey,Bucket bucket){
        List<Map<String,Object>> mapList = new ArrayList<Map<String,Object>>();
        N1qlQueryResult result = bucket.query(N1qlQuery.simple(sqlKey));
        Iterator<N1qlQueryRow> iterator = result.iterator();
        while (iterator.hasNext()) {
            N1qlQueryRow n1qlQueryRow = iterator.next();
            JsonObject jsonObject = n1qlQueryRow.value();
            Set<String> set = jsonObject.getNames();
            Iterator<String> iterator1 = set.iterator();
            Map<String,Object> map = new HashMap<String, Object>();
            while (iterator1.hasNext()) {
                String key = iterator1.next();
                Object object = jsonObject.get(key);
                if(object instanceof JsonArray) {
                    JsonArray value = (JsonArray) object;
                    List<Object> list1 = new ArrayList<Object>();
                    for(int i=0;i<value.size();i++) {
                        Object obj = value.get(i);
                        if(obj instanceof JsonObject) {
                            JsonObject jsonObject1 = (JsonObject) obj;
                            list1.add(jsonObject1.toMap());
                        } else {
                            list1.add(value.getString(i));
                        }
                    }
                    map.put(key,list1);
                } else if(object instanceof JsonObject) {
                    JsonObject value = (JsonObject) object;
                    Map map1 = value.toMap();
                    map.put(key,map1);
                } else {
                    map.put(key,object);
                }
            }
            mapList.add(map);
        }
        return mapList;
    }
}


第二种方法

public class AppServerCouchBaseClientUtils {
    private static String appServerCouchBaseClientPath;
    private static Map<String,CouchbaseClient> appServerBucketClientMap = new HashMap<String, CouchbaseClient>();
    private static List<URI> uris = new LinkedList<URI>();
    private static CouchbaseClient appServerCouchbaseClient;
    private static Cluster appServerClientCluster;
    private static Map<String,Bucket> appServerClientBucketMap = new HashMap<String, Bucket>();
    private static List<String> appServerCouchBaseClientPathList = new ArrayList<String>();
    static{
        appServerCouchBaseClientPath = APPPropertisUtils.getProperty("appServer.couchbase.path");
    }

    //初始化化缓存相关配置，外部必须显示调用此方法
    public static void init() {
        try{
            appServerClientCluster = CouchbaseCluster.create(getCouchBaseClientPathList(appServerCouchBaseClientPath));
            appServerClientBucketMap.put(getBucketName(APPPropertisUtils.getProperty("appServer.couchbase.bucketname")),openBucket(getBucketName(APPPropertisUtils.getProperty("appServer.couchbase.bucketname")),getBucketPwd(APPPropertisUtils.getProperty("appServer.couchbase.bucketname"))));
            appServerCouchbaseClient = new CouchbaseClient(getCouchBasePathList(appServerCouchBaseClientPath),getBucketName(APPPropertisUtils.getProperty("appServer.couchbase.bucketname")),getBucketPwd(APPPropertisUtils.getProperty("appServer.couchbase.bucketname")));
            appServerBucketClientMap.put(getBucketName(APPPropertisUtils.getProperty("appServer.couchbase.bucketname")),appServerCouchbaseClient);
        }catch (IOException ex){
            AppLogUtils.error(ex.getMessage(),"创建couchbaseClient失败！");
            throw new AppException(ErrorCodes.UNKNOWN, "创建couchbaseClient失败！");
        }
        AppLogUtils.info("appServer缓存服务器连接成功...");
    }
    /**
     *  打开桶
     * @param bucketName 桶名
     * @param password 密码
     * @return
     */
    private static Bucket openBucket(String bucketName,String password) {
        if(StringUtils.isEmpty(password)) {
            return appServerClientCluster.openBucket(bucketName,30,TimeUnit.SECONDS);
        } else {
            return appServerClientCluster.openBucket(bucketName,password,30,TimeUnit.SECONDS);
        }
    }

    public static List<String> getCouchBaseClientPathList(String path){
        if(null != appServerCouchBaseClientPathList&&appServerCouchBaseClientPathList.size() > 0){
            appServerCouchBaseClientPathList.removeAll(appServerCouchBaseClientPathList);
        }
        if(path.contains(",")){
            String[] arrayOne = path.split("\\,");
            for(int i = 0;i < arrayOne.length;i++){
                appServerCouchBaseClientPathList.add(arrayOne[i]);
            }
        }else{
            appServerCouchBaseClientPathList.add(path);
        }
        return appServerCouchBaseClientPathList;
    }


    public static List<URI> getCouchBasePathList(String path){
        if(null != uris&&uris.size() > 0){
            uris.removeAll(uris);
        }
        if(path.contains(",")){
            String[] arrayOne = path.split("\\,");
            for(int i = 0;i < arrayOne.length;i++){
                uris.add(URI.create(arrayOne[i]));
            }
        }else{
            uris.add(URI.create(path));
        }
        return uris;
    }

    //获取桶名称
    public static String getBucketName(String temp){
        if(temp.contains(",")){
            String[] arrayTwo = temp.split("\\,");
            if(arrayTwo.length != 2){
                AppLogUtils.error("配置文件有误！");
                throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
            }
            return arrayTwo[0];
        }else{
            return temp;
        }
    }

    //获取桶密码
    public static String getBucketPwd(String temp){
        if(temp.contains(",")){
            String[] arrayTwo = temp.split("\\,");
            if(arrayTwo.length != 2){
                AppLogUtils.error("配置文件有误！");
                throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
            }
            return arrayTwo[1];
        }else{
            return temp;
        }
    }


    public static CouchbaseClient getCouchBaseClient(){
        CouchbaseClient couchbaseClient = null;
        try {
            String bucketTemp = APPPropertisUtils.getProperty("ppServer.couchbase.bucketname");
            if(bucketTemp.contains(",")){
                String[] arrayTwo = bucketTemp.split("\\,");
                if(arrayTwo.length != 2){
                    AppLogUtils.error("配置文件有误！");
                    throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
                }
                couchbaseClient = AppServerCouchBaseClientUtils.appServerBucketClientMap.get(arrayTwo[0]);
            }else{
                couchbaseClient = AppServerCouchBaseClientUtils.appServerBucketClientMap.get(bucketTemp);
            }
            return couchbaseClient;
        } catch (Exception e) {
            AppLogUtils.error("连接Couchbase异常！", e.getMessage());
            throw new AppException(ErrorCodes.UNKNOWN, "连接Couchbase异常！");
        }

    }

    public static List<Map<String,Object>> queryCouchBase(String sqlKey){
        Bucket bucket = null;
        try {
            String bucketTemp = APPPropertisUtils.getProperty("appServer.couchbase.bucketname");
            if(bucketTemp.contains(",")){
                String[] arrayTwo = bucketTemp.split("\\,");
                if(arrayTwo.length != 2){
                    AppLogUtils.error("配置文件有误！");
                    throw new AppException(ErrorCodes.UNKNOWN, "配置文件有误！");
                }
                bucket = AppServerCouchBaseClientUtils.appServerClientBucketMap.get(arrayTwo[0]);
            }else{
                bucket = AppServerCouchBaseClientUtils.appServerClientBucketMap.get(bucketTemp);
            }
            List<Map<String,Object>> mapList = getMapList(sqlKey, bucket);
            return mapList;
        } catch (Exception e) {
            AppLogUtils.error("连接Couchbase异常！", e.getMessage());
            throw new AppException(ErrorCodes.UNKNOWN, "连接Couchbase异常！");
        }

    }

    /**
     * 新增或修改缓存数据（对象）
     * @param documentId
     * @param jsonObject
     * @param outTime 单位为秒
     */
    public static void addOrUpdateObjectData(String documentId,int outTime,JsonObject jsonObject) {
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        couchbaseClient.set(documentId, outTime, jsonObject);
        AppLogUtils.info("新增或更新[doucumentId=" + documentId + "]缓存数据成功");
    }
    /**
     * 新增或修改缓存数据（对象），默认失效时间为一天
     * @param documentId
     * @param jsonObject
     */
    public static void addOrUpdateObjectData(String documentId,JsonObject jsonObject) {
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        couchbaseClient.set(documentId, 24 * 60 * 60, jsonObject);
        AppLogUtils.info("新增或更新[doucumentId=" + documentId + "]缓存数据成功");
    }

    /**
     * 批量新增或修改缓存数据（集合对象）
     * @param documentIds documentid集合
     * @param jsonObject 数据集合
     */
    public static void addOrUpdateObjectData(List<String> documentIds,int outTime,List<JsonObject> jsonObject) {
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        for(int i=0;i<documentIds.size();i++) {
            String documentId = documentIds.get(i);
            JsonObject temp = jsonObject.get(i);
            couchbaseClient.set(documentId, outTime, temp);
            AppLogUtils.info("批量新增或修改缓存数据，当前进度为：["+((Float.valueOf(i) / documentIds.size()) * 100)+"%]");
        }
    }

    /**
     *  根据doucumentId获取数据
     * @param documentId
     * @return
     */
    public static JsonObject getDataByDocumentId(String documentId) {
        if(StringUtils.isEmpty(documentId)) {
            return null;
        }
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        JsonObject jsonObject = (JsonObject)couchbaseClient.get(documentId);
        return jsonObject;
    }


    /**
     * 根据doucumentId删除数据,单个删除
     * @param documentId
     * @return
     */
    public static void removeDataByDocumentId(String documentId) {
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        String bucketName = APPPropertisUtils.getProperty("appServer.couchbase.bucketname");
        try {
            couchbaseClient.delete(documentId);
        } catch (Exception e) {
            AppLogUtils.error("从bucket="+bucketName+"中移除documentId="+documentId+"失败",e);
        }
        AppLogUtils.info("删除[doucumentId=" + documentId + "]缓存数据成功");
    }

    /**
     * 根据doucumentId删除数据,批量删除
     * @param documentIds
     * @return
     */
    public static void removeDataByDocumentId(List<String> documentIds) {
        CouchbaseClient couchbaseClient = getCouchBaseClient();
        String bucketName = APPPropertisUtils.getProperty("appServer.couchbase.bucketname");
        for(String documentId : documentIds) {
            try {
                couchbaseClient.delete(documentId);
            } catch (Exception e) {
                AppLogUtils.error("从bucket="+bucketName+"中移除documentId="+documentId+"失败",e);
            }
        }
    }


    /**
     *  通过n1ql查询语句获取数据
     * @return
     */
    public static List<Map<String,Object>> getMapList(String sqlKey,Bucket bucket){
        List<Map<String,Object>> mapList = new ArrayList<Map<String,Object>>();
        N1qlQueryResult result = bucket.query(N1qlQuery.simple(sqlKey));
        Iterator<N1qlQueryRow> iterator = result.iterator();
        while (iterator.hasNext()) {
            N1qlQueryRow n1qlQueryRow = iterator.next();
            JsonObject jsonObject = n1qlQueryRow.value();
            Set<String> set = jsonObject.getNames();
            Iterator<String> iterator1 = set.iterator();
            Map<String,Object> map = new HashMap<String, Object>();
            while (iterator1.hasNext()) {
                String key = iterator1.next();
                Object object = jsonObject.get(key);
                if(object instanceof JsonArray) {
                    JsonArray value = (JsonArray) object;
                    List<Object> list1 = new ArrayList<Object>();
                    for(int i=0;i<value.size();i++) {
                        Object obj = value.get(i);
                        if(obj instanceof JsonObject) {
                            JsonObject jsonObject1 = (JsonObject) obj;
                            list1.add(jsonObject1.toMap());
                        } else {
                            list1.add(value.getString(i));
                        }
                    }
                    map.put(key,list1);
                } else if(object instanceof JsonObject) {
                    JsonObject value = (JsonObject) object;
                    Map map1 = value.toMap();
                    map.put(key,map1);
                } else {
                    map.put(key,object);
                }
            }
            mapList.add(map);
        }
        return mapList;
    }
}



第二种相当于创建了一个工具类，便于向couchbase中设置、获取、删除数据，设置时还可以设置此数据的失效时间，相当方便。
在代码中使用了很多类似于APPPropertisUtils.getProperty("appServer.couchbase.bucketname");的代码，这段代码的作用是从配置文件中读取数据，这个可以根据个人喜好，来进行配置。
couchBase.Server.path=http://XXX.XXX.XXX.XXX:8091,http://YYY.YYY.YYY.YYY:8091,http://MMM.MMM.MMM.MMM:8091
couchbase配置地址，多个地址用逗号分隔（这个不是规范，是我自己这么设置的），程序里会进行相应的分隔，用来支持couchbase集群
couchBase.website_company=bucketName,password//这个是桶名称以及桶密码的配置（密码可以不设，这种配置方式并不是规范，是我自己为了方便如此设置，也可以单独配置桶名和密码，希望这点不要迷惑到别人）
couchBase.queryProductList.sql=select * from `表名` //这个是sql语句的配置，表名会在程序里被替换


 




 

 

   
  

 

 


 
 

                

        

        

    




    

      

        

            

              
                
                  hao_kkkkk
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
                
  • 
                  
                    打赏
                    
                  
                  
    打赏
    
                
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
couchbase-client-1.1.2.jar

				
			

			

				

					08-17
				

			

		

		

			
				
用MemCached和Tomcat做集群共享session时，会用到这个类。

			
		

	



                

              
                



	

		

			

				
					
couchbase1.8安装包

				
			

			

				

					12-14
				

			

		

		

			
				
Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成

			
		

	



                


  
              

                


	

		

			

				
					
使用SQL和Couchbase查询工作台查询JSON

				
			

			

				

					danpu0978的博客
				

				

					04-25
					
					414
					
				

			

		

		

			
				
您想使用类似SQL的语法查询JSON文档数据库吗？ 
 Couchbase为您提供N1QL 。 
 N1QL是一种声明性查询语言，它扩展了JSON的SQL。 您可以通过本机框架和语言集成，流利的API或JDBC / ODBC驱动程序查询数据。 
 N1QL使您可以不受任何限制地查询JSON文档-使用单个查询对数据进行排序，过滤，转换，分组和合并。 那就对了。 您可以使用JOIN 合并来自多个...

			
		

	





	

		

			

				
					
Windows系统下Memcached缓存系列二:CouchbaseClient(c#客户端)的详细试用,单例模式

				
			

			

				

					
				

				

					03-17
					
					90
					
				

			

		

		

			
				
在上一篇文章里面 ( Windows系统下Memcached缓存系列一:Couchbase(服务器端)和CouchbaseClient(c#客户端)的安装教程 ),我们介绍了服务器端的安装和客户端的安装,以及一个简单的例子,这一篇介绍详细的使用方法.  这次以一个web项目为例.  配置文件配置调用  第一步：首先上一下配置文件,在web.config文件里面的 configuratio...

			
		

	



		

			
		



	

		

			

				
					
Couchbase Client Java

				
			

			

				

					赶路人儿
				

				

					06-19
					
					2694
					
				

			

		

		

			
				
javac -cp couchbase-client-1.0.3.jar:spymemcached-2.8.2.jar Main.java
java -cp .:couchbase-client-1.0.3.jar:spymemcached-2.8.2.jar:jettison-1.1.jar:netty-3.2.0.Final.jar:commons-codec-1.5.jar Main



			
		

	





	

		

			

				
					
Couchbase——查询信息

				
			

			

				

					EntropyArrow的专栏
				

				

					11-06
					
					2557
					
				

			

		

		

			
				
Getting views informationhuo xu

To retrieve views information, access any server node in a cluster on port 8092.

HTTP method and URI
GET /[bucket-name]/_design/[ddoc-name]/_view/[view-name]
Wh

			
		

	





	

		

			

				
					
couchbase C api

				
			

			

				

					04-12
				

			

		

		

			
				
Couchbase是一款分布式内存对象存储系统，常用于构建高性能、高可用性的数据存储解决方案。它的C API（应用程序接口）允许开发者使用C语言直接与Couchbase服务器进行交互，执行诸如插入、更新、删除和查询等操作。在...

			
		

	





	

		

			

				
					
android-couchbase.zip

				
			

			

				

					11-20
				

			

		

		

			
				
《Android与Couchbase Lite：一个深度探索的实践指南》  Couchbase Lite是一款轻量级、嵌入式的NoSQL数据库，特别适用于移动设备和物联网(IoT)应用。它为开发者提供了离线同步功能，使得数据在本地存储并能够在网络...

			
		

	





	

		

			

				
					
Couchbase Essentials

				
			

			

				

					06-27
				

			

		

		

			
				
Couchbase Essentials The Database Redefined. Scalability of NoSQL. Flexibility of JSON. Power of SQL. A NoSQL Pioneer & Leader。Scalable NoSQL Database。

			
		

	





	

		

			

				
					
couchbase官方教程

				
			

			

				

					11-27
				

			

		

		

			
				
couchbase官方教程

			
		

	





	

		

			

				
					
couchbase中文

				
			

			

				

					04-01
				

			

		

		

			
				
集群管理
节点管理
节点监控
可管理的REST API
统计报表
实时日志
Multitenancy
访问安全

			
		

	





	

		

			

				
					
python写couchbase增删改查

				
			

			

				

					09-07
				

			

		

		

			
				
python写couchbase增删改查
python写couchbase增删改查
python写couchbase增删改查
python写couchbase增删改查

			
		

	





	

		

			

				
					
Couchbase

				
			

			

				

					08-06
				

			

		

		

			
				
NULL
博文链接：https://mazilaidaige.iteye.com/blog/2068462

			
		

	





	

		

			

				
					
Couchbase Query Language Tutorial 

				
			

			

				

					iteye_4972的博客
				

				

					09-28
					
					253
					
				

			

		

		

			
				

 
 
http://query.pub.couchbase.com/tutorial/


			
		

	





	

		

			

				
					
大数据NoSQL技术之Couchbase Server数据库详解

				
			

			

				

					欧辰的专栏
				

				

					01-23
					
					5126
					
				

			

		

		

			
				
一.什么是Couchbase Server

　　大数据的NoSQL技术已发展成熟，这以MongoDB为代表，但我这里要介绍的是另一种NoSQL技术，叫做Couchbase
 Server, 近年来在国外发展迅猛，大有超过MongoDB之势。Couchbase Server是由早先的CouchDB发展而来, 继承了Memcached的技术特性, 是一个开源的、分布式的、面向文档（docume

			
		

	





	

		

			

				
					
couchBase相关入门

				
			

			

				

					yanfeng918的专栏
				

				

					12-31
					
					703
					
				

			

		

		

			
				
1.相关的文章：
http://www.nosqldb.cn/1373778649108.html  

http://www.couchbase.com/（官方网站）

http://docs.couchbase.com/couchbase-sdk-java-1.4/#getting-started（Java的开发文档，是英文的，资料比较难懂）

http://docs.couch

			
		

	





	

		

			

				
					
Couchbase数据模型与查询语言

					
最新发布

				
			

			

				

					禅与计算机程序设计艺术
				

				

					01-23
					
					804
					
				

			

		

		

			
				
1.背景介绍

1. 背景介绍

Couchbase 是一款高性能、分布式的 NoSQL 数据库系统，它基于 memcached 协议，支持键值存储、文档存储和全文搜索等功能。Couchbase 的数据模型与查询语言是其核心功能之一，它使得开发者可以方便地存储、查询和操作数据。

在本文中，我们将深入探讨 Couchbase 数据模型与查询语言的核心概念、算法原理、最佳实践以及实际应用场景。同时，...

			
		

	





	

		

			

				
					
Couchbase——查询View（详细版）

				
			

			

				

					EntropyArrow的专栏
				

				

					11-06
					
					6925
					
				

			

		

		

			
				
Getting views information

To retrieve views information, access any server node in a cluster on port 8092.

HTTP method and URI
GET /[bucket-name]/_design/[ddoc-name]/_view/[view-name]
Where:


			
		

	





	

		

			

				
					
【python 】查找couchbase中的键

				
			

			

				

					初夏的专栏
				

				

					12-21
					
					1111
					
				

			

		

		

			
				
#getfundacco.py
#!/usr/bin/python
# -*- coding: utf-8 -*-from couchbase.bucket import Bucket
import ConfigParser
import string
import os
import jsoncp= ConfigParser.ConfigParser()
cp.read('my.conf')
co

			
		

	





	

		

			

				
					
Couchbase服务器管理入门

				
			

			

				

					
				

			

		

		

			
				
"Couchbase Server的管理与入门"  Couchbase Server是企业级的分布式内存数据存储系统，尤其适合处理大规模的实时数据。作为NoSQL数据库，它提供了高性能、高可用性和可扩展性，广泛应用于大数据管理和分析。本资料...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
hao_kkkkk

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值