我的编程空间,编程开发者的网络收藏夹
学习永远不晚

java封装Mongodb3.2.1工具类

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

java封装Mongodb3.2.1工具类

       由于最近项目要使用mongodb来处理一些日志,提前学习了一下mongodb的一些基本用法,大概写了一些常用的。

       开发环境为:WIN7-64,JDK7-64,MAVEN3.3.9-64,IDEA2017-64.

       程序基本结构为:

java封装Mongodb3.2.1工具类


下面贴出核心代码示例:


pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>TestWebProjectMaven</groupId>
  <artifactId>TestWebProjectMaven</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>TestWebProjectMaven Maven Webapp</name>
  <!-- 设定主仓库 -->
  <repositories>
    <!-- nexus私服 -->
    <repository>
      <id>nexus-repos</id>
      <name>Team Nexus Repository</name>
      <url>http://192.168.200.205:8081/nexus/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
  </repositories>
  <!-- 设定插件仓库 -->
  <pluginRepositories>
    <pluginRepository>
      <id>nexus-repos</id>
      <name>Team Nexus Repository</name>
      <url>http://192.168.200.205:8081/nexus/content/groups/public/</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </pluginRepository>
  </pluginRepositories>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.1.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongo-java-driver</artifactId>
      <version>3.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.jetbrains</groupId>
        <artifactId>annotations-java5</artifactId>
        <version>RELEASE</version>
    </dependency>
    <dependency>
      <groupId>commons-configuration</groupId>
      <artifactId>commons-configuration</artifactId>
      <version>1.10</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>TestWebProjectMaven</finalName>
    <!-- 设置properties文件编译到target目录中,不然读取不到配置文件 -->
    <resources>
      <resource>
        <directory>class="lazy" data-src/main/java</directory>
        <includes>
          <include>**
public class MongodbUtil {
   private static MongoClient MONGODB_CLIENT = null;
   private static String MONGODB_IP = null;
   private static Integer MONGODB_PORT = null;
   private static String MONGODB_DATABASE_NAME = null;
   private static String MONGODB_COLLECTION_NAME = null;
   static{
       CompositeConfiguration compositeConfiguration = new CompositeConfiguration();
       try {
           compositeConfiguration.addConfiguration(new PropertiesConfiguration("mongodb.properties"));
       } catch (ConfigurationException e) {
           e.printStackTrace();
       }
       MONGODB_IP = compositeConfiguration.getString("MONGODB_IP");
       MONGODB_PORT = compositeConfiguration.getInt("MONGODB_PORT");
       MONGODB_DATABASE_NAME = compositeConfiguration.getString("MONGODB_DATABASE_NAME");
       MONGODB_COLLECTION_NAME = compositeConfiguration.getString("MONGODB_COLLECTION_NAME");
       MONGODB_CLIENT = new MongoClient(MONGODB_IP,MONGODB_PORT);
   }
    private MongodbUtil() {
    }
    
    public static MongoDatabase getMongodbDatabase(){
       return MONGODB_CLIENT.getDatabase(MONGODB_DATABASE_NAME);
    }
    
    public static void closeMongodbClient(){
        if(null != MONGODB_CLIENT){
            MONGODB_CLIENT.close();
            MONGODB_CLIENT = null;
        }
    }
    
    public static MongoCollection<Document> getMongoCollection(){
        return getMongodbDatabase().getCollection(MONGODB_COLLECTION_NAME);
    }
    
    public static void insertOneCollectionByMap(Map<String,Object> map){
        getMongoCollection().insertOne(handleMap(map));
    }
    
    public static void insertManyCollectionByMap(List<Map<String,Object>> listMap){
        List<Document> list = new ArrayList<Document>();
        for(Map<String,Object> map : listMap){
            Document document = handleMap(map);
            list.add(document);
        }
        getMongoCollection().insertMany(list);
    }
    
    public static void insertOneCollectionByModel(Object obj){
        getMongoCollection().insertOne(handleModel(obj));
    }
    
    public static void insertManyCollectionByModel(List<Object> listObj){
        List<Document> list = new ArrayList<Document>();
        for(Object obj : listObj){
            Document document = handleModel(obj);
            list.add(document);
        }
        getMongoCollection().insertMany(list);
    }
    
    public static String queryCollectionByCondition(Document queryDocument,Document sortDocument,PageVO pageVO){
        if(null == queryDocument || null == sortDocument || null == pageVO){
            return null;
        }else{
            String returnList = getQueryCollectionResult(queryDocument,sortDocument,pageVO);
            return returnList;
        }
    }
    
    public static String queryCollectionByMap(Map<String,Object> map,Document sortDocument,PageVO pageVO){
        String sql = getQueryCollectionResult(handleMap(map),sortDocument,pageVO);
        return sql;
    }
    
    public static String queryCollectionByModel(Object obj,Document sortDocument,PageVO pageVO){
        String sql = getQueryCollectionResult(handleModel(obj),sortDocument,pageVO);
        return sql;
    }
    
    private static String getQueryCollectionResult(Document queryDocument,Document sortDocument,PageVO pageVO){
        FindIterable<Document> findIterable = getMongoCollection().find(queryDocument)
                .sort(sortDocument).skip((pageVO.getPageNum()-1)*pageVO.getPageSize()).limit(pageVO.getPageSize());
        MongoCursor<Document> mongoCursor = findIterable.iterator();
        StringBuilder sql = new StringBuilder();
        Integer lineNum = 0;
        while(mongoCursor.hasNext()){
            sql.append("{");
            Document documentVal = mongoCursor.next();
            Set<Map.Entry<String,Object>> sets = documentVal.entrySet();
            Iterator<Map.Entry<String,Object>> iterators = sets.iterator();
            while(iterators.hasNext()){
                Map.Entry<String,Object> map = iterators.next();
                String key = map.getKey();
                Object value = map.getValue();
                sql.append("\"");
                sql.append(key);
                sql.append("\"");
                sql.append(":");
                sql.append("\"");
                sql.append((value == null ? "" : value));
                sql.append("\",");
            }
            sql.deleteCharAt(sql.lastIndexOf(","));
            sql.append("},");
            lineNum++;
        }
        //这里判断是防止上述没值的情况
        if(sql.length() > 0){
            sql.deleteCharAt(sql.lastIndexOf(","));
        }
        String returnList = getFinalQueryResultsSql(lineNum,sql.toString());
        return returnList;
    }
    
    private static String getFinalQueryResultsSql(Integer lineNum,String querySql) {
        StringBuilder sql = new StringBuilder();
        sql.append("{");
        sql.append("\"");
        sql.append("jsonRoot");
        sql.append("\"");
        sql.append(":");
        sql.append("\"");
        sql.append(lineNum);
        sql.append("\",");
        sql.append("\"");
        sql.append("jsonList");
        sql.append("\"");
        sql.append(":");
        sql.append("[");
        sql.append(querySql);
        sql.append("]");
        sql.append("}");
        return sql.toString();
    }
    
    public static List<String> getALLCollectionNameOfList(){
        List<String> list = new ArrayList<String>();
        MongoIterable<String> mongoIterable = getMongodbDatabase().listCollectionNames();
        for(String name : mongoIterable){
            list.add(name);
        }
        return list;
    }
    
    public static Map<String,String> getALLCollectionNameOfMap() {
        Map<String,String> map = new HashMap<String,String>();
        MongoIterable<String> mongoIterable = getMongodbDatabase().listCollectionNames();
        for(String name : mongoIterable){
            map.put(name,name);
        }
        return map;
    }
    
    public static Integer queryCollectionCount(Document queryDocument){
        int count = (int) getMongoCollection().count(queryDocument);
        return count;
    }
    
    public static String queryCollectionModelById(String id){
        ObjectId objectId = new ObjectId(id);//注意在处理主键问题上一定要用ObjectId转一下
        Document document = getMongoCollection().find(Filters.eq("_id",objectId)).first();
        return (document == null ? null : document.toJson());
    }
    
    public static void updateCollectionById(String id,Map<String,Object> updateMap){
        Document queryDocument = new Document();
        ObjectId objId = new ObjectId(id);//注意在处理主键问题上一定要用ObjectId转一下
        queryDocument.append("_id", objId);
        Document updateDocument = handleMap(updateMap);
        getMongoCollection().updateOne(queryDocument,new Document("$set",updateDocument));
    }
    
    public static void updateCollectionByCondition(Document queryDocument,Document updateDocument,Boolean
            ifInsert){
        UpdateOptions updateOptions = new UpdateOptions();
        updateOptions.upsert(ifInsert);
        getMongoCollection().updateMany(queryDocument,new Document("$set",updateDocument),updateOptions);
    }
    
    public static Integer deleteCollectionById(String id){
        ObjectId objectId = new ObjectId(id);
        Bson bson = Filters.eq("_id",objectId);
        DeleteResult deleteResult = getMongoCollection().deleteOne(bson);
        int count = (int) deleteResult.getDeletedCount();
        return count;
    }
    
    public static void deleteCollectionByMap(Map<String,Object> map){
        getMongoCollection().deleteMany(handleMap(map));
    }
    
    public static void deleteCollectionByModel(Object obj){
        getMongoCollection().deleteMany(handleModel(obj));
    }
    
    public static void deleteCollectionByDocument(Document document){
        getMongoCollection().deleteMany(document);
    }
    
    private static Document handleModel(Object obj){
        Document document = null;
        if(obj != null){
            document = new Document();
            try {
                Class clz = obj.getClass();
                Field fields[] = clz.getDeclaredFields();
                for(Field field : fields){
                    String fieldName = field.getName();
                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fieldName,clz);
                    Method method = propertyDescriptor.getReadMethod();
                    Object fieldValue = method.invoke(obj);
                    document.append(fieldName,(fieldValue == null ? "" : fieldValue));
                }
            } catch (IntrospectionException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }else{
            document = new Document("","");
        }
        return document;
    }
    
    private static Document handleMap(Map<String,Object> map){
        Document document = null;
        if(null != map){
            document = new Document();
            Set<String> sets = map.keySet();
            Iterator<String> iterators = sets.iterator();
            while(iterators.hasNext()){
                String key = iterators.next();
                Object value = map.get(key);
                document.append(key,(value == null ? "" : value));
            }
        }else{
            document = new Document("","");//这种设置查询不到任何数据
        }
        return document;
    }
    
    public static void dropDatabase(String databaseName){
        MONGODB_CLIENT.dropDatabase(databaseName);
    }
    
    public static void dropCollection(String databaseName,String collectionName){
        MONGODB_CLIENT.getDatabase(databaseName).getCollection(collectionName).drop();
    }
    
    public static void testquery(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(20);
        list.add(21);
        list.add(22);
        FindIterable<Document> findIterable =
        //getMongoCollection().find(Filters.and(Filters.lt("num",22),Filters.gt("num",17)));
        //getMongoCollection().find(Filters.in("num",17,18));
          getMongoCollection().find(Filters.nin("num",list));
        MongoCursor<Document> mongoCursor = findIterable.iterator();
        while(mongoCursor.hasNext()){
            Document document = mongoCursor.next();
            System.out.println(document.toJson());
        }
    }
}



免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

java封装Mongodb3.2.1工具类

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

封装JDBC工具类

封装JDBC工具类在实际JDBC的使用中,存在着大量的重复代码:例如连接数据库、关闭数据库等这些操作!我们需要把传统的JDBC代码进行重构,抽取出通用的JDBC工具类!以后连接的任何数据库、释放资源都可以使用这个工具类重用性方案封装获取连接、释放资源两个方法提
封装JDBC工具类
2017-12-18

Java日期工具类的封装详解

在日常的开发中,我们难免会对日期格式化,对日期进行计算,对日期进行校验,为了避免重复写这些琐碎的逻辑,我这里封装了一个日期工具类,方便以后使用,直接复制代码到项目中即可使用,需要的可以参考一下
2022-11-13

怎么在java中封装一个JDBC工具类

本篇文章给大家分享的是有关怎么在java中封装一个JDBC工具类,小编觉得挺实用的,因此分享给大家学习,希望大家阅读完这篇文章后可以有所收获,话不多说,跟着小编一起来看看吧。Java是什么Java是一门面向对象编程语言,可以编写桌面应用程序
2023-06-06

如何在java中封装一个JDBC工具类

如何在java中封装一个JDBC工具类?针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。Java是什么Java是一门面向对象编程语言,可以编写桌面应用程序、Web应用程序、分布
2023-06-14

Pandas怎么封装Excel工具类

这篇文章主要介绍了Pandas怎么封装Excel工具类的相关知识,内容详细易懂,操作简单快捷,具有一定借鉴价值,相信大家阅读完这篇Pandas怎么封装Excel工具类文章都会有所收获,下面我们一起来看看吧。引言Excel是一种广泛使用的电子
2023-07-06

Java利用Reflect实现封装Excel导出工具类

这篇文章主要为大家详细介绍了Java如何利用Reflect实现封装Excel导出工具类,文中的实现方法讲解详细,具有一定的借鉴价值,需要的可以参考一下
2022-11-13

HttpClient 4.0封装工具类是怎样的

这篇文章将为大家详细讲解有关HttpClient 4.0封装工具类是怎样的,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。以下为本人在实际开发过程中封装的HttpClient工具类,HttpC
2023-06-03

如何在Java中自定义封装一个JDBC工具类

如何在Java中自定义封装一个JDBC工具类?针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。步骤① 创建配置文件(config.properties),用于存放注册驱动和连接
2023-06-06

Pandas封装Excel工具类的方法步骤

本文主要介绍了Pandas封装Excel工具类的方法步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
2023-05-16

Android封装的http请求实用工具类

代码如下:import java.io.BufferedReader;import java.io.InputStreamReader;import java.net.URLEncoder;import java.security.KeyS
2022-06-06

利用怎么对Java输出打印工具类进行封装

这篇文章将为大家详细讲解有关利用怎么对Java输出打印工具类进行封装,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。在进行Java打印输出,进行查看字段值的时候,觉得每次写了System.ou
2023-05-31

Redis缓存穿透/击穿工具类的封装

目录1. 简单的步骤说明2. 逻辑缓存数据类型3. 缓冲工具类的封装3.1 CacheClient 类的类图结构3.2 CacheClient 类代码1. 简单的步骤说明创建一个逻辑缓存数据类型封装缓冲穿透和缓冲击穿工具类2. 逻辑缓
2022-07-27

C#串口通信工具类的封装方法

本篇内容介绍了“C#串口通信工具类的封装方法”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成! 1、SerialPortHelper串口工具类封
2023-06-29

java封装类是如何封装的

在Java中,封装是一种面向对象编程的概念,用于隐藏内部实现细节,并通过公共方法提供对数据的访问和操作。封装类是为了封装基本数据类型或非基本数据类型的对象。封装类使用类来封装数据,是将数据和操作数据的方法封装在一个类中。这样可以保护数据,
2023-10-23

编程热搜

目录