标签：where pom att ssi constant gdb rollback task bool
近期在做业务的时候用到了MongDB非关系型数据库一般用来存储聊天记录或者消息推送或者日志记录等等，话不多说直接上代码
首先先导入 pom 文件
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
yml 文件的配置data:
mongodb:
uri: mongodb://端口/库
username: 123456+
password: 1234567
MongoDB的查询方式很多种，下面只列了一些常用的，比如：
查询-----------------------------------------------------------start
注意：Article 这个是个实体类对象也就是mongdo数据库要查询的表对应的实体类对应的
???? 1、=查询
???? 2、模糊查询
???? 3、大于小于范围查询
???? 4、in查询
???? 5、or查询
???? 6、查询一条，查询全部
// 在写逻辑的业务层直接注入就可以使用了
@Autowired
private MongoTemplate mongoTemplate;
1.只查询符合条件的第一条数据，返回TaskDTO对象
Query query = new Query(Criteria.where("userId").is(userId)); // 条件一
query.addCriteria(Criteria.where("taskId").is(toDoDirectProcessingDTO.getTaskId())); // 条件二
query.addCriteria(Criteria.where("sysId").is(toDoDirectProcessingDTO.getSysId())); // 条件三
mongoTemplate.findOne(query, TaskDTO.class); // 查询 -- findOne(query,查询要映射的对象类);
2.查询多条
Query query = Query.query(Criteria.where("author").is("yinjihuan")); List<Article> articles = mongoTemplate.find(query, Article.class); //find(query, 实体类对象.class);
3. 查询集合中所有数据，不加条件
articles = mongoTemplate.findAll(Article.class);
4.查询符合条件的数量
query = Query.query(Criteria.where("author").is("yinjihuan")); long count = mongoTemplate.count(query, Article.class);
5.根据主键ID查询
article = mongoTemplate.findById(new ObjectId("57c6e1601e4735b2c306cdb7"), Article.class);
6.in查询
List<String> authors = Arrays.asList("yinjihuan", "jason");
query = Query.query(Criteria.where("author").in(authors));
articles = mongoTemplate.find(query, Article.class);
7.ne（!=）查询
query = Query.query(Criteria.where("author").ne("yinjihuan"));
articles = mongoTemplate.find(query, Article.class);
8. lt(<)查询访问量小于10的文章
query = Query.query(Criteria.where("visitCount").lt(10));
articles = mongoTemplate.find(query, Article.class);
9. 范围查询，大于5小于10
query = Query.query(Criteria.where("visitCount").gt(5).lt(10));
articles = mongoTemplate.find(query, Article.class);
10.模糊查询，author中包含a的数据
query = Query.query(Criteria.where("author").regex("a"));
articles = mongoTemplate.find(query, Article.class);
11.数组查询，查询tags里数量为3的数据
query = Query.query(Criteria.where("tags").size(3));
articles = mongoTemplate.find(query, Article.class);
12.or查询，查询author=jason的或者visitCount=0的数据
query = Query.query(Criteria.where("").orOperator( Criteria.where("author").is("jason"), Criteria.where("visitCount").is(0)));
articles = mongoTemplate.find(query, Article.class);
查询-----------------------------------------------------------end
修改-----------------------------------------------------------start
批量修改：
// List<ToDoDirectProcessingDTO> stringListTaskDTO 前端传过来要修改的数据
// msg 修改成什么
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = {RuntimeException.class,Exception.class })
public boolean batchUpdateMongodb (List<ToDoDirectProcessingDTO> stringListTaskDTO,String msg) {
try {
String userId = SingleSignInUtils.getUserId();
List<BatchUpdateOptionsDTO> list = new ArrayList<>();
for (ToDoDirectProcessingDTO dto : stringListTaskDTO) {
Query query = new Query(Criteria.where("userId").is(userId)); // 根据什么条件修改
query.addCriteria(Criteria.where("taskId").is(dto.getTaskId())); // 根据什么条件修改
query.addCriteria(Criteria.where("sysId").is(dto.getSysId())); // 根据什么条件修改
Update update = new Update();
// 删除 delete
if (msg.equals(URLMethodLConstant.DELETE_FLAG)) {
update.set("status", msg); // update.set("要修改的字段名","要修改的值")
}
// 暂缓 delay
if (msg.equals(URLMethodLConstant.DELAY_FLAG)) {
update.set("status", msg);
}
// 不同意 0
if (msg.equals(TaskConstant.TASK_SYSTEM_CODE_SUCCESS)) {
update.set("detailStatus", msg);
}
// 同意 1
if (msg.equals(TaskConstant.TASK_SYSTEM_CODE_SUCCESS_ONE)) {
update.set("detailStatus", msg);
}
list.add(new BatchUpdateOptionsDTO(query,update,false,true));
}
// int batchUpdateCount = MongoBaseDaoUtils.batchUpdate(mongoTemplate, "要操作的的表",操作的集合, true);
int batchUpdateCount = MongoBaseDaoUtils.batchUpdate(mongoTemplate, URLMethodLConstant.TASK_TABLE, list, true);
logger.info("准备更新: {} 条数据,实际更新了: {}条数据,操作结果 {} ",stringListTaskDTO.size(),batchUpdateCount,(batchUpdateCount == stringListTaskDTO.size()));
if (batchUpdateCount == stringListTaskDTO.size()) {
return true;
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException();
}
return false;
}
工具类： MongoBaseDaoUtils
/**
* 批量更新
* @param mongoTemplate
* @param collectionName 要操作的表名
* @param options false 更新过程不做插入
* @param ordered 如果为true,一条语句更新失败，剩下的语句将不再执。如果为false,一条语句更新失败，剩下的将继续执行。默认为true。
* @return
*/
public static int batchUpdate(MongoTemplate mongoTemplate, String collectionName, List<BatchUpdateOptionsDTO> options, boolean ordered) {
return doBatchUpdate(mongoTemplate, collectionName, options, ordered);
}
private static int doBatchUpdate(MongoTemplate mongoTemplate, String collName, List<BatchUpdateOptionsDTO> options, boolean ordered) {
DBObject command = new BasicDBObject();
command.put("update", collName);
List<BasicDBObject> updateList = new ArrayList<>();
for (BatchUpdateOptionsDTO option : options) {
BasicDBObject update = new BasicDBObject();
update.put("q", option.getQuery().getQueryObject());
update.put("u", option.getUpdate().getUpdateObject());
update.put("upsert", option.isUpsert());
update.put("multi", option.isMulti());
updateList.add(update);
}
command.put("updates", updateList);
command.put("ordered", ordered);
Document document = mongoTemplate.getDb().runCommand((Bson) command);
logger.info("doc:" + document);
logger.info("doc--n:" + document.get("n"));
logger.info("doc--nModified:" + document.get("nModified"));
// n为符合Query查询的记录总数 因为是根据id进行的查询, 原则上只要符合查询的记录数等于要更新的数量就代表成功
Object n = document.get("n");
logger.info("doc--n--class:" + n.getClass());
if (n.getClass() == Integer.class) {
return (Integer) n;
}
return Integer.parseInt(String.valueOf(n));
}
// 工具类
public class BatchUpdateOptionsDTO {
private Query query;
private Update update;
/** false 更新过程不做插入 */
private boolean upsert = false;
/** true,一条语句更新失败，剩下的语句将不再执。如果为false,一条语句更新失败，剩下的将继续执行 */
private boolean multi = false;
public BatchUpdateOptionsDTO(Query query, Update updateupdate, boolean b, boolean b1) {
this. query = query;
this. update = updateupdate;
this. upsert = b;
this. multi = b1;
}
public Query getQuery() {
return query;
}
public void setQuery(Query query) {
this.query = query;
}
public Update getUpdate() {
return update;
}
public void setUpdate(Update update) {
this.update = update;
}
public boolean isUpsert() {
return upsert;
}
public void setUpsert(boolean upsert) {
this.upsert = upsert;
}
public boolean isMulti() {
return multi;
}
public void setMulti(boolean multi) {
this.multi = multi;
}
}
标签：where pom att ssi constant gdb rollback task bool
原文地址：https://www.cnblogs.com/ysySelf/p/14041012.html
