Elasticsearch、XXLJob以及最近的學習記錄

前言

在這九月的最後一週，來總結一下最近的學習記錄，主要是對於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);

//        }

    }

}