AI 助理
备案控制台
开发者社区 数据库 文章 正文

分布式服务器框架之Servers.Core库中实现 MongoEntityBase 实现阻塞 异步对MongoDB的增删改查

2023-01-03 108
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 MongoDB，独享型 2核8GB
推荐场景：
构建全方位客户视图
简介： YFMongoDBModelBase类是个模板类，对模板参数进行了约束YFMongoEntityBase，必须要继承YFMongoEntityBase

YFMongoDBModelBase类是个模板类，对模板参数进行了约束YFMongoEntityBase，必须要继承YFMongoEntityBase


using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Driver;
namespace Servers.Core
{
    // MongoDBModel 基类
    //要继承YFMongoEntityBase
    public abstract class YFMongoDBModelBase<T>
        where T : YFMongoEntityBase, new()
    {
        #region 子类需要实现的属性
        //MongoDB的客户端类(MongoDB是服务器，链接MongoDb的服务器就变成了客户端了)
        protected abstract MongoClient Client
        {
            get;
        }
        //数据库名称
        protected abstract string DatabaseName
        {
            get;
        }
        //集合名称(对应的是Mysql或者是SqlServer中的Table)
        protected abstract string CollectionName
        {
            get;
        }
        //是否记录错误日志（这个一般都要开启的吧？）
        protected virtual bool CanLogError
        {
            get { return false; }
        }
        #endregion
        #region 获取文档集合 GetCollection
        //写了类型之后是会把Mongo中的二进制数据实例化成这个entity类？？
        private IMongoCollection<T> m_Collection = null;
        //获取文档集合(get某个类型的Collection，相当于获取某个类型的Table,不过怎么感觉那么奇怪)
        public IMongoCollection<T> GetCollection()
        {
            try
            {
                if (null == m_Collection)
                {
                    IMongoDatabase database = Client.GetDatabase(DatabaseName);
                    m_Collection = database.GetCollection<T>(CollectionName);
                }
                return m_Collection;
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:log类还没写，后面有了log类之后这里的log打印要补上
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }
        #endregion
        #region GetEntity 根据编号查询实体
        //根据编号查询实体
        public T GetEntity(long YFId)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", YFId);
                return collection.Find(filter).FirstOrDefault();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO：记录错误日志
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }
        //异步根据编号查询实体
        public async Task<T> GetEntityAsync(long YFId)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", YFId);
                return await collection.Find(filter).FirstOrDefaultAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO：记录错误日志
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }
        //根据条件查询实体
        public T GetEntity(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return collection.Find(filter).FirstOrDefault();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }
        //异步根据条件查询实体
        public async Task<T> GetEntityAsync(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return await collection.Find(filter).FirstOrDefaultAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }
        #endregion
        #region 查询数量
        //查询数量(传进去一个规则策略，寻找符合规则的集合数量)
        public long GetCount(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return collection.CountDocuments(filter);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else 
                {
                    throw e;
                }
                return 0;
            }
        }
        //异步查询数量
        public async Task<long> GetCountAsync(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return await collection.CountDocumentsAsync(filter);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return 0;
            }
        }
        #endregion
        #region 根据条件查询数据集合
        /// <summary>
        /// 异步根据条件查询数据集合
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <param name="sort">排序</param>
        /// <param name="skip">跳过</param>
        /// <param name="limit">限制数量</param>
        public List<T> GetList(FilterDefinition<T> filter, out long count, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                count = collection.CountDocuments(filter);
                //不指定查询字段???
                if (field == null || field.Length == 0)
                {
                    if (sort == null) 
                        return collection.Find(filter).ToList();
                    //如果有排序规则，进行排序
                    return collection.Find(filter).Sort(sort).ToList();
                }
                //这个的直接翻译叫投影，可以理解成一种投影关系,包含这个名字的（但是不知道include是查找所有的json字符串吗？）
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i=0;i< fieldList.Count;++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(fieldList[i].ToString()));
                }
                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);
                //可空类型,不为空就调用Clear
                fieldList?.Clear();
                //没排序规则，就不排序
                if (sort == null)
                    return collection.Find(filter).Project<T>(projection).ToList();
                //三重规则??mmp
                return collection.Find(filter).Sort(sort).Project<T>(projection).ToList();
            }
            catch(Exception e) 
            {
                if (CanLogError)
                {
                }
                else 
                {
                    throw e;
                }
                count = 0;
                return null;
            }
        }
        /// <summary>
        /// 异步根据条件查询数据集合
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <param name="sort">排序</param>
        /// <param name="skip">跳过</param>
        /// <param name="limit">限制数量</param>
        public async Task<List<T>> GetListAsync(FilterDefinition<T> filter,string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                //count = collection.CountDocuments(filter);
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return await collection.Find(filter).ToListAsync();
                    //如果有排序规则，进行排序
                    return await collection.Find(filter).Sort(sort).ToListAsync();
                }
                //这个的直接翻译叫投影，可以理解成一种投影关系,包含这个名字的（但是不知道include是查找所有的json字符串吗？）
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < fieldList.Count; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(fieldList[i].ToString()));
                }
                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);
                //可空类型,不为空就调用Clear
                fieldList?.Clear();
                //没排序规则，就不排序
                if (sort == null)
                    return await collection.Find(filter).Project<T>(projection).ToListAsync();
                return await collection.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                }
                else
                {
                    throw e;
                }
                //count = 0;
                return null;
            }
        }
        /// <summary>
        /// 查询分页集合
        /// </summary>
        /// <param name="filter">过滤器</param>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">当前页</param>
        /// <param name="count">总数量</param>
        /// <param name="field">字段</param>
        /// <param name="sort">排序</param>
        public List<T> GetListByPage(FilterDefinition<T>filter,int pageSize,int pageIndex,out long count,string[] field=null,SortDefinition<T>sort=null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                count = collection.CountDocuments(filter);
                //不查询指定字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return collection.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                    //如果有排序规则进行排序
                    collection.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }
                //制定查询字段
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));    
                }
                ProjectionDefinition<T> projection  =Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                //不排序
                if(sort==null)
                    return collection.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                //先投影再排序？这样投影出来的不久不会参与排序了嘛？
                return collection.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                count = 0;
                return null;
            }
        }
        /// <summary>
        /// 异步查询分页集合
        /// </summary>
        /// <param name="filter">过滤器</param>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">当前页</param>
        /// <param name="field">字段</param>
        /// <param name="sort">排序</param>
        public async Task<List<T>> GetListByPageAsync(FilterDefinition<T> filter, int pageSize, int pageIndex, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                //count = collection.CountDocuments(filter);
                //不查询指定字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return await collection.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                    //如果有排序规则进行排序
                    collection.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }
                //制定查询字段
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                //不排序
                if (sort == null)
                    return await collection.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                return await collection.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                //count = 0;
                return null;
            }
        }
        #endregion
        #region Add添加实体
        //添加实体
        public void Add(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                collection.InsertOne(entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                }
                else
                {
                    throw e;
                }
            }
        }
        //异步添加实体
        public async Task AddAsync(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                await collection.InsertOneAsync(entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion
        #region AddMany 添加多个实体
        //添加多个实体
        public void AddMany(List<T> lst)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                collection.InsertMany(lst);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:   
                }
                else
                {
                    throw e;
                }
            }
        }
        //异步添加多个实体
        public async Task AddManyAsync(List<T> lst)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                await collection.InsertManyAsync(lst);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:   
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion
        #region Update 修改实体
        //修改实体
        public void Update(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", entity.YFId);
                collection.FindOneAndReplace(filter,entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        //异步修改实体
        public async Task UpdateAsync(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", entity.YFId);
                await collection.FindOneAndReplaceAsync(filter, entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion
        #region 删除实体
        //删除实体
        public void Delete(long YFId)
        {
            try
            {
                T entity = GetEntity(YFId);
                if (null != entity)
                {
                    entity.Status = DataStatus.Delete;
                    Update(entity);
                }
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        //异步删除实体
        public async Task DeleteAsync(long YFId)
        {
            try
            {
                T entity = await GetEntityAsync(YFId);
                if (null != entity)
                {
                    entity.Status = DataStatus.Delete;
                    await UpdateAsync(entity);
                }
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion
        #region 删除所有文档
        public void DeletaAll()
        {
            try
            {
                //删库跑路了？？drop这个table
                IMongoDatabase database = Client.GetDatabase(DatabaseName);
                database.DropCollection(CollectionName);
                //drop了为啥还要再create一下？为了完全覆盖内存吗？？？
                database.CreateCollection(CollectionName);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO
                }
                else 
                {
                    throw e;
                }
            }
        }
        public async Task DeletaAllAsync()
        {
            try
            {
                IMongoDatabase database = Client.GetDatabase(DatabaseName);
                await database.DropCollectionAsync(CollectionName);
                await database.CreateCollectionAsync(CollectionName);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion
    }
}
文章标签：
云数据库 MongoDB 版
NoSQL
MongoDB
关键词：
分布式框架
云数据库 MongoDB 版服务器
分布式mongodb
分布式云数据库 MongoDB 版
分布式云服务器 ECS
相关实践学习
MongoDB数据库入门
MongoDB数据库入门实验。
快速掌握 MongoDB 数据库
本课程主要讲解MongoDB数据库的基本知识，包括MongoDB数据库的安装、配置、服务的启动、数据的CRUD操作函数使用、MongoDB索引的使用（唯一索引、地理索引、过期索引、全文索引等）、MapReduce操作实现、用户管理、Java对MongoDB的操作支持（基于2.x驱动与3.x驱动的完全讲解）。 通过学习此课程，读者将具备MongoDB数据库的开发能力，并且能够使用MongoDB进行项目开发。 &nbsp; 相关的阿里云产品：云数据库 MongoDB版 云数据库MongoDB版支持ReplicaSet和Sharding两种部署架构，具备安全审计，时间点备份等多项企业能力。在互联网、物联网、游戏、金融等领域被广泛采用。 云数据库MongoDB版（ApsaraDB for MongoDB）完全兼容MongoDB协议，基于飞天分布式系统和高可靠存储引擎，提供多节点高可用架构、弹性扩容、容灾、备份回滚、性能优化等解决方案。 产品详情: https://www.aliyun.com/product/mongodb
1569428123893308
目录
相关文章
想飞的雪糕
|
1月前
|
NoSQL 容灾 MongoDB
MongoDB主备副本集方案：两台服务器使用非对称部署的方式实现高可用与容灾备份
在资源受限的情况下，为了实现MongoDB的高可用性，本文探讨了两种在两台服务器上部署MongoDB的方案。方案一是通过主备身份轮换，即一台服务器作为主节点，另一台同时部署备节点和仲裁节点；方案二是利用`priority`设置实现自动主备切换。两者相比，方案二自动化程度更高，适合追求快速故障恢复的场景，而方案一则提供了更多的手动控制选项。文章最后对比了这两种方案与标准三节点副本集的优缺点，指出三节点方案在高可用性和数据一致性方面表现更佳。
想飞的雪糕
75 5
追逐时光者
|
2月前
|
网络协议 Unix Linux
一个.NET开源、快速、低延迟的异步套接字服务器和客户端库
一个.NET开源、快速、低延迟的异步套接字服务器和客户端库
追逐时光者
98 4
zzy的aly
|
2月前
|
Python
Flask学习笔记(二):基于Flask框架上传图片到服务器端并原名保存
关于如何使用Flask框架上传图片到服务器端并以其原名保存的教程。
zzy的aly
92 1
zzy的aly
|
2月前
|
Python
Flask学习笔记(三):基于Flask框架上传特征值(相关数据)到服务器端并保存为txt文件
这篇博客文章是关于如何使用Flask框架上传特征值数据到服务器端，并将其保存为txt文件的教程。
zzy的aly
34 0
Flask学习笔记(三):基于Flask框架上传特征值(相关数据)到服务器端并保存为txt文件
武子康
|
2月前
|
缓存 NoSQL Ubuntu
大数据-39 Redis 高并发分布式缓存 Ubuntu源码编译安装 云服务器 启动并测试 redis-server redis-cli
大数据-39 Redis 高并发分布式缓存 Ubuntu源码编译安装 云服务器 启动并测试 redis-server redis-cli
武子康
61 3
武子康
|
2月前
|
分布式计算 Hadoop
Hadoop-27 ZooKeeper集群 集群配置启动 3台云服务器 myid集群 zoo.cfg多节点配置 分布式协调框架 Leader Follower Observer
Hadoop-27 ZooKeeper集群 集群配置启动 3台云服务器 myid集群 zoo.cfg多节点配置 分布式协调框架 Leader Follower Observer
武子康
53 1
武子康
|
2月前
|
存储 SQL 消息中间件
Hadoop-26 ZooKeeper集群 3台云服务器 基础概念简介与环境的配置使用 架构组成 分布式协调框架 Leader Follower Observer
Hadoop-26 ZooKeeper集群 3台云服务器 基础概念简介与环境的配置使用 架构组成 分布式协调框架 Leader Follower Observer
武子康
54 0
栈江湖
|
3天前
|
存储 JSON NoSQL
学习 MongoDB：打开强大的数据库技术大门
MongoDB 是一个基于分布式文件存储的文档数据库，由 C++ 编写，旨在为 Web 应用提供可扩展的高性能数据存储解决方案。它与 MySQL 类似，但使用文档结构而非表结构。核心概念包括：数据库（Database）、集合（Collection）、文档（Document）和字段（Field）。MongoDB 使用 BSON 格式存储数据，支持多种数据类型，如字符串、整数、数组等，并通过二进制编码实现高效存储和传输。BSON 文档结构类似 JSON，但更紧凑，适合网络传输。
栈江湖
30 15
MongoDB小助手
|
11天前
|
存储 NoSQL 关系型数据库
阿里云数据库MongoDB版助力信也科技 打造互联网金融企业样板
我们的风控系统引入阿里云数据库MongoDB版后，解决了特征类字段灵活加减的问题，大大提高了开发效率，极大的提升了业务用户体验，获得了非常好的效果
MongoDB小助手
36 0
阿里云数据库MongoDB版助力信也科技 打造互联网金融企业样板
爱的不是纯牛奶-47754
|
1月前
|
NoSQL Cloud Native atlas
探索云原生数据库：MongoDB Atlas 的实践与思考
【10月更文挑战第21天】本文探讨了MongoDB Atlas的核心特性、实践应用及对云原生数据库未来的思考。MongoDB Atlas作为MongoDB的云原生版本，提供全球分布式、完全托管、弹性伸缩和安全合规等优势，支持快速部署、数据全球化、自动化运维和灵活定价。文章还讨论了云原生数据库的未来趋势，如架构灵活性、智能化运维和混合云支持，并分享了实施MongoDB Atlas的最佳实践。
爱的不是纯牛奶-47754
112 10

热门文章

最新文章

  • 1
    阿里云上1分钟搞定幻兽帕鲁联机服务器搭建
  • 2
    阿里云服务器ECS搭建个人网站新手教程（超详细）
  • 3
    阿里云服务器CPU内存配置详细指南，如何选择合适云服务器配置？
  • 4
    幻兽帕鲁专用服务器设置教程详解(已收藏)
  • 5
    云服务器 ECS > > 快速入门（二）
  • 6
    单IP无TMG拓扑Lync Server 2013：边缘服务器
  • 7
    dhcp服务器
  • 8
    Inotify自动监控并且同步到服务器的脚本
  • 9
    使用ssh连接到gitHub Actions服务器
  • 10
    构建企业服务之windows 2008 负载均衡服务器部署
  • 1
    2024年最全BATJ真题突击：Java基础+JVM+分布式高并发+网络编程+Linux(1)，2024年最新意外的惊喜
    73
  • 2
    云原生分布式数据库 PolarDB-X系统权限策略参考
    223
  • 3
    机器学习分布式框架Ray
    495
  • 4
    【JAVA】分布式链路追踪技术概论
    106
  • 5
    分布式系统的一致性级别划分及Zookeeper一致性级别分析
    91
  • 6
    秀出天际！阿里甩出的988页分布式微服务架构进阶神仙手册我粉了
    129
  • 7
    探索分布式系统演进之路：从负载均衡到微服务架构
    112
  • 8
    Hadoop分布式文件系统（HDFS）
    90
  • 9
    构建高可用的分布式数据库集群：使用Go语言与Raft共识算法
    108
  • 10
    PolarDB-X 是面向超高并发、海量存储和复杂查询场景设计的云原生分布式数据库系统
    317

    • 相关课程

    更多
  • Linux Web服务器Nginx搭建与配置
  • 7天玩转云服务器
  • 分布式文件存储系统技术及实现
  • 云服务器选型、迁云最佳实践
  • 云服务器ECS基本操作
  • 分布式协调系统 Zookeeper 快速入门

    • 相关电子书

    更多
  • 高并发分布式缓存Redis6.0
  • 基于社区的分布式 风险感知模型
  • 如何利用Redisson分布式化传统Web项目

    • 相关实验场景

    更多
  • 使用ECS和RDS搭建个人博客
  • 利用云备份Cloud Backup实现ECS文件备份
  • 基于ECS搭建FTP服务
  • 基于ECS和NAS搭建个人网盘
  • 体验PolarDB-X透明分布式
  • 使用ECS和OSS搭建个人网盘

    • 推荐镜像

    更多
  • mongodb
  • postgresql
  • clickhouse
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS