1. Toy模板网首页
  2. > Toy博客

基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理

10月前 作者：伍华聪 分类：Toy博客 阅读(51) 违法举报

这篇具有很好参考价值的文章主要介绍了基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

在一些复杂的业务表中间查询数据，有时候操作会比较复杂一些，不过基于SqlSugar的相关操作，处理的代码会比较简单一些，以前我在随笔《基于SqlSugar的开发框架循序渐进介绍（2）-- 基于中间表的查询处理》介绍过基于主表和中间表的联合查询，而往往实际会比这个会复杂一些。本篇随笔介绍联合多个表进行查询以及树形列表的条件展示的处理实现，系统能够给大家一些参考思路。

1、SqlSugar的开发框架的数据查询处理

在随笔《基于SqlSugar的开发框架循序渐进介绍（2）-- 基于中间表的查询处理》中，介绍过两个表的联合查询，如下所示代码所示。

/// <summary>
/// 根据用户ID获取对应的角色列表
/// </summary>
/// <param name="userID">用户ID</param>
/// <returns></returns>
private async Task<List<RoleInfo>> GetByUser(int userID)
{
    var query = this.Client.Queryable<RoleInfo, User_RoleInfo>(
    (t, m) => t.Id == m.Role_ID && m.User_ID == userID)
    .Select(t => t); //联合条件获取对象

    query = query.OrderBy(t => t.CreateTime);//排序
    var list = await query.ToListAsync();//获取列表
    return list;
}

/// <summary>
/// 根据机构获取对应的角色列表(判断机构角色中间表）
/// </summary>
/// <param name="ouID">机构的ID</param>
/// <returns></returns>
public async Task<List<RoleInfo>> GetRolesByOu(int ouID)
{
    var query = this.Client.Queryable<RoleInfo, OU_RoleInfo>(
    (t, m) => t.Id == m.Role_ID && m.Ou_ID == ouID)
    .Select(t => t); //联合条件获取对象

    query = query.OrderBy(t => t.CreateTime);//排序
    var list = await query.ToListAsync();//获取列表
    return list;
}

我们对于后端的数据查询，一般都是传入一个条件对象，通过条件类的属性进行构建查询信息，如下简单的处理操作。

/// <summary>
/// 应用层服务接口实现
/// </summary>
public class CustomerService : MyCrudService<CustomerInfo, string, CustomerPagedDto>, ICustomerService
{
    /// <summary>
    /// 自定义条件处理
    /// </summary>
    /// <param name="input">查询条件Dto</param>
    /// <returns></returns>
    protected override ISugarQueryable<CustomerInfo> CreateFilteredQueryAsync(CustomerPagedDto input)
    {
        var query = base.CreateFilteredQueryAsync(input);

        query = query
            .WhereIF(!input.ExcludeId.IsNullOrWhiteSpace(), t => t.Id != input.ExcludeId) //不包含排除ID
            .WhereIF(!input.Name.IsNullOrWhiteSpace(), t => t.Name.Contains(input.Name)) //如需要精确匹配则用Equals
                                                                                         //年龄区间查询
            .WhereIF(input.AgeStart.HasValue, s => s.Age >= input.AgeStart.Value)
            .WhereIF(input.AgeEnd.HasValue, s => s.Age <= input.AgeEnd.Value)

            //创建日期区间查询
            .WhereIF(input.CreateTimeStart.HasValue, s => s.CreateTime >= input.CreateTimeStart.Value)
            .WhereIF(input.CreateTimeEnd.HasValue, s => s.CreateTime <= input.CreateTimeEnd.Value)
            ;

        return query;
    }

上面的 CreateFilteredQueryAsync 方法是一个基类函数，主要是构建该业务表的一些数据查询的匹配处理，如对于复杂一些的查询条件，这个内容会增加很多，不过都是可以通过代码生成工具基于数据库表字段来进行一一对应的生成，从而避免人工繁琐的敲击代码。

如下面是基类函数的常规条件查询和计数的函数处理。

/// <summary>
/// 根据条件获取列表
/// </summary>
/// <param name="input">分页查询条件</param>
/// <returns></returns>
public virtual async Task<PagedResultDto<TEntity>> GetListAsync(TGetListInput input)
{
    var query = CreateFilteredQueryAsync(input);
    var totalCount = await query.CountAsync();

    query = ApplySorting(query, input);
    query = ApplyPaging(query, input);

    var list = await query.ToListAsync();

    return new PagedResultDto<TEntity>(
       totalCount,
       list
   );
}

/// <summary>
/// 根据条件计算记录数量
/// </summary>
/// <param name="input">查询条件，忽略分页信息</param>
/// <returns></returns>
public virtual async Task<long> CountAsync(TGetListInput input)
{
    var query = CreateFilteredQueryAsync(input);

    var totalCount = await query.CountAsync();
    return totalCount; //返回符合条件的所有数量
}

上面的 CreateFilteredQueryAsync 方法一般会在具体的业务类中进行重写，从而实现具体条件的查询过滤。

 

2、对于多表的联合处理操作

而对于复杂的多表之间的联合查询处理，如果分开多个函数来实现，可能会比较麻烦，而且也不够统一，因此我们可以统一整合在CreateFilteredQueryAsync 实现。

而一些特殊的条件，我们可以在原有生成的条件分页类里面，增加更多的属性，用来在联合查询中赋值、或者获取值。如下图是我们额外增加的几个特殊的属性，用来在其他业务表中进行关联查询的字段。

基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理

由于客户分组是在另外一张表里面记录的，客户和分组之间的关联，是通过中间表的联合查询获得的。

基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理

 客户和供应商也有一个中间表的关联关系，因此我们如何联合查询，根据条件，可以通过下面的代码进行联合查询获得。

            if (!input.GroupId.IsNullOrWhiteSpace())
            {
                // 联合 CustomerGroup_CustomerInfo 表进行查询
                query = this.Client.Queryable<CustomerInfo, CustomerGroup_CustomerInfo>(
                       (t, m) => t.Id == m.Customer_ID && m.CustomerGroup_ID == input.GroupId)
                       .Select(t => t).MergeTable(); //联合条件获取对象
            }       
            if(!input.SupplierId.IsNullOrEmpty())
            {
                query = this.Client.Queryable<CustomerInfo, Customer_SupplierInfo>(
                        (t, m) => t.Id == m.Customer_ID && m.Supplier_ID == input.SupplierId)
                        .Select(t => t).MergeTable(); //联合条件获取对象
            }

上面的代码，需要注意的是，不同表之间联合获得的结果，如果需要整合到主表进行的查询中，则需要使用 .MergeTable() 操作进行合并处理。

这种最终我们可以得到比较复杂一些的查询处理了。

        /// <summary>
        /// 自定义条件处理
        /// </summary>
        /// <param name="input">查询条件Dto</param>
        /// <returns></returns>
        protected override ISugarQueryable<CustomerInfo> CreateFilteredQueryAsync(CustomerPagedDto input)
        {
            var query = base.CreateFilteredQueryAsync(input);
            if (!input.GroupId.IsNullOrWhiteSpace())
            {
                // 联合 CustomerGroup_CustomerInfo 表进行查询
                query = this.Client.Queryable<CustomerInfo, CustomerGroup_CustomerInfo>(
                       (t, m) => t.Id == m.Customer_ID && m.CustomerGroup_ID == input.GroupId)
                       .Select(t => t).MergeTable(); //联合条件获取对象
            }       
            if(!input.SupplierId.IsNullOrEmpty())
            {
                query = this.Client.Queryable<CustomerInfo, Customer_SupplierInfo>(
                        (t, m) => t.Id == m.Customer_ID && m.Supplier_ID == input.SupplierId)
                        .Select(t => t).MergeTable(); //联合条件获取对象
            }

            //通过名称或代码查询，任一符合即可
            query = query.WhereIF(!input.NameOrCode.IsNullOrWhiteSpace(), t => t.Name.Contains(input.NameOrCode) || t.SimpleName.Contains(input.NameOrCode) || t.HandNo.Contains(input.NameOrCode));

            query = query
               .WhereIF(!input.ExcludeId.IsNullOrWhiteSpace(), t => t.Id != input.ExcludeId) //不包含排除ID
               .WhereIF(!input.HandNo.IsNullOrWhiteSpace(), t => t.HandNo.Contains(input.HandNo)) //如需要精确匹配则用Equals
                .WhereIF(!input.Name.IsNullOrWhiteSpace(), t => t.Name.Contains(input.Name)) //如需要精确匹配则用Equals
                .WhereIF(!input.SimpleName.IsNullOrWhiteSpace(), t => t.SimpleName.Contains(input.SimpleName)) //如需要精确匹配则用Equals
                .WhereIF(!input.Province.IsNullOrWhiteSpace(), t => t.Province.Contains(input.Province)) //如需要精确匹配则用Equals
                .WhereIF(!input.City.IsNullOrWhiteSpace(), t => t.City.Contains(input.City)) //如需要精确匹配则用Equals
                .WhereIF(!input.District.IsNullOrWhiteSpace(), t => t.District.Contains(input.District)) //如需要精确匹配则用Equals
                .WhereIF(!input.Area.IsNullOrWhiteSpace(), t => t.Area.Contains(input.Area)) //如需要精确匹配则用Equals
                .WhereIF(!input.Address.IsNullOrWhiteSpace(), t => t.Address.Contains(input.Address)) //如需要精确匹配则用Equals
                .WhereIF(!input.ZipCode.IsNullOrWhiteSpace(), t => t.ZipCode.Contains(input.ZipCode)) //如需要精确匹配则用Equals
                .WhereIF(!input.Telephone.IsNullOrWhiteSpace(), t => t.Telephone.Contains(input.Telephone)) //如需要精确匹配则用Equals
                .WhereIF(!input.Fax.IsNullOrWhiteSpace(), t => t.Fax.Contains(input.Fax)) //如需要精确匹配则用Equals
                .WhereIF(!input.Contact.IsNullOrWhiteSpace(), t => t.Contact.Contains(input.Contact)) //如需要精确匹配则用Equals
                .WhereIF(!input.ContactPhone.IsNullOrWhiteSpace(), t => t.ContactPhone.Contains(input.ContactPhone)) //如需要精确匹配则用Equals
                .WhereIF(!input.ContactMobile.IsNullOrWhiteSpace(), t => t.ContactMobile.Contains(input.ContactMobile)) //如需要精确匹配则用Equals
                .WhereIF(!input.Email.IsNullOrWhiteSpace(), t => t.Email.Contains(input.Email)) //如需要精确匹配则用Equals
                .WhereIF(!input.QQ.IsNullOrWhiteSpace(), t => t.QQ.Contains(input.QQ)) //如需要精确匹配则用Equals
                .WhereIF(!input.Industry.IsNullOrWhiteSpace(), t => t.Industry.Contains(input.Industry)) //如需要精确匹配则用Equals
                .WhereIF(!input.BusinessScope.IsNullOrWhiteSpace(), t => t.BusinessScope.Contains(input.BusinessScope)) //如需要精确匹配则用Equals
                .WhereIF(!input.Brand.IsNullOrWhiteSpace(), t => t.Brand.Contains(input.Brand)) //如需要精确匹配则用Equals
                .WhereIF(!input.PrimaryClient.IsNullOrWhiteSpace(), t => t.PrimaryClient.Contains(input.PrimaryClient)) //如需要精确匹配则用Equals
                .WhereIF(!input.PrimaryBusiness.IsNullOrWhiteSpace(), t => t.PrimaryBusiness.Contains(input.PrimaryBusiness)) //如需要精确匹配则用Equals
                                                                                                                              //注册资金区间查询
               .WhereIF(input.RegisterCapitalStart.HasValue, s => s.RegisterCapital >= input.RegisterCapitalStart.Value)
               .WhereIF(input.RegisterCapitalEnd.HasValue, s => s.RegisterCapital <= input.RegisterCapitalEnd.Value)
               //营业额区间查询
               .WhereIF(input.TurnOverStart.HasValue, s => s.TurnOver >= input.TurnOverStart.Value)
               .WhereIF(input.TurnOverEnd.HasValue, s => s.TurnOver <= input.TurnOverEnd.Value)
                .WhereIF(!input.LicenseNo.IsNullOrWhiteSpace(), t => t.LicenseNo.Contains(input.LicenseNo)) //如需要精确匹配则用Equals
                .WhereIF(!input.Bank.IsNullOrWhiteSpace(), t => t.Bank.Contains(input.Bank)) //如需要精确匹配则用Equals
                .WhereIF(!input.BankAccount.IsNullOrWhiteSpace(), t => t.BankAccount.Contains(input.BankAccount)) //如需要精确匹配则用Equals
                .WhereIF(!input.LocalTaxNo.IsNullOrWhiteSpace(), t => t.LocalTaxNo.Contains(input.LocalTaxNo)) //如需要精确匹配则用Equals
                .WhereIF(!input.NationalTaxNo.IsNullOrWhiteSpace(), t => t.NationalTaxNo.Contains(input.NationalTaxNo)) //如需要精确匹配则用Equals
                .WhereIF(!input.LegalMan.IsNullOrWhiteSpace(), t => t.LegalMan.Contains(input.LegalMan)) //如需要精确匹配则用Equals
                .WhereIF(!input.LegalTelephone.IsNullOrWhiteSpace(), t => t.LegalTelephone.Contains(input.LegalTelephone)) //如需要精确匹配则用Equals
                .WhereIF(!input.LegalMobile.IsNullOrWhiteSpace(), t => t.LegalMobile.Contains(input.LegalMobile)) //如需要精确匹配则用Equals
                .WhereIF(!input.Source.IsNullOrWhiteSpace(), t => t.Source.Contains(input.Source)) //如需要精确匹配则用Equals
                .WhereIF(!input.WebSite.IsNullOrWhiteSpace(), t => t.WebSite.Contains(input.WebSite)) //如需要精确匹配则用Equals
                .WhereIF(!input.CompanyPictureGUID.IsNullOrWhiteSpace(), t => t.CompanyPictureGUID.Contains(input.CompanyPictureGUID)) //如需要精确匹配则用Equals
                .WhereIF(!input.CustomerType.IsNullOrWhiteSpace(), t => t.CustomerType.Contains(input.CustomerType)) //如需要精确匹配则用Equals
                .WhereIF(!input.Grade.IsNullOrWhiteSpace(), t => t.Grade.Contains(input.Grade)) //如需要精确匹配则用Equals
                .WhereIF(!input.CreditStatus.IsNullOrWhiteSpace(), t => t.CreditStatus.Contains(input.CreditStatus)) //如需要精确匹配则用Equals
                .WhereIF(!input.Importance.IsNullOrWhiteSpace(), t => t.Importance.Contains(input.Importance)) //如需要精确匹配则用Equals
                .WhereIF(input.IsPublic.HasValue, t => t.IsPublic == input.IsPublic) //如需要精确匹配则用Equals
                .WhereIF(input.Satisfaction.HasValue, t => t.Satisfaction == input.Satisfaction) //如需要精确匹配则用Equals
                .WhereIF(!input.Note.IsNullOrWhiteSpace(), t => t.Note.Contains(input.Note)) //如需要精确匹配则用Equals
                .WhereIF(input.TransactionCount.HasValue, t => t.TransactionCount == input.TransactionCount) //如需要精确匹配则用Equals
              
                //交易金额区间查询
               .WhereIF(input.TransactionTotalStart.HasValue, s => s.TransactionTotal >= input.TransactionTotalStart.Value)
               .WhereIF(input.TransactionTotalEnd.HasValue, s => s.TransactionTotal <= input.TransactionTotalEnd.Value)
               //首次交易时间区间查询
               .WhereIF(input.TransactionFirstDayStart.HasValue, s => s.TransactionFirstDay >= input.TransactionFirstDayStart.Value)
               .WhereIF(input.TransactionFirstDayEnd.HasValue, s => s.TransactionFirstDay <= input.TransactionFirstDayEnd.Value)
               //最近交易时间区间查询
               .WhereIF(input.TransactionLastDayStart.HasValue, s => s.TransactionLastDay >= input.TransactionLastDayStart.Value)
               .WhereIF(input.TransactionLastDayEnd.HasValue, s => s.TransactionLastDay <= input.TransactionLastDayEnd.Value)
               //最近联系日期区间查询
               .WhereIF(input.LastContactDateStart.HasValue, s => s.LastContactDate >= input.LastContactDateStart.Value)
               .WhereIF(input.LastContactDateEnd.HasValue, s => s.LastContactDate <= input.LastContactDateEnd.Value)
                                                                                                      
               //创建时间区间查询
               .WhereIF(input.CreateTimeStart.HasValue, s => s.CreateTime >= input.CreateTimeStart.Value)
               .WhereIF(input.CreateTimeEnd.HasValue, s => s.CreateTime <= input.CreateTimeEnd.Value)   
               //编辑时间区间查询
               .WhereIF(input.EditTimeStart.HasValue, s => s.EditTime >= input.EditTimeStart.Value)
               .WhereIF(input.EditTimeEnd.HasValue, s => s.EditTime <= input.EditTimeEnd.Value)

               .WhereIF(!input.Stage.IsNullOrWhiteSpace(), t => t.Stage.Contains(input.Stage)) //如需要精确匹配则用Equals
               .WhereIF(!input.Status.IsNullOrWhiteSpace(), s => s.Status == input.Status)
               .WhereIF(!input.Creator.IsNullOrWhiteSpace(), t => t.Creator.Contains(input.Creator)) //如需要精确匹配则用Equals
               .WhereIF(!input.Editor.IsNullOrWhiteSpace(), t => t.Editor.Contains(input.Editor)) //如需要精确匹配则用Equals
               .WhereIF(input.Deleted.HasValue, s => s.Deleted == input.Deleted)
               .WhereIF(!input.Dept_ID.IsNullOrWhiteSpace(), t => t.Dept_ID.Contains(input.Dept_ID)) //如需要精确匹配则用Equals
               .WhereIF(!input.Company_ID.IsNullOrWhiteSpace(), t => t.Company_ID.Contains(input.Company_ID)) //如需要精确匹配则用Equals
               .WhereIF(!input.MarkColor.IsNullOrWhiteSpace(), t => t.MarkColor.Contains(input.MarkColor)) //如需要精确匹配则用Equals
               .WhereIF(!input.ShareUsers.IsNullOrWhiteSpace(), t => t.ShareUsers.Contains(input.ShareUsers)) //如需要精确匹配则用Equals
               ;

            return query;
        }

有了这个丰富条件的处理，我们就可以在前端进行属性赋值就可以了，简单的调用后端通用的接口查询即可。

//构建分页的条件和查询条件
pagerDto = new CustomerPagedDto(this.winGridViewPager1.PagerInfo)
{
    //添加所需条件
    NameOrCode = this.txtCustomerNo.Text.Trim(),
    Deleted = 0
};

查询获得接口数据处理如下代码所示。

var result = await BLLFactory<ICustomerService>.Instance.GetListAsync(pagerDto);
return result;

在分页列表中展示获得的记录详细信息如下代码所示。

/// <summary>
/// 绑定列表数据
/// </summary>
private async void BindData()
{
    //entity
    this.winGridViewPager1.DisplayColumns = displayColumns;
    this.winGridViewPager1.ColumnNameAlias = await BLLFactory<ICustomerService>.Instance.GetColumnNameAlias();//字段列显示名称转义

    //获取分页数据列表
    var result = await GetData();

    //设置所有记录数和列表数据源
    this.winGridViewPager1.PagerInfo.RecordCount = result.TotalCount; //需先于DataSource的赋值，更新分页信息
    this.winGridViewPager1.DataSource = result.Items;
    this.winGridViewPager1.PrintTitle = "客户信息列表";
}

基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理

 

3、对于多种属性、状态条件的统一处理

我在之前介绍过的CRM系统主界面中，关于客户关系信息的展示的时候，是通过一个复杂的树形列表来承载不同属性来进行快速的查询，如下界面所示。

基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理

这些树形列表的属性信息，在SqlSugar开发框架中，我们统一进行生成，首先定义一个通用的承载对象，如下类所示。

/// <summary>
/// 对CRM的业务数据进行统计的一个公共类
/// </summary>
public class CrmStaticsDto
{
    /// <summary>
    /// 节点显示名称
    /// </summary>
    public string Label { get; set; }

    /// <summary>
    /// 属性名称
    /// </summary>
    public string TypeName { get; set; }

    /// <summary>
    /// 数量
    /// </summary>
    public long Count { get; set; }

    /// <summary>
    /// 业务分类
    /// </summary>
    public string Category { get; set; }

    /// <summary>
    /// 记录的日期开始
    /// </summary>
    public DateTime? DateStart { get; set; }
    /// <summary>
    /// 记录的日期结束
    /// </summary>
    public DateTime? DateEnd { get; set; }

    /// <summary>
    /// 创建人信息
    /// </summary>
    public CListItem Creator { get; set; }

    /// <summary>
    /// 子节点集合
    /// </summary>
    public List<CrmStaticsDto> children { get; set; } = new List<CrmStaticsDto>();
}

这个类似一个嵌套的集合，通过children进行添加更多的子集记录。

后端提供一个获取统计信息的树形列表的方法，如下定义所示。

        /// <summary>
        /// 获取列表统计信息
        /// </summary>
        /// <returns></returns>
        public async Task<List<CrmStaticsDto>> GetStatics(string compnayId)
        {
           ................
        }

但我们为它添加各种属性的时候，设置相关的节点文本、类别信息即可。

    //所有记录
    var allNode = new CrmStaticsDto()
    {
        Label = "所有记录"
    };
    list.Add(allNode);

    var propertyNode = new CrmStaticsDto()
    {
        Label = "客户属性分类"
    };
    list.Add(propertyNode);


    var typeName = "客户状态";
    var count = await baseQuery.Clone().CountAsync();//Clone()避免进行多次查询时，可能会出现结果不正确的问题
    var statusNode = new CrmStaticsDto()
    {
        Label = $"{typeName}({count})",
        Count = count,
        TypeName = typeName
    };
    var dict = await dictDataService.FindByDictType(typeName);
    foreach (var info in dict)
    {
        var value = info.Value;
        var subCount = baseQuery.Clone().Where(s => s.Status == value).Count();
        statusNode.children.Add(new CrmStaticsDto()
        {
            Label = $"{info.Name}({subCount})",
            Count = subCount,
            Category = info.Value,
            TypeName = typeName
        });
    }
    propertyNode.children.Add(statusNode);

这样我们在前端的WInform界面中展示树形列表的时候，就会变得非常简单，通过一个递归的函数就可以添加相关的节点信息了，如下代码所示。

private async void InitTree()
{
    this.treeView1.BeginUpdate();
    this.treeView1.Nodes.Clear();

    //获取所有的统计列表
    var staticsList = await BLLFactory<ICustomerService>.Instance.GetStatics(this.SelectedCompanyID);
    await AddTreeData(staticsList, null);

    //this.treeView1.ExpandAll();
    this.treeView1.EndUpdate();
}

private async Task AddTreeData(List<CrmStaticsDto> staticsList, TreeNode parentNode = null)
{
    var i = 0;
    if (staticsList != null)
    {
        foreach (var info in staticsList)
        {
            var node = new TreeNode(info.Label, i, i);
            node.Tag = info;
            node.Text = info.Label;

            await AddTreeData(info.children, node);

            if (parentNode == null)
            {
                this.treeView1.Nodes.Add(node); //如果是顶级处理，则treeView1节点加入
            }
            else
            {
                parentNode.Nodes.Add(node); //如果是递归的，则加到父节点上
            }
        }
    }
}

以上就是对联合多个表进行查询以及树形列表的条件展示的处理思路，系统能够给大家一些参考思路。文章来源地址https://www.toymoban.com/news/detail-469235.html

到了这里，关于基于SqlSugar的开发框架循序渐进介绍（31）-- 在查询接口中实现多表联合和单表对象的统一处理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包