标签（Tag）的各种设计方案

标签（Tag）的各种设计方案

首先，标签（Tag）是什么？

我的理解：用来具体区分某一类内容的标识，和标签类似的一个概念是分类（Category），有一个示例可以很好的区分它们两个，比如人类分为：白种人、黄种人和黑种人（可以看作分类），但又可以根据职业分为：农民、工人和程序猿等等（可以看作标签）。

概括来说就是：分类是大而全的概念（用抽象概念来区分），标签是小而具体的概念（用具体值来区分）。

在所有的 CMS 内容管理系统中（比如园子中的博客、博问、新闻、网摘等），都存在标签（Tag）的概念，而且它们大多都有相似的功能，对于这类问题，我们最好把它抽象出来，然后单独去考虑并探讨它，如果一切顺利的话，最后完成的东西就是标签领域（TagDomain），当然这是最理想的方式。

我们先从实际应用出发，今天要探讨的是：各种标签（Tag）模型设计下，各类应用操作的实现方式。

标签（Tag）模型，我大概设计了 4 种（也可以在这个基础上进行扩展），如下：

  • 1. Tag 存在于 Post 中。
  • 2. Tag 独立 Post（一对多关系）。
  • 3. Tag 独立 Post（一对多关系），Post 中多一个 Tags。
  • 4. Tag 和 Post 都独立，创建 TagMap 映射（多对多关系）。

应用操作（EF Linq 实现），我大概想了 8 种，对于 Tag 的一般操作，我想应该都包含了，如下：

  • 1. 添加 Post-Tag
  • 2. 单独修改 Tag
  • 3. 在 Post 中修改 Tag
  • 4. 单独删除 Tag
  • 5. 在 Post 中删除Tag
  • 6. 查询 Tag（带数量统计）
  • 7. 查询 Post（Tag 展示）
  • 8. 根据 Tag 查询 Post 列表

下面我们分别来探讨下。

1. Tag 存在于 Post 中。

Tag 模型图：

Tag 模型说明：这个 Tag 模型是最简单的，Tag 直接存在 Post 中，但是模型简单，就意味着应用操作实现会很复杂。

应用操作实现代码：

public void Tags1()
{
    using (var context = new TagsDbContext())
    {
        //1.添加post-tag
        var postAdd = new Post1 { UserId = 1, Title = "title", Content = "content", Tags = ".net|asp.net vnext" };
        context.Post1s.Add(postAdd);

        //2.4.6单独对tag进行修改、删除、查询（带数量统计），难于登天。。。

        //3.在post中修改tag
        var postModify = context.Post1s.FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        postModify.Tags.Replace("asp.net vnext", "asp.net5");

        //5.在post中删除tag
        var postTagDelete = context.Post1s.FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        postTagDelete.Tags.Replace("asp.net vnext", "");

        //7.查询post（tag展示）
        var postSelect = context.Post1s.FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        postSelect.Tags.Replace(‘|‘, ‘,‘);

        //8.根据tag查询post
        var postTagSelect = context.Post1s.Where(p => p.Tags.Contains("asp.net5") && p.UserId == 1).ToList();

        context.SaveChanges();
    }
}

结论：可以看到，对于 2.4.6 应用操作，这种模型根本就没办法进行操作（也可以，但实现起来太复杂），2.4.6 应用操作属于对 Tag 的单独操作，如果应用场景只要求在 Post 中进行 Tag 操作，这种模型是完全可以胜任的，但如果要对 Tag 进行单独操作，用这种 Tag 模型，那就是自杀行为。。。

2. Tag 独立 Post（一对多关系）。

Tag 模型图：

Tag 模型说明：这种设计虽然把 Tag 和 Post 分离了，但需要注意的是，Post 和 Tag 的关系是一对多，有人会说，Post 和 Tag 的关系不是多对多的吗？一个 Tag 也可能对应多个 Post，但这种模型设计并不是这样，Tag 中有一个 PostId，表示这个 Tag 属于哪个 Post，比如有这样的示例：Tag 为 ASP.NET 的 Post 有两篇，那么在 Tag 中就会有两条 Tag 为 ASP.NET 的数据，但对应不同的 PostId。

应用操作实现代码：

public void Tags2()
{
    using (var context = new TagsDbContext())
    {
        //1.添加post-tag
        var postAdd = new Post2 { UserId = 1, Title = "title", Content = "content" };
        postAdd.Tag2s.Add(new Tag2 { UserId = 1, TagName = ".net" });
        postAdd.Tag2s.Add(new Tag2 { UserId = 1, TagName = "asp.net vnext" });
        context.Post2s.Add(postAdd);

        //2.单独修改tag
        var tagsModify = context.Tag2s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).ToList();
        tagsModify.ForEach(t => t.TagName = "asp.net5");

        //3.在post中修改tag
        var tagModify = context.Tag2s.FirstOrDefault(t => t.TagName == "asp.net vnext" && t.UserId == 1 && t.PostId == 1);
        tagModify.TagName = "asp.net5";

        //4.单独删除tag
        var tagsDelete = context.Tag2s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).ToList();
        context.Tag2s.RemoveRange(tagsDelete);

        //5.在post中删除tag
        var tagDelete = context.Tag2s.FirstOrDefault(t => t.TagName == "asp.net vnext" && t.UserId == 1 && t.PostId == 1);
        context.Tag2s.Remove(tagDelete);

        //6.查询tag（带数量统计）
        var tagsSelect = from t in context.Tag2s
                         where t.UserId == 1
                         group t by t.TagName into g
                         orderby g.Count() descending
                         select new
                         {
                             TagName = g.Key,
                             UseCount = g.Count()
                         };

        //7.查询post（tag展示）
        var postSelect = context.Post2s.Include(p => p.Tag2s).FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        var tags = string.Join(",", postSelect.Tag2s.Select(t => t.TagName));

        //8.根据tag查询post
        var postTagSelect = from p in context.Post2s
                            join t in context.Tag2s on p.PostId equals t.PostId
                            where t.TagName == "asp.net5" && p.UserId == 1
                            select p;

        context.SaveChanges();
    }
}

结论：可以看到，使用这种 Tag 模型，7种应用操作的实现都不是很复杂，但有一个缺点是：Tag 重复数据会很多，如果有 10 个 Post，每个 Post 有 3 个 Tag，不管 Tag 是否相同，那么 Tag 的数据就是 30 条。如果对于数据量要求不大的话，可以采用这种方式，毕竟实现起来不是很复杂（比如其他三种的实现），我个人也比较偏向这种 Tag 模型设计。

3. Tag 独立 Post（一对多关系），Post 中多一个 Tags。

Tag 模型说明：这种模型设计和上面第二种差不多，只不过在 Post 中多了个 Tags（String 类型），它的作用就是为了在 Post Tag 展示的时候，不用再去关联查找 Tag，方便是方便，但我们需要付出一些代码，那就是需要对 Post 中的 Tags 进行维护，利与弊，我们看下应用操作的实现，就知道了。

应用操作实现代码：

public void Tags3()
{
    using (var context = new TagsDbContext())
    {
        //1.添加post-tag
        var postAdd = new Post3 { UserId = 1, Title = "title", Content = "content", Tags = ".net|asp.net vnext" };
        context.Post3s.Add(postAdd);
        context.Tag3s.Add(new Tag3 { UserId = 1, TagName = ".net" });
        context.Tag3s.Add(new Tag3 { UserId = 1, TagName = "asp.net vnext" });

        //2.单独修改tag
        var tagsModify = context.Tag3s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).ToList();
        var postsModify = (from p in context.Post3s
                           join t in tagsModify on p.PostId equals t.PostId
                           select p).ToList();
        tagsModify.ForEach(t => t.TagName = "asp.net5");
        postsModify.ForEach(p => p.Tags.Replace("asp.net vnext", "asp.net5"));

        //3.在post中修改tag
        var tagModify = context.Tag3s.FirstOrDefault(t => t.TagName == "asp.net vnext" && t.UserId == 1 && t.PostId == 1);
        tagModify.TagName = "asp.net5";
        var postModify = context.Post3s.FirstOrDefault(t => t.UserId == 1 && t.PostId == 1);
        postModify.Tags.Replace("asp.net vnext", "asp.net5");

        //4.单独删除tag
        var tagsDelete = context.Tag3s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).ToList();
        var postsTagsModify = (from p in context.Post3s
                               join t in tagsModify on p.PostId equals t.PostId
                               select p).ToList();
        context.Tag3s.RemoveRange(tagsDelete);
        postsModify.ForEach(p => p.Tags.Replace("asp.net vnext", ""));

        //5.在post中删除tag
        var tagDelete = context.Tag3s.FirstOrDefault(t => t.TagName == "asp.net vnext" && t.UserId == 1 && t.PostId == 1);
        context.Tag3s.Remove(tagDelete);
        var postTagDelete = context.Post3s.FirstOrDefault(t => t.UserId == 1 && t.PostId == 1);
        postTagDelete.Tags.Replace("asp.net vnext", "");

        //6.查询tag（带数量统计）
        var tagsSelect = from t in context.Tag3s
                         where t.UserId == 1
                         group t by t.TagName into g
                         orderby g.Count() descending
                         select new
                         {
                             TagName = g.Key,
                             UseCount = g.Count()
                         };

        //7.查询post（tag展示）
        var postSelect = context.Post3s.FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        postSelect.Tags.Replace("|", ",");

        //8.根据tag查询post
        var postTagSelect = from p in context.Post3s
                            join t in context.Tag3s on p.PostId equals t.PostId
                            where t.TagName == "asp.net5" && p.UserId == 1
                            select p;

        context.SaveChanges();
    }
}

结论：先不看应用操作的具体实现，单纯从代码量上和第二种进行对比，会发现这种 Tag 模型的应用操作实现代码会比较多，添加、修改和删除 Tag，都要对 Post 中的 Tags 进行操作，而我们做这些多余的工作，仅仅是换来的是，最后查询 Post 而不关联 Tag，总感觉有点得不偿失，但并不意味着这种 Tag 模型实现就无用武之地，如果我们的应用场景，要求对 Tag 操作，必须通过 Post，比如修改 Tag，则必须通过 Post 进行修改，也就是不能对 Tag 进行独立操作，那么这种 Tag 模型就很适用。

应用场景不要求对 Tag 进行独立操作，上面说到，第一种 Tag 模型设计也适用啊，它们有什么不同呢？ 分离 Tag 的好处是什么呢？很简单，就是为了方便 Tag 使用数量的统计，如果应用场景要求这个操作，第一种 Tag 模型设计就不适用了。

4. Tag 和 Post 都独立，创建 TagMap 映射（多对多关系）。

Tag 模型说明：这种 Tag 模型和上面第二种形成鲜明对比，上面第二种 Post 和 Tag 是一对多关系，而这种是多对多关系，第二种会出现重复 Tag 数据，而这种则不会。从模型图中，我们可以看到，Post 和 Tag 是独立存在的，它们通过一个 TagMap 进行映射关联，Tag 中的 UserId 和 TagName 是唯一的，并且多了一个 UseCount，在第二种 Tag 模型中，因为 Tag 根据 Post 产生，我们想要统计 Tag 的使用数量，直接对 Tag 进行 GroupBy 就可以了（具体看第二种的实现代码），而这种 Tag 模型，某一特定用户下的 Tag 是唯一的，所以要想统计 Tag 的使用数量，就必须通过 TagMap（需要关联 Tag 实现），既然 Tag 是独立的，那还不如增加一个 UseCount 更加方便。

这种 Tag 模型设计是四种方案中最复杂的，好处就是模型更加健壮，方便扩展，没有荣冗余数据产生，那坏处呢？我们接着看下面。

应用操作实现代码：

public void Tags4()
{
    using (var context = new TagsDbContext())
    {
        //1.添加post-tag
        var postAdd = new Post4 { UserId = 1, Title = "title", Content = "content" };
        context.Post4s.Add(postAdd);
        var tagAdd1 = context.Tag4s.FirstOrDefault(t => t.TagName == ".net" && t.UserId == 1);
        var tagAdd2 = context.Tag4s.FirstOrDefault(t => t.TagName == "asp.net vnext" && t.UserId == 1);
        if (tagAdd1 != null)
            tagAdd1.UseCount++;
        else
            context.Tag4s.Add(new Tag4 { UserId = 1, TagName = ".net", UseCount = 1 });
        if (tagAdd2 != null)
            tagAdd1.UseCount++;
        else
            context.Tag4s.Add(new Tag4 { UserId = 1, TagName = "asp.net vnext", UseCount = 1 });
        context.TagMap4s.Add(new TagMap4 { PostId = postAdd.PostId, TagId = tagAdd1.TagId });
        context.TagMap4s.Add(new TagMap4 { PostId = postAdd.PostId, TagId = tagAdd2.TagId });

        //2.单独修改tag
        var tagModify = context.Tag4s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).FirstOrDefault();
        tagModify.TagName = "asp.net5";

        //3.在post中修改tag
        var tagModify2 = (from t in context.Tag4s
                          where t.UserId == 1 && t.TagName == "asp.net vnext"
                          join m in context.TagMap4s on t.TagId equals m.TagId
                          where m.PostId == 1
                          select t).FirstOrDefault();
        tagModify2.UseCount--;
        var tagModify3 = context.Tag4s.FirstOrDefault(t => t.TagName == "asp.net 5" && t.UserId == 1);
        if (tagModify3 != null)
            tagModify3.UseCount++;
        else
            context.Tag4s.Add(new Tag4 { UserId = 1, TagName = "asp.net 5", UseCount = 1 });
        var postModify = context.Post4s.FirstOrDefault(p => p.PostId == 1 && p.UserId == 1);
        var tagMapDelete= context.TagMap4s.FirstOrDefault(p => p.PostId == 1 && p.TagId == tagModify2.TagId);
        context.TagMap4s.Remove(tagMapDelete);
        postModify.TagMap4s.Add(new TagMap4 { PostId = postModify.PostId, TagId = tagModify3.TagId });

        //4.单独删除tag
        var tagDelete = context.Tag4s.Where(t => t.TagName == "asp.net vnext" && t.UserId == 1).FirstOrDefault();
        var tagMapsDelete = context.TagMap4s.Where(t => t.TagId == tagDelete.TagId).ToList();
        context.Tag4s.Remove(tagDelete);
        context.TagMap4s.RemoveRange(tagMapsDelete);

        //5.在post中删除tag
        var tagDelete2 = (from t in context.Tag4s
                          where t.UserId == 1 && t.TagName == "asp.net vnext"
                          join m in context.TagMap4s on t.TagId equals m.TagId
                          where m.PostId == 1
                          select t).FirstOrDefault();
        tagDelete2.UseCount--;
        var tagMapDelete2 = context.TagMap4s.FirstOrDefault(p => p.PostId == 1 && p.TagId == tagDelete2.TagId);
        context.TagMap4s.Remove(tagMapDelete2);

        //6.查询tag（带数量统计）
        var tagsSelect = context.Tag4s.Where(t => t.UserId == 1).ToList();

        //7.查询post（tag展示）
        var postSelect = context.Post4s.FirstOrDefault(p =>p.PostId == 1 && p.UserId == 1);
        var tagsSelect2 = (from t in context.Tag4s
                           where t.UserId == 1
                           join m in context.TagMap4s on t.TagId equals m.TagId
                           select t).ToList();
        var tags = string.Join(",", tagsSelect2.Select(t => t.TagName));

        //8.根据tag查询post
        var postTagSelect = from p in context.Post4s
                            join m in context.TagMap4s on p.PostId equals m.PostId
                            join t in context.Tag4s on m.TagId equals t.TagId
                            where t.TagName == "asp.net5" && p.UserId == 1 && t.UserId == 1
                            select p;

        context.SaveChanges();
    }
}

结论：单从代码量上来说，这种应用操作实现代码量最多，其实大部分操作都是在判断 Tag，也就是为了利用现有的 Tag 数据，并不是像前面两种，不管 Tag 是否存在，直接添加、修改和删除，统计 Tag 使用数量实现，是四种方案中最简单的，其余的应用操作，因为模型层级越多、关联越多，操作起来就会越复杂，但不可否认，这种设计，是四种方案中“最理想”的。

5. 简要总结

深入去设计并实现这四种 Tag 模型方案，其实有很多的感触，是之前没实现体会不到的，比如：

  • 模型的简单和复杂是相对的：并不是模型越简单越好，也不是越复杂越好，第一和第二种方案就说明这点。
  • 模型的设计是相对于应用场景的：在不能确定应用场景的情况下，不能说哪种模型设计是好是坏，交通工具有很多种，飞机快过汽车，但飞机在陆地上跑不过汽车。

最后，简要总结下四种 Tag 模型设计的一些应用场景：

  • 1. Tag 存在于 Post 中：1.3.5.7.8 应用操作，不要求独立对 Tag 进行操作和数量统计。
  • 2. Tag 独立 Post（一对多关系）：1-8 应用操作，数据量不是很大，对 Tag 操作比较频繁，对 Post 操作不频繁。
  • 3. Tag 独立 Post（一对多关系），Post 中多一个 Tags：1-8 应用操作，数据量不是很大，对 Post 操作比较频繁，对 Tag 操作不频繁。
  • 4. Tag 和 Post 都独立，创建 TagMap 映射（多对多关系）：1-8 应用操作，Tag 业务变化比较频繁，对 Tag 和 Post 操作都比较频繁。

对于我自己来说，上面四种 Tag 模型设计，我最偏向于第二种和第四种，如果非要选择一种的话，我可能会选择第二种，为什么呢？因为谁写过应用操作的实现代码，谁知道，哈哈！！！

相关参考资料：

未完待续。。。

时间： 2024-07-31 09:30:37

标签（Tag）的各种设计方案的相关文章

JSP自定义分页标签TAG

首先我们需要在WEB-INF/tld/目录下创建page.tld文件 <?xml version="1.0" encoding="ISO-8859-1"?> <taglib> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>page</short-name> <u

struts2 官方系列教程三：使用struts2 标签 tag

避免被爬,先贴上本帖地址:struts2 官方系列教程一:使用struts2 标签 tag http://www.cnblogs.com/linghaoxinpian/p/6901316.html 本教材假定你已完成了HelloWorld项目,你可以在 struts2 官方系列教程三:使用struts2 标签 tag 下载本章节的代码 在上一节教程中,我们在index.jsp中使用 url tag 创建了一个超链接hello.action 这节我们将探索struts2中其它tags Web应用程

一、变量.二、过滤器(filter).三、标签(tag).四、条件分支tag.五、迭代器tag.六、自定义过滤器与标签.七、全系统过滤器（了解）

一.变量 ''' 1.视图函数可以通过两种方式将变量传递给模板页面 -- render(request, 'test_page.html', {'变量key1': '变量值1', ..., '变量keyn': '变量值n'}) -- render(request, 'test_page.html', locals()) # locals() 就是将视图函数中的所有变量都传递给模板页面 2.模板页面中对变量的使用 def dtl(request): num = 3.14 ss = '大碗宽面' #

Struts2 自定义下拉框标签Tag

自定义标签主要包括三个步骤: 1.编写java类,继承TagSupport类: 2.创建tld文件,影射标签名和标签的java类: 3.jsp页面引入tld. 例子:自定义下拉框标签 如果页面上有下拉选择框,通常最好的解决方法是使用数据字典,因为有可能多个页面 使用同一个下拉框,便于后台统一维护. 自定义Tag类 import java.io.IOException; import javax.servlet.jsp.JspException; import javax.servlet.jsp.

androi自定义自动换行的View（类似网页的标签Tag）

看来只有礼拜天才有时间写点博客啊,平时只能埋头苦干了.今天在公司加班,遇到一个需求,就是自动换行的TextView,有点像网页的tag标签,点击一下,就自动加上去了,不过这个是根据后台拿来的数据来显示多少个View,在网上找找,看见了许多,我自己也封装写一个吧,以便以后需要...开工 package com.woyou.ui.component; import android.content.Context; import android.util.AttributeSet; import an

jsp自定义标签tag EL函数

原文:jsp自定义标签tagEL函数 源代码下载地址:http://www.zuidaima.com/share/1550463459052544.htm 简单易懂的自定义EL函数 tag.java </pre><p> </p><pre name="code" class="java">package com.zuidaima.tag; import java.io.IOException; import javax.

DESTOON B2B标签(tag)调用手册

什么是标签调用?标签调用是根据调用条件(condition)从数据表(table)读取调用数量(pagesize)条数据,并按排序方式(order)排序,最终通过标签模板的布局输出数据.可以看出,标签的工作分两个部分,一是读取数据,二是显示数据. 标签函数原型标签函数保存于 include/tag.func.php tag($parameter, $expires = 0) $parameter 表示传递给tag函数的字符串,系统自动将其转换为多个变量.例如传递 table=destoon&pa

Java解析HTML标签Tag

import java.util.HashMap; import java.util.Map; public class TagParser { private Integer index = 0; private char[] tagChar; private int position = 0; /* 解析符号 */ private char symbol = '"'; public static final String START_SCRIPT = "<script&quo

ASP.NET MVC View中的标签(tag)

在编辑View的时候会用到各种HTML标签,如<a>,<input>,<p>等待,这些标签在ASP.NET MVC中都有对应的编程语法,它叫Razor,它是帮助我们动态的生成HTML标签,好处是可以绑定数据. 现在就让我们来复习一下HTML标签的用法:<input>, 因为它是最常用的表单标签之一,所以先从它开始. 可以移步:http://www.w3cschool.cn/htmltags/tag-label.html 看下它的定义. 基本都是用于接收用户输

PHP标签Tag的设计模式

没有太多时间进行全文翻译,就把重点挑出来,用自己的话串起来,名曰 选择性翻译. 以后可能会比较多的采用这种方式. 社会书签的tag存储一直是一个比较麻烦的问题. 一个好的数据表设计,不但要能准确查出tag,还应该支持tag的AND/OR/NOT查询.我们来看看解决方案. “MySQLicious” solution 表结构 存储实例 Intersection (AND) “search+webservice+semweb”类的查询: SELECT * FROM `delicious` WHERE