Java使用mongodb原生增删改查语句

最新推荐文章于 2022-12-05 14:36:17 发布
最新推荐文章于 2022-12-05 14:36:17 发布
阅读量594 收藏 1
点赞数
文章标签： 数据库 java json
原文链接：http://www.cnblogs.com/Ming8006/p/8583054.html
版权

Java使用mongodb原生增删改查语句

2018-03-16

自动化测试时，需校验数据库数据，为了快速自动化，在代码中用原生增删改查语句操作mongodb

结构

代码

0 pom.xml

  <dependencies>
      <dependency>
          <groupId>org.mongodb</groupId>
          <artifactId>mongo-java-driver</artifactId>
          <version>3.2.2</version>
      </dependency>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.31</version>
      </dependency>
  </dependencies>

1 客户端操作Client.java

package com.mongodb.util;

import com.mongodb.util.DBConnection.DriverName;

public class Client {

    public static void main(String[] args) {
        DBConnection conn = new DBConnection();
        conn.setDbConnectionName("mongoDb1");
        conn.setSource("****");
        conn.setDbName("****");
        conn.setDriverName(DriverName.mongodb);
        conn.setServerHost("****");
        conn.setServerPort("27017");
        conn.setUserName("****");
        conn.setPassword("****");
        String querySqlWithFields = "db.getCollection('laAppInterface').find({$or:[{'appCode':'100005'},{'appCode':'10005'}]},{'appCode':1,'interfaceId':1})";
        String querySqlWithoutFields = "db.getCollection('laAppInterface').find({$or:[{'appCode':'100005'},{'appCode':'10005'}]})";
        
        Crud.Connect(conn);
        
        //注意：客户端工具Robomogon中,保存整数1，要用NumberInt(1),否则会变成1.0
        String create = "db.getCollection('laAppInterface').save({'appCode':'10005','interfaceId':'TEST-API-0000068','invokeType':1,'callbackAddress':'',})";
        System.out.println("Create: "+Crud.OperateDB(create,false));
        System.out.println(Crud.OperateDB(querySqlWithFields, false));
        System.out.println(Crud.OperateDB(querySqlWithFields, true));
        System.out.println(Crud.OperateDB(querySqlWithoutFields, false));
        System.out.println(Crud.OperateDB(querySqlWithoutFields, true));
        String update="db.getCollection('laAppInterface').update({'interfaceId':'TEST-API-0000068'},{$set:{'appCode':'100005'}});";
        System.out.println("Update: "+Crud.OperateDB(update,false));
        System.out.println(Crud.OperateDB(querySqlWithFields, false));
        
        String delete="db.getCollection('laAppInterface').remove({$or:[{'appCode':'100005'},{'appCode':'10005'}]});";
        System.out.println("Delete: "+Crud.OperateDB(delete,false));
        System.out.println(Crud.OperateDB(querySqlWithFields, false));
        

        //比较运算
        String queryGt="db.getCollection('laAppInterface').find({'invokeType':{$gt:1}},{'appCode':1,'invokeType':1})";        
        System.out.println("queryGt: "+Crud.OperateDB(queryGt, false));
        
        //暂不支持模糊查询 {'appCode':/0005/}        
    }
}
View Code

执行结果：

Create: 0
[["10005","TEST-API-0000068"]]
[{"appCode":"10005","interfaceId":"TEST-API-0000068"}]
[[{"counter":7184126,"date":1521186717000,"machineIdentifier":7002056,"processIdentifier":13740,"time":1521186717000,"timeSecond":1521186717,"timestamp":1521186717},"10005","TEST-API-0000068",1,""]]
[{"_id":{"counter":7184126,"date":1521186717000,"machineIdentifier":7002056,"processIdentifier":13740,"time":1521186717000,"timeSecond":1521186717,"timestamp":1521186717},"appCode":"10005","interfaceId":"TEST-API-0000068","invokeType":1,"callbackAddress":""}]
Update: 1
[["100005","TEST-API-0000068"]]
Delete: 1
[]
queryGt: [["1002",4],["1002",4],["1002",4],["1002",4],["1002",4],["1004",4],["1002",4],["1002",4],["1002",4],["1002",4],["1001",4],["1001",4],["1001",4],["1001",4],["1001",4]]

2 mongodb增删改查操作Crud.java

只暴露两个方法

public static void Connect(DBConnection dbCon);
public static String OperateDB(String sql, Boolean hasColumnName); 
package com.mongodb.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.WriteResult;
import com.mongodb.util.DBConnection.DriverName;

public class Crud {

    static DB mongoConn = null;

    public static void Connect(DBConnection dbCon) {
        if (dbCon.getDriverName() == DriverName.mongodb) {
            ServerAddress serverAddress = new ServerAddress(dbCon.getServerHost(), Integer.valueOf(dbCon.getServerPort()));
            List<ServerAddress> addrs = new ArrayList<>();
            addrs.add(serverAddress);
            MongoCredential credential = MongoCredential.createScramSha1Credential(dbCon.getUserName(), dbCon.getSource(), dbCon.getPassword().toCharArray());
            List<MongoCredential> credentials = new ArrayList<>();
            credentials.add(credential);

            // 通过连接认证获取MongoDB连接
            MongoClient mongoClient = new MongoClient(addrs, credentials);

            @SuppressWarnings("deprecation")
            DB con = mongoClient.getDB(dbCon.getDbName());
            
            mongoConn = con;
        }
    }

    public static String OperateDB(String sql, Boolean hasColumnName) {
        String result = "";
        if (sql.toUpperCase().contains(").FIND(")) {
            result = Query(sql, hasColumnName);

        }
        else if(sql.toUpperCase().contains(").REMOVE("))
        {
            result=String.valueOf(Delete(sql));
        }    
        else if(sql.toUpperCase().contains(").UPDATE("))
        {
            result=String.valueOf(Update(sql));
        }    
        else {
            result= String.valueOf(Create(sql));
        }
        return result;
    }
    

    private static String Query(String sql, Boolean hasColumnName) {
        String tableName = RegExpUtil.getTableName(sql);
        String query = RegExpUtil.getQuery(sql);
        List<String> columnNames = getColumnNames(query);

        BasicDBObject queryObject = (BasicDBObject) JSON.parse(query);
        DBCursor cursor = mongoConn.getCollection(tableName).find(queryObject);
        JSONArray lists = new JSONArray();

        while (cursor.hasNext()) {
            JSONObject jsonObj = new JSONObject();
            JSONArray subLists = new JSONArray();
            DBObject o = cursor.next();
            if (!columnNames.isEmpty()) {
                if(!hasColumnName)
                {
                    for (String columnName : columnNames)
                        subLists.add(o.get(columnName));
                    lists.add(subLists);
                }
                else {
                    for (String columnName : columnNames)
                        jsonObj.put(columnName, o.get(columnName));
                    lists.add(jsonObj);
                }
            } else {
                if(!hasColumnName)
                {
                    Iterator<String> it = o.keySet().iterator();
                    while(it.hasNext())
                        subLists.add(o.get(it.next()));
                    lists.add(subLists);
                }
                else {
                    lists.add(o);
                }
            }

        }
        return FastJsonUtil.ObjectToString(lists);
    }

    private static int Create(String sql)
    {
        String tableName = RegExpUtil.getTableName(sql);
        String create = RegExpUtil.getCreate(sql);
        BasicDBObject createObject = (BasicDBObject) JSON.parse(create);
        WriteResult writeResult = mongoConn.getCollection(tableName).save(createObject);
        return writeResult.getN();
    }
    
    private static int Update(String sql)
    {
        String tableName = RegExpUtil.getTableName(sql);
        
        String update = RegExpUtil.getUpdate(sql);
        BasicDBObject updateQueryObject = (BasicDBObject) JSON.parse(update);
        
        String upset = getUpset(update);
        BasicDBObject upsetObject = (BasicDBObject) JSON.parse(upset);
        WriteResult updateResult = mongoConn.getCollection(tableName).update(updateQueryObject, upsetObject);
        return updateResult.getN();
    }
    
    private static int Delete(String sql)
    {
        String tableName = RegExpUtil.getTableName(sql);
        String delete = RegExpUtil.getRemove(sql);
        BasicDBObject deleteObject = (BasicDBObject) JSON.parse(delete);
        WriteResult writeResult = mongoConn.getCollection(tableName).remove(deleteObject);
        return writeResult.getN();
    }
    
    private static List<String> getColumnNames(String query) {
        String tmp = RegExpUtil.getObject(query,1);
        return RegExpUtil.getColumnNames(tmp);
    }
    
    private static String getUpset(String query) {
        String tmp  = RegExpUtil.getObject(query, 1);
        return tmp;
    }
}
View Code

3 实体类DBConnection.java

package com.mongodb.util;

public class DBConnection {
    public enum DriverName {
        oracle, db2, sqlserver, mysql, sybase, postgresql,mongodb
    }
    private String dbConnectionName;
    private DriverName driverName;
    private String serverHost;
    private String serverPort;
    private String source;
    private String dbName;
    private String userName;
    private String password;
    public String getDbConnectionName() {
        return dbConnectionName;
    }
    public void setDbConnectionName(String dbConnectionName) {
        this.dbConnectionName = dbConnectionName;
    }
    public DriverName getDriverName() {
        return driverName;
    }
    public void setDriverName(DriverName driverName) {
        this.driverName = driverName;
    }
    public String getServerHost() {
        return serverHost;
    }
    public void setServerHost(String serverHost) {
        this.serverHost = serverHost;
    }
    public String getServerPort() {
        return serverPort;
    }
    public void setServerPort(String serverPort) {
        this.serverPort = serverPort;
    }
    public String getDbName() {
        return dbName;
    }
    public void setDbName(String dbName) {
        this.dbName = dbName;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getSource() {
        return source;
    }
    public void setSource(String source) {
        this.source = source;
    }
    
}
View Code

4 RegExpUtil.java

package com.mongodb.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegExpUtil {

    static String tableRegExp = "getCollection\\('(\\w+?)'\\)";
    static String queryRegExp = "\\.find\\((.*?)\\)";
    static String columnNameRegExp = "'(\\w+?)':";
    static String createRegExp = "\\.save\\((.*?)\\)";
    static String removeRegExp = "\\.remove\\((.*?)\\)";
    static String updateRegExp = "\\.update\\((.*?)\\)";

    static public String getObject(String str, int index) {
        int len = str.length();
        char[] chars = str.toCharArray();
        Stack<Character> stack = new Stack<Character>();
        int begin = 0, end = 0, i = 0, curIndex = 0;
        while (i < len && curIndex <= index) {
            // '{'入栈
            while (i < len&&stack.empty()) {
                if (chars[i] == '{') {
                    stack.push(chars[i]);
                    begin = i;
                }
                ++i;
            }
            if (stack.empty()) {
                return "";
            }
            // 第curIndex个object
            while (!stack.empty() && i < len) {
                if (chars[i] == '{') {
                    stack.push(chars[i]);

                }
                if (chars[i] == '}') {
                    if (!stack.empty() && stack.peek() == '{') {
                        stack.pop();
                    }
                }
                ++i;
            }
            if (stack.empty()) {
                end = i - 1;
                if (curIndex == index)
                    return str.substring(begin, end+1);
            } else {
                return "";
            }

            ++curIndex;
        }
        return "";
    }

    public static List<String> getColumnNames(String sql) {
        return GetWithRegExps(sql, columnNameRegExp);
    }

    public static String getTableName(String sql) {
        return GetWithRegExp(sql, tableRegExp);
    }

    public static String getQuery(String sql) {
        return GetWithRegExp(sql, queryRegExp);
    }

    public static String getCreate(String sql) {
        return GetWithRegExp(sql, createRegExp);
    }

    public static String getUpdate(String sql) {
        return GetWithRegExp(sql, updateRegExp);
    }

    public static String getRemove(String sql) {
        return GetWithRegExp(sql, removeRegExp);
    }

    private static String GetWithRegExp(String s, String regExp) {
        Pattern r = Pattern.compile(regExp);
        // 现在创建 matcher 对象
        Matcher m = r.matcher(s);
        if (m.find()) {
            return m.group(1);
        }

        return "";
    }

    private static List<String> GetWithRegExps(String s, String regExp) {
        List<String> ss = new ArrayList<String>();
        Pattern r = Pattern.compile(regExp);
        // 现在创建 matcher 对象
        Matcher m = r.matcher(s);
        while (m.find()) {
            ss.add(m.group(1));
        }

        return ss;
    }

}
View Code

5 FastJsonUtil.java

package com.mongodb.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONPath;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;

public class FastJsonUtil {
    public static String ObjectToString(Object o) {
        String s = JSON.toJSONString(o);
        return TrimDoubleQuote(s);
    }
    
    private static String TrimDoubleQuote(String s) {
        if (s.startsWith("\"") && s.endsWith("\"")) {
            s = s.substring(1, s.length());
            s = s.substring(0, s.length() - 1);
        }
        return s;
    }    
}
View Code

待完善

代码暂不支持：

  • 正则表达式查询，如 db.getCollection('laAppInterface').find({'appCode':/^1.*?1$/})  中正则表达式 /^1.*?1$/
  • 不支持函数，如db.getCollection('laAppInterface').update({'interfaceId':'TEST-API-0000068'},{$set:{"invokeType":NumberInt(1)}}); 中函数NumberInt(1)

 

转载于:https://www.cnblogs.com/Ming8006/p/8583054.html

weixin_33696106
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MongoDB Java 原生使用示例
github_35735591的博客
04-20 1674
MongoDB作为一个常用的数据库，Spring对其也进行了很好的支持，但了解Java如何原生使用对应使用Spring Data封装后的API是很有帮助的
java使用原生语句操作mongo_Java 中 MongoDB 使用指南
weixin_39663378的博客
12-02 2796
MongoDB是当今非常流行的一款NoSQL数据库，本文介绍如何使用MongoDB的Java驱动来操作MongoDB。一、引入MongoDB Java Driver包如果需要操作MongoDB的Java项目是一个Maven项目，可以在依赖中加上以下的配置。<dependencies> <dependency> <groupId>org.m...
java操作原生mongoDB进行条件查询
mahongb的博客
07-29 6145
最近进行项目开发，公司用的原生mongo进行数据操作，找了很久找到了以下的原生操作方法 1.进行ip与port的封装，封装为ServerAddress对象 ServerAddress address = new ServerAddress(ip, port); 2.接下来封装用户名、数据库名、密码的对象 ...
mongodb的java driver执行“原生查询”语句
孙健的专栏
09-29 1万+
DBObject o=(DBObject) JSON.parse("{ groups.groupName : 'group1' }");               DBObject o2=(DBObject) JSON.parse("{ groups.size : 0 }")
Java实现原生MongoDB的分组查询（非SpringBoot）
horsetaill的博客
12-05 657
这几天网上查了很多关于MongoDB的查询，但要么是在命令行中的查询，要么是SpringBoot封装好的查询语句，对于我这种用java swing“应付”一下实验的人来说完全是远水解不了近渴。在我孜孜不倦地搜索之下，终于“拼凑”出来了，代码附在下面。 结果展示：（没时间美化界面了，能看就行）
mongoDB 原生查询语句
日日留心的技术专栏
05-05 8981
一个成功的案例参考：https://blog.csdn.net/leinminna/article/details/100741502 mongoTemplate常用方法汇总：https://blog.csdn.net/leinminna/article/details/101277443 mongoDB 分页查询 Query query = new Query(); ...
java连接Mongodb实现增删改查
08-24
主要为大家详细介绍了java连接Mongodb实现增删改查，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java连接Mongodb进行增删改查_java连接Mongodb进行增删改查_curiousjop_depthklb_Mong
10-03
java连接Mongodb进行增删改查，包括查询、删除、增加等功能
Java连接MongoDB进行增删改查的操作
08-30
主要介绍了Java连接MongoDB进行增删改查的操作的相关资料,需要的朋友可以参考下
nodejs操作mongodb的增删改查功能实例
10-19
主要介绍了nodejs操作mongodb的增删改查功能,简单分析了mongodb模块的安装并结合实例形式分析了nodejs操作mongodb数据库进行增删改查的相关实现技巧,需要的朋友可以参考下
Java springboot Mongodb增删改查代码实例
08-18
主要介绍了Java springboot Mongodb增删改查代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java 执行cmd命令及mongodb脚本
03-27
NULL 博文链接：https://wangzijian777.iteye.com/blog/1141763
java操作mongodb之update
热门推荐
sanding的博客
07-06 3万+
一：环境搭建                    环境搭建代码（SSM+mongdb）点击打开链接二：根据_id跟新collection中存在的字段。    1，写法            _id，及值是存在的。field   orderDate也是存在的。2，test3,结果三：根据_id更新collection中不存在的field1,写法    2，结果使用mongoTemplate.ups...
Java操作mongodb增删改查的基本操作
qq_59510147的博客
10-07 2030
删除一条数据:db.集合名称.remove({name：“张三”},{justOne:true});db.集合名称.find().limit(number).skip(number);增加多条数据：db.集合名称.insert({name:“张三”，sex:"男"});db.集合名称.update({查询条件},{$inc:{字段名：number（1）}})9.修改数据：db.集合名称.update({查询条件}，{$set:{更新内容}}，包含张的内容：db.集合名称.find({name：/张/})
mongodb java 原生语言查询
fyddaben的专栏
03-12 1999
由于原数据库使用的是mysql。项目要求，制作查询组件，即，可以根据sql语句，来查询不同内容，从而不需要修改后台代码。      这两天，系统要改造，前端查询改为mongodb数据库。看文档，查询都是采用的属性键值对赋值给BasicDBObject的形式。后来发现，http://cn.docs.mongodb.org/manual/applications/aggregation/  即聚
java执行mongodb语句_mongodb的java driver执行“原生查询”语句
weixin_35826166的博客
02-16 596
DBObject o=(DBObject) JSON.parse("{ groups.groupName : 'group1' }");DBObject o2=(DBObject) JSON.parse("{ groups.size : 0 }");//这个格外的部分是 filed selection，为0你看结果里面就没有这个filed，如果为1则是只有这个filed被返回DBdb = new ...
JavaAPI mongodb查询语句
小周先生的博客
07-23 425
JavaAPI mongodb查询语句 开发时做的记录，借鉴了一些其他语法方式， Document documents = new Document(); 普通查询// 查询所有 mongodb语句: db.collection.find(documents); sql 语句: select * from 表 一般条件查询 //1.根据id查询 documents.put("id",1); //2.根据判断条件查询 "$gte"---大于等于 "$gt"----大于 "$lt"--
mongodb增删改查语句
最新发布
10-14
好的，以下是 MongoDB 的增删改查语句： 1. 插入文档： db.collection.insertOne()：插入一条文档 db.collection.insertMany()：插入多条文档 2. 删除文档： db.collection.deleteOne()：删除一条文档 db....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值