sensitive word
stopword all, and stop_zh
Sensitives Wort ist ein Hochleistungs-sensitives Wort-Tool, das auf dem DFA-Algorithmus basiert.
Online -Erfahrung
Wenn Sie einige schwierige und komplizierte Krankheiten haben, können Sie teilnehmen: Technical Exchange Group
Sensitive Wort-Adminaler ist die entsprechende Konsolenanwendung. Die Funktionen befinden sich derzeit in den frühen Entwicklungsstadien und die MVP -Version ist verfügbar.
Hallo allerseits, ich bin lao ma.
Ich wollte schon immer ein einfaches und benutzerfreundliches sensibles Wort-Tool implementieren, daher habe ich dieses Tool Open Source implementiert.
Basierend auf der Implementierung des DFA -Algorithmus enthält der Inhalt des sensiblen Thesaurus derzeit 6W+ (Quelldatei 18W+ nach einer Löschung).
Im späteren Stadium wird der empfindliche Thesaurus kontinuierlich optimiert und ergänzt, und die Leistung des Algorithmus wird weiter verbessert.
V0.24.0 hat begonnen, die Klassifizierung und Verfeinerung sensibler Wörter zu unterstützen, aber die Arbeitsbelastung ist relativ groß, sodass es unvermeidlich unterbrochen wird.
Willkommen bei PR -Verbesserungen, Github -Anfragen oder schließen Sie sich der technischen Exchange -Gruppe an, um zu kommunizieren und zu prahlen!
6W+ Thesaurus und kontinuierliche Optimierung und Aktualisierung
Basierend auf der Umsetzung der fließenden API, der eleganten und präzisen Verwendung
Basierend auf dem DFA -Algorithmus beträgt die Leistung 7W+ QPS. Die Anwendung ist unempfindlich
Unterstützen Sie gemeinsame Operationen wie Urteilsvermögen, Rückgabe und Desensibilisierung sensibler Wörter
Unterstützt die Konvertierung des gemeinsamen Formates
Die halbe Breite mit voller Breite, englischer Falltausch, gemeinsame Formen von Zahlen, traditionelle chinesische und vereinfachte Chinesen, gemeinsame Formen des englischen Austauschs, ignorieren doppelte Wörter usw.
Unterstützung der sensiblen Worterkennung, E -Mail -Erkennung, digitaler Erkennung, Website -Erkennung, IPv4 usw.
Unterstützt kundenspezifische Ersatzrichtlinien
Unterstützt benutzerdefinierte sensible Wörter und Whitelisten
Unterstützt dynamische Datenaktualisierungen (Benutzeranpassung), die in Echtzeit effektiv effektiv sind
Unterstützt die Tag-Schnittstelle + integrierte Klassifizierungsimplementierung für sensible Wörter
Unterstützen Sie das Überspringen einiger Sondercharaktere, um die Übereinstimmung flexibler zu gestalten
Unterstützt einzelne Zugabe/Modifikation von Schwarz -Weiß
Change_log.md
Manchmal gibt es eine Konsole für sensible Wörter, die es flexibler und bequemer macht.
Wie implementieren Sie sensible Wortkonsolenservice in der Box?
Eine große Anzahl sensibler Word -Tag -Dateien wurden ausgeklärt, wodurch unsere sensiblen Wörter bequemer werden können.
Diese beiden Materialien können in dem folgenden Artikel gelesen werden:
V0.11.0-Neue Funktionen sensibler Wörter und entsprechender Tagendateien
Derzeit verfügt V0.24.0 über integrierte Word-Tags, und es wird empfohlen, bei Bedarf auf die neueste Version zu upgraden.
Open Source ist nicht einfach. Wenn dieses Projekt für Sie hilfreich ist, können Sie Lao Ma einladen, eine Tasse Milchtee zu haben.
JDK1.8+
Maven 3.x+
< dependency >
< groupId >com.github.houbb</ groupId >
< artifactId >sensitive-word</ artifactId >
< version >0.24.0</ version >
</ dependency > SensitiveWordHelper ist eine Werkzeugklasse für sensible Wörter. Die Kernmethoden sind wie folgt:
Hinweis: SensitiveWordHelper WordHelper bietet Standardkonfigurationen. Wenn Sie flexible benutzerdefinierte Konfigurationen erstellen möchten
| Verfahren | Parameter | Rückgabewert | veranschaulichen |
|---|---|---|---|
| Enthält (Zeichenfolge) | Die zu verifizierte Zeichenfolge | Boolescher Wert | Stellen Sie sicher, dass die Zeichenfolge sensible Wörter enthält |
| Ersetzen (String, Issensitive WordReplace) | Ersetzen Sie sensible Wörter durch angegebene Ersatzstrategie | Saite | Gibt die desensibilisierte Zeichenfolge zurück |
| ersetzen (Zeichenfolge, Zeichen) | Verwenden Sie das angegebene Zeichen, um das empfindliche Wort zu ersetzen | Saite | Gibt die desensibilisierte Zeichenfolge zurück |
| Ersetzen (Zeichenfolge) | Verwenden Sie * , um empfindliche Wörter zu ersetzen | Saite | Gibt die desensibilisierte Zeichenfolge zurück |
| findall (String) | Die zu verifizierte Zeichenfolge | Liste der Saiten | Gibt alle sensiblen Wörter in der Zeichenfolge zurück |
| findFirst (String) | Die zu verifizierte Zeichenfolge | Saite | Gibt das erste sensible Wort in der Zeichenfolge zurück |
| findall (String, iwordResultHandler) | IWordResultHandler -Ergebnisverarbeitungsklasse | Liste der Saiten | Gibt alle sensiblen Wörter in der Zeichenfolge zurück |
| findfirst (String, iwordResaulthandler) | IWordResultHandler -Ergebnisverarbeitungsklasse | Saite | Gibt das erste sensible Wort in der Zeichenfolge zurück |
| Tags (String) | Holen Sie sich Tags für sensible Wörter | Sensitive Wort Zeichenfolge | Kehren Sie zur Liste der Tags für sensible Wörter zurück |
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
Assert . assertTrue ( SensitiveWordHelper . contains ( text )); final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
String word = SensitiveWordHelper . findFirst ( text );
Assert . assertEquals ( "五星红旗" , word );Sensitive WordHelper.findfirst (Text) entspricht:
String word = SensitiveWordHelper . findFirst ( text , WordResultHandlers . word ()); final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
List < String > wordList = SensitiveWordHelper . findAll ( text );
Assert . assertEquals ( "[五星红旗, 毛主席, 天安门]" , wordList . toString ());Gibt alle sensiblen Wörter verwendet. Die Verwendung ist ähnlich wie sensitivwordhelper.findfirst () und unterstützt auch die Angabe von Ergebnisverarbeitungsklassen.
Sensitive WordHelper.findall (Text) entspricht:
List < String > wordList = SensitiveWordHelper . findAll ( text , WordResultHandlers . word ());Wordresulthandlers.raw () kann die entsprechenden Einweisinformationen und Kategorieninformationen beibehalten:
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
// 默认敏感词标签为空
List < WordTagsDto > wordList1 = SensitiveWordHelper . findAll ( text , WordResultHandlers . wordTags ());
Assert . assertEquals ( "[WordTagsDto{word='五星红旗', tags=[]}, WordTagsDto{word='毛主席', tags=[]}, WordTagsDto{word='天安门', tags=[]}]" , wordList1 . toString ()); final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
String result = SensitiveWordHelper . replace ( text );
Assert . assertEquals ( "****迎风飘扬，***的画像屹立在***前。" , result ); final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
String result = SensitiveWordHelper . replace ( text , '0' );
Assert . assertEquals ( "0000迎风飘扬，000的画像屹立在000前。" , result );V0.2.0 unterstützt diese Funktion.
Szenenbeschreibung: Manchmal möchten wir, dass unterschiedliche sensible Wörter unterschiedliche Ersatzergebnisse erzielen. Zum Beispiel wird [Game] durch [E-Sport] ersetzt und [Arbeitslosigkeit] durch [flexible Beschäftigung] ersetzt.
Zugegeben, es ist in Ordnung, regelmäßig im Voraus Austausch von Strings zu verwenden, aber die Leistung ist durchschnittlich.
Beispiel der Verwendung:
/**
* 自定替换策略
* @since 0.2.0
*/
@ Test
public void defineReplaceTest () {
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
ISensitiveWordReplace replace = new MySensitiveWordReplace ();
String result = SensitiveWordHelper . replace ( text , replace );
Assert . assertEquals ( "国家旗帜迎风飘扬，教员的画像屹立在***前。" , result );
} Unter ihnen ist MySensitiveWordReplace unsere angepasste Ersatzrichtlinie, die wie folgt implementiert wird:
public class MyWordReplace implements IWordReplace {
@ Override
public void replace ( StringBuilder stringBuilder , final char [] rawChars , IWordResult wordResult , IWordContext wordContext ) {
String sensitiveWord = InnerWordCharUtils . getString ( rawChars , wordResult );
// 自定义不同的敏感词替换策略，可以从数据库等地方读取
if ( "五星红旗" . equals ( sensitiveWord )) {
stringBuilder . append ( "国家旗帜" );
} else if ( "毛主席" . equals ( sensitiveWord )) {
stringBuilder . append ( "教员" );
} else {
// 其他默认使用 * 代替
int wordLength = wordResult . endIndex () - wordResult . startIndex ();
for ( int i = 0 ; i < wordLength ; i ++) {
stringBuilder . append ( '*' );
}
}
}
} Für einige der Wörter werden wir festgelegt, und die anderen werden standardmäßig in * konvertiert.
IwordResultHandler kann die Ergebnisse sensibler Wörter verarbeiten und Benutzern ermöglichen, sie anzupassen.
In der integrierten Implementierung finden Sie in WordResultHandlers -Toolklasse:
Nur sensible Wörter bleiben erhalten.
Halten Sie Informationen in Bezug auf sensible Wörter, einschließlich der Anfänger- und End -Indexs von sensiblen Wörtern.
Gleichzeitig werden die Wörter und entsprechenden Informationen zur Wortbezeichnung beibehalten.
Siehe Sensitive WordHelperTest für alle Testfälle
1) grundlegende Beispiele
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
List < String > wordList = SensitiveWordHelper . findAll ( text );
Assert . assertEquals ( "[五星红旗, 毛主席, 天安门]" , wordList . toString ());
List < String > wordList2 = SensitiveWordHelper . findAll ( text , WordResultHandlers . word ());
Assert . assertEquals ( "[五星红旗, 毛主席, 天安门]" , wordList2 . toString ());
List < IWordResult > wordList3 = SensitiveWordHelper . findAll ( text , WordResultHandlers . raw ());
Assert . assertEquals ( "[WordResult{startIndex=0, endIndex=4}, WordResult{startIndex=9, endIndex=12}, WordResult{startIndex=18, endIndex=21}]" , wordList3 . toString ()); Wir geben die Tag -Informationen des entsprechenden Wortes in der Datei dict_tag_test.txt an.
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
// 默认敏感词标签为空
List < WordTagsDto > wordList1 = SensitiveWordHelper . findAll ( text , WordResultHandlers . wordTags ());
Assert . assertEquals ( "[WordTagsDto{word='五星红旗', tags=[]}, WordTagsDto{word='毛主席', tags=[]}, WordTagsDto{word='天安门', tags=[]}]" , wordList1 . toString ());
List < WordTagsDto > wordList2 = SensitiveWordBs . newInstance ()
. wordTag ( WordTags . file ( "dict_tag_test.txt" ))
. init ()
. findAll ( text , WordResultHandlers . wordTags ());
Assert . assertEquals ( "[WordTagsDto{word='五星红旗', tags=[政治, 国家]}, WordTagsDto{word='毛主席', tags=[政治, 伟人, 国家]}, WordTagsDto{word='天安门', tags=[政治, 国家, 地址]}]" , wordList2 . toString ());Die nachfolgenden Merkmale richten sich hauptsächlich auf verschiedene Verarbeitungsverarbeitungen an verschiedene Situationen, um die Trefferquote sensibler Wörter so weit wie möglich zu verbessern.
Dies ist eine lange Schlacht von Straftat und Verteidigung.
final String text = "fuCK the bad words." ;
String word = SensitiveWordHelper . findFirst ( text );
Assert . assertEquals ( "fuCK" , word ); final String text = "ｆｕｃｋ the bad words." ;
String word = SensitiveWordHelper . findFirst ( text );
Assert . assertEquals ( "ｆｕｃｋ" , word );Hier wird die Umwandlung gemeinsamer Digitalformen implementiert.
final String text = "这个是我的微信：9⓿二肆⁹₈③⑸⒋➃㈤㊄" ;
List < String > wordList = SensitiveWordBs . newInstance (). enableNumCheck ( true ). init (). findAll ( text );
Assert . assertEquals ( "[9⓿二肆⁹₈③⑸⒋➃㈤㊄]" , wordList . toString ()); final String text = "我爱我的祖国和五星紅旗。" ;
List < String > wordList = SensitiveWordHelper . findAll ( text );
Assert . assertEquals ( "[五星紅旗]" , wordList . toString ()); final String text = "Ⓕⓤc⒦ the bad words" ;
List < String > wordList = SensitiveWordHelper . findAll ( text );
Assert . assertEquals ( "[Ⓕⓤc⒦]" , wordList . toString ()); final String text = "ⒻⒻⒻfⓤuⓤ⒰cⓒ⒦ the bad words" ;
List < String > wordList = SensitiveWordBs . newInstance ()
. ignoreRepeat ( true )
. init ()
. findAll ( text );
Assert . assertEquals ( "[ⒻⒻⒻfⓤuⓤ⒰cⓒ⒦]" , wordList . toString ());Persönliche Informationen wie die E -Mail -Adresse sind standardmäßig nicht aktiviert.
final String text = "楼主好人，邮箱 [email protected]" ;
List < String > wordList = SensitiveWordBs . newInstance (). enableEmailCheck ( true ). init (). findAll ( text );
Assert . assertEquals ( "[[email protected]]" , wordList . toString ());Es wird im Allgemeinen verwendet, um Werbeinformationen wie Mobiltelefonnummer/QQ zu filtern und standardmäßig nicht aktiviert.
Nach V0.2.1 werden die durch numCheckLen(长度) erkannten Längen unterstützt.
final String text = "你懂得：12345678" ;
// 默认检测 8 位
List < String > wordList = SensitiveWordBs . newInstance ()
. enableNumCheck ( true )
. init (). findAll ( text );
Assert . assertEquals ( "[12345678]" , wordList . toString ());
// 指定数字的长度，避免误杀
List < String > wordList2 = SensitiveWordBs . newInstance ()
. enableNumCheck ( true )
. numCheckLen ( 9 )
. init ()
. findAll ( text );
Assert . assertEquals ( "[]" , wordList2 . toString ());Wird verwendet, um gemeinsame URL -Informationen zu filtern, die standardmäßig nicht aktiviert sind.
v0.18.0 optimiert die URL -Erkennung, die strenger ist und die Fehleinschätzung verringert
final String text = "点击链接 https://www.baidu.com 查看答案" ;
final SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance (). enableUrlCheck ( true ). init ();
List < String > wordList = sensitiveWordBs . findAll ( text );
Assert . assertEquals ( "[https://www.baidu.com]" , wordList . toString ());
Assert . assertEquals ( "点击链接 ********************* 查看答案" , sensitiveWordBs . replace ( text ));v0.17.0 Unterstützung
Vermeiden Sie Benutzer, die die URL -Erkennung über IP usw. umgehen, was standardmäßig nicht aktiviert ist.
final String text = "个人网站，如果网址打不开可以访问 127.0.0.1。" ;
final SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance (). enableIpv4Check ( true ). init ();
List < String > wordList = sensitiveWordBs . findAll ( text );
Assert . assertEquals ( "[127.0.0.1]" , wordList . toString ());Die oben genannten Funktionen sind standardmäßig aktiviert, und manchmal muss das Unternehmen die damit verbundenen Konfigurationsfunktionen flexibel definieren.
Also öffnet V0.0.14 die Eigenschaftskonfiguration.
Um eleganter zu verwenden, wird die Definition von fließendem API einheitlich verwendet.
Benutzer können SensitiveWordBs verwenden, um es wie folgt zu definieren:
HINWEIS: Verwenden Sie nach der Konfiguration unser neu definiertes SensitiveWordBs -Objekt anstelle der vorherigen Tool -Methode. Die Konfiguration der Werkzeugmethode ist alle standardmäßig.
SensitiveWordBs wordBs = SensitiveWordBs . newInstance ()
. ignoreCase ( true )
. ignoreWidth ( true )
. ignoreNumStyle ( true )
. ignoreChineseStyle ( true )
. ignoreEnglishStyle ( true )
. ignoreRepeat ( false )
. enableNumCheck ( false )
. enableEmailCheck ( false )
. enableUrlCheck ( false )
. enableIpv4Check ( false )
. enableWordCheck ( true )
. numCheckLen ( 8 )
. wordTag ( WordTags . none ())
. charIgnore ( SensitiveWordCharIgnores . defaults ())
. wordResultCondition ( WordResultConditions . alwaysTrue ())
. init ();
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
Assert . assertTrue ( wordBs . contains ( text ));Die Beschreibung jeder Konfiguration lautet wie folgt:
| Seriennummer | Verfahren | veranschaulichen | Standardwert |
|---|---|---|---|
| 1 | Ignorecase | Fall ignorieren | WAHR |
| 2 | Ignorewidth | Ignorieren Sie die abgerundeten Ecken mit halben Ecken | WAHR |
| 3 | ignorenumstyle | Ignorieren Sie das Schreiben von Zahlen | WAHR |
| 4 | Ignorieren Sie Chinesestyle | Ignorieren Sie das chinesische Schreibformat | WAHR |
| 5 | IgnoreEnglishstyle | Ignorieren Sie das Format des englischen Schreibens | WAHR |
| 6 | ignorerepeat | Ignorieren Sie doppelte Wörter | FALSCH |
| 7 | Ensablenumcheck | Ob digitale Erkennung aktiviert werden soll. | FALSCH |
| 8 | enableemailcheck | Die E -Mail -Erkennung ist aktiviert | FALSCH |
| 9 | Aktivieren Sie | Ob die Linkerkennung aktiviert werden soll | FALSCH |
| 10 | EnableIPV4Check | Ob die IPv4 -Erkennung aktiviert werden soll | FALSCH |
| 11 | Aktivieren Sie WordCheck | Ob sensible Worterkennung aktiviert werden soll | WAHR |
| 12 | Numchecklen | Digitale Erkennung, passen Sie die angegebene Länge an. | 8 |
| 13 | Wordtag | Die entsprechenden Wörter Tags | keiner |
| 14 | Charignore | Ignorierte Charaktere | keiner |
| 15 | mordresultcondition | Zusätzliche Verarbeitung für die Übereinstimmung mit sensiblen Wörtern, z. B. die Begrenzung der Notwendigkeit vollständiger Übereinstimmungen englischer Wörter | Immer wahr |
V0.16.1 wird unterstützt. Manchmal müssen wir den Speicher freisetzen, der wie folgt sein kann:
Über Speicherrecyclingprobleme
SensitiveWordBs wordBs = SensitiveWordBs . newInstance ()
. init ();
// 后续因为一些原因移除了对应信息，希望释放内存。
wordBs . destroy ();Verwendungsszenario: Nach der Initialisierung möchten wir ein einzelnes Wort hinzufügen/löschen, anstatt es vollständig neu zu initialisieren. Diese Funktion ist dafür vorbereitet.
Unterstützte Version: v0.19.0
addWord(word) fügt sensible Wörter hinzu und unterstützt einzelne Wörter/Sammlungen
removeWord(word) entfernt sensible Wörter, unterstützt einzelne Wörter/Sammlungen
final String text = "测试一下新增敏感词，验证一下删除和新增对不对" ;
SensitiveWordBs sensitiveWordBs =
SensitiveWordBs . newInstance ()
. wordAllow ( WordAllows . empty ())
. wordDeny ( WordDenys . empty ())
. init ();
// 当前
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增单个
sensitiveWordBs . addWord ( "测试" );
sensitiveWordBs . addWord ( "新增" );
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除单个
sensitiveWordBs . removeWord ( "新增" );
Assert . assertEquals ( "[测试]" , sensitiveWordBs . findAll ( text ). toString ());
sensitiveWordBs . removeWord ( "测试" );
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增集合
sensitiveWordBs . addWord ( Arrays . asList ( "新增" , "测试" ));
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除集合
sensitiveWordBs . removeWord ( Arrays . asList ( "新增" , "测试" ));
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增数组
sensitiveWordBs . addWord ( "新增" , "测试" );
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除集合
sensitiveWordBs . removeWord ( "新增" , "测试" );
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());Verwendungsszenario: Nach der Initialisierung möchten wir ein einzelnes Wort hinzufügen/löschen, anstatt es vollständig neu zu initialisieren. Diese Funktion ist dafür vorbereitet.
Unterstützte Version: v0.21.0
addWordAllow(word) fügt einen neuen Whitelisten hinzu, unterstützt einzelne Wörter/Sammlungen
removeWordAllow(word) entfernt Whitelisten, unterstützt einzelne Wörter/Sammlungen
final String text = "测试一下新增敏感词白名单，验证一下删除和新增对不对" ;
SensitiveWordBs sensitiveWordBs =
SensitiveWordBs . newInstance ()
. wordAllow ( WordAllows . empty ())
. wordDeny ( new IWordDeny () {
@ Override
public List < String > deny () {
return Arrays . asList ( "测试" , "新增" );
}
})
. init ();
// 当前
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增单个
sensitiveWordBs . addWordAllow ( "测试" );
sensitiveWordBs . addWordAllow ( "新增" );
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除单个
sensitiveWordBs . removeWordAllow ( "测试" );
Assert . assertEquals ( "[测试]" , sensitiveWordBs . findAll ( text ). toString ());
sensitiveWordBs . removeWordAllow ( "新增" );
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增集合
sensitiveWordBs . addWordAllow ( Arrays . asList ( "新增" , "测试" ));
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除集合
sensitiveWordBs . removeWordAllow ( Arrays . asList ( "新增" , "测试" ));
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());
// 新增数组
sensitiveWordBs . addWordAllow ( "新增" , "测试" );
Assert . assertEquals ( "[]" , sensitiveWordBs . findAll ( text ). toString ());
// 删除集合
sensitiveWordBs . removeWordAllow ( "新增" , "测试" );
Assert . assertEquals ( "[测试, 新增, 新增]" , sensitiveWordBs . findAll ( text ). toString ());Diese Methode ist aufgegeben . Es wird empfohlen, die oben inkrementelle Additionsmethode zu verwenden, um die volle Belastung zu vermeiden. Für die Kompatibilität bleibt diese Methode bestehen.
So verwenden Sie: Wenn Sie sensitiveWordBs.init() aufrufen, bauen Sie das sensible Vokabular basierend auf iworddeny+iWordallow wieder auf. Da die Initialisierung lange dauern kann (zweite Ebene), wirken sich alle Optimierungen, die initiert werden, nicht die alte Vokabularfunktion, wenn sie nicht abgeschlossen ist, und der neue muss nach Abschluss durchgesetzt werden .
@ Component
public class SensitiveWordService {
@ Autowired
private SensitiveWordBs sensitiveWordBs ;
/**
* 更新词库
*
* 每次数据库的信息发生变化之后，首先调用更新数据库敏感词库的方法。
* 如果需要生效，则调用这个方法。
*
* 说明：重新初始化不影响旧的方法使用。初始化完成后，会以新的为准。
*/
public void refresh () {
// 每次数据库的信息发生变化之后，首先调用更新数据库敏感词库的方法，然后调用这个方法。
sensitiveWordBs . init ();
}
} Wie oben erwähnt, können Sie aktiv die Initialisierung von sensitiveWordBs.init(); Wenn sich das Datenbank -Lexikon ändert und die Datenbank wirksam werden muss.
Andere Verwendungen bleiben gleich, ohne die App neu zu starten.
Unterstützte Version: v0.13.0
Manchmal möchten wir beispielsweise die passenden sensiblen Wörter weiter einschränken, obwohl wir [AV] als empfindliches Wort definieren, aber wir möchten nicht, dass [sie] übereinstimmt.
Sie können die wordresultcondition -Schnittstelle anpassen und Ihre eigenen Richtlinien implementieren.
Die integrierte Richtlinie in WordResultConditions#alwaysTrue() ist immer wahr, während WordResultConditions#englishWordMatch() erfordert, dass die englische Sprache mit dem vollständigen Wort übereinstimmen muss.
Die Toolklasse für mordresultconditions kann übereinstimmende Richtlinien erhalten
| erreichen | veranschaulichen | Unterstützte Version |
|---|---|---|
| Immer ausdrücken | Immer wahr | |
| englischwordmatch | Englisches Wort volles Wort Matching | v0.13.0 |
| englischwordnummatch | Englisches Wort/Nummer volles Wort Matching | v0.20.0 |
| Wordtags | Diejenigen, die bestimmte Tags erfüllen, z. B. nur die Fokussierung auf die [Werbung] Tags | v0.23.0 |
| Ketten (iWordResultcondition ... Bedingungen) | Unterstützt die Angabe mehrerer Bedingungen und erfüllt sie gleichzeitig | v0.23.0 |
Originale Standardsituation:
final String text = "I have a nice day。" ;
List < String > wordList = SensitiveWordBs . newInstance ()
. wordDeny ( new IWordDeny () {
@ Override
public List < String > deny () {
return Collections . singletonList ( "av" );
}
})
. wordResultCondition ( WordResultConditions . alwaysTrue ())
. init ()
. findAll ( text );
Assert . assertEquals ( "[av]" , wordList . toString ());Wir können angeben, dass die Engländer mit dem vollständigen Wort übereinstimmen müssen.
final String text = "I have a nice day。" ;
List < String > wordList = SensitiveWordBs . newInstance ()
. wordDeny ( new IWordDeny () {
@ Override
public List < String > deny () {
return Collections . singletonList ( "av" );
}
})
. wordResultCondition ( WordResultConditions . englishWordMatch ())
. init ()
. findAll ( text );
Assert . assertEquals ( "[]" , wordList . toString ());Natürlich können nach Bedarf komplexere Strategien implementiert werden.
Unterstützte Version: v0.23.0
Wir können nur sensible Wörter zurückgeben, die mit einem bestimmten Etikett verbunden sind.
Wir haben zwei sensible Wörter angegeben: Produkt, AV
MyWordTag ist eine sensible Word -Tag -Implementierung, die wir definieren:
/**
* 自定义单词标签
* @since 0.23.0
*/
public class MyWordTag extends AbstractWordTag {
private static Map < String , Set < String >> dataMap ;
static {
dataMap = new HashMap <>();
dataMap . put ( "商品" , buildSet ( "广告" , "中文" ));
dataMap . put ( "AV" , buildSet ( "色情" , "单词" , "英文" ));
}
private static Set < String > buildSet ( String ... tags ) {
Set < String > set = new HashSet <>();
for ( String tag : tags ) {
set . add ( tag );
}
return set ;
}
@ Override
protected Set < String > doGetTag ( String word ) {
return dataMap . get ( word );
}
}Zum Beispiel simulieren wir zwei verschiedene Implementierungsklassen, die jeweils auf ein anderes Wort -Tag konzentrieren.
// 只关心SE情
SensitiveWordBs sensitiveWordBsYellow = SensitiveWordBs . newInstance ()
. wordDeny ( new IWordDeny () {
@ Override
public List < String > deny () {
return Arrays . asList ( "商品" , "AV" );
}
})
. wordAllow ( WordAllows . empty ())
. wordTag ( new MyWordTag ())
. wordResultCondition ( WordResultConditions . wordTags ( Arrays . asList ( "色情" )))
. init ();
// 只关心广告
SensitiveWordBs sensitiveWordBsAd = SensitiveWordBs . newInstance ()
. wordDeny ( new IWordDeny () {
@ Override
public List < String > deny () {
return Arrays . asList ( "商品" , "AV" );
}
})
. wordAllow ( WordAllows . empty ())
. wordTag ( new MyWordTag ())
. wordResultCondition ( WordResultConditions . wordTags ( Arrays . asList ( "广告" )))
. init ();
final String text = "这些 AV 商品什么价格？" ;
Assert . assertEquals ( "[AV]" , sensitiveWordBsYellow . findAll ( text ). toString ());
Assert . assertEquals ( "[商品]" , sensitiveWordBsAd . findAll ( text ). toString ());Unsere sensiblen Wörter sind im Allgemeinen kontinuierlicher, wie z. B. [alberner Hut]
Dann gibt es eine clevere Entdeckung, dass Sie einige Zeichen in der Mitte hinzufügen können, wie z. B. [albern! @#$ Hat], um die Erkennung zu überspringen, aber die Angriffskraft des Fluchens ist nicht reduziert.
Wie kann man also mit diesen ähnlichen Szenarien umgehen?
Wir können übersprungene Sätze von Sonderzeichen angeben und diese bedeutungslosen Zeichen ignorieren.
v0.11.0 beginnt Unterstützung
Die Charakterstrategie, die Charignore entspricht, kann von Benutzern flexibel definiert werden.
final String text = "傻@冒，狗+东西" ;
//默认因为有特殊字符分割，无法识别
List < String > wordList = SensitiveWordBs . newInstance (). init (). findAll ( text );
Assert . assertEquals ( "[]" , wordList . toString ());
// 指定忽略的字符策略，可自行实现。
List < String > wordList2 = SensitiveWordBs . newInstance ()
. charIgnore ( SensitiveWordCharIgnores . specialChars ())
. init ()
. findAll ( text );
Assert . assertEquals ( "[傻@冒, 狗+东西]" , wordList2 . toString ());Manchmal möchten wir sensiblen Worten ein klassifiziertes Etikett hinzufügen: wie soziale Situation, Gewalt usw.
Auf diese Weise können mehr Eigenschaften nach Beschriftungen usw. durchgeführt werden, z. B. nur eine bestimmte Art von Beschriftung.
Unterstützte Version: v0.10.0
Hauptfunktionen Support Version: v0.24.0
Dies ist nur eine abstrakte Oberfläche, und Benutzer können die Implementierung selbst definieren. Zum Beispiel aus Datenbankabfrage, Dateilesen, API -Aufrufen usw.
public interface IWordTag {
/**
* 查询标签列表
* @param word 脏词
* @return 结果
*/
Set < String > getTag ( String word );
} Um in den meisten Situationen die Verwendung zu erleichtern, werden einige Szenenstrategien in WordTags -Klasse implementiert
| Implementierungsmethode | veranschaulichen | Bemerkung |
|---|---|---|
| keiner() | Leere Implementierung | v0.10.0 Unterstützung |
| Datei (Zeichenfolge Filepath) | Geben Sie den Dateipfad an | v0.10.0 Unterstützung |
| Datei (String Filepath, String WordSplit, String TagSplit) | Geben Sie Dateipfade sowie Word -Separatoren und Tag -Separatoren an | v0.10.0 Unterstützung |
| Karte (endgültige Karte <String, Set> WordTagMap) | Initialisierung gemäß Karte | v0.24.0 Unterstützung |
| Linien (Sammellinien) | Liste der Saiten | v0.24.0 Unterstützung |
| Zeilen (Sammlungszeilen, String WordSplit, String -Tagspli) | Liste der Saiten sowie Wortabscheider und Etikettenabscheider | v0.24.0 Unterstützung |
| System() | Eingebaute Implementierung der Systemdateien und Integration der Netzwerkklassifizierung | v0.24.0 Unterstützung |
| Standardeinstellungen () | Die Standardrichtlinie ist derzeit System | v0.24.0 Unterstützung |
| Ketten (iWordtag ... andere) | Kettenmethode unterstützt die Benutzerintegration zur Implementierung mehrerer Richtlinien | v0.24.0 Unterstützung |
Das Format sensibler Wort -Tags Wir sind standardmäßig zu den folgenden敏感词tag1,tag2 , was bedeutet, dass die Tags敏感词Tag1 und Tag2 sind.
Zum Beispiel
五星红旗 政治,国家
Dies wird auch für alle Dateizeileninhalte und den angegebenen String -Inhalt empfohlen. Wenn es nicht zufrieden ist, implementieren Sie es einfach auf kundenspezifische Weise.
Ab V0.24.0 ist das Standard -Word -Tag WordTags.system() .
Hinweis: Derzeit stammen die Datenstatistiken aus dem Internet und es gibt viele Auslassungen. Jeder ist auch willkommen, das Problem zu beheben und weiter zu verbessern ...
SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance ()
. wordTag ( WordTags . system ())
. init ();
Set < String > tagSet = sensitiveWordBs . tags ( "博彩" );
Assert . assertEquals ( "[3]" , tagSet . toString ());Um die Komprimierungsgröße zu optimieren, werden die entsprechenden Kategorien durch Zahlen dargestellt.
Die Bedeutungsliste der Zahlen lautet wie folgt:
0 政治
1 毒品
2 色情
3 赌博
4 违法
Hier nehmen wir die Datei als Beispiel, um zu demonstrieren, wie sie verwendet werden.
final String path = "~ \ test \ resources \ dict_tag_test.txt" ;
// 演示默认方法
IWordTag wordTag = WordTags . file ( path );
SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance ()
. wordTag ( wordTag )
. init ();
Set < String > tagSet = sensitiveWordBs . tags ( "零售" );
Assert . assertEquals ( "[广告, 网络]" , tagSet . toString ());
// 演示指定分隔符
IWordTag wordTag2 = WordTags . file ( path , " " , "," );
SensitiveWordBs sensitiveWordBs2 = SensitiveWordBs . newInstance ()
. wordTag ( wordTag2 )
. init ();
Set < String > tagSet2 = sensitiveWordBs2 . tags ( "零售" );
Assert . assertEquals ( "[广告, 网络]" , tagSet2 . toString ()); Wo dict_tag_test.txt Unser benutzerdefinierter Inhalt ist wie folgt:
零售 广告,网络
Wenn wir sensible Wörter erhalten, können wir die entsprechende Ergebnisverarbeitungsstrategie festlegen, um die entsprechenden sensiblen Wort -Tag -Informationen zu erhalten
// 自定义测试标签类
IWordTag wordTag = WordTags . lines ( Arrays . asList ( "天安门 政治,国家,地址" ));
// 指定初始化
SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance ()
. wordTag ( wordTag )
. init ()
;
List < WordTagsDto > wordTagsDtoList1 = sensitiveWordBs . findAll ( "天安门" , WordResultHandlers . wordTags ());
Assert . assertEquals ( "[WordTagsDto{word='天安门', tags=[政治, 国家, 地址]}]" , wordTagsDtoList1 . toString ()); Wir passen die Tags für天安门-Schlüsselwörter an und geben dann an, dass die Ergebnisverarbeitungsstrategie von FindAll WordResultHandlers.wordTags() sind und die entsprechende Tag -Liste erhalten, während wir empfindliche Wörter erhalten.
Manchmal möchten wir die Belastung sensibler Wörter in dynamische, wie z. B. Konsolenänderung, gestalten, die dann in Echtzeit wirksam werden können.
V0.0.13 unterstützt diese Funktion.
Um diese Funktion zu implementieren und mit früheren Funktionen kompatibel zu sein, haben wir zwei Schnittstellen definiert.
Die Schnittstelle lautet wie folgt. Sie können Ihre eigene Implementierung anpassen.
Die zurückgegebene Liste bedeutet, dass das Wort ein empfindliches Wort ist.
/**
* 拒绝出现的数据-返回的内容被当做是敏感词
* @author binbin.hou
* @since 0.0.13
*/
public interface IWordDeny {
/**
* 获取结果
* @return 结果
* @since 0.0.13
*/
List < String > deny ();
}Zum Beispiel:
public class MyWordDeny implements IWordDeny {
@ Override
public List < String > deny () {
return Arrays . asList ( "我的自定义敏感词" );
}
}Die Schnittstelle lautet wie folgt. Sie können Ihre eigene Implementierung anpassen.
Die zurückgegebene Liste bedeutet, dass das Wort kein sensibles Wort ist.
/**
* 允许的内容-返回的内容不被当做敏感词
* @author binbin.hou
* @since 0.0.13
*/
public interface IWordAllow {
/**
* 获取结果
* @return 结果
* @since 0.0.13
*/
List < String > allow ();
}wie:
public class MyWordAllow implements IWordAllow {
@ Override
public List < String > allow () {
return Arrays . asList ( "五星红旗" );
}
}Nachdem die Schnittstelle angepasst wurde, muss natürlich angegeben werden, um wirksam zu werden.
Um eleganter zu verwenden, haben wir die SensitiveWordBs entworfen.
Sie können sensible Wörter durch worddeny () angeben, wordallow () gibt nicht sensible Wörter an und initialisieren sensible Wörter Dictionary über init ().
SensitiveWordBs wordBs = SensitiveWordBs . newInstance ()
. wordDeny ( WordDenys . defaults ())
. wordAllow ( WordAllows . defaults ())
. init ();
final String text = "五星红旗迎风飘扬，毛主席的画像屹立在天安门前。" ;
Assert . assertTrue ( wordBs . contains ( text ));Hinweis: Init () ist zeitaufwändig, um das sensible Wort DFA zu erstellen. Es wird im Allgemeinen empfohlen, bei der Anwendung der Initialisierung nur einmal initialisiert zu werden . Anstatt die Initialisierung zu wiederholen!
Wir können die benutzerdefinierte Implementierung wie folgt testen:
String text = "这是一个测试，我的自定义敏感词。" ;
SensitiveWordBs wordBs = SensitiveWordBs . newInstance ()
. wordDeny ( new MyWordDeny ())
. wordAllow ( new MyWordAllow ())
. init ();
Assert . assertEquals ( "[我的自定义敏感词]" , wordBs . findAll ( text ). toString ()); Hier ist der einzige, bei dem我的自定义敏感词sensible Wörter sind und测试keine sensiblen Wörter sind.
Hier sind natürlich alle unsere benutzerdefinierten Implementierungen. Es wird im Allgemeinen empfohlen, die Standardkonfiguration + benutzerdefinierte Konfiguration des Systems zu verwenden.
Die folgende Methode kann verwendet werden.
WordDenys.chains() Methode verbindet mehrere Implementierungen in dieselbe iWorddeny.
WordAllows.chains() Methoden verschmelzen mehrere Implementierungen in dieselbe iWordallow.
Beispiel:
String text = "这是一个测试。我的自定义敏感词。" ;
IWordDeny wordDeny = WordDenys . chains ( WordDenys . defaults (), new MyWordDeny ());
IWordAllow wordAllow = WordAllows . chains ( WordAllows . defaults (), new MyWordAllow ());
SensitiveWordBs wordBs = SensitiveWordBs . newInstance ()
. wordDeny ( wordDeny )
. wordAllow ( wordAllow )
. init ();
Assert . assertEquals ( "[我的自定义敏感词]" , wordBs . findAll ( text ). toString ());Alle verwenden gleichzeitig die Systemstandardkonfiguration und benutzerdefinierte Konfiguration.
HINWEIS: Wir initialisieren neue Words, verwenden Sie also neue Words, um zu beurteilen. Anstatt die vorherige SensitiveWordHelper -Tool -Methode zu verwenden, ist die Tool -Methode -Konfiguration die Standardeinstellung!
In der tatsächlichen Verwendung können Sie beispielsweise die Seitenkonfiguration ändern und dann in Echtzeit wirksam werden.
Die Daten werden in der Datenbank gespeichert. Das Folgende ist ein Beispiel für Pseudo-Code. Sie können sich auf SpringsesesitivwordConfig.java beziehen
Erforderlich, Version V0.0.15 und höher.
Der vereinfachte Pseudo-Code ist wie folgt, und die Quelle der Daten ist eine Datenbank.
MyddWordallow und myddworddeny sind benutzerdefinierte Implementierungsklassen, die auf Datenbanken als Quelle basieren.
@ Configuration
public class SpringSensitiveWordConfig {
@ Autowired
private MyDdWordAllow myDdWordAllow ;
@ Autowired
private MyDdWordDeny myDdWordDeny ;
/**
* 初始化引导类
* @return 初始化引导类
* @since 1.0.0
*/
@ Bean
public SensitiveWordBs sensitiveWordBs () {
SensitiveWordBs sensitiveWordBs = SensitiveWordBs . newInstance ()
. wordAllow ( WordAllows . chains ( WordAllows . defaults (), myDdWordAllow ))
. wordDeny ( myDdWordDeny )
// 各种其他配置
. init ();
return sensitiveWordBs ;
}
}Die Initialisierung des sensiblen Vokabulars ist zeitaufwändig. Es wird daher empfohlen, die Initialisierung einmal zu Beginn des Programms durchzuführen.
Fügen Sie nach V0.6.0 den entsprechenden Benchmark -Test hinzu.
Benchmarkimestest
Die Testumgebung ist ein normales Notizbuch:
处理器 12th Gen Intel(R) Core(TM) i7-1260P 2.10 GHz
机带 RAM 16.0 GB (15.7 GB 可用)
系统类型 64 位操作系统, 基于 x64 的处理器
PS: Verschiedene Umgebungen variieren, aber der Anteil ist im Grunde stabil.
Testdaten: 100+ String, Loop 10W -mal.
| Seriennummer | Szene | zeitaufwendig | Bemerkung |
|---|---|---|---|
| 1 | Machen Sie nur sensible Wörter ohne Formatumwandlung | 1470 ms, ca. 7,2 W QPS | Wenn Sie extreme Leistung verfolgen, können Sie es so konfigurieren |
| 2 | Machen Sie nur sensible Wörter, unterstützen Sie die gesamte Formatkonvertierung | 2744 ms, ca. 3,7W QPS | Treffen Sie die meisten Szenarien |
Entfernen Sie sensible Wörter aus einzelnen chinesischen Zeichen. In China sollten Phrasen als ein einziges Wort angesehen werden, um die Fehleinschätzung zu verringern.
Unterstützt individuelle sensible Wortänderungen?
entfernen, hinzufügen, bearbeiten?
Sensible Word -Tag -Schnittstelle Unterstützung
Tag -Unterstützung bei der Verarbeitung sensibler Wörter
Speicherverbrauch Vergleich + Optimierung von WordData
Benutzer geben benutzerdefinierte Phrasen an und ermöglichen die Kombination bestimmter Phrasen, sodass sie flexibler sind
FormatCombine/CheckCombine/ALLGENYCOMBINE -Kombinationspolitik, die die Benutzeranpassung ermöglichen.
Optimierung der Word -Check -Strategie, einheitlicher Traversal + Conversion
Fügen Sie Threadlokal- und andere Leistungsoptimierungen hinzu
Sensitive Wort-Admin sensitive Wortkonsole v1.2.0 Open Source
Wie unterstütze ich die verteilte Bereitstellung in sensiblen Wörtern-Admin V1.3.0 Release?
01-Beinner von Open Source Sensitive Word Tool
02 Wie ein sensibles Wortwerkzeug implementieren? Klären Sie die Idee der Implementierung verbotener Wörter
03 Support Word Stopword-Stopp-Wortoptimierung und spezielle Symbole
04-Dictionary von sensiblen Wörtern, die abschneiden
05 detaillierte Erklärung des DFA-Algorithmus sensibler Wörter (Trie-Baum-Algorithmus)
06-sensitive Wörter (schmutzige Wörter) Wie kann man bedeutungslose Zeichen ignorieren? Bessere Filtereffekt erzielen
V0.10.0-Preliminary-Unterstützung für die Klassifizierungs-Tag der Dirty Word-Klassifizierung
v0.11.0 - Neue Merkmale sensibler Wörter: Ignorieren Sie bedeutungslose Zeichen, Word -Tag -Wörterbuch
V0.12.0-sensitive Word/Dirty Word-Kennzeichnung Fähigkeit wird weiter verbessert
V0.13.0-Sensitive Word Feature Version Version Release unterstützt das vollständige Wort Matching in englischen Wörtern
V0.16.1-Dictionary Memory Resource Ressourcenveröffentlichung neuer Merkmale sensibler Wörter
V0.19.0 - Sensitive Wörter mit neuen Merkmalen sensibler Wörter, die individuell ohne wiederholte Initialisierung bearbeitet wurden
v0.20.0 Die neuen Eigenschaften sensibler Wörter stimmen mit allen Zahlen überein, nicht teilweise Übereinstimmungen
V0.21.0 Whitelists mit neuen Merkmalen sensibler Wörter unterstützen eine einzelne Bearbeitung und beheben das Problem, wenn Whitelists Blacklists enthalten
Pinyin zu Pinyin
Pinyin2Hanzi Pinyin zu chinesischen Charakteren
Segment High Performance Chinese Word Segmentierung
OpenCC4J Chinesische traditionelle chinesische chinesische vereinfachte chinesische Konvertierung vereinfacht
NLP-HANZI-Ähnliche chinesische Charakterähnlichkeit
Word-Checker-Rechtschreibungserkennung
Sensitive Wortempfindlichkeitswörter
