.NET 6 实现敏感词过滤

镇海的鱼

一、什么是敏感词过滤？

敏感词过滤是一种处理网络内容的技术，可以检测和过滤出网络中的敏感/违禁词汇。它通过给定的关键字或字符串，判断网络内容是否包含某些敏感信息，从而防止违反法律法规的信息流通。
通常，可以使用两种方法来过滤敏感词：

• 黑名单过滤：即定义一个黑名单，将所有敏感词择记录在其中，然后对输入的文本进行对比，如果发现有敏感词，就将其过滤掉。
  
• 白名单过滤：即定义一个白名单，将所有不敏感的词汇记录在其中，然后对输入的文本进行对比，如果发现有不在白名单中的词汇，就将其过滤掉。
  

二、ToolGood.Words是什么？

ToolGood.Words是一款高性能非法词(敏感词)检测组件，附带繁体简体互换，支持全角半角互换，获取拼音首字母，获取拼音字母，拼音模糊搜索等功能。
ToolGood.Words的源码网站：ToolGood.Words源码网站
三、在Visual Studio中安装ToolGood.Words

3.1、右键项目解决方案，选择“管理NuGet程序包”，如下图所示：

3.2、切换到“浏览”选项卡，搜索“ToolGood.Words”并安装：

安装完之后最好重新编译生成项目
四、创建“subContentCheck”类

敏感/违禁词汇因特殊内容不便上传，可自行在网站上查找

1. using Microsoft.AspNetCore.DataProtection.KeyManagement;
2. using Microsoft.AspNetCore.Http;
3. using Microsoft.CodeAnalysis.Text;
4. using Newtonsoft.Json;
5. using System.Collections;
6. using System.Text;
7. using ToolGood.Words;
8. using static System.Net.Mime.MediaTypeNames;
9. using IHostingEnvironment = Microsoft.AspNetCore.Hosting.IHostingEnvironment;
11. namespace WebApplication1 //放在自己项目中时，需要更换为自己的命名空间
12. {
13.     public class keywords
14.     {
15.         public List<string> IllegalKeywords { get; set; }
16.     }
18.     public class urlwords
19.     {
20.         public List<string> IllegalUrls { get; set; }
21.     }
23.     /// <summary>
24.     /// 提交的内容敏感违禁词检查类
25.     /// </summary>
26.     public class subContentCheck
27.     {
28.         /// <summary>
29.         /// 本地静态文件地址路径
30.         /// </summary>
31.         private IHostingEnvironment _hostingEnv;
33.         /// <summary>
34.         /// 敏感词库
35.         /// </summary>
36.         private string dictionaryPath = "/sensitiveWords/sensitiveWords.txt";
38.         /// <summary>
39.         /// 敏感链接、网站、网址库
40.         /// </summary>
41.         private string urlsPath = "/sensitiveWords/IllegalUrls.txt";
43.         /// <summary>
44.         /// 保存敏感词组
45.         /// </summary>
46.         public string[] Words { get; set; }
48.         /// <summary>
49.         /// 一个参数的构造函数
50.         /// </summary>
51.         /// <param name="hostingEnv">本地静态文件地址路径</param>
52.         public subContentCheck(IHostingEnvironment hostingEnv)
53.         {
54.             _hostingEnv = hostingEnv;
55.             InitDictionary();
56.         }
58.         /// <summary>
59.         /// 初始化内存敏感词库
60.         /// </summary>
61.         public void InitDictionary()
62.         {
63.             Words = new string[] { };
64.             string wordsPath = _hostingEnv.WebRootPath + dictionaryPath;
65.             string urlPath = _hostingEnv.WebRootPath + urlsPath;
66.             //List<keywords> keys = new List<keywords>();
67.             //List<urlwords> urls = new List<urlwords>();
68.             string[] readAllWords = System.IO.File.ReadAllLines(wordsPath, System.Text.Encoding.UTF8);
69.             string[] readAllurl = System.IO.File.ReadAllLines(urlPath, System.Text.Encoding.UTF8);
70.             //由于数组是非动态的，不能进行动态的添加，所有先将它转成list，操作
71.             ArrayList arrayList = new ArrayList(Words.ToList());
72.             if (readAllWords.Length > 0 || readAllurl.Length > 0)
73.             {
74.                 if (readAllWords.Length > 1)
75.                 {
76.                     //keywords key = new keywords();
77.                     //key.IllegalKeywords = new List<string>();
78.                     foreach (string itemWords in readAllWords)
79.                     {
80.                         string[] allSplitWords = itemWords.Split('|');
81.                         foreach (string itemSplitWords in allSplitWords)
82.                         {
83.                             if (!string.IsNullOrEmpty(itemSplitWords))
84.                             {
85.                                 arrayList.Add(itemSplitWords);
86.                                 //string aaa = itemSplitWords;
87.                                 //key.IllegalKeywords.Add(aaa);
88.                                 //IllegalKeywords.Add(itemSplitWords);
89.                             }
90.                         }
91.                     }
92.                     //keys.Add(key);
93.                 }
94.                 else
95.                 {
96.                     if (readAllWords.Length == 1)
97.                     {
98.                         string[] allSplitWords = readAllWords[0].Split('|');
99.                         //keywords key = new keywords();
100.                         //key.IllegalKeywords = new List<string>();
101.                         foreach (string itemSplitWords in allSplitWords)
102.                         {
103.                             if (!string.IsNullOrEmpty(itemSplitWords))
104.                             {
105.                                 arrayList.Add(itemSplitWords);
106.                                 //string aaa = itemSplitWords;
107.                                 //key.IllegalKeywords.Add(aaa);
108.                                 //IllegalKeywords.Add(itemSplitWords);
109.                             }
110.                         }
111.                         //keys.Add(key);
112.                     }
113.                 }
115.                 if (readAllurl.Length > 1)
116.                 {
117.                     //urlwords url = new urlwords();
118.                     //url.IllegalUrls = new List<string>();
119.                     foreach (string itemUrls in readAllurl)
120.                     {
121.                         string[] allSplitUrls = itemUrls.Split('|');
122.                         foreach (string itemSplitUrls in allSplitUrls)
123.                         {
124.                             if (!string.IsNullOrEmpty(itemSplitUrls))
125.                             {
126.                                 arrayList.Add(itemSplitUrls);
127.                                 //string Keyword = itemSplitUrls;
128.                                 //url.IllegalUrls.Add(Keyword);
129.                                 //IllegalUrls.Add(itemSplitUrls);
130.                             }
131.                         }
132.                     }
133.                     //urls.Add(url);
134.                 }
135.                 else
136.                 {
137.                     if (readAllurl.Length == 1)
138.                     {
139.                         string[] allSplitUrls = readAllurl[0].Split('|');
140.                         //urlwords url = new urlwords();
141.                         //url.IllegalUrls = new List<string>();
142.                         foreach (string itemSplitUrls in allSplitUrls)
143.                         {
144.                             if (!string.IsNullOrEmpty(itemSplitUrls))
145.                             {
146.                                 arrayList.Add(itemSplitUrls);
147.                                 //IllegalUrls.Add(itemSplitUrls);
148.                                 //string Keyword = itemSplitUrls;
149.                                 //url.IllegalUrls.Add(Keyword);
150.                             }
151.                         }
152.                         //urls.Add(url);
153.                     }
154.                 }
155.             }
156.             //我们在将list转换成String[]数组
157.             Words = (string[])arrayList.ToArray(typeof(string));
158.         }
160.         /// <summary>
161.         /// 过滤替换敏感词
162.         /// </summary>
163.         /// <param name="sourceText">需要过滤替换的原内容</param>
164.         /// <param name="replaceChar">敏感词替换的字符；默认替换为‘*’</param>
165.         /// <returns>返回状态码；为空则表示传入的内容为空；“0”：设置违禁词时发生错误；“1”：敏感内容替换时发生错误；“2”：需要替换的文本内容为空；其余则返回替换成功的字符串内容</returns>
166.         public string FilterWithChar(string sourceText, char replaceChar = '*')
167.         {
168.             if (!string.IsNullOrEmpty(sourceText))
169.             {
170.                 string result = "";
171.                 WordsSearch wordsSearch = new WordsSearch();
172.                 try
173.                 {
174.                     wordsSearch.SetKeywords(Words);
175.                 }
176.                 catch (Exception ex)
177.                 {
178.                     result = "0";
179.                     return result;
180.                 }
182.                 try
183.                 {
184.                     result = wordsSearch.Replace(sourceText, replaceChar);
185.                     return result;
186.                 }
187.                 catch (Exception ex)
188.                 {
189.                     return result = "1";
190.                 }
191.             }
192.             else
193.             {
194.                 return "2";
195.             }
196.         }
198.         /// <summary>
199.         /// 查找原内容中知否包含敏感/违禁词
200.         /// </summary>
201.         /// <param name="sourceText">需要判断的原内容</param>
202.         /// <returns>返回状态码；为空则表示传入的内容为空；“0”：设置违禁词时发生错误；“1”：敏感内容查询时发生错误；“2”：需要替换的文本内容为空；“3”：原内容中包含敏感/违禁词汇；“4”：原内容中不包含敏感/违禁词汇</returns>
203.         public string FindSensitiveKey(string sourceText)
204.         {
205.             string result = "";
206.             if (!string.IsNullOrEmpty(sourceText))
207.             {
208.                 WordsSearch wordsSearch = new WordsSearch();
209.                 try
210.                 {
211.                     wordsSearch.SetKeywords(Words);
212.                 }
213.                 catch (Exception ex)
214.                 {
215.                     result = "0";
216.                     return result;
217.                 }
219.                 try
220.                 {
221.                     bool res = wordsSearch.ContainsAny(sourceText);
222.                     if (res)
223.                     {
224.                         result = "3";
225.                         return result;
226.                     }
227.                     else
228.                     {
229.                         result = "4";
230.                         return result;
231.                     }
232.                 }
233.                 catch (Exception ex)
234.                 {
235.                     return result = "1";
236.                 }
237.             }
238.             else
239.             {
240.                 result = "2";
241.             }
242.             return result;
243.         }
245.         /// <summary>
246.         /// 把对象写入到json文件中
247.         /// </summary>
248.         /// <param name="obj"></param>
249.         /// <returns></returns>
250.         public static void Write(List<keywords> jsonData, List<urlwords> urlJsonData, string filename)
251.         {
252.             var directorypath = Directory.GetCurrentDirectory();
253.             string strFileName = directorypath + "\" + filename + ".json";
254.             string ListJson = "";
255.             if (jsonData != null)
256.             {
257.                 ListJson = JsonConvert.SerializeObject(jsonData);
258.             }
259.             else
260.             {
261.                 ListJson = JsonConvert.SerializeObject(urlJsonData);
262.             }
264.             Console.WriteLine(ListJson);
266.             writeJsonFile(strFileName, ListJson);
268.             //将序列化的json字符串内容写入Json文件，并且保存
269.             void writeJsonFile(string path, string jsonConents)
270.             {
271.                 using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite, FileShare.ReadWrite))
272.                 {
273.                     //如果json文件中有中文数据，可能会出现乱码的现象，那么需要加上如下代码
274.                     Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
275.                     using (StreamWriter sw = new StreamWriter(fs, Encoding.GetEncoding("GB2312")))
276.                     {
277.                         sw.WriteLine(jsonConents);
278.                     }
279.                 }
280.             }
281.         }
282.     }
283. }

复制代码

五、写API接口

1. /// <summary>
2. /// 进行敏感词脱敏
3. /// </summary>
4. /// <param name="sourctText">需要脱敏的文本内容</param>
5. /// <returns></returns>
6. [HttpPost]
7. public IActionResult sensitive_words_replace2(string sourctText)
8. {
9.     string resultStr = "";
10.     //实例化敏感词库
11.     subContentCheck strCheck = new subContentCheck(_hostingEnv);
12.     if (string.IsNullOrEmpty(sourctText))
13.     {
14.         return Json(new { code = 230, msg = "需要替换的文本内容为空！", resultStr = resultStr });
15.     }
16.     try
17.     {
18.         resultStr = strCheck.FilterWithChar(sourctText);
19.         string resMsg = "";
20.         int resCode = 200;
21.         if (resultStr=="0")
22.         {
23.             resCode = 210;
24.             resultStr = "";
25.             resMsg = "设置违禁词时发生错误，请联系管理员！";
26.         }else if (resultStr=="1")
27.         {
28.             resCode = 240;
29.             resultStr = "";
30.             resMsg = "敏感内容替换时发生错误！";
31.         }
32.         else if (resultStr == "2")
33.         {
34.             resCode = 260;
35.             resultStr = "";
36.             resMsg = "需要替换的文本内容为空！";
37.         }
38.         else
39.         {
40.             resCode = 200;
41.             resMsg = "敏感词替换请求成功！";
42.         }
43.         return Json(new { code = resCode, msg = resMsg, resultStr = resultStr });
44.     }
45.     catch (Exception ex)
46.     {
47.         return Json(new { code = 220, msg = "敏感内容替换时发生错误！", resultStr = "" });
48.     }
49. }
51. /// <summary>
52. /// 进行敏感词判断
53. /// </summary>
54. /// <param name="sourctText">需要脱敏的文本内容</param>
55. /// <returns></returns>
56. [HttpPost]
57. public IActionResult whether_sensitive_words(string sourctText)
58. {
59.     string resultStr = "";
60.     //实例化敏感词库
61.     subContentCheck strCheck = new subContentCheck(_hostingEnv);
62.     if (string.IsNullOrEmpty(sourctText))
63.     {
64.         return Json(new { code = 230, msg = "需要替换的文本内容为空！", resultStr = resultStr });
65.     }
66.     try
67.     {
68.         resultStr = strCheck.FindSensitiveKey(sourctText);
69.         string resMsg = "";
70.         int resCode = 200;
71.         if (resultStr == "0")
72.         {
73.             resCode = 210;
74.             resultStr = "";
75.             resMsg = "设置违禁词时发生错误，请联系管理员！";
76.         }
77.         else if (resultStr == "1")
78.         {
79.             resCode = 240;
80.             resultStr = "";
81.             resMsg = "敏感内容匹配时发生错误！";
82.         }
83.         else if (resultStr == "2")
84.         {
85.             resCode = 260;
86.             resultStr = "";
87.             resMsg = "需要判断的文本内容为空！";
88.         }
89.         else if (resultStr == "3")
90.         {
91.             resCode = 270;
92.             resultStr = "";
93.             resMsg = "内容中含有敏感/违禁词！";
94.         }
95.         else
96.         {
97.             resCode = 200;
98.             resMsg = "内容中不含敏感/违禁词！";
99.         }
100.         return Json(new { code = resCode, msg = resMsg, resultStr = resultStr });
101.     }
102.     catch (Exception ex)
103.     {
104.         return Json(new { code = 220, msg = "敏感内容匹配时发生错误！", resultStr = "" });
105.     }
106. }

复制代码

六、前端封装JS方法

1. /**
2. * 敏感词/违禁词替换
3. * @param {string} sourctText 需要进行替换的内容
4. * @param {string} boxid 将替换成功之后的内容赋值的元素容器id属性名
5. * @param {object} layui Layui实例
6. * @returns 替换之后的文本内容
7. */
8. function sensitive_words_replace(sourctText, boxid, layui) {
9.     let resultStr = "";
10.     //let url = ["/Home/sensitive_words_replace", "/Home/sensitive_words_replace1", "/Home/sensitive_words_replace2"];
11.     $.ajax({
12.         url: "/Home/sensitive_words_replace2",//请求后端接口的路径
13.         dataType: "JSON",
14.         type: "POST",
15.         data: {
16.             "sourctText": sourctText
17.         },
18.         success: function (res) {
19.             let resCode = res.code;
20.             let resMsg = res.msg;
21.             if ((resCode == "210" || resCode == 210) || (resCode == 220 || resCode == "220") || (resCode == 230 || resCode == "230") || (resCode == 240 || resCode == "240") || (resCode == 260 || resCode == "260")) {
22.                 //返回数据后关闭loading
23.                 layer.closeAll();
24.                 resultStr = res.resultStr;
25.                 layui.layer.alert(resMsg, { icon: 5, title: "温馨提示", closeBtn: 0 });
26.             } else if (resCode == 200 || resCode == "200") {
27.                 resultStr = res.resultStr;
28.                 $("#" + boxid).val(resultStr);
29.                 //返回数据后关闭loading
30.                 layer.closeAll();
31.             }
32.         },
33.         error: function (error) {
34.             //返回数据后关闭loading
35.             layer.closeAll();
36.             layui.layer.alert(error, { icon: 5, title: "温馨提示", closeBtn: 0 });
37.         }
38.     });
39.     return resultStr;
40. }
42. /**
43. * 查询是否包含敏感/违禁词
44. * @param {string} sourctText 需要进行替换的内容
45. * @param {string} boxid 将替换成功之后的内容赋值的元素容器id属性名
46. * @param {object} layui Layui实例
47. * @returns 返回Bool；包含：“true”；不包含：“false”
48. */
49. function whether_sensitive_words(sourctText, boxid, layui) {
50.     let resultBool = false;
51.     $.ajax({
52.         url: "/Home/whether_sensitive_words",//请求后端接口的路径
53.         dataType: "JSON",
54.         type: "POST",
55.         async: false,//此处需要注意的是要想获取ajax返回的值这个async属性必须设置成同步的，否则获取不到返回值
56.         data: {
57.             "sourctText": sourctText
58.         },
59.         success: function (res) {
60.             let resCode = res.code;
61.             let resMsg = res.msg;
62.             if ((resCode == "210" || resCode == 210) || (resCode == 220 || resCode == "220") || (resCode == 230 || resCode == "230") || (resCode == 240 || resCode == "240") || (resCode == 260 || resCode == "260")) {
63.                 resultBool = false;
64.                 layui.layer.alert(resMsg, { icon: 5, title: "温馨提示", closeBtn: 0 });
65.             } else if (resCode == 270 || resCode == "270") {
66.                 resultBool = true;
67.             } else if (resCode == 200 || resCode == "200") {
68.                 resultBool = false;
69.                 //返回数据后关闭loading
70.                 layer.closeAll();
71.             }
72.         },
73.         error: function (error) {
74.             layui.layer.alert(error, { icon: 5, title: "温馨提示", closeBtn: 0 });
75.         }
76.     });
77.     return resultBool;
78. }

复制代码

来源:https://www.cnblogs.com/lucasDC/archive/2023/03/25/17255906.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！