检测敏感词汇

package cn.com.connext.commenservice.utils;

import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

public class BeanValidator {

private static ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();

@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> Map<String,String> validate(T t,Class... groups){
    Validator validator = validatorFactory.getValidator();
    Set validateResult = validator.validate(t, groups);
    if(validateResult.isEmpty()){
        return Collections.EMPTY_MAP;
    } else {
        LinkedHashMap errors = Maps.newLinkedHashMap();
        Iterator iterator = validateResult.iterator();
        while(iterator.hasNext()){
            ConstraintViolation violation = (ConstraintViolation)iterator.next();
            errors.put(violation.getPropertyPath().toString(), violation.getMessage());
        }
        return errors;
    }
}

public static <T> Map<String,String> validateList(Collection<?> collection){

    Preconditions.checkNotNull(collection);
    Iterator<?> iterator = collection.iterator();
    Map errors;
    do {
        if(!iterator.hasNext()){
            return Collections.EMPTY_MAP;
        }
        Object object = iterator.next();
        errors = validate(object, new Class[0]);
    } while (errors.isEmpty());

    return errors;
}

public static <T> Map<String,String> validateObject(Object first,Object... objects){
    if(objects != null && objects.length > 0){
        return validateList(Lists.asList(first, objects));
    } else {
        return validate(first,new Class[0]);
    }
}

}

/**
 * @param content
 * @return 返回false表示有敏感词
 */
public static boolean checkContent(String content) {
	Set<String> set = BadWordUtil.getBadWord(content, 2);
	log.info("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);
	if(set.size()>0){
		return false;
	}else{
		return true;
	}
}
@PostMapping("/check")
@ApiOperation(value = "检测敏感词汇", notes = "检测敏感词汇")
public LYResultVO check(@RequestBody Topic params)  {
	
	Map<String, String> map = BeanValidator.validateObject(params);
    if(MapUtils.isNotEmpty(map)){
        String r = "";
        for (Map.Entry<String, String> entry : map.entrySet()) {
            log.info("{}->{}",entry.getKey(), entry.getValue());
            r = r + entry.getValue();
        }
        return LYResultVO.errorResultVO(r);
    }
	
	log.info(JsonUtils.toJSONString(params));
	
	if(!BadWordUtil.checkContent(params.getContent())){
		 return LYResultVO.errorResultVO("发帖失败,内容包含敏感词");
	}
	return LYResultVO.successResultVO("检测通过");
}