springboot整合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;
} }