本文主要介绍Mongodb在java应用中如何进行增、删、查、改操作。

一、配置

1、将 common.jar库引入到项目环境中： (源代码：https://gitee.com/cnsugar/common，可直接下载lib目录下的jar文件使用) 

　　如果是maven项目，可以通过mvn install命令将common.jar加入到本地仓库：

  1. mvn install:install-file -Dfile=D:\lib\common-1.0.jar -DgroupId=com.cnsugar -DartifactId=common -Dversion=1.0 -Dpackaging=jar

然后在pom.xml中加入以下配置：

  1. <dependency>
  2.     <groupId>com.cnsugar</groupId>
  3.     <artifactId>common</artifactId>
  4.     <version>1.0</version>
  5. </dependency>

　　

　　也可以直接将jar文件放到项目中，用下面的方式引入：

  1. <dependency>
        <groupId>com.cnsugar</groupId>
        <artifactId>common</artifactId>
        <version>1.0</version>
        <scope>system</scope>
        <systemPath>${project.basedir}/lib/common-1.0.jar</systemPath>
    </dependency>

 

2、用同样的方式将 common-mongodb.jar库引入到项目环境中： (源代码：https://gitee.com/cnsugar/common-mongondb，可直接下载lib目录下的jar文件使用) 

3、增加依赖包　　

  1.     <properties>
  2.         <fastjson-version>1.2.23</fastjson-version>
  3.         <spring.version>4.2.8.RELEASE</spring.version>
  4.         <spring.mongodb-version>1.9.5.RELEASE</spring.mongodb-version>
  5.         <mongo-version>3.3.0</mongo-version>
  6.     </properties>
  7.  
  8.     <dependencies>
  9.         <dependency>
  10.             <groupId>com.alibaba</groupId>
  11.             <artifactId>fastjson</artifactId>
  12.             <version>${fastjson-version}</version>
  13.         </dependency>
  14.  
  15.         <dependency>
  16.             <groupId>org.springframework</groupId>
  17.             <artifactId>spring-jdbc</artifactId>
  18.             <version>${spring.version}</version>
  19.         </dependency>
  20.         <!-- mongo -->
  21.         <dependency>
  22.             <groupId>org.springframework.data</groupId>
  23.             <artifactId>spring-data-mongodb</artifactId>
  24.             <version>${spring.mongodb-version}</version>
  25.             <exclusions>
  26.                 <exclusion>
  27.                     <groupId>org.springframework</groupId>
  28.                     <artifactId>*</artifactId>
  29.                 </exclusion>
  30.             </exclusions>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.mongodb</groupId>
  34.             <artifactId>mongo-java-driver</artifactId>
  35.             <version>${mongo-version}</version>
  36.         </dependency>
  37.     </dependencies>

 

 

4、增加spring配置文件

　　mongodb-config.properties

  1. #集群模式
  2. #mongodb.hosts=10.10.10.239:20000,10.10.10.224:20000,10.10.10.238:20000

  3. #单机模式
  4. mongodb.host=192.168.241.34
  5. mongodb.port=27017

    #数据库名称
  6. mongodb.dataname=DataGateway

 

 

　　spring-context-config.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
  6.           
  7.     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  8.         <property name="locations">
  9.             <list>
  10.                 <value>classpath:mongodb-config.properties</value>
  11.             </list>
  12.         </property>
  13.     </bean>
  14. </beans>

 

　　如果需要在项目中读取其他配置文件中的内容，可以将org.springframework.beans.factory.config.PropertyPlaceholderConfigurer 换成 com.cnsugar.common.config.SystemConfig，可以直接使用SystemConfig中的静态get方法读取配置文件。

　　

　　spring-context-mongodb.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:mongo="http://www.springframework.org/schema/data/mongo"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
  6.           http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd 
  7.           http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  8.     <mongo:mongo-client id="mongo" 
  9.         host="${mongodb.host}"
  10.         port="${mongodb.port}">
  11.         <mongo:client-options connections-per-host="10"
  12.             threads-allowed-to-block-for-connection-multiplier="5"
  13.             connect-timeout="30000" 
  14.             socket-timeout="60000" 
  15.             write-concern="SAFE" />
  16.     </mongo:mongo-client>
  17.     <bean id="mongoSupport" class="com.cnsugar.common.mongodb.MongoSupport">
  18.         <constructor-arg name="mongo" ref="mongo" />
  19.         <constructor-arg name="dbname" value="${mongodb.dataname}" />
  20.     </bean>
  21. </beans>  
  1. 　　mongo-client配置属性说明：
            id: MongoClient的名称，默认值：mongoClient
            port： 连到到MongoDB服务器的端口号，默认：27017
            host： 连接到MongoDB服务器的host，默认：localhost
            replica-set： 逗号分隔的的副本集集合，格式为host:port,host:port
            credentials: 用户身份认证逗号分隔的配置，格式：username:password@database，如果传递的认证包含逗号，则使用单引号括起来
    client-options配置属性说明：
            description: 描述
            min-connections-per-host： 客户端最小连接数
            connections-per-host： 客户端最大连接数，超过了将会被阻塞，默认100
            threads-allowed-to-block-for-connection-multiplier： 可被阻塞的线程数因子，默认值为5，如果connectionsPerHost配置为10，那么最多能阻塞50个线程，超过50个之后就会收到一个异常
            max-wait-time： 阻塞线程获取连接的最长等待时间，默认120000 ms
            max-connection-idle-time： 连接池连接最大空闲时间
            max-connection-life-time： 连接池连接的最大存活时间
            connect-timeout： 连接超时时间，默认值是0，就是不超时
            socket-timeout： socket超时时间，默认值是0，就是不超时
            socket-keep-alive： keep alive标志，默认false
            server-selection-timeout： 服务器查询超时时间，它定义驱动在抛出异常之前等待服务器查询成功，默认30s,单位milliseconds
            read-preference： MongoDB有5种ReadPreference模式：
                primary    主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。
                primaryPreferred   首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。
                secondary    从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。
                secondaryPreferred    首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。
                nearest    最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点。
            write-concern： WriteConcern的7种写入安全机制抛出异常的级别：
                NONE: 没有异常抛出
                NORMAL: 仅抛出网络错误异常，没有服务器错误异常，写入到网络就返回。
                SAFE: 抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
                MAJORITY: 抛出网络错误异常、服务器错误异常；并多数主服务器完成写操作。
                FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
                JOURNAL_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
                REPLICAS_SAFE: 抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。
            heartbeat-frequency： 驱动用来确保集群中服务器状态的心跳频率
            min-heartbeat-frequency： 驱动重新检查服务器状态最少等待时间
            heartbeat-connect-timeout： 集群心跳连接的超时时间
            heartbeat-socket-timeout： 集群心跳连接的socket超时时间
            ssl： 驱动是否使用ssl进行连接，默认是false
            ssl-socket-factory-ref： 用来进行ssl连接的SSLSocketFactory，如果配置为none，则使用SSLSocketFactory.getDefault()
      

二、使用示例

 　　测试之前先新建一个实体类TestEntity，增加@Collection注解指明对应mongodb中test表。mongodb在新增数据时会自动生成一个主键_id，如果要以_id为条件进行操作需要转成ObjectId对象才能使用，继承MongoEntity可以调用getObjectId()自动处理。

　　如果要控制字段的顺序，可在字段上添加@JSONField注解，用ordinal属性进行控制。如果表中的字段名与实体中的字段名不一致，可以添加name属性进行设置（如下面的代码，实体中testScore字段对应的数据库中的名字为test_score）。

  1. @Collection("test")
  2. public class TestEntity extends MongoEntity {
  3.     @JSONField(ordinal = 2)
  4.     private String name;
  6.     @JSONField(ordinal = 3)
  7.     private int status; 
  9.     @JSONField(name="test_score", ordinal = 4)
  10.     private Float testScore;

        private Date onTime = new Date();
  12.     @JSONField(serialize = false)
  13.     private String msgId;//不需要保存到数据库中的字段，serialize设为false
  15.     //setter、getter方法
  16. }

 

　　1、新增示例

　　使用save方法进行新增数据，批量新增用saveAll方法。

  1. 　　@org.junit.Test
  2.     public void testSave() {
  3.         //保存实体对象
  4.         TestEntity entity = new TestEntity();
  5.         entity.setName("sugar");
  6.         entity.setStatus(2);
  7.         entity.setTestScore(97.5f);
  8.         MongoUtils.save(entity);
  10.         //保存map对象，需要指定集合名称
  11.         Map<String, Object> map = new HashMap<>();
  12.         map.put("name", "zhangshan");
  13.         map.put("status", 2);
  14.         map.put("test_score", 97.5f);
  15.         MongoUtils.save(map, "test");
  17.         //保存Document对象，与map类似，需要指定集合名称
  18.         Document doc = new Document();
  19.         doc.put("name", "lisi");
  20.         doc.put("status", 2);
  21.         doc.put("test_score", 97.5f);
  22.         MongoUtils.save(doc, "test");
  23.     }

 　　使用Robomongo客户端查看执行后的结果如下：

　　 

 

　　2、更新

　　调用update开头的方法进行更新操作，更新条件使用Filters对象设置，更新内容使用Update对象设置；批量更新用updateAll方法。

  1. 　　@org.junit.Test
  2.     public void testUpdate() {
  3.         //更新java对象，必须要指定id，如果字段值为null，不会更新旧的数据
  4.         TestEntity entity = new TestEntity();
  5.         entity.setId("5c343804fdfad4230852e1f5");
  6.         entity.setName("sugar2");
  7.         entity.setStatus(1);
  8.         MongoUtils.update(entity);
  10.         //自定义更新的集合名、条件、字段
  11.         String collectionName = "test";
  12.         Bson filter = Filters.eq("_id", new ObjectId("5c343804fdfad4230852e1f6"));
  13.         Update update = new Update();
  14.         update.set("name", "zhangshan2");
  15.         update.inc("status", 1);//相当于status += 1
  16.         MongoUtils.update(collectionName, filter, update);
  17.     }

 　　更新后的结果如下图：

　　

　　

　　3、查询

　　调用find开头的方法进行查询，查询条件使用Filters对象设置；分页查询用findPage。

  1.     @org.junit.Test
  2.     public void testQuery() {
  3.         //查询出实体列表
  4.         List<TestEntity> ll = MongoUtils.findAll(TestEntity.class);
  5.         System.out.println(ll);
  7.         //查询Document对象列表，需要指定集合名
  8.         List<Document> list = MongoUtils.findAll("test");
  9.         System.out.println(list);
  11.         //用Filters生成条件查询，查询名字以2结尾的数据
  12.         List<TestEntity> ll2 = MongoUtils.find(TestEntity.class, Filters.regex("name", ".*2"));
  13.         System.out.println(ll2);
  15.         //分页查询，查询分数大于90的数据，查询第1页，每页10条
  16.         Page page = new Page(10, 1);
  17.         page.setClazz(TestEntity.class);//指定列表中的对象类型
  18.         page = MongoUtils.findPage(page, Filters.gt("test_score", 90));
  19.         System.out.println(page.getList());
  20.     }

 

 

　　4、删除

　　调用delete开头的方法进行删除操作，条件使用Filters对象设置

  1. 　　@org.junit.Test
  2.     public void testDelete() {
  3.         //根据ID删除
  4.         MongoUtils.deleteById("test", "587482defdfad41a9c94c9b6");
  6.         //删除一条数据
  7.         MongoUtils.deleteOne("test", Filters.eq("_id", new ObjectId("587482defdfad41a9c94c9b6")));
  9.         //批量删除
  10.         List<ObjectId> del = new ArrayList<ObjectId>();
  11.         del.add(new ObjectId("587482defdfad41a9c94c9b6"));
  12.         del.add(new ObjectId("58748350fdfad41a1c5fba14"));
  13.         del.add(new ObjectId("5874930ffdfad40df031215a"));
  14.         MongoUtils.deleteAll("test", Filters.in("_id", del));
  15.     }

 

 

　　5、数据聚合分析

　　使用count或mapReduce进行数据聚合分析；

  1. 　　@org.junit.Test
  2.     public void testCount() {
  3.         //统计test表数据总数
  4.         long count = MongoUtils.count("test");
  6.         //统计test表中status=2的数据总数
  7.         long count2 = MongoUtils.count("test", Filters.eq("status", 2));
  8.         
  9.         //根据status进行分组统计
  10.         List<Document> list = MongoUtils.count("test", new String[]{"status"});
  11.         System.out.println(list);
  13.         //自定义mapReduce函数进行数据分析，按天统计数据总数和status=1的总数
  14.         StringBuilder mapFunction = new StringBuilder("function(){emit(");
  15.         mapFunction.append("new Date(this.onTime).toLocaleDateString()");
  16.         mapFunction.append(",{count:1, send:this.status==1?1:0}");
  17.         mapFunction.append(");}");
  18.         StringBuilder reduceFunction = new StringBuilder("function(key, values){");
  19.         reduceFunction.append("var _total = 0, _send = 0;");
  20.         reduceFunction.append("values.forEach(function(val){_total += val.count; _send += val.send;});");
  21.         reduceFunction.append("return {count:_total, send:_send};");
  22.         reduceFunction.append("}");
  23.         List<Document> list2 = MongoUtils.mapReduce("test", mapFunction.toString(), reduceFunction.toString());
  24.         System.out.println(list2);
  25.     }

 

 

　　更多使用方法请参考：http://doc.tinnar.cn/javadoc/common-mongodb/com/cnsugar/common/mongodb/MongoUtils.html

 

版权声明：本文为cnsugar原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/cnsugar/p/10239201.html