mongoDB 封装基本的增删改查操作

最新推荐文章于 2024-05-06 04:49:52 发布
最新推荐文章于 2024-05-06 04:49:52 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiayu8706/article/details/92806192
版权

Hutool的mongoDB工具类封装了链接的多源于连接接池的，并没有细节的增删改查等操作，所以根据自己的当前项目特征封装了一套自己用的。

api


import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

import cn.hutool.db.nosql.mongo.MongoDS;
import cn.hutool.db.nosql.mongo.MongoFactory;
import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import cn.hutool.setting.GroupedMap;
import cn.hutool.setting.Setting;

/**
 * mongo CRUB 基类
 * @author lijiayu
 * @date 2019-05-29
 */
public class MongoApi {

	protected static Log LOG = LogFactory.get();

	// MongoDB实例连接列表

	public static MongoDS ds;

	// 初始化mongoDs
	static {
		try {
			Setting setting = new Setting(MongoDS.MONGO_CONFIG_PATH);
			GroupedMap gMap = setting.getGroupedMap();
			List<String> groups = new ArrayList<String>();
			Set<Entry<String, LinkedHashMap<String, String>>> set = gMap.entrySet();
			for (Entry<String, LinkedHashMap<String, String>> entry : set) {
				if (entry.getKey() == null || entry.getKey().equals("")) {
					continue;
				}
				String host = entry.getValue().get("host");
				if (host == null || host.equals("null") || host.equals("")) {
					continue;
				}
				LOG.info("Mongo,初始化数据源[{}]信息", entry.getKey());
				LOG.info("Mongo,初始化数据源host[{}]信息", host);
				groups.add(entry.getKey());
			}
			if (groups.size() > 0) {
				ds = MongoFactory.getDS(groups);
			} else {
				ds = MongoFactory.getDS("master");
			}

		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static MongoDS getDS() {
		return ds;
	}

}

base


import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import org.bson.types.ObjectId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.eims.cto.framework.common.base.exception.BusinessException;
import com.eims.cto.framework.project.ylm.mongodb.entity.MongoBaseEntity;
import com.mongodb.Block;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

/**
 * mongo CRUB 基类
 * @author lijiayu
 * @date 2019-05-29
 */
public abstract class MongoBaseService<T extends MongoBaseEntity> {

	protected Logger log = LoggerFactory.getLogger(this.getClass());

	public abstract String getDbName();

	public abstract String getTableName();

	public abstract Class<T> getClaz();

	protected MongoCollection<Document> getCollection() {
		return MongoApi.getDS().getCollection(getDbName(), getTableName());
	}

	/**
	 * 根据 mongoId查询
	 * @param _id
	 * @return
	 */
	public T selectByMgId(String _id) {
		try {
			MongoCollection<Document> table = getCollection();
			Document query = getIdQuery(_id);
			Document doc = table.find(query).first();
			if (doc == null) {
				return null;
			}
			return documentToEntity(doc);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 根据 mongoId查询
	 * @param _id
	 * @return
	 */
	public T selectByMgId(ObjectId _id) {
		return selectByMgId(_id.toHexString());
	}

	/**
	 * 根据实体对象获取单条记录
	 * @param entity
	 * @return
	 */
	public T selectOne(T entity) {
		List<T> list = listByEntity(entity);
		if (list.size() > 0) {
			return list.get(0);
		} else {
			return null;
		}
	}

	/**
	 * 根据实体对象字段查询
	 * @param entity 为null 查询所有
	 * @return
	 */
	public List<T> listByEntity(T entity) {
		try {
			return listByEntity(entity, null);
		} catch (Exception e) {
			log.error("listByEntity error:{}", e.getMessage());
		}
		return new ArrayList<>();
	}

	/**
	 * 根据实体对象字段查询并排序
	 * @param entity 为null 查询所有
	 * @param sort 为null不排序，字段值 1 升序， -1 降序
	 * @return
	 */
	public List<T> listByEntity(T entity, T sort) {
		try {
			MongoCollection<Document> table = getCollection();

			Document query = getDocumentByEntity(entity);
			log.debug("=================== listByEntity get query document is:{}", query.toJson().toString());

			List<T> ret = new ArrayList<>();
			Block<Document> processBlock = new Block<Document>() {

				@Override
				public void apply(final Document document) {
					ret.add(documentToEntity(document));
				}
			};

			if (sort == null) {
				table.find(query).forEach(processBlock);
			} else {
				Document docsort = getDocumentByEntity(sort);
				table.find(query).sort(docsort).forEach(processBlock);
			}
			return ret;
		} catch (Exception e) {
			log.error("listByEntity error:{}", e.getMessage());
		}
		return new ArrayList<>();
	}

	/**
	 * 查询所有
	 * @param entity
	 * @param sort
	 * @return
	 */
	public List<T> listAll() {
		return listAll(null);
	}

	/**
	 * 查询所有并排序
	 * @param entity
	 * @param sort
	 * @return
	 */
	public List<T> listAll(T sort) {
		return listByEntity(null, sort);
	}

	/***
	 * 插入单条记录
	 * @param table 表连接
	 * @param obj 单条数据 obj double 处理不规范
	 * @return
	 */
	public String insertOne(T obj) {
		if (obj == null) {
			return null;
		}
		MongoCollection<Document> table = getCollection();

		Document docine = Document.parse(JSON.toJSONString(obj));
		docine.remove("_id");
		docine.put("_id", new ObjectId());
		table.insertOne(docine);
		return docine.get("_id").toString();
	}

	/**
	 * 更新数据 注意 多余字段 会在库表记录追加
	 * @param obj
	 * @return
	 */
	public long updateOne(T obj) {
		long num = 0;
		try {
			MongoCollection<Document> table = getCollection();
			Document updateset = getUpdateSet(obj);
			log.debug("=================== updateOne _id is {},get update set document is:{}",
					obj.get_id().toHexString(), updateset.toJson().toString());
//			UpdateResult result = table.updateOne(getIdQuery(obj.get_id()), updateset);
			UpdateResult result = table.updateMany(getIdQuery(obj.get_id()), updateset);
			num = result.getModifiedCount();
			log.debug("updateOne:{}", num);
		} catch (Exception e) {
			log.error("updateOne error {}", e.getMessage());
			throw new BusinessException(e.getMessage());
		}
		return num;
	}

	/**
	 * 批量更新
	 * @param query 用于查询条件的实体对象
	 * @param upset 用于更新的实体对象
	 * @return
	 */
	public long updateBatch(T query, T upset) {
		long num = 0;
		try {
			Document qfilter = getDocumentByEntity(query);
			log.debug("=================== updateBatch get query document is:{}", qfilter.toJson().toString());
			Document updateset = getUpdateSet(upset);
			log.debug("=================== updateBatch get update set document is:{}", updateset.toJson().toString());

			UpdateResult result = getCollection().updateMany(qfilter, updateset);
			num = result.getModifiedCount();
			log.debug("updateBatch ModifiedCount:{}", num);
		} catch (Exception e) {
			log.error("updateBatch error {}", e.getMessage());
			throw new BusinessException(e.getMessage());
		}
		return num;
	}

	/**
	 * 删除，根据ID
	 * @param id
	 * @return
	 */
	public long deleteOne(ObjectId id) {
		return deleteOne(id.toHexString());
	}

	/**
	 * 删除，根据ID
	 * @param id
	 * @return
	 */
	public long deleteOne(String id) {
		Document query = getIdQuery(id);
		MongoCollection<Document> table = getCollection();
		DeleteResult re = table.deleteOne(query);
		return re.getDeletedCount();
	}

	/**
	 * 批量删除，根据实体类设置的属性值
	 * @param entity
	 * @return
	 */
	public long deleteByEntity(T entity) {
		if (entity == null) {
			log.error("deleteByEntity error: update entity is null");
			return 0;
		}
		try {
			Document query = getDocumentByEntity(entity);
			log.debug("=================== deleteByEntity get query document is:{}", query.toJson().toString());
			if (query.size() <= 0) {
				log.error("deleteByEntity error: entity doesn't have any properties");
				throw new BusinessException("deleteByEntity error: entity doesn't have any properties");
			}
			DeleteResult re = getCollection().deleteMany(query);
			return re.getDeletedCount();
		} catch (Exception e) {
			log.error("deleteByEntity error {} class:{}", e.getMessage(), entity.getClass().getName());
			throw new BusinessException(e.getMessage());
		}
	}

	private Document getDocumentByEntity(T entity) throws IllegalAccessException, InvocationTargetException {
		Document query = new Document();
		if (entity == null) {
			return query;
		}
		Field[] fields = MongoUtil.getFields(getClaz());
		for (Field f : fields) {
			if (f.getName().equals("serialVersionUID")) {
				continue;
			}
			f.setAccessible(true);
			Object obj = f.get(entity);
			if (null == obj) {
				continue;
			}
			query.append(f.getName(), obj);
		}
		return query;
	}

	private T documentToEntity(Document doc) {
		try {
			T t = getClaz().newInstance();
			Field[] fields = MongoUtil.getFields(getClaz());
			for (Field f : fields) {
				if (doc.get(f.getName()) == null) {
					continue;
				}
				Object value = doc.get(f.getName());
				if (null == value) {
					continue;
				}
				if (f.getName().equals("_id")) {
					value = new ObjectId(String.valueOf(value));
				}
				setFieldValue(t, f, value);
			}
			return t;
		} catch (Exception e) {
			throw new BusinessException(e.getMessage());
		}
	}

	private void setFieldValue(T t, Field field, Object value) {
		try {
			field.setAccessible(true);
			field.set(t, value);
		} catch (Exception e) {
			log.error("IllegalAccess for {}.{}", t.getClass(), field.getName());
			throw new BusinessException(e.getMessage());
		}
	}

	private Document getUpdateSet(T entity) throws IllegalAccessException, InvocationTargetException {
		Document set = getDocumentByEntity(entity);
		set.remove("_id");
		set = new Document("$set", set);
		return set;
	}

	private Document getIdQuery(ObjectId id) {
		Document query = new Document();
		query.append("_id", id);
		return query;
	}

	private Document getIdQuery(String id) {
		return getIdQuery(new ObjectId(id));
	}

	protected BusinessException handleBusinessException(Exception e) {
		if (e instanceof BusinessException) {
			return (BusinessException) e;
		} else {
			e.printStackTrace();
			return new BusinessException(-500, "未知异常Mongdo Server Error:" + e.getMessage());
		}
	}

}


import java.io.Serializable;

import org.bson.types.ObjectId;

/**
 * mongo实体的基类
 * @author lijiayu
 * @date 2019-05-28
 */
public class MongoBaseEntity implements Serializable {

	private static final long serialVersionUID = -5786688718211843023L;

	/**
	 * 在MongoDB中，存储于集合中的每一个文档都需要一个唯一的 _id 字段作为 primary_key。如果一个插入文档操作遗漏了``_id``
	 * 字段，MongoDB驱动会自动为``_id``字段生成一个 ObjectId
	 */
	private ObjectId _id;

	public ObjectId get_id() {
		return _id;
	}

	public void set_id(ObjectId _id) {
		this._id = _id;
	}

}

util 主要用于反射实体等操作的工具类


import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 用于mongoBase的专用工具
 * @author lijiayu
 * @date 2019-05-30
 */
public class MongoUtil {

	private static final Map<String, Field[]> FIELDS_CACHE = new ConcurrentHashMap<String, Field[]>();

	public static Field[] getFields(Class<?> claz) throws SecurityException {
		Field[] allFields = FIELDS_CACHE.get(claz.toString());
		if (null != allFields) {
			return allFields;
		}

		allFields = getFieldsDirectly(true, claz);
		FIELDS_CACHE.put(claz.toString(), allFields);
		return allFields;
	}

	public static Field[] getFieldsDirectly(boolean withSuperClassFieds, Class<?> claz) throws SecurityException {
		Field[] allFields = null;
		Class<?> searchType = claz;
		Field[] declaredFields;
		while (searchType != null) {
			declaredFields = searchType.getDeclaredFields();
			if (null == allFields) {
				allFields = declaredFields;
			} else {
				allFields = append(allFields, declaredFields);
			}
			searchType = withSuperClassFieds ? searchType.getSuperclass() : null;
		}

		return allFields;
	}

	private static Field[] append(Field[] buffer, Field... newElements) {
		if (isEmpty(buffer)) {
			return newElements;
		}
		return insert(buffer, buffer.length, newElements);
	}

	private static Field[] insert(Field[] array, int index, Field... newFieldlements) {
		if (isEmpty(newFieldlements)) {
			return array;
		}
		if (isEmpty(array)) {
			return newFieldlements;
		}

		final int len = length(array);
		if (index < 0) {
			index = (index % len) + len;
		}

		Field[] result = newArray(array.getClass().getComponentType(), Math.max(len, index) + newFieldlements.length);
		System.arraycopy(array, 0, result, 0, Math.min(len, index));
		System.arraycopy(newFieldlements, 0, result, index, newFieldlements.length);
		if (index < len) {
			System.arraycopy(array, index, result, index + newFieldlements.length, len - index);
		}
		return result;
	}

	private static Field[] newArray(Class<?> componentType, int newSize) {
		return (Field[]) Array.newInstance(componentType, newSize);
	}

	private static boolean isEmpty(Field... array) {
		return array == null || array.length == 0;
	}

	private static int length(Object array) throws IllegalArgumentException {
		if (null == array) {
			return 0;
		}
		return Array.getLength(array);
	}
}

使用的具体业务类

@Service
public class MgCustImageService extends MongoBaseService<CustImage> {

	@Override
	public String getDbName() {
		return MongoConstants.Dbs.customerInfo;
	}

	@Override
	public String getTableName() {
		return MongoConstants.customerInfo.custImage;
	}

	@Override
	public Class<CustImage> getClaz() {
		return CustImage.class;
	}

}

CustImage 就是普通的javabean 但是需要继承 MongoBaseEntity

JerryEagle
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MongoDB数据库更新操作的十种修改器的使用
You_are_my_dream的博客
02-26 1175
提示：下面代码中所操作的文档都已经插入到数据库中了，只是对MongoDB十种修改器的基本介绍 # 首先贴出一个每次修改完以后都会使用的语句：查询 db.student.find( {"name" : "对应的姓名"} ).skip(0).limit(5).sort( {"$natural" : -1} ).pretty() # 修改器 # 对于MongoDB数据库而言，数据的修改会牵扯到内容
SpringBoot集成MongoDB并运用MongoTemplate封装工具类进行增删改及聚合查询
qq_40312403的博客
07-25 4249
本文示例的MongoDB版本为：4.2.1 ，JDK1.8 , SpringBoot 2.3 首先在pom中引入依赖 （Spring Boot对各种流行的数据源都进行了封装，当然也包括了mongodb，不需要在引入spring-data-mongodb） <!--集成MongoDB--> <dependency> <groupId>org.springframework.boot&l...
封装对MongoDB数据库的增删改查访问方法（基于MongoDB官方发布的C#驱动）
weixin_30887919的博客
01-05 57
本文利用MongoDB官方发布的C#驱动，封装了对MongoDB数据库的增删改查访问方法。先用官方提供的mongo-csharp-driver ,当前版本为1.7.0.4714 编写数据库访问帮助类 MongoDbHelper.cs using System; using System.Collections.Generic; using System.Linq; using Mon...
Nodejs中mongodb的使用及封装
最新发布
2401_84097820的博客
05-06 839
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
MongoDB：mongodb修改器
拒绝熬夜啊的博客
03-03 1193
MongoDB：mongodb修改器
Mongdo操作工具类
程门立雪的博客
08-17 1128
 MongoDBUtil.java package com.jk.utils; import java.util.ArrayList; import org.bson.Document; import org.bson.types.ObjectId; import com.mongodb.MongoClient; import com.mongodb.MongoClientOption...
Mongodb Service接口封装
06-13 150
/** * */ package org.zxy.chats.domain; import java.io.Serializable; import org.springframework.data.annotation.Id; /** * 说明: * * @author zxy * @version 1.0 * * 2017年5月16日 下午3:11:44 */ pu
java连接mongoDB并进行增删改查操作实例详解
08-26
Java 连接 MongoDB 并进行增删改查操作实例详解 Java 连接 MongoDB 是一项常见的数据存储操作，MongoDB 是一个流行的 NoSQL 数据库。在 Java 项目中，连接 MongoDB 需要使用 MongoDB 的 Java 驱动程序。在本文中，...
MongoDB.NET 2.2.4驱动版本对Mongodb3.3数据库中GridFS增删改查
09-09
在2.2.4版本中，这个驱动提供了对GridFS操作的支持，使得开发者能够轻松地在C#代码中实现对MongoDB数据库中的GridFS的增删改查操作。 在提供的代码示例中，`Program.cs`类展示了如何使用`GridFSHelper`类来操作...
mongodb+php实现简单的增删改查
09-10
以上就是使用PHP和MongoDB进行基本的增删改查操作的步骤。在实际项目中，你可能需要根据具体需求对这些操作进行更复杂的封装和逻辑处理。注意，对于PHP 7及更高版本，推荐使用新的`mongodb`扩展（而不是`mongo`扩展...
MongoDB增删改查操作案例-用户信息增删改查.zip
07-18
在本案例"MongoDB增删改查操作案例-用户信息增删改查.zip"中，我们将探讨如何使用MongoDB进行基本的数据操作，包括添加（Add）、删除（Delete）、修改（Update）和查询（Query）用户信息。 1. 添加操作（Add）： 在...
详解Nodejs基于mongoose模块的增删改查的操作
10-20
本篇文章主要介绍了Nodejs基于mongoose模块的增删改查的操作，Mongoose是MongoDB的一个对象模型工具，封装了MongoDB对文档的的一些增删改查等常用方法，让NodeJS操作Mongodb数据库变得更加灵活简单。
Golang对MongoDB数据库的操作简单封装教程
01-03
Golang 对MongoDB的操作简单封装 使用MongoDB的Go驱动库 mgo,对MongoDB的操作做一下简单封装 mgo（音mango）是MongoDB的Go语言驱动，它用基于Go语法的简单API实现了丰富的特性，并经过良好测试。 初始化 操作没有...
Python-基于ER模型Flask封装对MongoDB的增删改查
08-10
对于增删改查操作，通常会定义以下四个接口： 1. **创建（Create）**：POST请求，用于向集合添加新文档。在Flask中，我们可以定义一个路由，接收JSON数据，解析并插入MongoDB。 2. **读取（Read）**：GET请求，...
mongodb 简单的数据库操作，增删改查
11-08
一个简单的mogodb的操作封装，mongodb 简单的数据库操作，增删改查
SpringBoot+MyBatisPlus+Thymeleaf 增删改查CRUD
12-03
下面将详细介绍这三个组件以及它们在实现增删改查（CRUD）操作中的作用。 **Spring Boot** Spring Boot是由Pivotal团队提供的全新框架，旨在简化Spring应用的初始搭建以及开发过程。它集成了大量常用的第三方库配置...
第15章 MongoDB 删除文档教程
02-09 473
在前面的几个章节中咱们已经学习了 MongoDB 中如何为集合添加数据和更新数据。在本章节中咱们将继续学习 MongoDB 集合的删除。MongoDB remove() 函数是用来移除集合中的数据。MongoDB 数据更新可以使用 update() 函数。在执行 remove() 函数前先执行 find() 命令来判断执行的条件是否正确，这是一个比较好的习惯。
java操作MongoDB工具类分享
绿茵场的激情
08-27 671
  .limit(mongoDBCursor.getLimit()); } if (mongoDBCursor.getSortObject() != null) { cursorToUse = cursorToUse.sort(mongoDBCursor.getSortObject()); } return cursorToUse; ...
Hutool学习 —— 数据库 - db （三）其他配置
waiter_chen的博客
06-29 2066
Hutool 官网：https://www.hutool.cn 官方参考文档：https://www.hutool.cn/docs 本节内容对应官方文档位置：概述 (hutool.cn) Hutool 版本：5.7.1 SQL执行器-SqlExecutor 对JDBC的薄封装，里面的静态方法只有两种：执行非查询的SQL语句和查询的SQL语句 SqlExecutor.query(conn,sql, new EntityListHandler())查询的SQL语句 SqlExecutor.execute(c.
springboot有哪些提供增删改查方法的工具
07-13
Spring Boot提供了许多用于增删改查（CRUD）操作的工具和框架。以下是一些常用的工具： 1. Spring Data JPA：它是Spring的一个子项目，简化了对关系型数据库的访问和操作。它提供了一组注解和接口，通过继承和命名规范，可以自动生成常见的增删改查方法。 2. Spring Data JDBC：与JPA类似，但更关注于JDBC（Java数据库连接）的使用。它提供了一些注解和接口，可以将实体对象映射到数据库表，并自动生成增删改查的SQL语句。 3. Spring Data MongoDB：如果你使用的是MongoDB这样的NoSQL数据库，Spring Data MongoDB可以帮助你进行增删改查操作。它提供了一组注解和接口，可以简化MongoDB的使用。 4. Spring JDBC Template：这是Spring框架提供的一个JDBC访问数据库的工具类。它封装了JDBC的一些复杂性，提供了一组简化的API，可以进行数据库的增删改查操作。 除了以上提到的工具，还有其他一些第三方库和框架，如MyBatis、Hibernate等，也可以用于实现增删改查功能。根据具体的需求和技术栈选择合适的工具和框架是很重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值