자바 DFA 알고리즘 을 이용 하여 민감 한 단어 여과 기능 실현
10736 단어 자바민감 한 단어 여과dfa 알고리즘
민감 한 단어 필 터 는 너무 많은 설명 을 안 드 려 도 되 겠 죠?분명히 말 하면 프로젝트 에 어떤 글 자 를 입력 할 때(예 를 들 어 xxoo 와 관련 된 문 자 를 입력 할 때)검사 할 수 있어 야 한 다 는 것 이다.
많은 항목 에 민감 한 단어 관리 모듈 이 있 는 것 으로 나 타 났 습 니 다.민감 한 단어 관리 모듈 에 민감 한 단 어 를 넣 은 다음 에 가입 한 민감 한 단어 에 따라 걸 러 낼 수 있 습 니 다.
내용 에 있 는 민감 한 단 어 를 입력 하고 해당 하 는 처 리 를 합 니 다.힌트 를 주거 나 하 이 라이트 로 표시 하거나 다른 문자 나 기호 로 대체 합 니 다.
민감 한 단 어 를 걸 러 내 는 방법 은 매우 많다.나 는 내 가 현재 이해 하고 있 는 몇 가 지 를 간단하게 설명 한다.
① 데이터베이스 에 있 는 민감 한 단 어 를 조회 하고 모든 민감 한 단 어 를 순환 한 다음 입력 한 텍스트 에서 처음부터 끝까지 검색 하여 이 민감 한 단어 가 존재 하 는 지 확인 하고 있 으 면 사진 을 찍 는 다.
응당 처리 해 야 한다.이런 방식 은 말하자면 하 나 를 찾 아서 처리 하 는 것 이다.
장점:so easy.자바 코드 로 실현 하 는 것 은 거의 어렵 지 않다.
단점:이 효율 은 내 마음속 에 10 만 마리 의 진흙 말 을 뛰 어 넘 게 했 고,일치 하 는 것 은 약간 아 픈 것 이 아 닙 니까?만약 영어 일 때 당신 은 매우 어 이 없 는 일 을 발견 할 수 있 습 니 다.예 를 들 어 영어 와 같은 것 입 니 다.
a.민감 한 단어 입 니 다.만약 에 제 가 영어 문서 라면 프로그램 동생 은 민감 한 단 어 를 몇 번 이나 처리 해 야 합 니까?누가 나 에 게 알려 줄 수 있 습 니까?
② 전설 적 인 DFA 알고리즘(가난 한 자동 동기 가 있 음)은 바로 제 가 여러분 에 게 공유 하고 자 하 는 것 입 니 다.왜냐하면 통용 되 는 것 같 기 때문에 알고리즘 의 원 리 는 여러분 이 직접 인터넷 에서 찾 아 보 셨 으 면 좋 겠 습 니 다.
자 료 는 여기 서 상세 하 게 설명 하지 않 겠 습 니 다.
장점:적어도 위의 sb 보다 효율 이 높다.
단점:알고리즘 을 배 운 것 은 어렵 지 않 을 것 입 니 다.알고리즘 을 배 운 적 이 없 는 것 도 어렵 지 않 습 니 다.이해 하기 가 좀 아 프 고 일치 효율 도 높 지 않 으 며 메모리 소모 가 많 습 니 다.
민감 한 단어 가 많 을 수록 메모리 사용량 이 커진다.
③ 세 번 째 는 여기 서 특별히 설명해 야 한다.그것 이 바로 네가 직접 알고리즘 을 쓰 거나 기 존의 알고리즘 을 바탕 으로 최적화 하 는 것 이다.이것 도 추구 하 는 최고의 경지 중 하나 이다.
그렇다면 전설의 DFA 알고리즘 은 어떻게 이 뤄 졌 을 까?
첫 번 째 단계:민감 한 단어 라 이브 러 리 초기 화(민감 한 단 어 를 DFA 알고리즘 의 원리 로 민감 한 단어 라 이브 러 리 에 봉 하고 민감 한 단어 라 이브 러 리 는 HashMap 으로 저장)코드 는 다음 과 같 습 니 다.
package com.cfwx.rox.web.sysmgr.util;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.cfwx.rox.web.common.model.entity.SensitiveWord;
/**
*
*
* @author AlanLee
*
*/
public class SensitiveWordInit
{
/**
*
*/
public HashMap sensitiveWordMap;
/**
*
*
* @return
*/
public Map initKeyWord(List<SensitiveWord> sensitiveWords)
{
try
{
// Set
Set<String> keyWordSet = new HashSet<String>();
for (SensitiveWord s : sensitiveWords)
{
keyWordSet.add(s.getContent().trim());
}
// HashMap
addSensitiveWordToHashMap(keyWordSet);
}
catch (Exception e)
{
e.printStackTrace();
}
return sensitiveWordMap;
}
/**
*
*
* @param keyWordSet
*/
@SuppressWarnings("rawtypes")
private void addSensitiveWordToHashMap(Set<String> keyWordSet)
{
// HashMap
sensitiveWordMap = new HashMap(keyWordSet.size());
//
String key = null;
//
Map nowMap = null;
//
Map<String, String> newWorMap = null;
//
Iterator<String> iterator = keyWordSet.iterator();
while (iterator.hasNext())
{
key = iterator.next();
// ，HashMap ， nowMap ，sensitiveWordMap
nowMap = sensitiveWordMap;
for (int i = 0; i < key.length(); i++)
{
// ， HashMap Key
char keyChar = key.charAt(i);
//
Object wordMap = nowMap.get(keyChar);
if (wordMap != null)
{
nowMap = (Map) wordMap;
}
else
{
newWorMap = new HashMap<String, String>();
newWorMap.put("isEnd", "0");
nowMap.put(keyChar, newWorMap);
nowMap = newWorMap;
}
// ，
if (i == key.length() - 1)
{
nowMap.put("isEnd", "1");
}
System.out.println(" ："+sensitiveWordMap);
}
System.out.println(" :" + sensitiveWordMap);
}
}
}
package com.cfwx.rox.web.sysmgr.util;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
*
* @author AlanLee
*
*/
public class SensitivewordEngine
{
/**
*
*/
public static Map sensitiveWordMap = null;
/**
*
*/
public static int minMatchTYpe = 1;
/**
*
*/
public static int maxMatchType = 2;
/**
*
*
* @return
*/
public static int getWordSize()
{
if (SensitivewordEngine.sensitiveWordMap == null)
{
return 0;
}
return SensitivewordEngine.sensitiveWordMap.size();
}
/**
*
*
* @param txt
* @param matchType
* @return
*/
public static boolean isContaintSensitiveWord(String txt, int matchType)
{
boolean flag = false;
for (int i = 0; i < txt.length(); i++)
{
int matchFlag = checkSensitiveWord(txt, i, matchType);
if (matchFlag > 0)
{
flag = true;
}
}
return flag;
}
/**
*
*
* @param txt
* @param matchType
* @return
*/
public static Set<String> getSensitiveWord(String txt, int matchType)
{
Set<String> sensitiveWordList = new HashSet<String>();
for (int i = 0; i < txt.length(); i++)
{
int length = checkSensitiveWord(txt, i, matchType);
if (length > 0)
{
//
sensitiveWordList.add(txt.substring(i, i + length));
i = i + length - 1;
}
}
return sensitiveWordList;
}
/**
*
*
* @param txt
* @param matchType
* @param replaceChar
* @return
*/
public static String replaceSensitiveWord(String txt, int matchType, String replaceChar)
{
String resultTxt = txt;
Set<String> set = getSensitiveWord(txt, matchType);
Iterator<String> iterator = set.iterator();
String word = null;
String replaceString = null;
while (iterator.hasNext())
{
word = iterator.next();
replaceString = getReplaceChars(replaceChar, word.length());
resultTxt = resultTxt.replaceAll(word, replaceString);
}
return resultTxt;
}
/**
*
*
* @param replaceChar
* @param length
* @return
*/
private static String getReplaceChars(String replaceChar, int length)
{
String resultReplace = replaceChar;
for (int i = 1; i < length; i++)
{
resultReplace += replaceChar;
}
return resultReplace;
}
/**
*
*
* @param txt
* @param beginIndex
* @param matchType
* @return
*/
public static int checkSensitiveWord(String txt, int beginIndex, int matchType)
{
boolean flag = false;
//
int matchFlag = 0;
char word = 0;
Map nowMap = SensitivewordEngine.sensitiveWordMap;
for (int i = beginIndex; i < txt.length(); i++)
{
word = txt.charAt(i);
//
nowMap = (Map) nowMap.get(word);
if (nowMap != null)
{
matchFlag++;
// ，
if ("1".equals(nowMap.get("isEnd")))
{
flag = true;
// ， ，
if (SensitivewordEngine.minMatchTYpe == matchType)
{
break;
}
}
}
else
{
break;
}
}
if (!flag)
{
matchFlag = 0;
}
return matchFlag;
}
}
@SuppressWarnings("rawtypes")
@Override
public Set<String> sensitiveWordFiltering(String text)
{
//
SensitiveWordInit sensitiveWordInit = new SensitiveWordInit();
// （ Dao ， service ）
List<SensitiveWord> sensitiveWords = sensitiveWordDao.getSensitiveWordListAll();
//
Map sensitiveWordMap = sensitiveWordInit.initKeyWord(sensitiveWords);
// SensitivewordEngine
SensitivewordEngine.sensitiveWordMap = sensitiveWordMap;
// ， 2
Set<String> set = SensitivewordEngine.getSensitiveWord(text, 2);
return set;
}
/**
*
*
* @param text
* @return
*/
@RequestMapping(value = "/word/filter")
@ResponseBody
public RespVo sensitiveWordFiltering(String text)
{
RespVo respVo = new RespVo();
try
{
Set<String> set = sensitiveWordService.sensitiveWordFiltering(text);
respVo.setResult(set);
}
catch (Exception e)
{
throw new RoxException(" ， ");
}
return respVo;
}이상 이 바로 이 문장의 전체 내용 입 니 다.코드 에 많은 주석 을 썼 으 니 여러분 은 자신의 머리 를 써 서 잘 이해 하 실 수 있 습 니 다.본 논문 의 내용 이 여러분 의 학습 이나 업무 에 어느 정도 도움 이 되 기 를 바 랍 니 다.궁금 한 점 이 있 으 시 면 댓 글 을 남 겨 주 셔 서 저희 에 대한 지지 에 감 사 드 립 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Is Eclipse IDE dying?In 2014 the Eclipse IDE is the leading development environment for Java with a market share of approximately 65%. but ac...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
