敏感字过滤

一、前言

开发中经常要处理用户一些文字的提交，所以涉及到了敏感词过滤的功能，参考资料中DFA有穷状态机算法的实现，创建有向图。完成了对敏感词、广告词的过滤，而且效率较好，所以分享一下。

具体实现：

1、匹配大小写过滤

2、匹配全角半角过滤

3、匹配过滤停顿词过滤。

4、敏感词重复词过滤。

 

例如：

支持如下类型类型过滤检测：

fuck 全小写

FuCk 大小写

ｆｕｃｋ全角半角

f!!!u&c ###k 停顿词

fffuuuucccckkk 重复词

二、代码实现

其目录结构如下：

 

其中resources资源目录中：

stopwd.txt ：停顿词，匹配时间直接过滤。

wd.txt：敏感词库。

 

1、WordFilter敏感词过滤类

 

 

[java] view plain copyprint?

1. package org.andy.sensitivewdfilter;
2.  
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStreamReader;
6. import java.util.ArrayList;
7. import java.util.HashMap;
8. import java.util.HashSet;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Set;
12.  
13. import org.andy.sensitivewdfilter.util.BCConvert;
14.  
15. /**
16. * 创建时间：2016年8月30日 下午3:01:12
17. *
18. * 思路： 创建一个FilterSet，枚举了0~65535的所有char是否是某个敏感词开头的状态
19. *
20. * 判断是否是 敏感词开头 | | 是 不是 获取头节点 OK--下一个字 然后逐级遍历，DFA算法
21. *
22. * @author andy
23. * @version 2.2
24. */
25. public class WordFilter {
26.  
27. private static final FilterSet set = new FilterSet(); // 存储首字
28. private static final Map<Integer, WordNode> nodes = new HashMap<Integer, WordNode>(1024, 1); // 存储节点
29. private static final Set<Integer> stopwdSet = new HashSet<>(); // 停顿词
30. private static final char SIGN = '*'; // 敏感词过滤替换
31.  
32. static {
33. try {
34. long a = System.nanoTime();
35. init();
36. a = System.nanoTime() - a;
37. System.out.println("加载时间 : " + a + "ns");
38. System.out.println("加载时间 : " + a / 1000000 + "ms");
39. } catch (Exception e) {
40. throw new RuntimeException("初始化过滤器失败");
41. }
42. }
43.  
44. private static void init() {
45. // 获取敏感词
46. addSensitiveWord(readWordFromFile("wd.txt"));
47. addStopWord(readWordFromFile("stopwd.txt"));
48. }
49.  
50. /**
51. * 增加敏感词
52. * @param path
53. * @return
54. */
55. private static List<String> readWordFromFile(String path) {
56. List<String> words;
57. BufferedReader br = null;
58. try {
59. br = new BufferedReader(new InputStreamReader(WordFilter.class.getClassLoader().getResourceAsStream(path)));
60. words = new ArrayList<String>(1200);
61. for (String buf = ""; (buf = br.readLine()) != null;) {
62. if (buf == null || buf.trim().equals(""))
63. continue;
64. words.add(buf);
65. }
66. } catch (Exception e) {
67. throw new RuntimeException(e);
68. } finally {
69. try {
70. if (br != null)
71. br.close();
72. } catch (IOException e) {
73. }
74. }
75. return words;
76. }
77.  
78. /**
79. * 增加停顿词
80. *
81. * @param words
82. */
83. private static void addStopWord(final List<String> words) {
84. if (words != null && words.size() > 0) {
85. char[] chs;
86. for (String curr : words) {
87. chs = curr.toCharArray();
88. for (char c : chs) {
89. stopwdSet.add(charConvert(c));
90. }
91. }
92. }
93. }
94.  
95. /**
96. * 添加DFA节点
97. * @param words
98. */
99. private static void addSensitiveWord(final List<String> words) {
100. if (words != null && words.size() > 0) {
101. char[] chs;
102. int fchar;
103. int lastIndex;
104. WordNode fnode; // 首字母节点
105. for (String curr : words) {
106. chs = curr.toCharArray();
107. fchar = charConvert(chs[0]);
108. if (!set.contains(fchar)) {// 没有首字定义
109. set.add(fchar);// 首字标志位 可重复add,反正判断了，不重复了
110. fnode = new WordNode(fchar, chs.length == 1);
111. nodes.put(fchar, fnode);
112. } else {
113. fnode = nodes.get(fchar);
114. if (!fnode.isLast() && chs.length == 1)
115. fnode.setLast(true);
116. }
117. lastIndex = chs.length - 1;
118. for (int i = 1; i < chs.length; i++) {
119. fnode = fnode.addIfNoExist(charConvert(chs[i]), i == lastIndex);
120. }
121. }
122. }
123. }
124.  
125. /**
126. * 过滤判断 将敏感词转化为成屏蔽词
127. * @param src
128. * @return
129. */
130. public static final String doFilter(final String src) {
131. char[] chs = src.toCharArray();
132. int length = chs.length;
133. int currc;
134. int k;
135. WordNode node;
136. for (int i = 0; i < length; i++) {
137. currc = charConvert(chs[i]);
138. if (!set.contains(currc)) {
139. continue;
140. }
141. node = nodes.get(currc);// 日 2
142. if (node == null)// 其实不会发生，习惯性写上了
143. continue;
144. boolean couldMark = false;
145. int markNum = -1;
146. if (node.isLast()) {// 单字匹配（日）
147. couldMark = true;
148. markNum = 0;
149. }
150. // 继续匹配（日你/日你妹），以长的优先
151. // 你-3 妹-4 夫-5
152. k = i;
153. for (; ++k < length;) {
154. int temp = charConvert(chs[k]);
155. if (stopwdSet.contains(temp))
156. continue;
157. node = node.querySub(temp);
158. if (node == null)// 没有了
159. break;
160. if (node.isLast()) {
161. couldMark = true;
162. markNum = k - i;// 3-2
163. }
164. }
165. if (couldMark) {
166. for (k = 0; k <= markNum; k++) {
167. chs[k + i] = SIGN;
168. }
169. i = i + markNum;
170. }
171. }
172.  
173. return new String(chs);
174. }
175.  
176. /**
177. * 是否包含敏感词
178. * @param src
179. * @return
180. */
181. public static final boolean isContains(final String src) {
182. char[] chs = src.toCharArray();
183. int length = chs.length;
184. int currc;
185. int k;
186. WordNode node;
187. for (int i = 0; i < length; i++) {
188. currc = charConvert(chs[i]);
189. if (!set.contains(currc)) {
190. continue;
191. }
192. node = nodes.get(currc);// 日 2
193. if (node == null)// 其实不会发生，习惯性写上了
194. continue;
195. boolean couldMark = false;
196. if (node.isLast()) {// 单字匹配（日）
197. couldMark = true;
198. }
199. // 继续匹配（日你/日你妹），以长的优先
200. // 你-3 妹-4 夫-5
201. k = i;
202. for (; ++k < length;) {
203. int temp = charConvert(chs[k]);
204. if (stopwdSet.contains(temp))
205. continue;
206. node = node.querySub(temp);
207. if (node == null)// 没有了
208. break;
209. if (node.isLast()) {
210. couldMark = true;
211. }
212. }
213. if (couldMark) {
214. return true;
215. }
216. }
217.  
218. return false;
219. }
220.  
221. /**
222. * 大写转化为小写 全角转化为半角
223. *
224. * @param src
225. * @return
226. */
227. private static int charConvert(char src) {
228. int r = BCConvert.qj2bj(src);
229. return (r >= 'A' && r <= 'Z') ? r + 32 : r;
230. }
231.  
232. }

package org.andy.sensitivewdfilter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.andy.sensitivewdfilter.util.BCConvert;

/**
 * 创建时间：2016年8月30日 下午3:01:12
 * 
 * 思路： 创建一个FilterSet，枚举了0~65535的所有char是否是某个敏感词开头的状态
 * 
 * 判断是否是 敏感词开头 | | 是 不是 获取头节点 OK--下一个字 然后逐级遍历，DFA算法
 * 
 * @author andy
 * @version 2.2
 */
public class WordFilter {

	private static final FilterSet set = new FilterSet(); // 存储首字
	private static final Map<Integer, WordNode> nodes = new HashMap<Integer, WordNode>(1024, 1); // 存储节点
	private static final Set<Integer> stopwdSet = new HashSet<>(); // 停顿词
	private static final char SIGN = '*'; // 敏感词过滤替换

	static {
		try {
			long a = System.nanoTime();
			init();
			a = System.nanoTime() - a;
			System.out.println("加载时间 : " + a + "ns");
			System.out.println("加载时间 : " + a / 1000000 + "ms");
		} catch (Exception e) {
			throw new RuntimeException("初始化过滤器失败");
		}
	}

	private static void init() {
		// 获取敏感词
		addSensitiveWord(readWordFromFile("wd.txt"));
		addStopWord(readWordFromFile("stopwd.txt"));
	}

	/**
	 * 增加敏感词
	 * @param path
	 * @return
	 */
	private static List<String> readWordFromFile(String path) {
		List<String> words;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new InputStreamReader(WordFilter.class.getClassLoader().getResourceAsStream(path)));
			words = new ArrayList<String>(1200);
			for (String buf = ""; (buf = br.readLine()) != null;) {
				if (buf == null || buf.trim().equals(""))
					continue;
				words.add(buf);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			try {
				if (br != null)
					br.close();
			} catch (IOException e) {
			}
		}
		return words;
	}

	/**
	 * 增加停顿词
	 * 
	 * @param words
	 */
	private static void addStopWord(final List<String> words) {
		if (words != null && words.size() > 0) {
			char[] chs;
			for (String curr : words) {
				chs = curr.toCharArray();
				for (char c : chs) {
					stopwdSet.add(charConvert(c));
				}
			}
		}
	}

	/**
	 * 添加DFA节点
	 * @param words
	 */
	private static void addSensitiveWord(final List<String> words) {
		if (words != null && words.size() > 0) {
			char[] chs;
			int fchar;
			int lastIndex;
			WordNode fnode; // 首字母节点
			for (String curr : words) {
				chs = curr.toCharArray();
				fchar = charConvert(chs[0]);
				if (!set.contains(fchar)) {// 没有首字定义
					set.add(fchar);// 首字标志位 可重复add,反正判断了，不重复了
					fnode = new WordNode(fchar, chs.length == 1);
					nodes.put(fchar, fnode);
				} else {
					fnode = nodes.get(fchar);
					if (!fnode.isLast() && chs.length == 1)
						fnode.setLast(true);
				}
				lastIndex = chs.length - 1;
				for (int i = 1; i < chs.length; i++) {
					fnode = fnode.addIfNoExist(charConvert(chs[i]), i == lastIndex);
				}
			}
		}
	}

	/**
	 * 过滤判断 将敏感词转化为成屏蔽词
	 * @param src
	 * @return
	 */
	public static final String doFilter(final String src) {
		char[] chs = src.toCharArray();
		int length = chs.length;
		int currc;
		int k;
		WordNode node;
		for (int i = 0; i < length; i++) {
			currc = charConvert(chs[i]);
			if (!set.contains(currc)) {
				continue;
			}
			node = nodes.get(currc);// 日 2
			if (node == null)// 其实不会发生，习惯性写上了
				continue;
			boolean couldMark = false;
			int markNum = -1;
			if (node.isLast()) {// 单字匹配（日）
				couldMark = true;
				markNum = 0;
			}
			// 继续匹配（日你/日你妹），以长的优先
			// 你-3 妹-4 夫-5
			k = i;
			for (; ++k < length;) {
				int temp = charConvert(chs[k]);
				if (stopwdSet.contains(temp))
					continue;
				node = node.querySub(temp);
				if (node == null)// 没有了
					break;
				if (node.isLast()) {
					couldMark = true;
					markNum = k - i;// 3-2
				}
			}
			if (couldMark) {
				for (k = 0; k <= markNum; k++) {
					chs[k + i] = SIGN;
				}
				i = i + markNum;
			}
		}

		return new String(chs);
	}
	
	/**
	 * 是否包含敏感词
	 * @param src
	 * @return
	 */
	public static final boolean isContains(final String src) {
		char[] chs = src.toCharArray();
		int length = chs.length;
		int currc;
		int k;
		WordNode node;
		for (int i = 0; i < length; i++) {
			currc = charConvert(chs[i]);
			if (!set.contains(currc)) {
				continue;
			}
			node = nodes.get(currc);// 日 2
			if (node == null)// 其实不会发生，习惯性写上了
				continue;
			boolean couldMark = false;
			if (node.isLast()) {// 单字匹配（日）
				couldMark = true;
			}
			// 继续匹配（日你/日你妹），以长的优先
			// 你-3 妹-4 夫-5
			k = i;
			for (; ++k < length;) {
				int temp = charConvert(chs[k]);
				if (stopwdSet.contains(temp))
					continue;
				node = node.querySub(temp);
				if (node == null)// 没有了
					break;
				if (node.isLast()) {
					couldMark = true;
				}
			}
			if (couldMark) {
				return true;
			}
		}

		return false;
	}

	/**
	 * 大写转化为小写 全角转化为半角
	 * 
	 * @param src
	 * @return
	 */
	private static int charConvert(char src) {
		int r = BCConvert.qj2bj(src);
		return (r >= 'A' && r <= 'Z') ? r + 32 : r;
	}

}

 

 

其中：

isContains ：是否包含敏感词

doFilter：过滤敏感词

 

2、WordNode敏感词节点

 

[java] view plain copyprint?

1. package org.andy.sensitivewdfilter;
2.  
3. import java.util.LinkedList;
4. import java.util.List;
5.  
6. /**
7. * 创建时间：2016年8月30日 下午3:07:45
8. *
9. * @author andy
10. * @version 2.2
11. */
12. public class WordNode {
13.  
14. private int value; // 节点名称
15.  
16. private List<WordNode> subNodes; // 子节点
17.  
18. private boolean isLast;// 默认false
19.  
20. public WordNode(int value) {
21. this.value = value;
22. }
23.  
24. public WordNode(int value, boolean isLast) {
25. this.value = value;
26. this.isLast = isLast;
27. }
28.  
29. /**
30. *
31. * @param subNode
32. * @return 就是传入的subNode
33. */
34. private WordNode addSubNode(final WordNode subNode) {
35. if (subNodes == null)
36. subNodes = new LinkedList<WordNode>();
37. subNodes.add(subNode);
38. return subNode;
39. }
40.  
41. /**
42. * 有就直接返回该子节点， 没有就创建添加并返回该子节点
43. *
44. * @param value
45. * @return
46. */
47. public WordNode addIfNoExist(final int value, final boolean isLast) {
48. if (subNodes == null) {
49. return addSubNode(new WordNode(value, isLast));
50. }
51. for (WordNode subNode : subNodes) {
52. if (subNode.value == value) {
53. if (!subNode.isLast && isLast)
54. subNode.isLast = true;
55. return subNode;
56. }
57. }
58. return addSubNode(new WordNode(value, isLast));
59. }
60.  
61. public WordNode querySub(final int value) {
62. if (subNodes == null) {
63. return null;
64. }
65. for (WordNode subNode : subNodes) {
66. if (subNode.value == value)
67. return subNode;
68. }
69. return null;
70. }
71.  
72. public boolean isLast() {
73. return isLast;
74. }
75.  
76. public void setLast(boolean isLast) {
77. this.isLast = isLast;
78. }
79.  
80. @Override
81. public int hashCode() {
82. return value;
83. }
84.  
85. }

package org.andy.sensitivewdfilter;

import java.util.LinkedList;
import java.util.List;

/**
 * 创建时间：2016年8月30日 下午3:07:45
 * 
 * @author andy
 * @version 2.2
 */
public class WordNode {

	private int value; // 节点名称

	private List<WordNode> subNodes; // 子节点

	private boolean isLast;// 默认false

	public WordNode(int value) {
		this.value = value;
	}

	public WordNode(int value, boolean isLast) {
		this.value = value;
		this.isLast = isLast;
	}

	/**
	 * 
	 * @param subNode
	 * @return 就是传入的subNode
	 */
	private WordNode addSubNode(final WordNode subNode) {
		if (subNodes == null)
			subNodes = new LinkedList<WordNode>();
		subNodes.add(subNode);
		return subNode;
	}

	/**
	 * 有就直接返回该子节点， 没有就创建添加并返回该子节点
	 * 
	 * @param value
	 * @return
	 */
	public WordNode addIfNoExist(final int value, final boolean isLast) {
		if (subNodes == null) {
			return addSubNode(new WordNode(value, isLast));
		}
		for (WordNode subNode : subNodes) {
			if (subNode.value == value) {
				if (!subNode.isLast && isLast)
					subNode.isLast = true;
				return subNode;
			}
		}
		return addSubNode(new WordNode(value, isLast));
	}

	public WordNode querySub(final int value) {
		if (subNodes == null) {
			return null;
		}
		for (WordNode subNode : subNodes) {
			if (subNode.value == value)
				return subNode;
		}
		return null;
	}

	public boolean isLast() {
		return isLast;
	}

	public void setLast(boolean isLast) {
		this.isLast = isLast;
	}

	@Override
	public int hashCode() {
		return value;
	}

}

 

 

 

 

三、测试结果

 

项目包含敏感词库，源码，停顿词库等，只需运行maven打jar包直接可运行。

 

 

 

博客来源：http://blog.csdn.net/fengshizty?viewmode=list

项目源码：http://download.csdn.net/detail/fengshizty/9617695