前言

在這九月的最後一周，來總結一下最近的學習記錄，主要是對於Elasticsearch、XXLjob的初步學習，想著還是多記錄點，以便後面去看看，具體的錯誤認知點在哪，以及找到一些自己的認識點。

後台數據脫敏

一、普通方式

首先該功能是基於Spring Boot項目做的，所以這是一個簡單的流程。
具體實現：首先設定一個角色code，比如「涉密人員」「secret」；
通過登錄時獲取token中的用戶名然後通過用戶名去獲取他的角色code，同時去動態的獲取涉密人員的角色code（即做判斷的時候不能寫死，從資料庫中獲取），
然後將他們的code做判斷；

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
* <p>
*
* </p>
*
* @author yuyueq
* @since 2021/9/13
*/
@Component
@Slf4j
public class JudgeSecret {
  //TODO
  @Autowired
  private BosuserIdentityService bosuserIdentityService;

  @Autowired
  private BosRoleService bosRoleService;

  public Boolean judgingSecret(HttpServletRequest servletRequest) {
      boolean flag = false;
      String token = JwtTokenUtil.getToken(servletRequest);
      String username = JwtUtil.getUsername(token);
      //做角色code獲取並進行判斷
      for (*:*) {
          if (role.getId().equals(sRole.getId())) {
              flag = true;// 是涉密員
              break;
          }
      }
      return flag;
  }

  public String mobileReplace(String mobile) {
      if (StrUtil.isNotBlank(mobile)) {
          return mobile.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
      } else {
          return "-";
      }
  }

  public String nameReplace(String name) {
      if (StrUtil.isNotBlank(name)) {
          return StringUtils.rightPad(StringUtils.left(name, 1), StringUtils.length(name), "*");
      } else {
          return "-";
      }
  }

}

二、Spring AOP實現

只需要給serviceImpl加EncryptMethod註解，以及在需要加密的欄位加上EncryptMobileField、EncryptNameField註解


package net.liangyihui.dhbos.aspect;

import cn.hutool.core.util.ReflectUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import javax.servlet.http.HttpServletRequest;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName : ServiceAspect
 * @Author : yuyueq
 * @Date: 2021/9/18 14:23
 * @Description :
 */
@Slf4j
@Configuration
@Aspect
public class ServiceAspect {

    private final String ExpGetResultDataPoint = "@annotation(位置)";

    @Autowired
    private JudgeSecret judgeSecret;

    @Pointcut(ExpGetResultDataPoint)
    public void EncryptMethod() {

    }

    @Around("EncryptMethod()")
    public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
        log.info("環繞通知的目標方法名：" + proceedingJoinPoint.getSignature().getName());
        processInputArg(proceedingJoinPoint.getArgs());
        try {//obj之前可以寫目標方法執行前的邏輯
            Object obj = proceedingJoinPoint.proceed();
            processOutPutObj(obj);
            return obj;
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return null;
    }

    /**
     * 處理返回對象
     */
    private void processOutPutObj(Object object) {
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest servletRequest = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
        boolean flag = !judgeSecret.judgingSecret(servletRequest);
        if (flag) {
            if (object instanceof Page) {
                //page
                Page page = (Page) object;
                page.getRecords().forEach(o -> {
                    try {
                        Field[] fields = o.getClass().getDeclaredFields();
                        for (Field field : fields) {
                            encrypt(field, o);
                        }
                    } catch (Exception e) {
                        log.info("反射錯誤" + e);
                    }
                });
            } else {
                try {
                    Class clazz = object.getClass();
                    Field[] fields = ReflectUtil.getFieldsDirectly(clazz, true);
                    for (Field field : fields) {
                        field.setAccessible(true);
                        String proType = field.getGenericType().toString();
                        if (proType.contains("class java.lang")
                                || proType.contains("class java.math.")
                                || proType.contains("class java.util")) {
                            encrypt(field, object);
                        } else if ("byte".equals(proType) || "short".equals(proType) || "int".equals(proType) || "long".equals(proType) || "double".equals(proType) || "float".equals(proType) || "boolean".equals(proType)) {
                            encrypt(field, object);
                        } else if (proType.startsWith("java.util")) {
//                            if (field.getGenericType() instanceof ParameterizedType) {
//                                Class newClazz = (Class) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
//                                Object obj = newClazz.newInstance();
//                                processOutPutObj(obj);
//                            }
                        } else if (field.getType().isArray()) {
                            //屬性是數組類型則遍歷

                        } else {
                            //class類型的遍歷
                            PropertyDescriptor descriptor = new PropertyDescriptor(field.getName(), clazz);
                            Method method = descriptor.getReadMethod();
                            Object obj = method.invoke(object);
                            if (null != obj) {
                                processOutPutObj(obj);
                            }
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    log.info("脫敏加密失敗" + e);
                }
            }
        }
    }

    private Field encrypt(Field field, Object obj) {
        try {
            if (field.isAnnotationPresent(EncryptMobileField.class)) {
                field.setAccessible(true);
                Object value = field.get(obj);
                if (value instanceof Long || value == null) {
                    field.set(obj, null);
                } else {
                    field.set(obj, judgeSecret.mobileReplace(value.toString()));
                }
            }
            if (field.isAnnotationPresent(EncryptNameField.class)) {
                field.setAccessible(true);
                Object value = field.get(obj);
                if (value != null) {
                    field.set(obj, judgeSecret.nameReplace(value.toString()));
                } else {
                    field.set(obj, null);
                }
            }
        } catch (IllegalAccessException e) {

        }
        return field;
    }

    /**
     * 處理輸入參數
     *
     * @param args 入參列表
     */
    private void processInputArg(Object[] args) {
//        for (Object arg : args) {
//            System.out.println("ARG原來為:" + arg);
//        }
    }
}