spring aop给返回值添加额外字段
1、默认情况下直接修改返回值为新对象时无法达到预期结果、但可通过序列化方式达到给原对象增加字段的目的
import cn.hutool.core.util.ReflectUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.databind.node.ObjectNode;
import lombok.extern.slf4j.Slf4j;
import cn.as.foundation.web.api.BusinessCode;
import cn.as.foundation.web.exception.BusinessException;
import cn.as.geekbidder.core.annotation.Dict;
import cn.as.geekbidder.core.util.JacksonTool;
import cn.as.maple.platform.api.model.User;
import cn.as.maple.platform.api.service.UserService;
import cn.as.maple.process.api.model.FlowTask;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.flowable.engine.TaskService;
import org.flowable.identitylink.api.IdentityLink;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Aspect
@Component
@Slf4j
public class AddCurrentUser {
@Autowired
private TaskService taskService;
@Autowired
private UserService userService;
/**
* Pointcut
*/
@Pointcut("execution(* cn.togeek.maple.process.controller.FlowTaskController.*(..))")
public void joinPoint() {}
private void addOtherInfo(Object result) {
if (result instanceof IPage) {
List<ObjectNode> items = new ArrayList<>();
List<?> records = ((IPage<?>) result).getRecords();
if(CollectionUtils.isEmpty(records)) {
return;
}
for (Object record : records) {
ObjectNode item = doAdd(record);
items.add(item);
}
((IPage<ObjectNode>) result).setRecords(items);
}
}
public ObjectNode doAdd(Object record) {
//解决@JsonFormat注解解析不了的问题
String json = JacksonTool.object2String(record);
ObjectNode item = JacksonTool.string2Object(json, ObjectNode.class);
if(Objects.isNull(item)) {
throw new BusinessException(BusinessCode.SYSTEM_ERROR.getCode(), "返回值解析失败");
}
String taskId = (String) ReflectUtil.getFieldValue(record, "taskId");
List<IdentityLink> idList = this.taskService.getIdentityLinksForTask(taskId);
List<User> collect = idList.stream().map(e -> {
List<User> users;
if(e.getUserId() != null) {
users = userService.getUsersByIds(Collections.singletonList(e.getUserId()));
}
else {
users = userService.getUserByRole(e.getGroupId());
}
return users;
}).flatMap(Collection::stream).collect(Collectors.toList());
String users = collect.stream().map(User::getName).collect(Collectors.joining(","));
item.put("currentUser", users);
return item;
}
@AfterReturning(value = "joinPoint()", returning = "methodResult")
public void afterRt(JoinPoint jp, Object methodResult) {
addOtherInfo(methodResult);
}
}
2、工具类
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* json 工具类
* @author ludangxin
* @date 2021/4/1
*/
@Slf4j
public class JacksonTool {
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private static final String STANDARD_PATTERN = "yyyy-MM-dd HH:mm:ss";
private static final String DATE_PATTERN = "yyyy-MM-dd";
private static final String TIME_PATTERN = "HH:mm:ss";
static {
//设置java.util.Date时间类的序列化以及反序列化的格式
OBJECT_MAPPER.setDateFormat(new SimpleDateFormat(STANDARD_PATTERN));
// 初始化JavaTimeModule
JavaTimeModule javaTimeModule = new JavaTimeModule();
//处理LocalDateTime
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(STANDARD_PATTERN);
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(dateTimeFormatter));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(dateTimeFormatter));
//处理LocalDate
DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern(DATE_PATTERN);
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(dateFormatter));
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(dateFormatter));
//处理LocalTime
DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern(TIME_PATTERN);
javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(timeFormatter));
javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(timeFormatter));
//处理Long
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
OBJECT_MAPPER.registerModule(simpleModule);
//注册时间模块, 支持支持jsr310, 即新的时间类(java.time包下的时间类)
OBJECT_MAPPER.registerModule(javaTimeModule);
// 包含所有字段
OBJECT_MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);
// 在序列化一个空对象时时不抛出异常
OBJECT_MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 忽略反序列化时在json字符串中存在, 但在java对象中不存在的属性
OBJECT_MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
}
public static <T> String object2String(T object) {
if(object == null) {
return null;
}
try {
return object instanceof String ? (String) object:OBJECT_MAPPER.writeValueAsString(object);
}
catch(IOException e) {
log.warn("Parse object to string error", e);
return null;
}
}
public static <T> String object2StringPretty(T object) {
if(object == null) {
return null;
}
try {
return object instanceof String ? (String) object:OBJECT_MAPPER.writerWithDefaultPrettyPrinter()
.writeValueAsString(object);
}
catch(IOException e) {
log.warn("Parse object to string error", e);
return null;
}
}
public static <T> T string2Object(String str, Class<T> clazz) {
if(StringUtils.isEmpty(str) || clazz == null) {
return null;
}
try {
return clazz.equals(String.class) ? (T) str : OBJECT_MAPPER.readValue(str, clazz);
}
catch(Exception e) {
log.warn("Parse String to object error!", e);
return null;
}
}
public static <T> T string2Object(String str, TypeReference<T> typeReference) {
if(StringUtils.isEmpty(str) || typeReference == null) {
return null;
}
try {
return typeReference.getType().equals(String.class) ? (T)str : OBJECT_MAPPER.readValue(str, typeReference);
}
catch(Exception e) {
log.warn("Parse String to object error!", e);
return null;
}
}
public static <T> T string2Object(String str, Class<?> collectionClass, Class<?>... elementClass) {
JavaType javaType = OBJECT_MAPPER.getTypeFactory().constructParametricType(collectionClass, elementClass);
try {
return OBJECT_MAPPER.readValue(str, javaType);
}
catch(Exception e) {
log.warn("Parse String to object error!", e);
return null;
}
}
/**
* 把对象转换为有序map,在序列化时确保对象的顺序和属性编排时一致
*/
public static Map<String, Object> objectToLinkedHashMap(Object obj) {
if(null == obj) {
return Maps.newHashMap();
}
return objectToLikedMap(obj);
}
public static LinkedHashMap<String, Object> objectToLikedMap(Object data) {
try {
return string2Object(object2String(data), LinkedHashMap.class);
}
catch(Exception e) {
return Maps.newLinkedHashMap();
}
}
/**
* json字符串转成list
*
* @param jsonString
* @param cls
* @return
*/
public static <T> List<T> jsonToList(String jsonString, Class<T> cls) {
try {
return OBJECT_MAPPER.readValue(jsonString, getCollectionType(List.class, cls));
} catch (JsonProcessingException e) {
String className = cls.getSimpleName();
log.error(" parse json [{}] to class [{}] error：{}", jsonString, className, e);
}
return null;
}
/**
* 获取泛型的Collection Type
*
* @param collectionClass 泛型的Collection
* @param elementClasses 实体bean
* @return JavaType Java类型
*/
private static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
return OBJECT_MAPPER.getTypeFactory().constructParametricType(collectionClass, elementClasses);
}
}
