MongoDB的常用指令、Java客户端访问和Spring集成方法

MongoDB的常用指令集

创建数据库

创建数据库

use DBName

如果数据库不存在，则创建成功，否则切换该数据库

展示数据库

show DBName

生成集合并插入数据

db.mycollection.insert({"name":"aab"})

删除数据库

删除数据库

切换数据库后

db.dropDatabase()

创建集合

db.createCollection(name,option)
参数说明：
name：要创建的集合名称
option：可选参数，指定有关内存大小及索引的选择
option如下选择：

字段	类型	描述
capped	bool	（可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最
大值时，它会自动覆盖最早的文档。 当该值为 true 时，必须指定 size 参数。
autoIndexId	bool	（可选）如为 true，自动在 _id 字段创建索引。默认为 false。
size	数值	（可选）为固定集合指定一个最大值（以字节计）。 如果 capped 为 true，也需要指
定该字段。
max	数值	（可选）指定固定集合中包含文档的最大数量。

展示集合

show collections

删除集合

db.collectionName.drop

插入数据

db.COLLECTION_NAME.insert(document)

删除文档

db.collection.remove( 
<query>, 
{ 
justOne: <boolean>, 
writeConcern: <document> 
} )

参数说明：
query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除
所有匹配条件的文档。
writeConcern :（可选）抛出异常的级别。
如：

db.mycollecion.remove({'title':'aaa'})

db.mycollection.remove(DELETION_CRITERIA,1)

删除所有数据，可以使用以下方法

db.mycollection.remove({})

查询文档

db.collection.find(query, projection)

参数说明：
query ：可选，使用查询操作符指定查询条件
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认
省略）。

展示所有文档

>db.mycollection.find().pretty()

limit方法

>db.COLLECTION_NAME.find().limit(NUMBER)

NUMBER表示几条展示

skip方法

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

skip表示跳过几条，从0开始算起

文档排序

db.COLLECTION_NAME.find().sort({KEY:1})

KEY为待排序字段， 1为升序，-1为降序
如：

>db.mycollection.find({},{"title":1,_id:0}).sort({"likes":-1})

索引操作

创建索引

>db.collection.createIndex(keys, options)

Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。

createIndex() 方法中你也可以设置使用多个字段创建索引（关系型数据库中称作复合索引）。
如：

>db.col.createIndex({"title":1,"description":-1})

查看集合索引

db.col.getIndexes()

查看集合索引大小

db.col.totalIndexSize()

删除集合所有索引

db.col.dropIndexes()

删除集合指定索引

db.col.dropIndex("索引名称")

聚合索引

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

表达式	SQL操作	描述
$group	group by	分组
$sum	count()、sum()	计算总和。
$avg	avg()	计算平均值
$min	min()	获取集合中所有文档对应值得最小值。
$max	max()	获取集合中所有文档对应值得最大值。
$match	where、having	查询条件
$sort	order by	排序
$limit	limit	取条数
$project	select	选择
$lookup （v3.2 新增）	join	连接

$group

按城市分组对年龄进行求和

> db.LIST1.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}])

$sum

按照城市分组对年龄进行求和

> db.LIST1.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}])

按照城市分组求总个数

> db.LIST1.aggregate([{$group : {_id : "$city", sc : {$sum : 1}}}])

$avg

按照城市分组对年龄进行求平均

> db.LIST1.aggregate([{$group : {_id : "$city", avg : {$avg : "$age"}}}])

$min

按照城市分组获得每组最小年龄

> db.LIST1.aggregate([{$group : {_id : "$city", min : {$min : "$age"}}}])

$max

> db.LIST1.aggregate([{$group : {_id : "$city", max : {$max : "$age"}}}])

$match

取年龄大于3并且小于10的记录再按照城市分组求个数和

> db.LIST1.aggregate( [{ $match : { age : { $gt : 3, $lte : 10 } } },{ $group: { _id: "$city",count: { $sum: 1 } } }] ); { "_id" : "TJ", "count" : 4 } { "_id" : "BJ", "count" : 3 }

$sort

> db.LIST1.aggregate( [{ $sort:{ age :-1}}] )

$limit

取前5条数据

> db.LIST1.aggregate( { $limit:5} )

$project

不显示_id字段 显示 name和city字段

> db.LIST1.aggregate( [ {$project :{_id:0,name:1,city:1} } ] )

$lookup

建立新的集合

> db.sex.find() { "_id" : 1, "name" : "male" } { "_id" : 2, "name" : "female" }

给LIST1新增字段sex

> db.LIST1.update({},{$set:{sex:1}},{multi:1}) WriteResult({ "nMatched" : 10, "nUpserted" : 0, "nModified" : 10 }) > db.LIST1.find() { "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1 } { "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1 }

将两个文档关联

> db.LIST1.aggregate([{$lookup:{from:"sex",localField:"sex",foreignField:"_id",as:"docs"}}, {$project:{"_id":0}}]) { "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } { "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] }

LIST1中的数据字段sex关联sex中的数据字段_id，在LIST1中显示sex对应的中文，显示在docs中，不显示LIST1中的
__id
在这里：
from：需要关联的表【sex】
localField: 【LIST1】表需要关联的键。
foreignField：【sex】的matching key 主键
as：对应的外键集合的数据，【因为是一对多的】

MongoDB java客户端访问

配置pom文件，添加maven依赖

		    <dependency>
                <groupId>org.mongodb</groupId>
                <artifactId>mongo-java-driver</artifactId>
                <version>3.10.1</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
                <scope>test</scope>
            </dependency>

客户端访问测试用例如下

package cilent;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import com.mongodb.client.model.Filters;
import org.bson.Document;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

/**
 * 官方的java创建使用
 */
public class MongoDBDemo {

    private MongoClient client;
    private MongoCredential credential;

    @Before
    public void init(){
        //        没有鉴权
        //        client = new MongoClient("127.0.0.1",27017);
        //存在鉴权
        credential = MongoCredential.createCredential("用户名","查询的库表","密码".toCharArray());
        ServerAddress serverAddress = new ServerAddress("IP",端口);
        client = new MongoClient(serverAddress, Arrays.asList(credential));

    }

    @Test
    public void connectDB(){
        MongoDatabase database = client.getDatabase("test");
        System.out.println("connect successiful-------"+database.getName());
    }

    //创建集合
    @Test
    public void createCollection(){
        MongoDatabase database = client.getDatabase("test");
        System.out.println("connect successful");
        database.createCollection("mycollection");
        System.out.println("集合创建成功");
    }

    //获取集合
    @Test
    public void getCollections(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("test");
        System.out.println("获取集合成功："+collection.getNamespace());
        MongoIterable<String> collectionNames = database.listCollectionNames();
        for(String string : collectionNames){
            System.out.println(string);
        }
    }

    //创建文档
    @Test
    public void insertDocument(){
        MongoDatabase database = client.getDatabase("test");
        System.out.println("链接成功");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        System.out.println("获取集合成功："+collection.getNamespace());
        Document document = new Document("name","wangtong");
        document.append("age",30);
        document.append("sex","男");
        Document document2 = new Document("name","最帅金老板");
        document2.append("age",30);
        document2.append("sex","男");
        Document document3 = new Document("name","美女小张");
        document3.append("age",26);
        document3.append("sex","女");

        List<Document> documents = new ArrayList<Document>();
        documents.add(document);
        documents.add(document2);
        documents.add(document3);

        collection.insertMany(documents);
        System.out.println("文档插入成功");
    }

    //查询文档
    @Test
    public void findDocuments(){
        MongoDatabase database = client.getDatabase("test");
        System.out.println("connect successful");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        System.out.println("获取集合成功：" + collection.getNamespace());

        FindIterable<Document> iterable = collection.find();
        for(Document document : iterable){
            System.out.println(document.toJson());
        }
    }

    //修改文档
    @Test
    public void updateDocuments(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection= database.getCollection("mycollection");

        collection.updateMany(Filters.eq("age",24),new Document("$set",new Document("age",20)));

        FindIterable<Document> iterable = collection.find();
        for(Document document : iterable){
            System.out.println(document.toJson());
        }
    }

    //删除文档
    @Test
    public void deleteDocuments(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        collection.deleteMany(Filters.eq("name","最帅金老板"));

        FindIterable<Document> iterable = collection.find();
        for(Document document : iterable){
            System.out.println(document.toJson());
        }
    }

    //查询
    @Test
    public void testQuery1(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        //获取第一条记录
        Document document = collection.find().first();

        //根据key获得数据
        System.out.println(document.get("name"));

        //查询指定字段
        Document doc = new Document();
        doc.append("_id", 0); //0是不包含字段
        doc.append("name",1); //1是包含字段

        FindIterable<Document> iterable = collection.find().projection(doc);
        for(Document d : iterable){
            System.out.println(d);
        }
    }

    //排序
    @Test
    public void testQuery2(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        //按指定字段排序
        Document doc = new Document();
        //按年龄倒序
        doc.append("age",-1);
        FindIterable<Document> iterable = collection.find().sort(doc);
        for(Document document : iterable){
            System.out.println(document.toJson());
        }
    }

    @Test
    public void testFilters1(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> docu = database.getCollection("mycollection");
        FindIterable<Document> findIterable = docu.find(Filters.eq("name","wt"));
        for (Document d : findIterable){
            System.out.println(d.toJson());
        }
    }

    @Test
    //大于29的记录
    public void testFilters2(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> docu = database.getCollection("mycollection");
        FindIterable<Document> findIterable = docu.find(Filters.gt("age",29));
        for (Document document : findIterable){
            System.out.println(document.toJson());
        }
    }

    @Test
    //多个过滤器
    public void testFilter3(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection collection = database.getCollection("mycollection");
        FindIterable<Document> findIterable = collection.find(Filters.or(Filters.gt("age",29), Filters.eq("name","最帅金老板")));
        for(Document document : findIterable){
            System.out.println(document.toJson());
        }
    }

    @Test
    //模糊查询
    public void testLike(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection collection = database.getCollection("mycollection");
        //采用正则表达式匹配 包含王统
        Pattern pattern = Pattern.compile("^.*美女小张.*$",Pattern.CASE_INSENSITIVE);
        BasicDBObject query = new BasicDBObject();
        query.put("name",pattern);
        FindIterable<Document> findIterable = collection.find(query);
        for(Document document : findIterable){
            System.out.println(document.toJson());
        }
    }

    //分页查询
    @Test
    public void testPage(){
        MongoDatabase database = client.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("mycollection");
        //利用正则 模糊匹配
        Pattern pattern = Pattern.compile("^.*美女小张.*$",Pattern.CASE_INSENSITIVE);
        //查询条件
        BasicDBObject query = new BasicDBObject();
        query.put("name",pattern);
        //按年龄排序
        BasicDBObject sort = new BasicDBObject();
        sort.put("age",-1);
        //获取总条数
        System.out.println(collection.countDocuments()+"条记录");

        /**
         * 取出第1条
         * query: 查询条件
         * sort: 排序
         * skip: 跳过数，从0开始
         * limit：取几条
         */
        FindIterable<Document> findIterable = collection.find(query).sort(sort).skip(0).limit(1);
        for(Document document : findIterable){
            System.out.println(document.toJson());
        }
    }
}

Spring集成

Spring依赖导入

<dependencies>
            <dependency>
                <groupId>org.mongodb</groupId>
                <artifactId>mongo-java-driver</artifactId>
                <version>3.10.1</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
                <scope>test</scope>
            </dependency>


            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-mongodb</artifactId>
                <version>2.1.1.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
        </dependencies>

Spring的xml文件配置导入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/data/mongo
       http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">
    <!-- 加载mongodb的配置属性文件 -->
    <context:property-placeholder location="classpath:mongodb.properties" />
    <!-- 扫描持久层 -->
    <context:component-scan base-package="com.springdata" />
    <!-- 配置mongodb客户端连接服务器的相关信息 -->
    
    <!--credentials配置权限，如果没有开启auth，可以不用添加-->
    <mongo:mongo-client host="${mongo.host}" port="${mongo.port}" credentials="${mongo.user}:${mongo.pwd}@${mongo.defaultDBName}" id="mongo">
        <mongo:client-options write-concern="${mongo.writeconcern}"
                              connect-timeout="${mongo.connectTimeout}"
                              socket-keep-alive="${mongo.socketKeepAlive}" />
    </mongo:mongo-client>
    <!-- mongo:db-factory dbname="database" mongo-ref="mongo" / -->
    <!--这里的dbname就是自己的数据库/collection的名字 -->
    <mongo:db-factory id="mongoDbFactory" dbname="test" mongo-ref="mongo" />
    <!-- 配置mongodb的模板类：MongoTemplate -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
    </bean>
</beans>

属性文件

mongo.host=xxxxxxx
mongo.port=27017 
mongo.connectionsPerHost=8 
mongo.threadsAllowedToBlockForConnectionMultiplier=4 
#连接超时时间
mongo.connectTimeout=1000 
#等待时间
mongo.maxWaitTime=1500 
mongo.autoConnectRetry=true
mongo.socketKeepAlive=true 
#socket超时时间
mongo.socketTimeout=1500 
mongo.slaveOK=true 
mongo.writeconcern=safe
mongo.user=root
mongo.pwd=password
mongo.defaultDBName=test

创建PO类

package com.springdata.po;

public class User {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

创建接口和实现类

package com.springdata.service;

import com.mongodb.client.result.UpdateResult;
import com.springdata.po.User;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;

public interface UserDao {

    /**
     * 根据条件查询
     * @param query
     * @return
     */
    public List<User> find(Query query);

    /**
     * 根据条件查询一个
     * @param query
     * @return
     */
    public User findOne(Query query);

    /**
     * 插入
     * @param entity
     */
    public void save(User entity);

    /**
     * 根据条件更新
     * @param query
     * @param update
     * @return
     */
    public UpdateResult update(Query query, Update update);

    /**
     * 获得所有类型记录，并指定了集合名
     * @param collectionName
     * @return
     */
    public List<User> findAll(String collectionName);

    /**
     * 获取条数
     * @param query
     * @param collectionName
     * @return
     */
    public long count(Query query,String collectionName);

    /**
     * 删除对象
     */
    public void remove(Query query,String collectionName);
}

在这里插入代码片package com.springdata.service;

import com.mongodb.client.result.UpdateResult;
import com.springdata.po.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class UserDaoImpl implements UserDao{

    @Autowired
    private MongoTemplate mongoTemplate;

    public List<User> find(Query query) {
        return mongoTemplate.find(query,User.class);
    }

    public User findOne(Query query) {
        return mongoTemplate.findOne(query,User.class);
    }

    public void save(User entity) {
        mongoTemplate.save(entity);
    }

    public UpdateResult update(Query query, Update update) {
        return mongoTemplate.updateMulti(query,update,User.class);
    }

    public List<User> findAll(String collectionName) {
        return mongoTemplate.findAll(User.class,collectionName);
    }

    public long count(Query query, String collectionName) {
        return mongoTemplate.count(query,collectionName);
    }

    public void remove(Query query,String collectionName) {
        mongoTemplate.remove(query,collectionName);
    }
}

测试类

package springdata;

import com.mongodb.client.result.UpdateResult;
import com.springdata.po.User;
import com.springdata.service.UserDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class test {
    @Autowired
    private UserDao userDao;

    @Test
    public void test1(){
        User user = new User();
        user.setName("罗家有金矿的男人");
        user.setAge(26);
        user.setSex("男");
        userDao.save(user);

        User user1 = new User();
        user1.setName("美女小张");
        user1.setAge(25);
        user1.setSex("女");
        userDao.save(user1);

        User user2 = new User();
        user2.setName("土豪金老板");
        user2.setAge(29);
        user2.setSex("男");
        userDao.save(user2);

        User user3 = new User();
        user3.setName("余发财");
        user3.setAge(33);
        user3.setSex("男");
        userDao.save(user3);

        User user4 = new User();
        user4.setName("梦中有君子");
        user4.setAge(30);
        user4.setSex("男");
        userDao.save(user4);

        User user5 = new User();
        user5.setName("马多金");
        user5.setAge(32);
        user5.setSex("男");
        userDao.save(user5);

        System.out.println("存储成功");
    }

    @Test
    public void test2(){
        Query query = new Query(Criteria.where("name").is("土豪金老板"));
        List<User> list = userDao.find(query);
        for(User user : list){
            System.out.println(user);
        }
        System.out.println("=====================");

        List<User> list1 = userDao.find(new Query());
        for(User user : list1){
            System.out.println(user);
        }

        System.out.println("=====================");
        User user = userDao.findOne(query);
        System.out.println(user);
    }

    @Test
    public void test3(){
        Query query = new Query(Criteria.where("name").is("土豪金老板"));
        Update update = new Update();
        update.set("age","30");
        UpdateResult updateResult = userDao.update(query,update);
        System.out.println(updateResult.getModifiedCount());
    }

    @Test
    public void test4(){
        List<User> findAll = userDao.findAll("user");
        for(User user : findAll){
            System.out.println(user);
        }
    }

    @Test
    public void test5(){
        Query query = new Query();
        long count = userDao.count(query,"user");
        System.out.println("总条数:"+count);
    }

    @Test
    public void test6(){
        Query query = new Query(Criteria.where("name").is("美女小张"));
        userDao.remove(query,"user");
    }

}