springboot 学习之路 14(整合mongodb的Api操作)

springboot整合mongodb：

　　mongodb的安装和权限配置  请点击连接参考

mongodb集成　：

　　第一步：引如pom文件　

　　　　

　　第二步：配置文件配置mongodb路径：

　　　　

　

　　第三步：关于mongodb的api操作整理如下：（这是根据springboot1.5.13版本做的整理，springboot2.x系列对mongodb的变动较大，后期我会整理发布）

　　

package com.xf.water.springboot_mongdb;

import com.mongodb.*;
import com.xf.water.springboot_mongdb.entity.A;
import com.xf.water.springboot_mongdb.entity.MaxValue;
import com.xf.water.springboot_mongdb.entity.Sl6512014;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.GroupOperation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

/**
 * @author : huhy on 2018/7/31.
 * @Project_name:springboot_self_gitlab
 * @LOCAL:com.xf.water.springboot_mongdb
 * @description:mongodb的操作
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class MongodbUtilsTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public  void test(){
        Query query6 = new Query(Criteria.where("a").lte("9"));
        //设置安装某一个子段进行降序
        query6.with(new Sort(Sort.Direction.DESC,"a"));
        query6.maxScan(6).skip(0);
        List<A> a = mongoTemplate.find(query6, A.class, "a");
        for (A a1 : a) {
            System.out.println(a1);
        }
    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/7/31 17:03 
     * @Description: 获取当前mongodb中的使用库和当前数据库的链接测试
     */
    @Test
    public  void testConnAndMongodb(){
        /**
         * mongoTemplate.getDb()   获取当前数据库
         * mongoTemplate.dropCollection("a")   删除集合
         * 创建集合：  根据类型或者直接指定集合名创建    同时可是设置集合内部的参数信息，大小，文档类型等
         *      <T> DBCollection createCollection(Class<T> var1);
         *      <T> DBCollection createCollection(Class<T> var1, CollectionOptions var2);
         *      DBCollection createCollection(String var1);
         *      DBCollection createCollection(String var1, CollectionOptions var2);
         * 集合是否存在：
         *      <T> boolean collectionExists(Class<T> var1);   根据类型判断
         *      boolean collectionExists(String var1);          根据集合名判断
         * mongoTemplate.getCollectionNames();   获取所有集合名的列表
         */
        System.out.println(mongoTemplate.getDb());
        MongoClientURI mongoClientURI = new MongoClientURI("mongodb://yang:123456@localhost:27017/huhy");
        MongoClient mongoClient = new MongoClient(mongoClientURI);
        System.out.println(mongoClient);
        mongoTemplate.dropCollection("a");
        mongoTemplate.createCollection(A.class);
        mongoTemplate.collectionExists("a");
        mongoTemplate.getCollectionNames();
    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/8/1 14:02 
     * @Description: 测试mongoTemplate的CRUD操作
     */
    @Test
    public void testMongdbTemplateCrud(){
        /**
         * 添加文档主要介绍两种方式：
         *  mongoTemplate.insert("实体对象","集合名");   往集合插入数据的方式
         *  mongoTemplate.save(对象，集合名（可省略）);  参数必须是对象
         *      insert和save都适用
         *          不写集合名，默认对象类名作为集合名（如实体类是A  集合名是a）
         *          写集合名，则把数据写到对应集合下
         *          1.void save(Object var1);                传入对象，不传集合名
         *          2.void save(Object var1, String var2);   传入对象，传集合名
         *          3.void insert(Object var1);              传入对象，不传集合名
         *          4.void insert(Object var1, String var2); 传入对象，传集合名
         *          5.void insert(Collection<? extends Object> var1, Class<?> var2);  下面三个方法是批量插入的实现方法
         *          6.void insert(Collection<? extends Object> var1, String var2);
         *          7.void insertAll(Collection<? extends Object> var1);
         * 查询mongodb的操作：
         *      find 和findone方法都有两种实现
         *          1.List<T> find(Query var1, Class<T> var2)               不指定集合名
         *          2.List<T> find(Query var1, Class<T> var2, String var3)  指定集合名
         *          3.<T> T findOne(Query var1, Class<T> var2);             不指定集合名
         *          4.<T> T findOne(Query var1, Class<T> var2, String var3);指定集合名
         *           eg。
         *              maxvalue在数据库中就对应一个集合，可以不指定集合名直接查询
         *              Sl6512014 在数据对应很多集合  必须知道集合名才能查询出数据
         *
         *        findall
         *              1.<T> List<T> findAll(Class<T> var1);   根据类型查询所有
         *              2.<T> List<T> findAll(Class<T> var1, String var2);  查询集合下的该类型数据
         *
         *       findById:
         *              <T> T findById(Object var1, Class<T> var2);                 var1  是mongodb的_id子段值
         *              <T> T findById(Object var1, Class<T> var2, String var3);    指定集合名
         *  更新操作：
         *         updateFirst  更新符合条件的第一条   updateMulti  更新多个，符合条件都会更改
         *           //修改第一条符合条件数据
         *           1.WriteResult updateFirst(Query var1, Update var2, Class<?> var3);                 指定类型
         *           2.WriteResult updateFirst(Query var1, Update var2, String var3);                   更新操作指定集合名
         *           3.WriteResult updateFirst(Query var1, Update var2, Class<?> var3, String var4);    详细指定类型和集合名
         *           //批量修改
         *           4.WriteResult updateMulti(Query var1, Update var2, Class<?> var3);                 指定类型
         *           5.WriteResult updateMulti(Query var1, Update var2, String var3);                   指定集合名
         *           6.WriteResult updateMulti(Query var1, Update var2, Class<?> var3, String var4);    详细指定类型和集合名
         *           //同updateFirst
         *           7.WriteResult upsert(Query var1, Update var2, Class<?> var3);
         *           8.WriteResult upsert(Query var1, Update var2, String var3);
         *           9.WriteResult upsert(Query var1, Update var2, Class<?> var3, String var4);
         * 删除操作：
         *           1.WriteResult remove(Object var1);
         *           2.WriteResult remove(Object var1, String var2);
         *           3.WriteResult remove(Query var1, Class<?> var2);                根据条件删除
         *           4.WriteResult remove(Query var1, Class<?> var2, String var3);   详细指定类型和集合名进行删除
         *           5.WriteResult remove(Query var1, String var2);                 指定集合名进行删除
         *  其他一些操作：简单介绍：
         *          //查询出后删除
         *            <T> List<T> findAllAndRemove(Query var1, String var2);    指定集合名
                      <T> List<T> findAllAndRemove(Query var1, Class<T> var2);   指定类型
                      <T> List<T> findAllAndRemove(Query var1, Class<T> var2, String var3); 在集合下查询删除的类型数据
                    //查处后修改
                     <T> T findAndModify(Query var1, Update var2, Class<T> var3);    指定修改类型
                     <T> T findAndModify(Query var1, Update var2, Class<T> var3, String var4);  在集合下修改的数据类型
                     <T> T findAndModify(Query var1, Update var2, FindAndModifyOptions var3, Class<T> var4);
                     <T> T findAndModify(Query var1, Update var2, FindAndModifyOptions var3, Class<T> var4, String var5);
                     <T> T findAndRemove(Query var1, Class<T> var2);
                     <T> T findAndRemove(Query var1, Class<T> var2, String var3);
                    //判断是否存在
                     boolean exists(Query var1, String var2);
                     boolean exists(Query var1, Class<?> var2);
                     boolean exists(Query var1, Class<?> var2, String var3);
         */
        //insert操作
        //mongoTemplate.save(new A("1","2","3"));
        //mongoTemplate.insert(new A("1","2","3"));
        Query query = new Query(Criteria.where("a").is("11"));
        //find操作
        /*Sl6512014 sl6512014_1 = mongoTemplate.findOne(query, Sl6512014.class);
        Sl6512014 sl6512014_2 = mongoTemplate.findOne(query, Sl6512014.class,"1");
        List<Sl6512014> sl6512014_3 = mongoTemplate.find(query, Sl6512014.class);
        List<Sl6512014> sl6512014_4 = mongoTemplate.find(query, Sl6512014.class,"1");
        System.out.println(sl6512014_1);*/
        //update操作
       /* Update update= new Update();
        A a = mongoTemplate.findOne(query, A.class);
        System.out.println(a);
        update.set("a","1");*/
        //更新两种方式
        //mongoTemplate.updateFirst(query,update,A.class);
        //mongoTemplate.updateFirst(query,update,"a");
       // mongoTemplate.updateMulti(query,update,"a");
        //mongoTemplate.upsert(query,update,A.class);
        //mongoTemplate.remove(query,"a");

        //测试一些其他方法
        System.out.println(mongoTemplate.findById("5b615babec6032159050d879",A.class));

    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/7/31 17:17 
     * @Description: DBCollection下的简单使用
     */
    @Test
    public void testDBCollection(){
        /**
         * mongoTemplate.getCollection("error")   获取集合  一般获取之前判断是否存在
         * collection.getCount()    集合下又有多少数据
         * collection.find().next()  获取集合的第一条符合要求的数据
         * collection.getFullName()  返回当前库+集合的名字组合
         * collection.getName()   返回集合名
         * collection.rename("fail")   修改集合名
         * collection.distinct("ut")    返回值是list集合，返回的是ut的集合，并进行去重
         *  collection.createIndex("huhy")   在error集合上创建一个index 名字是huhy_1   不存在就创建

         */
        DBCollection collection = mongoTemplate.getCollection("error");
        //这个集合下的数据量
        System.out.println(collection.getCount());
        //返回值是list集合，返回的是ut的集合，并进行去重
        List serial = collection.distinct("ut");
        System.out.println(serial);
        DBCursor dbObjects = collection.find();
        //next只会查询出符合条件的第一个数据
        System.out.println(dbObjects.next());
        //返回的库名+集合名
        String fullName = collection.getFullName();
        System.out.println(fullName);
        //返回的集合名
        System.out.println(collection.getName());
        System.out.println(collection.getHintFields());
        long count = collection.count();
        System.out.println(count);

       // 有四种创建索引的方式，自己看api
        collection.createIndex("yang");


    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/8/1 9:40 
     * @Description:Query的用法
     *     maxvalue在数据库中就对应一个集合，可以不指定集合名直接查询
     *     Sl6512014 在数据对应很多集合  必须知道集合名才能查询出数据
     */
    @Test
    public  void testMongodbQuery(){
        /**
         * is相当于等于
         * in相当于sql中的in
         * ne相当于不等于
         * orOperator接受多个条件，组成or逻辑  addOperator同理
         * Criteria.where("author").is("mongodb")  author = mongodb的数据
         * Criteria.where("serial").lte(500).and("st").is("1703230781").and("c").in("5.7")   多条件的查询
         * Criteria.where("st").exists(true)   判断这个字段存在
         * Criteria.where("serial").ne(1)    不等于1的数据
         * Criteria.where("serial").nin(1)    nin 不在这个范围中
         * Criteria.where("serial").is(3).orOperator().is().andOperator() 追加or条件或者and条件
         * Criteria.where("a").regex("1")   模糊查询   可以用正则表达式
         * query6.with(new Sort(Sort.Direction.DESC,"a"));  按照a字段把结果降序
         * query6.skip(n);    跳过结果集的第n个   超过总条数就是啥都不输出   n<=0  时 查询到结束不跳过
         * query6.skip(n).limit(m)   跳过n条并显示m条记录
         *  query6.addCriteria(Criteria.where("b").is("11"));   再加条件  查询子段不能是上一个query查询过的子段
         *  query6.maxScan(6).skip(-2);   先截取六条数据再跳过两条
         * */
        //通过整个mongodb中查询author = mongodb的数据，返回的一个对象
        Query query = new Query(Criteria.where("author").is("mongodb"));
        List<MaxValue> maxValues = mongoTemplate.find(query, MaxValue.class);
        System.out.println(maxValues.size());

        //Sl6512014在数据库中对应很多集合，在查询中要指定集合名
        Query query1 = new Query(Criteria.where("serial").is(3));
        List<Sl6512014> sl6512014s = mongoTemplate.find(query1, Sl6512014.class,"1");
        System.out.println(sl6512014s.size());

        // lte -- <=    lt  ---  <    gt ---  >    lgt----  >=
        Query query2 = new Query(Criteria.where("serial").lte(1500));
        List<Sl6512014> sl6512014s2 = mongoTemplate.find(query2, Sl6512014.class,"1703230781");
        System.out.println(sl6512014s2.size());

        //多条件的查询  and 增加条件，in 判断符合条件的数据
        Query query3 = new Query(Criteria.where("serial").lte(500).and("st").is("1703230781").and("c").in("5.7"));
        List<Sl6512014> sl6512014s3 = mongoTemplate.find(query3, Sl6512014.class,"1703230781");
        System.out.println(sl6512014s3.size());

        Query query4 = new Query(Criteria.where("st").exists(true));
        List<Sl6512014> sl6512014s1 = mongoTemplate.find(query4, Sl6512014.class, "1703230781");
        System.out.println(sl6512014s1.size());
        //Criteria.where("serial").is(3).orOperator().is().andOperator()
        Query query5 = new Query(Criteria.where("serial").is(3));
        List<Sl6512014> sl6512014s5 = mongoTemplate.find(query5, Sl6512014.class, "1");
        System.out.println(sl6512014s5.size());
        //regex还可以用正则
        Query query6 = new Query(Criteria.where("a").lte("9"));
        //设置安装某一个子段进行降序
        query6.with(new Sort(Sort.Direction.DESC,"a"));
        query6.skip(3);
        List<A> a = mongoTemplate.find(query6, A.class, "a");
        for (A a1 : a) {
            System.out.println(a1);
        }
    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/8/1 13:34 
     * @Description: mongodb的高级用法，分组等操作
     */
    @Test
    public void testMongodbGroup(){
        Criteria criteria = Criteria.where("a").in("1","2","3","4");
        GroupOperation groupOperation = Aggregation.group("a").last("a").as("a").last("b").as("b").last("c").as("c");
        Aggregation agg = Aggregation.newAggregation(A.class,Aggregation.match(criteria),groupOperation);
        AggregationResults<A> a = mongoTemplate.aggregate(agg, "a", A.class);
        List<A> mappedResults = a.getMappedResults();
        for (A mappedResult : mappedResults) {
            System.out.println(mappedResult);
        }
    }
    /**
     * @author huhy
     * @ClassName:MongodbUtilsTest
     * @date 2018/8/1 17:22
     * @Description: 分组
     */
    public  List<Sl6512014> selectDataByGroupFildes(String collectionName,String... fildes){
        Aggregation agg = Aggregation.newAggregation(
                // 第一步：挑选所需的字段，类似select *，*所代表的字段内容
                Aggregation.project("_id", "serial", "ut", "st", "tt", "pj",
                        "pt", "va", "vt", "z","zt","sbl1","turb","stt"),
                // 第二步：sql where 语句筛选符合条件的记录
               /* Aggregation.match(
                        Criteria.where("companyName").is(companyName).and("addedDate").gte(startTime).lte(endTime)),*/
                // 第三步：分组条件，设置分组字段
                Aggregation.group(fildes)
                        .count().as("allCount")// 增加COUNT为分组后输出的字段
                        .last("_id").as("id").last("serial").as("serial").last("ut").as("ut")
                        .last("st").as("st").last("tt").as("tt").last("pj").as("pj")
                        .last("pt").as("pt").last("va").as("va")
                        .last("vt").as("vt").last("z").as("z")
                        .last("zt").as("zt").last("sbl1").as("sbl1")
                        .last("turb").as("turb").last("stt").as("stt"),
                // 第四步：重新挑选字段
                Aggregation.project("id", "serial", "ut", "st", "tt", "pj",
                        "pt", "va", "vt", "z","zt","sbl1","turb","stt")
        );
        AggregationResults<Sl6512014> results = mongoTemplate.aggregate(
                agg, collectionName, Sl6512014.class);
        List<Sl6512014> mappedResults = results.getMappedResults();
        return mappedResults;
    }


}