使用注解对手机号及卡号加验工具类

一、定义加验地注解类

/**
 * @Description:加掩码注解
 * @Author: yunpeng.zhao
 * @date 2017-08-19 18:51
 */
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
public @interface Cover {

    /***
     * 替换字符串
     * @return
     */
    String replace()
        default "****";
}

二、加验工具类

/***
 * @Descriptoin:常用工具类
 * @Author: yunpeng.zhao
 * @Date: 2017/3/15
 */
public class CoverUtils {

    private final static Logger logger = LoggerFactory.getLogger(CoverUtils.class);

    /**
     *
     * <p>反序列化</p>
     * @Title deserializeObject
     * @param buf
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     * @return Object
     * @author shihj
     * @Create 2014年1月19日
     */
    public static  Object deserializeObject(byte[] buf) throws IOException, ClassNotFoundException {
        Object object = null;
        ByteArrayInputStream sais = new ByteArrayInputStream(buf);
        ObjectInputStream ois = new ObjectInputStream(sais);
        object =  ois.readObject();
        return object;
    }

    /**
     *  取卡号后四位
     * @param cardNo
     * @return
     */
    public static String getLast4CardNo(String cardNo){
        try {
            if(cardNo!=null && cardNo.trim().length()>4){
                String temp = cardNo.trim();
                return temp.substring(cardNo.length()-4);
            }
        } catch (Exception e) {
            logger.error("取卡号后四位发生异常", e);
        }
        return cardNo;
    }

    /**
     * 对卡号进行遮盖，只显示前6后4
     * @param cardNo
     * @return
     */
    public static String coverCardNo(String cardNo){
        try {
            if(cardNo!=null && cardNo.trim().length()>10){
                String temp = cardNo.trim();
                return temp.substring(0, 6)+"******"+temp.substring(cardNo.length()-4);
            }
        } catch (Exception e) {
            logger.error("对卡号进行遮盖发生异常", e);
        }
        return cardNo;
    }

    /***
     * 对敏感信息进行遮掩
     * @param coverStr
     * @return
     */
    public static String cover(String coverStr){
        try {
            if(StringUtils.isNotBlank(coverStr)){
                String temp = coverStr.trim();
                if(coverStr.length() > 11){
                    return temp.substring(0, 6)+"*****"+temp.substring(coverStr.length()-4);
                }else if(coverStr.length() > 4){
                    return temp.substring(0, 3)+"****"+temp.substring(coverStr.length()-4);
                }else if(coverStr.length() > 0){
                    return "***";
                }
            }
        } catch (Exception e) {
            logger.error("对敏感信息进行遮盖发生异常", e);
        }
        return coverStr;
    }

    /***
     * 通过注解toString方法
     * @param object
     * @return
     */
    public static String toString(Object object){
        return toString(object, true);
    }


    /***
     * 通过注解toString方法
     * @param object
     * @param isFormatBigDecimal
     * @return
     */
    public static String toString(Object object, boolean isFormatBigDecimal){
        if(object == null){
            return "null";
        }
        Class<?> clazz = object.getClass();
        Map<String, Object> paramMap = new HashMap<String, Object>(16);
        List<Object> objects =  new ArrayList<Object>();
        List<Field> fieldList = getObjectFields(object);
        for(Field field : fieldList){
            field.setAccessible(true);
            Object o = null;
            try {
                o = field.get(object);
                boolean fieldAnnotationPresent = field.isAnnotationPresent(Cover.class);
                //对字符串且添加注解的值进行掩码
                if(o instanceof String && fieldAnnotationPresent){
                    String value = (String) o;
                    value = cover(value);
                    paramMap.put(field.getName(), value);
                }else {
                    if(o == null){
                        continue;
                    }
                    if(o instanceof Enum){
                        paramMap.put(field.getName(), o);
                    }else if(o instanceof Double){
                        Double d = (Double) o;
                        NumberFormat nf = NumberFormat.getNumberInstance();
                        // 保留3位小数
                        nf.setMaximumFractionDigits(2);
                        // 如果不需要四舍五入，可以使用RoundingMode.DOWN
                        nf.setRoundingMode(RoundingMode.UP);
                        paramMap.put(field.getName(), nf.format(d));
                    }else if(o instanceof BigDecimal && isFormatBigDecimal){
                        BigDecimal decimal = (BigDecimal) o;
                        NumberFormat nf = NumberFormat.getNumberInstance();
                        // 保留3位小数
                        nf.setMaximumFractionDigits(2);
                        // 如果不需要四舍五入，可以使用RoundingMode.DOWN
                        nf.setRoundingMode(RoundingMode.UP);
                        paramMap.put(field.getName(), nf.format(decimal));
                    }else if(o.getClass().toString().contains("com.yeepay.g3") && fieldAnnotationPresent){
                        paramMap.put(field.getName(), toString(o));
                    }else if("extendMap".equals(field.getName())){
                        continue;
                    }else{
                        paramMap.put(field.getName(), o);
                    }
                }
            } catch (IllegalAccessException e) {
                logger.error("获取变量值出现IllegalAccessException异常", e);
            }
        }

        return JSONUtils.toJsonString(paramMap);
    }

    /***
     * 通过参数名重新toString方法
     * @param object
     * @param coverParams
     * @return
     */
    public static String toString(Object object, String[] coverParams){
        String str = JSONObject.toJSONString(object);
        Map<String, String> map = JSONUtils.jsonToMap(str, String.class, String.class);
        if(map !=null && map.size() > 0){
            for(Map.Entry<String, String> entry : map.entrySet()){
                String key = entry.getKey();
                for(String coverParam : coverParams){
                    if(coverParam.equals(key)){
                        map.put(key, cover(entry.getValue()));
                    }
                }
            }
            return JSONObject.toJSONString(map);
        }
        return str;
    }

    /***
     * 通过参数名设置对象成员对应值
     * @param object
     * @param fieldName
     * @param value
     */
    public static void setFieldValue(Object object, String fieldName, Object value){

        if(object == null && StringUtils.isBlank(fieldName)){
            logger.info("通过参数名设置对象成员对应值失败,object或fieldName为空");
            return;
        }
        try {
            Class<?> clazz = object.getClass();
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(object, value);
        } catch (Exception e) {
            logger.error("通过参数名设置对象成员对应值出现异常", e);
        }
    }



    /***
     * 获取对象成员信息
     * @param object
     * @return
     */
    public static  List<Field> getObjectFields(Object object){

        List<Field> fieldList = new ArrayList<Field>();
        if(object == null){
            return fieldList;
        }
        Class<?> clazz = object.getClass();
        Field[] fields = clazz.getDeclaredFields();
        Field[] superFields = clazz.getSuperclass().getDeclaredFields();
        Map<String, Object> paramMap = new HashMap<String, Object>();
        for(Field field :superFields){
            fieldList.add(field);
        }
        for(Field field :fields){
            fieldList.add(field);
        }
        //多重继承需要
        if (clazz.getSuperclass().getSuperclass() != null){
            Field[] super2Fields = clazz.getSuperclass().getSuperclass().getDeclaredFields();
            for(Field field :super2Fields){
                fieldList.add(field);
            }
        }
        return fieldList;
    }

    /**
     * yop请求验证appKey和商户商编 是否 不匹配
     * @param appKey
     * @param customerNo
     * @return
     */
    public static boolean validateCustomer (String appKey , String customerNo){
        if(!getStringArray(appKey,"_").equals(customerNo)){
            return true;
        }
        return false;
    }

    /**
     * 将字符串用regex切割返回数组最后一个值
     * @param str
     * @param regex
     * @return
     */
    public static String getStringArray(String str , String regex){
        if(StringUtils.isNotBlank(str) && StringUtils.isNotBlank(regex)){
            String[] stringArray = str.split(regex);
            return stringArray[stringArray.length - 1];
        }
        return "";
    }
}

三、如何使用：对需要加验地类重写toString()方法即可。

LOGGER.info("{}请求参数：{}",name, CoverUtils.toString(args[0]));

四、该注解需要spring扫描管理后，才能使用