• mongodb高级操作及在Java企业级开发中的应用.


     

    Java连接mongoDB

    Java连接MongoDB需要驱动包,个人所用包为mongo-2.10.0.jar.可以在网上下载最新版本.

    package org.dennisit.mongodb.study;
    
    import com.mongodb.BasicDBObject;
    import com.mongodb.DB;
    import com.mongodb.DBCollection;
    import com.mongodb.Mongo;
    
    /**
     * 
     *    MongoDBUtil.java
     *
     *     功   能: Java连接MongoDB小Demo(连接并插入一条数据)
     *     类   名: MongoDBUtil
     *
     *  ver      変更日        角色           担当者     変更内容
     *     ──────────────────────────────────────────────
     *  V1.00   2013-1-16   Demo模块    苏若年     初版
     *
     *     Copyright (c) 2013 dennisit corporation All Rights Reserved.
     *   
     *  Email:<a href="mailto:DennisIT@163.com">发送邮件</a>
     *
     */
    public class MongoDBUtil {
    
        public static void main(String[] args) {
            Mongo mongo = null;
            try {
                //通过连接字符串得到一个数据库实例的连接
                mongo = new Mongo("127.0.0.1",27017);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //获得一个数据库对象,mydb为数据库民称
            DB db = mongo.getDB("mydb");
            //指定安全授权信息[mydb数据库的用户名为mydbusr,密码为123]
            db.authenticate("mydbusr", "123".toCharArray());
            
            //声明一个collection对象
            DBCollection collection = db.getCollection("user");
            //声明一个document文档对象,用户存储数据
            BasicDBObject doc = new BasicDBObject();
            doc.put("name", "suruonian");
            doc.put("email", "dennisit@163.com");
            BasicDBObject experience = new BasicDBObject();
            experience.put("year of 2012", "i work in hangzhou");
            experience.put("year of 2013", "i work in shenzhen");
            doc.put("work experience", experience);
            //调用collection的insert方法,将数据持久化到磁盘上.
            collection.insert(doc);
            System.out.println("test data insert finish ");
        }
    }
    
    这时登录到mydb.查看
    > db.user.find({},{_id:0});
    { "name" : "suruonian", "email" : "dennisit@163.com", "work experience" : { "year of 2012" : "i work in hangzhou", "year of 2013" : "i work in shenzhen" } }
    >

     

    mongoDB查询数据

    通过findOne()查询一条数据

             //连接到mongodb
            
            //获得一个数据库对象,mydb为数据库民称
            DB db = mongo.getDB("mydb");
            //指定安全授权信息[mydb数据库的用户名为mydbusr,密码为123]
            db.authenticate("mydbusr", "123".toCharArray());
            
            //声明一个collection对象
            DBCollection collection = db.getCollection("user");
            DBObject userdoc= collection.findOne();
            System.out.println("查询到的一条记录为:" + userdoc);
        

    mongoDB更新数据

    将user集合中name为suruonian的name值改成dennisit.

             
             //连接到mongodb
    
            //声明collection对象
            DBCollection collection = db.getCollection("user");
            
            //定义一个查询对象,
            DBObject updateAim = new BasicDBObject();
            updateAim.put("name", "suruonian");
            
            System.out.println("通过用户名查找到的对象为:" + collection.findOne(updateAim));
            
            //定义一个更新对象,类似于set语句
            DBObject updatedValue = new BasicDBObject();
            updatedValue.put("name", "dennisit");
            
            //db.user.update({name:"suruonian"},{$set:{name:dennisit}});
            DBObject updateSetValue = new BasicDBObject("$set",updatedValue);
            
            //将查询对象和更新对象作为参数传给update来完成更新.
            collection.update(updateAim, updateSetValue);
            
            System.out.println("更新后查询到的一条记录为:" + collection.findOne());
        

    mongoDB删除数据

    删除操作user集合中name为dennisit的用户

            
             //连接到mongodb
    
             //声明collection对象
            DBCollection collection = db.getCollection("user");
            
            //定义一个查询对象,
            DBObject aimObj = new BasicDBObject();
            aimObj.put("name", "dennisit");
            
            System.out.println("通过用户名查找到的对象为:" + collection.findOne(aimObj));
            
            collection.remove(aimObj);
            System.out.println("删除后查询到的一条记录为:" + collection.findOne());

    MonggoDB保证事物的一致性

    MongoDB的Java驱动是线程安全的,对于一般的应用,只要一个mongo实例即可.mongo有个内置的连接池(连接池默认可容纳10个数据库连接),在有大量写和读的环境中,为了确保在一个session中使用同一个DB时,可以通过DB类的requestStart()方法打开失去控制,待所有业务代码编写完毕后,再通过DB类的requestDone()方法结束事物控制.这样就保证了事物的原子性.

           
            //声明collection对象
            DBCollection collection = db.getCollection("user");
            
            //开始事务控制
            db.requestStart();
            
            //事务相关操作
            
            //结束事物控制
            db.requestDone();
            

    MongoDB库级别操作

    获取连接的IP地址

    mongo.getAddress();

     

    列出所有数据库[此操作只针对超级用户]

    mongo.getDatabaseNames();

     

    删除指定数据库[此操作只针对超级用户]

    mongo.dropDatabase("testdb");

     

    代码演示

        public static void main(String[] args) {
            
            Mongo mongo = null;
            try {
                //通过连接字符串得到一个数据库实例的连接
                mongo = new Mongo("127.0.0.1",27017);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //连接超级用户
            DB db = mongo.getDB("admin");
            //指定安全授权信息[超级用户的用户名为root,密码为root123]
            db.authenticate("root", "root123".toCharArray());
            
            //getAddress方法获取IP和端口
            System.out.println("当前连接的IP和端口为:" + mongo.getAddress());
            
            //列出所有数据库,此操作只针对超级用户
            System.out.println("系统中的所有数据库为:" + mongo.getDatabaseNames());
            
            //删除数据库,此操作只针对超级用户
            mongo.dropDatabase("testdb");
            System.out.println("系统中的所有数据库为:" + mongo.getDatabaseNames());
    
        }
    控制台输出信息
    当前连接的IP和端口为:127.0.0.1:27017
    系统中的所有数据库为:[admin, mydb, testdb, local, test]
    系统中的所有数据库为:[admin, mydb, local, test]

    MongoDB对用户的操作

    为连接的数据库添加用户

            DB db = mongo.getDB("mydb");
            db.addUser("username", "password".toCharArray(),true);

     

    参数说明

    第一个参数为要条件的用户名

    第二个参数为要添加的用户对应的访问口令

    第三个参数为readOnly,代表用户的权限,为true表示值读权限,为false表示为读/写权限.默认为false.不传参代表默认.

     

    删除某个用户

            DB db = mongo.getDB("mydb");
            db.removeUser("username");

    参数说明

    传入的参数为要删除的用户名.要删除的用户必须应是已存在的.

     

    MongoDB对集合collection的操作

    Collection是MongoDB中存储数据的最小单元.

    列出连接数据库下的所有集合

             DB db = mongo.getDB("mydb");
            //指定安全授权信息[超级用户的用户名为root,密码为root123]
            db.authenticate("mydbusr", "123".toCharArray());
            
            //列出mydb数据库中的所有collection
            Set<String> collets = db.getCollectionNames();
            for(String str : collets){
                System.out.println(str);
            }

     

    判断某个collection是否存在

            //判断user集合是否存在,返回值为boolean类型
            System.out.println(db.collectionExists("user"));

     

    新建collection

    Java可以通过DB类的createCollection(String name, DBObject option)方法新建集合

    参数说明

    第一个参数表示创建的collection的名字

    第二个参数决定了是否创建的是Capped Collection.

            //创建非CappedCollection对象,false表示不是一个CappedCollection
            DBObject optial = new BasicDBObject().append("capped", false);
            //显示创建非CappedCollection
            db.createCollection("nocapped", optial);
            System.out.println(db.getCollection("nocapped").getStats().toString());
            
            //创建CappedCollection对象,true表示是一个CappedCollection
            DBObject opt = new BasicDBObject().append("capped", true).append("max", 5);
            db.createCollection("iscapped", opt);
            
            System.out.println(db.getCollection("iscapped").getStats().toString());
            
            //使用isCapped()判断是否为CappedCollection
            System.out.println(db.getCollection("nocapped").isCapped()); //false
            System.out.println(db.getCollection("iscapped").isCapped()); //true

     

    删除collection

    通过DBCollection的drop()方法删除集合.

             DBCollection collect = db.getCollection("iscapped");
            collect.drop();    //删除iscapped集合

     

    计算document数量

            //控制台插入测试数据for (i=1; i<=5;i++){ db.user.insert( {name:"user"+i , age: i+4*5 } ); }
            DBCollection collectuser = db.getCollection("user");
            System.out.println("集合" + collectuser + "下共有" + collectuser.getCount() + "条记录");
            
            BasicDBObject  obj = new BasicDBObject();
            BasicDBObject gtTag = new BasicDBObject();
            gtTag.put("$gt", 23);
            //db.user.find({age:{$gt:23}});
            obj.put("age", gtTag);
            System.out.println("集合" + collectuser + "下年龄大于25的共有" + collectuser.getCount(obj) + "条记录");
    
    控制台输出
    集合user下共有5条记录
    集合user下年龄大于25的共有2条记录

     

    通过游标获取所有document

    Java可以通过游标DBCursor的方式来获取每一条document.

            DBCollection collection = db.getCollection("user");
            //用游标获取所有数据
            DBCursor cur = collection.find();    
            while(cur.hasNext()){
                System.out.println(cur.next());
            }
    也可以查询部分,如部分显示:DBCursor cur = collection.find().limit(3);    

     

    对索引的操做

     

    创建索引

    Java可以通过DBCollection类的createIndex(DBObject keys)方法创建索引,它接收一个DBObject类型的参数“keys”用于表明在哪些列上创建索引.

            DBCollection collection = db.getCollection("user");
            //在user集合的name列上创建索引
            collection.createIndex(new BasicDBObject("name",1));
    可以通过db.user.getIndexes();查看索引信息

     

    获取索引

    DBCollection类的getIndexInfo();

            DBCollection collection = db.getCollection("user");
            //获取集合中的所有索引信息
            List<DBObject> list = collection.getIndexInfo();
            for(DBObject var : list){
                System.out.println(var);
            }
    类似于 db.user.getIndexes();

     

    删除索引

    DBCollection的dropIndexes()删除当前集合中的所有索引.

            DBCollection collection = db.getCollection("user");
            
            //删除集合中的指定索引信息,删除name索引,1表示删除为真
            collection.dropIndex(new BasicDBObject("name",1));
            
            //删除该集合中所有索引[_id索引不支持删除]
            collection.dropIndexes();
    可以通过db.user.getIndexKeys();查看user集合中的索引

     

    Java对MongoDB的高级查询

     

    使用QueryBuilder查询构造器对MongoDB进行高级查询

    SQL语句:
             select * from user where username = ‘user3’;
    MongoDB:
             db.user.find( { name:"user3"} );
    Java代码:
            DBCollection collection = db.getCollection("user");
            //查询用户名为user3的用户
            DBObject query = new QueryBuilder().put("name").is("user3").get();
            DBCursor cur = collection.find(query);
            while(cur.hasNext()){
                System.out.println(cur.next());
            }
    输出结果:
              { "_id" : { "$oid" : "50f6d250778eafb6ef5bcee7"} , "name" : "user3" , "age" : 23.0}

     

    notEquals不等于

    查询user集合中用户名name值不等于user3的用户

    SQL语句:
             select * from user where username != ‘user3’;
    MongoDB:
             db.user.find( { name:{$ne:"user3"} } );
    Java代码:
            DBCollection collection = db.getCollection("user");
            //查询用户名不为user3的用户
            DBObject query = new QueryBuilder().put("name").notEquals("user3").get();
            DBCursor cur = collection.find(query);
            while(cur.hasNext()){
                System.out.println(cur.next());
            }
    输出结果:
              { "_id" : { "$oid" : "50f6d250778eafb6ef5bcee5"} , "name" : "user1" , "age" : 21.0}
              { "_id" : { "$oid" : "50f6d250778eafb6ef5bcee6"} , "name" : "user2" , "age" : 22.0}
              { "_id" : { "$oid" : "50f6d250778eafb6ef5bcee8"} , "name" : "user4" , "age" : 24.0}
              { "_id" : { "$oid" : "50f6d250778eafb6ef5bcee9"} , "name" : "user5" , "age" : 25.0}

     

    greaterThan大于

    查询user集合中age大于22的用户

    SQL语句:
             select * from user where age > 22;
    MongoDB:
             db.user.find( { age:{$gt:22} } );
    QueryBuilder构造:
            DBObject query = new QueryBuilder().put("age").greaterThan(22).get();

     

     

    greaterThanEquals大于等于

    查询user集合中age大于等于22的用户

    SQL语句:
             select * from user where age >= 22;
    MongoDB:
             db.user.find( { age:{$gte:22} } );
    QueryBuilder构造:
            DBObject query = new QueryBuilder().put("age").greaterThanEquals(22).get();

     

    lessThan小于

    查询user集合中age小于22的用户

    SQL语句:
             select * from user where age < 22;
    MongoDB:
             db.user.find( { age:{$lt:22} } );
    QueryBuilder构造:
            DBObject query = new QueryBuilder().put("age").lessThan(22).get();

     

    lessThanEquals小于等于

    查询user集合中age小于等于22的用户

    SQL语句:
             select * from user where age <= 22;
    MongoDB:
             db.user.find( { age:{$lte:22} } );
    QueryBuilder构造:
            DBObject query = new QueryBuilder().put("age").lessThanEquals(22).get();

     

     

    In范围内

    查询user集合中age在23或24的记录

    SQL语句:
             select * from user where age in (23,24);
    MongoDB:
             db.user.find( { age:{$in:[23,24]} } );
    Java代码:
            DBCollection collection = db.getCollection("user");
            //查询user集合中age为23或者24的用户
            int[] inList = {23,24};
            DBObject query = new QueryBuilder().put("age").in(inList).get();
            DBCursor cur = collection.find(query);
            while(cur.hasNext()){
                System.out.println(cur.next());
            }

     

     

    notIn范围外

    查询user集合中age不是23或24的记录

    SQL语句:
             select * from user where age not in (23,24);
    MongoDB:
             db.user.find( { age:{$nin:[23,24]} } );
    Java代码:
            DBCollection collection = db.getCollection("user");
            //查询user集合中age为23或者24的用户
            int[] inList = {23,24};
            DBObject query = new QueryBuilder().put("age").notIn(inList).get();
            DBCursor cur = collection.find(query);
            

     

    and逻辑与

    查询user集合中age大于22并且性别为”man“的用户

    SQL语句:
             select * from user where sex = ‘man’ and age > 20;
    MongoDB:
             db.user.find({sex:"man",age:{$gt:20}});
    Java代码:
            //查询user集合中age大于22并且性别为”man“的用户
            DBObject query = new QueryBuilder().put("sex").is("man").and("age").greaterThan(20).get();

     

    正则表达式

    查询name以user开头的记录

    SQL语句:
             select * from user where name like ‘user%’;
    MongoDB:
             db.user.find({name:/^user.*/});
    Java代码:
            DBCollection collection = db.getCollection("user");
            Pattern pattern = Pattern.compile("^user");
            BasicDBObject query = new BasicDBObject("name",pattern);

     

    分页查询

    mongoDB中通过skip()和limit()结合实现分页

        public static void main(String[] args) {
            
            Mongo mongo = null;
            try {
                //通过连接字符串得到一个数据库实例的连接
                mongo = new Mongo("127.0.0.1",27017);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //连接超级用户
            DB db = mongo.getDB("mydb");
            //指定安全授权信息[超级用户的用户名为root,密码为root123]
            db.authenticate("mydbusr", "123".toCharArray());
            
            int  perNum = 10;        //每页显示的数目
            int  count = 0;            //数据库中总共记录数目
            int  pageNum = 0;        //分页后的页数
            
            DBCollection collection = db.getCollection("user");
            
            count = (int)collection.getCount();        //总共记录数
            pageNum = (count-1)/perNum + 1;            //计算总共页数
            
            System.out.println("数据库"+collection+"中共有"+count+"条记录,每页显示"+perNum+"条记录,可显示"+pageNum+"页");
            
            //循环分页打印
            for(int i=0; i<pageNum; i++){
                System.out.println("------------第" + (i+1) + "页数据------------");
                DBCursor cur = collection.find().skip(i*perNum).limit(perNum);
                while(cur.hasNext()){
                    System.out.println(cur.next());
                }
            }
        }

     

     

    Java操作GridFS

     

    插入数据

    使用GridFS类的createFile(File file)方法可以将大文件保存到MongoDB中,该方法接收一个参数,表示本地文件路径

    public static void main(String[] args) {
            Mongo mongo = null;
            try {
                mongo = new Mongo("127.0.0.1",27017);
            } catch (Exception e) {
                // TODO: handle exception
            }
            DB db = mongo.getDB("mydb");
            db.authenticate("mydbusr", "123".toCharArray());
            
    
            File zipFile = new File("D:/freemarker源码.rar");    //创建文件对象
            //将文件存放到file数据库中
            GridFS gfs = new GridFS(db,"file");    
            
            //创建大文件对象输入流
            GridFSInputFile gfsFile = null;    
            try {
                //将本地文件存储到mongo中
                gfsFile = gfs.createFile(zipFile);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //设置存储的文件名
            gfsFile.setFilename("demozip");
            gfsFile.save();
        }
    在mydb数据库下查看存储的文件信息
    > db
    mydb
    > show collections;
    file.chunks
    file.files
    system.indexes
    system.users
    user
    > db.file.files.findOne();
    {
            "_id" : ObjectId("50f780a7de886482c92a56c9"),
            "chunkSize" : NumberLong(262144),
            "length" : NumberLong(83711),
            "md5" : "51f235ccf838511eb0f53633dbca22b3",
            "filename" : "demozip",
            "contentType" : null,
            "uploadDate" : ISODate("2013-01-17T04:40:07.240Z"),
            "aliases" : null
    }

     

    查询数据

    因为上传了一个zip文档,为了方便观察,使用GridFS类的findOne(DBObject query)方法,按文件名查找数据库中的GridFS对象信息,该方法结束1个参数,代表查询条件.

            DB db = mongo.getDB("mydb");
            db.authenticate("mydbusr", "123".toCharArray());
            
            //将文件存放到file数据库中
            GridFS gfs = new GridFS(db,"file");    
            
            //查询GridFS数据,按照文件名查询 db.file.files.findOne({filename:"demozip"});
            GridFSDBFile zipfile = gfs.findOne("demozip");
            System.out.println(zipfile);

     

    读取并保存数据

    首先用find或者findOne方法找到GridFS对象,再用writeTo方法将数据写到本地.

            DB db = mongo.getDB("mydb");
            db.authenticate("mydbusr", "123".toCharArray());
            
            GridFS gfs = new GridFS(db,"file");    
            
            //查询GridFS数据,按照文件名查询 db.file.files.find({filename:"demozip"});
            GridFSDBFile zipfile = gfs.findOne("demozip");
            System.out.println("服务器端文件MD5值为:" + zipfile.getMD5());
            try {
                //将读取到的文件写到本地
                zipfile.writeTo("E:/downgidfs.zip");
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
    控制台输出:服务器端文件MD5值为:51f235ccf838511eb0f53633dbca22b3
    验证下载到的文件的MD5
    E:\>md5sum downgidfs.zip
    51f235ccf838511eb0f53633dbca22b3 *downgidfs.zip

     

    删除数据

    Java中使用remove(DBObject query)来实现移除数据

            GridFS gfs = new GridFS(db,"file");        
            //查询GridFS数据,按照文件名查询 db.file.files.find({filename:"demozip"});
            GridFSDBFile zipfile = gfs.findOne("demozip");
            //删除查询到的GridFS数据
            gfs.remove(zipfile);

     

    转载请注明出处:[http://www.cnblogs.com/dennisit/archive/2013/01/29/2881006.html]

    在线交谈

     

     

  • 相关阅读:
    冲刺周2
    java 流
    java 线程控制方法
    java界面编程(下)
    java 界面编程(上)
    java数组
    java 异常
    java程序中的存储区
    java中稍微有些陌生的关键字
    IOCP服务器搭建
  • 原文地址:https://www.cnblogs.com/dennisit/p/2881006.html
Copyright © 2020-2023  润新知