package com.gxhj.safecampus.visit.aop;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.gxhj.commontools.utils.BeanUtils;
import com.gxhj.commontools.utils.CollectionUtils;
import com.gxhj.safecampus.person.controller.EmployeeController;
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.controller.GroupController;
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.core.base.controller.BaseController.saveOrUpdateInfo(..))")
public void saveOrUpdateInfo() { }
/**
* 新增员工切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.saveInfo(..)) && target(com.gxhj.safecampus.person.controller.EmployeeController)")
public void saveEmployeeInfoMethods() {
}
/**
* 新增组织切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.saveInfo(..)) && target(com.gxhj.usermanage.controller.GroupController)")
public void saveGroupInfoMethods() {
}
/**
* 更新员工切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.updateInfoById(..)) && target(com.gxhj.safecampus.person.controller.EmployeeController)")
public void updateEmployeeInfoMethods() {
}
/**
* 更新组织切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.updateInfoById(..)) && target(com.gxhj.usermanage.controller.GroupController)")
public void updateGroupInfoMethods() {
}
/**
* 删除员工切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.delete*(..)) && target(com.gxhj.safecampus.person.controller.EmployeeController)")
public void deleteEmployeeInfoMethods() {
}
/**
* 删除组织切点
*/
@Pointcut("execution(* com.gxhj.core.base.controller.BaseController.delete*(..)) && target(com.gxhj.usermanage.controller.GroupController)")
public void deleteGroupInfoMethods() {
}
/**
* 新增(更新/删除)同步数据
* @param joinPoint
* @return
* @throws Throwable
*/
@Around(value = "saveOrUpdateInfo()")
public Object saveOrUpdateInfo(ProceedingJoinPoint joinPoint) throws Throwable {
// 获取对象
Object target = joinPoint.getTarget();
Object[] args = joinPoint.getArgs();
Object arg = args[AopParamIndex.DELETE_INDEX];
if (arg==null) {
return null;
}
DataSynchronousInfo dataSynchronousInfo = null;
Object objResult = null;
// 判断是那个对象
if (target instanceof EmployeeController){
EmployeeInfo employeeInfo = (EmployeeInfo) arg;
String employeeId = employeeInfo.getEmployeeId();
if (employeeId==null||employeeId.equals("")) {
// save
objResult = joinPoint.proceed();
dataSynchronousInfo = saveOrUpdateEmployee(joinPoint,SynchronousDataOperateTypes.AddOperate,AopParamIndex.SAVE_INDEX);
}else {
// update
dataSynchronousInfo = saveOrUpdateEmployee(joinPoint,SynchronousDataOperateTypes.UpdateOperate,AopParamIndex.SAVE_INDEX);
objResult = joinPoint.proceed();
}
}else if (target instanceof GroupController){
GroupInfo groupInfo = (GroupInfo) arg;
String groupId = groupInfo.getGroupId();
if (StringUtils.isBlank(groupId)) {
// save
objResult = joinPoint.proceed();
dataSynchronousInfo = saveOrUpdateGroup(joinPoint, SynchronousDataOperateTypes.AddOperate, AopParamIndex.SAVE_INDEX);
}else {
// update
dataSynchronousInfo = saveOrUpdateGroup(joinPoint, SynchronousDataOperateTypes.UpdateOperate, AopParamIndex.SAVE_INDEX);
objResult = joinPoint.proceed();
}
}
// 正常后置
if (dataSynchronousInfo != null) {
try {
datasynchronousService.saveValidInfo(dataSynchronousInfo);
log.info("同步数据存储成功");
} catch (Exception e) {
log.error("新建同步信息失败", e);
}
}
return objResult;
}
/**
* 新增员工同步数据
*
* @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;
}
}
网友评论