aop添加同步

package com.gxhj.safecampus.visit.aop;


import com.alibaba.fastjson.JSONObject;
import com.gxhj.commontools.utils.BeanUtils;
import com.gxhj.commontools.utils.CollectionUtils;
import com.gxhj.safecampus.person.entity.EmployeeInfo;
import com.gxhj.safecampus.person.service.IEmployeeService;
import com.gxhj.safecampus.visit.constant.AopParamIndex;
import com.gxhj.safecampus.visit.entity.DataSynchronousInfo;
import com.gxhj.safecampus.visit.enums.SynchronousDataOperateTypes;
import com.gxhj.safecampus.visit.enums.SynchronousDataTypes;
import com.gxhj.safecampus.visit.enums.SynchronousStatuses;
import com.gxhj.safecampus.visit.service.impl.DataSynchronousServiceImpl;
import com.gxhj.safecampus.visit.vo.EmployeeInfoSynchronousVo;
import com.gxhj.safecampus.visit.vo.GroupInfoSynchronousVo;
import com.gxhj.usermanage.entity.GroupInfo;
import com.gxhj.usermanage.service.IGroupService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Configuration
@Component
@Aspect
@ConditionalOnBean(DataSynchronousServiceImpl.class)
public class SynchronousAop {

    private static final Logger log = LoggerFactory.getLogger(SynchronousAop.class);
    @Autowired
    private DataSynchronousServiceImpl datasynchronousService;
    @Autowired
    private IGroupService groupService;
    @Autowired
    private IEmployeeService employeeService;


    /**
     * 新增员工切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.saveInfo(..)) &&  target(com.gxhj.safecampus.person.controller.EmployeeController)")
    public void saveEmployeeInfoMethods() {
    }

    /**
     * 新增组织切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.saveInfo(..)) &&  target(com.gxhj.usermanage.controller.GroupController)")
    public void saveGroupInfoMethods() {
    }

    /**
     * 更新员工切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.updateInfoById(..)) &&  target(com.gxhj.safecampus.person.controller.EmployeeController)")
    public void updateEmployeeInfoMethods() {
    }

    /**
     * 更新组织切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.updateInfoById(..)) &&  target(com.gxhj.usermanage.controller.GroupController)")
    public void updateGroupInfoMethods() {
    }

    /**
     * 删除员工切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.delete*(..)) && target(com.gxhj.safecampus.person.controller.EmployeeController)")
    public void deleteEmployeeInfoMethods() {
    }

    /**
     * 删除组织切点
     */
    @Pointcut("execution(* com.gxhj.usermanage.utils.BaseController.delete*(..)) && target(com.gxhj.usermanage.controller.GroupController)")
    public void deleteGroupInfoMethods() {
    }

    /**
     * 新增员工同步数据
     *
     * @param joinPoint
     * @param returnValue 目标方法返回值
     * @return 目标方法返回值
     */
    @AfterReturning(value = "saveEmployeeInfoMethods()", returning = "returnValue")
    public Object saveEmployee(JoinPoint joinPoint, Object returnValue) {
        // 同步类型判断
        DataSynchronousInfo datasynchronousInfo = saveOrUpdateEmployee(joinPoint, SynchronousDataOperateTypes.AddOperate, AopParamIndex.SAVE_INDEX);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return returnValue;
    }

    /**
     * 新增组织同步数据
     *
     * @param joinPoint
     * @param returnValue 目标方法返回值
     * @return 目标方法返回值
     */
    @AfterReturning(value = "saveGroupInfoMethods()", returning = "returnValue")
    public Object saveGroup(JoinPoint joinPoint, Object returnValue) {
        DataSynchronousInfo datasynchronousInfo = saveOrUpdateGroup(joinPoint, SynchronousDataOperateTypes.AddOperate, AopParamIndex.SAVE_INDEX);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return returnValue;
    }

    /**
     * 更新员工同步数据
     *
     * @param joinPoint
     * @param returnValue 目标方法返回值
     * @return 目标方法返回值
     */
    @AfterReturning(value = "updateEmployeeInfoMethods()", returning = "returnValue")
    public Object updateEmployee(JoinPoint joinPoint, Object returnValue) {
        // 同步类型判断
        DataSynchronousInfo datasynchronousInfo = saveOrUpdateEmployee(joinPoint, SynchronousDataOperateTypes.UpdateOperate, AopParamIndex.UPDATE_INDEX);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return returnValue;
    }

    /**
     * 更新组织同步数据类型
     *
     * @param joinPoint
     * @param returnValue 目标方法返回值
     * @return 目标方法返回值
     */
    @AfterReturning(value = "updateGroupInfoMethods()", returning = "returnValue")
    public Object updateGroup(JoinPoint joinPoint, Object returnValue) {
        // 同步类型判断
        DataSynchronousInfo datasynchronousInfo = saveOrUpdateGroup(joinPoint, SynchronousDataOperateTypes.UpdateOperate, AopParamIndex.UPDATE_INDEX);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return returnValue;
    }

    /**
     * 删除员工同步数据
     *
     * @param joinPoint
     * @return 目标方法返回值
     * @throws Throwable
     */
    @Around("deleteEmployeeInfoMethods()")
    public Object deleteEmployeeAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //前置
        List<String> contentIds = deleteEmployee(joinPoint, AopParamIndex.DELETE_INDEX);
        Object objResult = joinPoint.proceed();
        // 正常后置
        DataSynchronousInfo datasynchronousInfo = getDelDataSynchronous(SynchronousDataTypes.EmployeeType, contentIds);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return objResult;
    }

    /**
     * 删除组织同步数据
     *
     * @param joinPoint
     * @return 目标方法返回值
     * @throws Throwable
     */
    @Around("deleteGroupInfoMethods()")
    public Object deleteGroubAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前置
        List<String> contentIds = deleteGroup(joinPoint, AopParamIndex.DELETE_INDEX);
        Object objResult = joinPoint.proceed();
        // 正常后置
        DataSynchronousInfo datasynchronousInfo = getDelDataSynchronous(SynchronousDataTypes.GroupType, contentIds);
        if (datasynchronousInfo != null) {
            try {
                datasynchronousService.saveValidInfo(datasynchronousInfo);
                log.info("同步数据存储成功");
            } catch (Exception e) {
                log.error("新建同步信息失败", e);
            }
        }
        return objResult;
    }

    /**
     * 获取要插入的删除记录
     *
     * @param type 员工 or 组织 判断类型
     * @return DataSynchronousInfo
     */
    private DataSynchronousInfo getDelDataSynchronous(SynchronousDataTypes type, List<String> contentIds) {

        if (CollectionUtils.isEmpty(contentIds)) {
            return null;
        }
        // 构造同步数据记录
        DataSynchronousInfo datasynchronousInfo = new DataSynchronousInfo();
        // 组同步记录数据
        datasynchronousInfo.setDataType(type);
        datasynchronousInfo.setDataContent(JSONObject.toJSONString(contentIds));
        datasynchronousInfo.setSynchronousStatus(SynchronousStatuses.SynchronousWait);
        // 数据操作类型
        datasynchronousInfo.setOperateType(SynchronousDataOperateTypes.DeleteOperate);
        return datasynchronousInfo;
    }

    /**
     * 获取需要组织信息
     *
     * @param joinPoint
     * @param index     参数索引
     * @return
     */
    private List<String> deleteGroup(JoinPoint joinPoint, Integer index) {
        // 判断是否需要同步
        Object[] args = joinPoint.getArgs();
        Object arg = args[index];
        List<String> idArgs = new ArrayList<>();
        if (arg instanceof ArrayList) {
            idArgs = (List<String>) arg;
        } else {
            idArgs.add(arg.toString());
        }

        if (CollectionUtils.isEmpty(idArgs)) {
            return null;
        }
        // 获取同步数据的组织编号列表
        return this.groupService.lambdaQuery()
                .select(GroupInfo::getGroupId)
                .in(GroupInfo::getGroupId, idArgs)
                .eq(GroupInfo::getSynchronousData, true)
                .list()
                .stream().map(GroupInfo::getGroupId)
                .collect(Collectors.toList());
    }

    /**
     * 获取需要同步的员工信息
     *
     * @param joinPoint
     * @param index     参数索引
     * @return
     */
    private List<String> deleteEmployee(JoinPoint joinPoint, Integer index) {
        // 判断是否需要同步
        Object[] args = joinPoint.getArgs();
        Object arg = args[index];
        List<String> idArgs = new ArrayList<>();
        if (arg instanceof ArrayList) {
            idArgs = (List<String>) arg;
        } else {
            idArgs.add(arg.toString());
        }

        if (CollectionUtils.isEmpty(idArgs)) {
            return null;
        }
        // 获取同步员工信息
        // 获取同步组织ID
        List<String> lstGroupId = this.groupService.lambdaQuery()
                .select(GroupInfo::getGroupId)
                .eq(GroupInfo::getSynchronousData, true)
                .list()
                .stream().map(GroupInfo::getGroupId).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(lstGroupId)) {
            return null;
        }

        return this.employeeService.lambdaQuery()
                .in(EmployeeInfo::getEmployeeId, idArgs)
                .in(EmployeeInfo::getGroupId, lstGroupId)
                .list()
                .stream().map(EmployeeInfo::getEmployeeId).collect(Collectors.toList());

    }


    /**
     * 组织数据添加或跟新时同步调用
     *
     * @param joinPoint   joinPoint
     * @param operateType 数据操作类型
     * @param index       取参索引
     * @return
     */
    private DataSynchronousInfo saveOrUpdateGroup(JoinPoint joinPoint, SynchronousDataOperateTypes operateType, Integer index) {
        // 构造同步数据记录
        DataSynchronousInfo datasynchronousInfo = new DataSynchronousInfo();
        // 判断是否需要同步
        Object[] args = joinPoint.getArgs();

        Object arg = args[index];
        if (arg == null)
            return null;
        GroupInfo groupInfo = JSONObject.parseObject(JSONObject.toJSONString(arg), GroupInfo.class);
        if (groupInfo == null || !groupInfo.getSynchronousData())
            return null;
        // 需要同步
        // 构造同步内容
        GroupInfoSynchronousVo groupInfoSynchronousVo = new GroupInfoSynchronousVo();
        BeanUtils.copy(groupInfo, groupInfoSynchronousVo);
        ArrayList<GroupInfoSynchronousVo> groupInfoSynchronousVos = new ArrayList<>();
        groupInfoSynchronousVos.add(groupInfoSynchronousVo);

        // 组织同步数据
        datasynchronousInfo.setDataContent(JSONObject.toJSONString(groupInfoSynchronousVos));
        datasynchronousInfo.setDataType(SynchronousDataTypes.GroupType);
        datasynchronousInfo.setSynchronousStatus(SynchronousStatuses.SynchronousWait);
        // 数据操作类型
        datasynchronousInfo.setOperateType(operateType);
        return datasynchronousInfo;
    }

    /**
     * 员工数据添加或跟新时同步调用
     *
     * @param joinPoint   joinPoint
     * @param operateType 数据操作类型
     * @param index       取参索引
     * @return
     */
    private DataSynchronousInfo saveOrUpdateEmployee(JoinPoint joinPoint, SynchronousDataOperateTypes operateType, Integer index) {
        // 构造同步数据记录
        DataSynchronousInfo datasynchronousInfo = new DataSynchronousInfo();
        // 判断是否需要同步
        Object[] args = joinPoint.getArgs();

        Object arg = args[index];
        if (arg == null) {
            return null;
        }
        EmployeeInfo employeeInfo = JSONObject.parseObject(JSONObject.toJSONString(arg), EmployeeInfo.class);
        GroupInfo groupInfo = this.groupService.getById(employeeInfo.getGroupId());
        if (groupInfo == null || !groupInfo.getSynchronousData()) {
            return null;
        }
        // 构造同步内容
        EmployeeInfoSynchronousVo employeeInfoSynchronousVo = new EmployeeInfoSynchronousVo();
        BeanUtils.copy(employeeInfo, employeeInfoSynchronousVo);
        ArrayList<EmployeeInfoSynchronousVo> employeeInfoSynchronousVos = new ArrayList<>();
        employeeInfoSynchronousVos.add(employeeInfoSynchronousVo);

        // 组同步记录数据
        datasynchronousInfo.setDataType(SynchronousDataTypes.EmployeeType);
        datasynchronousInfo.setDataContent(JSONObject.toJSONString(employeeInfoSynchronousVos));
        datasynchronousInfo.setSynchronousStatus(SynchronousStatuses.SynchronousWait);
        // 数据操作类型
        datasynchronousInfo.setOperateType(operateType);
        return datasynchronousInfo;
    }

}