Spring Boot 集成MongoDB
1、在POM中添加mongoDB支持
org.springframework.boot
spring-boot-starter-data-mongodb
org.springframework.data
spring-data-mongodb
2、在application.porperties 配置文件中配置mongodb的连接信息
#mongo
spring.data.mongodb.database= #数据库
spring.data.mongodb.host=#地址
spring.data.mongodb.username=#用户名
spring.data.mongodb.password=#密码
spring.data.mongodb.port=#端口
3、创建Mongodb工具类
package com.ydrt.cp.mapper.mongo;
import com.ydrt.cp.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
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 java.lang.reflect.ParameterizedType;
import java.util.List;
/**
* Stone.Cai
* 2020年6月2日13:46:09
* 添加
* mongo 工具
* @param
*/
public class MongoBaseDao {
/**
* Stone.Cai
* 2020年6月3日17:08:47
* 添加
* 注入工具
*/
@Autowired
protected MongoTemplate mongoTemplate;
/**
* Stone.Cai
* 2020年6月2日13:54:39
* 添加
* 根据查询条件查询信息
* @param query
* @return
*/
public List find(Query query) {
return mongoTemplate.find(query, this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日13:56:01
* 添加
* 指定表查询数据
* @param query
* @param collectionName
* @return
*/
public List find(Query query, String collectionName) {
return mongoTemplate.find(query, this.getEntityClass(), collectionName);
}
/**
* Stone.Cai
* 2020年6月2日13:56:59
* 添加
* 通过唯一条件查询一条数据
* @param query
* @return
*/
public T findOne(Query query) {
return mongoTemplate.findOne(query, this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日13:57:34
* 添加
* 根据唯一条件指定表查询一条数据
* @param query
* @param collectionName
* @return
*/
public T findOne(Query query, String collectionName) {
return mongoTemplate.findOne(query, this.getEntityClass(), collectionName);
}
/**
* Stone.Cai
* 2020年6月2日13:58:50
* 添加
* 通过条件更新数据
* @param query
* @param update
*/
public void update(Query query, Update update) {
mongoTemplate.findAndModify(query, update, this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日13:59:51
* 添加
* 根据查询条件指定表更新数据
* @param query
* @param update
* @param collectionName
*/
public void update(Query query, Update update, String collectionName) {
mongoTemplate.findAndModify(query, update, this.getEntityClass(), collectionName);
}
/**
* Stone.Cai
* 2020年6月2日14:00:38
* 添加
* 根据数据id 这里是指的MONGO自己生成的ID
* @param id
* @param collectionName
*/
public void removeById(String id, String collectionName){
Query query = new Query();
query.addCriteria(Criteria.where("_id").is(id));
mongoTemplate.remove(query, collectionName);
}
/**
* Stone.Cai
* 2020年6月2日14:29:32
* 添加
* 根据_id删除
* @param id
*/
public void removeById(String id){
Query query = new Query();
query.addCriteria(Criteria.where("_id").is(id));
mongoTemplate.remove(query);
}
/**
* Stone.Cai
* 2020年6月2日14:31:01
* 添加
* 根据条件进行删除
* @param query
*/
public void removeByQuery(Query query){
mongoTemplate.findAndRemove(query,this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日14:31:57
* 添加
* 根据条件进行删除 并指定表
* @param query
* @param collectionName
*/
public void removeByQuery(Query query, String collectionName){
mongoTemplate.findAndRemove(query,this.getEntityClass(),collectionName);
}
/**
* Stone.Cai
* 2020年6月2日13:53:26
* 添加
* 获取当前要操作的实体类
* @return
*/
public Class getEntityClass(){
Class tClass = (Class)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
return tClass;
}
/**
* Stone.Cai
* 2020年6月2日14:01:36
* 添加
* 保存一个对象到MONGO
* @param entity
* @return
*/
public T save(T entity) {
mongoTemplate.save(entity);
return entity;
}
/**
* Stone.Cai
* 2020年6月2日14:02:07
* 添加
* 保存一个对象并指定表保存对象到MONGO
* @param entity
* @param collectionName
* @return
*/
public T save(T entity, String collectionName) {
mongoTemplate.insert(entity, collectionName);
return entity;
}
/**
* Stone.Cai
* 2020年6月2日14:03:03
* 添加
* 根据ID查询 这里ID指的是mongo自己生成的id
* @param id
* @return
*/
public T findById(String id) {
return mongoTemplate.findById(id, this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日14:04:26
* 添加
* 根据ID查询 并指定表 这里ID指的是mongo自己生成的id
* @param id
* @param collectionName
* @return
*/
public T findById(String id, String collectionName) {
return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
}
/**
* Stone.Cai
* 2020年6月2日14:05:19
* 添加
* 根据条件查询数据条数
* @param query
* @return
*/
public long count(Query query){
return mongoTemplate.count(query, this.getEntityClass());
}
/**
* Stone.Cai
* 2020年6月2日14:05:19
* 添加
* 根据条件查询数据条数指定表
* @param query
* @return
*/
public long count(Query query, String collectionName){
return mongoTemplate.count(query, this.getEntityClass(), collectionName);
}
/**
* Stone.Cai
* 2020年6月2日14:08:17
* 添加
* 分页查询
* @param page
* @param query
* @return
*/
public PageBean findPage(PageBean page, Query query){
long count = this.count(query);
page.setResourceSize(count);
int pageNumber = page.getCurrentPage();
int pageSize = page.getPageSize();
query.skip((pageNumber - 1) * pageSize).limit(pageSize);
List rows = this.find(query);
page.setData(rows);
return page;
}
/**
* Stone.Cai
* 2020年6月2日14:08:17
* 添加
* 分页查询 区分表名
* @param page
* @param query
* @return
*/
public PageBean findPage(PageBean page, Query query, String collectionName){
long count = this.count(query);
page.setResourceSize(count);
int pageNumber = page.getCurrentPage();
int pageSize = page.getPageSize();
query.skip((pageNumber - 1) * pageSize).limit(pageSize);
List rows = this.find(query,collectionName);
page.setData(rows);
return page;
}
}
4、有了工具类就可以操作MongoDB了,我们这边写一个服务来继承这个工具在服务里写我们的逻辑。在这之前我们还是要和hibernate一样配置一下我们的实体类
实体类USER Class 和Base user 和Class 是一对一关系 Class 和user 是一对多的关系
package com.ydrt.cp.bean.mongo;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.util.Date;
/**
* Stone.Cai
* 2020年6月2日09:53:32
* 添加
* 用户数据
*/
@Document(collection = "user_info") //指定表
public class MongoUsers extends MongoBase {
@Indexed //这个表示在这个字段上创建索引
@Field("userId")
private Long userId;
@Field("userName")
private String username;
@Field("password")
private String password;
@Field("del")
private Boolean del;
@Field("userInfo") //这个是内置了一个对象和其他字段是一样的
private MongoUserInfo userInfo;
@DBRef //这个表示这个类引用了下面这个类的这样写应该是一对一吧
private MongoClassInfo classInfo;
private Date createDate=new Date();
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public void setPassword(String password) {
this.password = password;
}
public Boolean getDel() {
return del;
}
public void setDel(Boolean del) {
this.del = del;
}
public MongoUserInfo getUserInfo() {
return userInfo;
}
public void setUserInfo(MongoUserInfo userInfo) {
this.userInfo = userInfo;
}
public MongoClassInfo getClassInfo() {
return classInfo;
}
public void setClassInfo(MongoClassInfo classInfo) {
this.classInfo = classInfo;
}
}
package com.ydrt.cp.bean.mongo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.annotation.Id;
import java.util.UUID;
/**
* Stone.Cai
* 2020年6月3日17:17:09
* 添加
* BASE
*/
public class MongoBase {
@Id //这个是指定数据的ID在mongo里如果有这字段会mongo就不会自动创建id了
private String id;
public String getId() {
if(StringUtils.isBlank(id)){
return UUID.randomUUID().toString().replaceAll("-","");
}
return id;
}
public void setId(String id) {
this.id = id;
}
}
package com.ydrt.cp.bean.mongo;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import java.util.List;
@Document(collection = "class_info")
public class MongoClassInfo extends MongoBase {
@Indexed
@Field("classId")
private Long classId;
@Indexed
@Field("className")
private String className;
@DBRef
private List usersList;
public Long getClassId() {
return classId;
}
public void setClassId(Long classId) {
this.classId = classId;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public List getUsersList() {
return usersList;
}
public void setUsersList(List usersList) {
this.usersList = usersList;
}
}
5、创建一个用户服务
package com.ydrt.cp.service;
import com.ydrt.cp.bean.mongo.MongoClassInfo;
import com.ydrt.cp.bean.mongo.MongoUsers;
import com.ydrt.cp.mapper.mongo.MongoBaseDao;
import com.ydrt.cp.util.ResultData;
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.stereotype.Service;
import java.util.List;
/**
* Stone.Cai
* 2020年6月1日17:16:21
* 添加
* mongo 服务
*/
@Service
public class MongoUserService extends MongoBaseDao {
@Autowired
private MongoClassService mongoClassService;
/**
* Stone.Cai
* 2020年6月2日14:19:31
* 添加
* 保存一个对象到MONGO
* @param users
* @return
*/
public ResultData saveUser(MongoUsers users){
//查询id是否已存在
Query query=new Query();
Criteria criteria = Criteria.where("userId").is(users.getUserId());
query.addCriteria(criteria);
List list= this.find(query);
if(list.size()!=0){
return ResultData.error("用户数据已存在!");
}
//这个地方在保存用户的时候需要把CLASS的引用放入
MongoClassInfo classInfo= mongoClassService.findMongoClassInfoByClassId(users.getClassInfo());
users.setClassInfo(classInfo);
this.save(users);
return ResultData.success();
}
/**
* Stone.Cai
* 2020年6月2日14:33:19
* 添加
* 根据Id删除数据
* @return
*/
public ResultData remvoeUsersByUserId(MongoUsers users){
Query query=new Query();
query.addCriteria(Criteria.where("userId").is(users.getUserId()));
this.removeByQuery(query);
return ResultData.success();
}
/**
* Stone.Cai
* 2020年6月2日17:21:43
* 添加
* 更新用户信息
* @param users
* @return
*/
public ResultData updateMongUserById(MongoUsers users){
Query query = new Query(Criteria.where("userId").is(users.getUserId()));
Update update =new Update();
update.set("del","0");
update.set("username",users.getUsername());
this.update(query,update);
return ResultData.success();
}
/**
* Stone.Cai
* 2020年6月3日10:38:37
* 添加
* 获取用户信息根据ID
* @param users
* @return
*/
public ResultData findUserByUserId(MongoUsers users){
Query query = new Query(Criteria.where("userId").is(users.getUserId()));
MongoUsers users1= this.findOne(query);
return ResultData.success(users1);
}
/**
* Stone.Cai
* 2020年6月3日10:38:37
* 添加
* 获取用户信息昵称获取
* @param users
* @return
*/
public ResultData findUserByNickName(MongoUsers users){
Query query = new Query(Criteria.where("userInfo.nickName").is(users.getUserInfo().getNickName()));
MongoUsers users1= this.findOne(query);
return ResultData.success(users1);
}
}
package com.ydrt.cp.service;
import com.ydrt.cp.bean.mongo.MongoClassInfo;
import com.ydrt.cp.bean.mongo.MongoUsers;
import com.ydrt.cp.mapper.mongo.MongoBaseDao;
import com.ydrt.cp.util.ResultData;
import org.bson.types.ObjectId;
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.stereotype.Service;
import java.util.Collections;
import java.util.List;
/**
* Stone.Cai
* 2020年6月3日10:27:34
* 添加
* 班级
*/
@Service
public class MongoClassService extends MongoBaseDao {
/**
* Stone.Cai
* 2020年6月3日10:29:31
* 添加
* 保存班级
* @param classInfo
* @return
*/
public ResultData saveMongoClassInfo(MongoClassInfo classInfo){
Query query=new Query();
//这里的查询是或者的关系 就是className 存在或是classId 存在就会提示数据存在
query.addCriteria(new Criteria().orOperator(Criteria.where("className").is(classInfo.getClassName()),Criteria.where("classId").is(classInfo.getClassId())));
List list= this.find(query);
if(list.size()!=0){
return ResultData.error("班级已存在!");
}
classInfo.setUsersList(Collections.emptyList());
this.save(classInfo);
return ResultData.success();
}
/**
* Stone.Cai
* 根据ClassId获取班级数据
* @param classInfo
* @return
*/
public MongoClassInfo findMongoClassInfoByClassId(MongoClassInfo classInfo){
Query query=new Query();
Criteria criteria = Criteria.where("classId").is(classInfo.getClassId());
query.addCriteria(criteria);
MongoClassInfo classInfo1= this.findOne(query);
//这里先把班级查询出来 在根据id把班级下用户数据查询出来
Query userquery=new Query();
userquery.addCriteria(Criteria.where("classInfo.$id").is(new ObjectId(classInfo1.getId())));
classInfo1.setUsersList(mongoTemplate.find(userquery, MongoUsers.class));
return classInfo1;
}
/**
* Stone.Cai
* 2020年6月3日15:36:36
* 添加
* 根据ID获取班级信息
* @param classInfo
* @return
*/
public ResultData findMongoClassInfoByClassIdResult(MongoClassInfo classInfo){
return ResultData.success(findMongoClassInfoByClassId(classInfo));
}
/**
* Stone.Cai
* 2020年6月4日09:22:43
* 添加
* 根据名称模糊搜索
* @param classInfo
* @return
*/
public ResultData findMongoClassInfoByNameLike(MongoClassInfo classInfo){
Query query=new Query();
query.addCriteria(Criteria.where("className").regex(".*?"+classInfo.getClassName()+".*"));
return ResultData.success(this.find(query),this.count(query));
}
/**
* Stone.Cai
* 2020年6月4日09:38:12
* 添加
* 使用IN查询数据
* @param classInfo
* @return
*/
public ResultData findMongoClassInfoByClassIdIn(List classInfo){
List ids=new ArrayList<>();
for (MongoClassInfo mongoClassInfo : classInfo) {
ids.add(mongoClassInfo.getClassId());
}
Query query=new Query();
query.addCriteria(Criteria.where("classId").in(ids));
return ResultData.success(this.find(query),this.count(query));
}
/**
* Stone.Cai
* 2020年6月4日10:00:10
* 添加
* 分页查询
* @param pageBean
* @param classInfo
* @return
*/
public ResultData findClassInfoPage(PageBean pageBean,MongoClassInfo classInfo){
Query query=new Query();
return ResultData.success(this.findPage(pageBean,query));
}
}